display: Update to AU187 proprietary drop
Update to AU_LINUX_ANDROID_LA.HB.1.3.9.06.00.01.213.187 display_hal: 897a3ef sdm: Add support for color mode & color transform 489b7cd sdm: color-manager: New color management feature. f4a1f34 hwc2: Use floating value refresh rate 94c3c93 Merge branch display.lnx.3.0-dev into LA.HB.1.3.92a3c7d9
hwc2: Fix lint error.201bb83
Merge "Merge branch 'LA.HB.1.3.9' into display.lnx.3.0-dev"d3010dd
Merge "sdm: Fix HDMI Primary and Virtual Display concurrency use case"776f125
sdm: Fix HDMI Primary and Virtual Display concurrency use casee74eb40
gralloc: Handle RAW_OPAQUE formats similar to blob57db735
Merge branch 'LA.HB.1.3.9' into display.lnx.3.0-dev7c060b4
Merge "sdm : Remove un necessary log messages"33d6fee
Merge "hwc2: Add hwc specific dump"d477e60
Merge "hwc2: Locking fixes"d3a5303
Merge "gralloc1 : initial implementation"41451dd
Merge "sdm: Remove LayerCache from HWC" into display.lnx.3.0-dev791dc00
Merge "sdm: Handle spurious wakeup from pthread_cond_wait" into display.lnx.3.0-dev577a919
Merge "gralloc: Set default CSC to 601_FR" into display.lnx.3.0-dev670815a
Merge "sdm: Set system property when HDMI is Primary" into display.lnx.3.0-dev31e5d8f
Merge "IQService: Remove process name in debug logs" into display.lnx.3.0-dev96e9234
gralloc1 : initial implementation1fd59ea
hwc2: Add hwc specific dumpaddcabf
hwc2: Locking fixes9aabdd0
hwc2: Fix validated check093fd32
hwc2: Ignore null client target223796e
sdm: Handle spurious wakeup from pthread_cond_waitca8b2f3
sdm: Set system property when HDMI is Primary935f831
sdm: Remove LayerCache from HWCf2a6466
gralloc: Set default CSC to 601_FR57c19c7
Merge "sdm: Re-define MultiRect MDP flags" into display.lnx.3.0-dev9c0bf73
IQService: Remove process name in debug logs20a80cb
Merge "common: Do not enable QTI_BSP flag" into display.lnx.3.0-dev378b492
sdm: Re-define MultiRect MDP flagsc55bcb1
Merge "sdm: Full ROI for 1 frame after resolution switch" into display.lnx.3.0-dev74d720f
sdm: Full ROI for 1 frame after resolution switch6f9612b
sdm: Add support to report the pixel format of the displayc3c2f85
common: Do not enable QTI_BSP flag9cc2303
qdMetadata: Add MetaData operation functions0d36263
sdm: Enable HDMI dynamic frame rate switch feature9eade06
sdm : Remove un necessary log messages Change-Id: I70d35cfe58d9f5ac56b36c053119a6ae68ff3552
This commit is contained in:
parent
712d1ef449
commit
52af24f459
|
@ -1,6 +1,11 @@
|
|||
display-hals := libgralloc libcopybit liblight libmemtrack libqservice libqdutils
|
||||
display-hals += hdmi_cec
|
||||
display-hals := libcopybit liblight libmemtrack libqservice libqdutils
|
||||
ifneq ($(TARGET_USES_GRALLOC1), true)
|
||||
display-hals += libgralloc
|
||||
else
|
||||
display-hals += libgralloc1
|
||||
endif
|
||||
|
||||
display-hals += hdmi_cec
|
||||
sdm-libs := sdm/libs
|
||||
display-hals += $(sdm-libs)/utils $(sdm-libs)/core $(sdm-libs)/hwc $(sdm-libs)/hwc2
|
||||
|
||||
|
|
|
@ -16,7 +16,11 @@ common_libs := liblog libutils libcutils libhardware
|
|||
#Common C flags
|
||||
common_flags := -DDEBUG_CALC_FPS -Wno-missing-field-initializers
|
||||
common_flags += -Wconversion -Wall -Werror
|
||||
common_flags += -isystem $(display_top)/libgralloc
|
||||
ifneq ($(TARGET_USES_GRALLOC1), true)
|
||||
common_flags += -isystem $(display_top)/libgralloc
|
||||
else
|
||||
common_flags += -isystem $(display_top)/libgralloc1
|
||||
endif
|
||||
|
||||
ifeq ($(TARGET_USES_POST_PROCESSING),true)
|
||||
common_flags += -DUSES_POST_PROCESSING
|
||||
|
@ -39,10 +43,10 @@ common_deps :=
|
|||
kernel_includes :=
|
||||
|
||||
# Executed only on QCOM BSPs
|
||||
#ifeq ($(TARGET_USES_QCOM_BSP),true)
|
||||
# ifeq ($(TARGET_USES_QCOM_BSP),true)
|
||||
# Enable QCOM Display features
|
||||
# common_flags += -DQTI_BSP
|
||||
#endif
|
||||
# endif
|
||||
|
||||
ifeq ($(TARGET_COMPILE_WITH_MSM_KERNEL),true)
|
||||
# This check is to pick the kernel headers from the right location.
|
||||
|
|
|
@ -31,11 +31,12 @@
|
|||
|
||||
#include <copybit.h>
|
||||
#include "gralloc_priv.h"
|
||||
#include "gr.h"
|
||||
|
||||
#define COPYBIT_SUCCESS 0
|
||||
#define COPYBIT_FAILURE -1
|
||||
|
||||
#define ALIGN(x, y) (((x) + y - 1) & (~(y - 1)))
|
||||
|
||||
int convertYV12toYCrCb420SP(const copybit_image_t *src,private_handle_t *yv12_handle);
|
||||
|
||||
/*
|
||||
|
|
|
@ -135,11 +135,6 @@ int gpu_context_t::gralloc_alloc_buffer(unsigned int size, int usage,
|
|||
flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED;
|
||||
}
|
||||
|
||||
ColorSpace_t colorSpace = ITU_R_601;
|
||||
if (usage & GRALLOC_USAGE_HW_CAMERA_MASK) {
|
||||
colorSpace = ITU_R_601_FR;
|
||||
}
|
||||
|
||||
if (usage & (GRALLOC_USAGE_HW_VIDEO_ENCODER |
|
||||
GRALLOC_USAGE_HW_CAMERA_WRITE |
|
||||
GRALLOC_USAGE_HW_RENDER |
|
||||
|
@ -164,6 +159,7 @@ int gpu_context_t::gralloc_alloc_buffer(unsigned int size, int usage,
|
|||
hnd->offset = data.offset;
|
||||
hnd->base = (uint64_t)(data.base) + data.offset;
|
||||
hnd->gpuaddr = 0;
|
||||
ColorSpace_t colorSpace = ITU_R_601_FR;
|
||||
setMetaData(hnd, UPDATE_COLOR_SPACE, (void*) &colorSpace);
|
||||
|
||||
*pHandle = hnd;
|
||||
|
|
|
@ -0,0 +1,25 @@
|
|||
# Gralloc module
|
||||
LOCAL_PATH := $(call my-dir)
|
||||
include $(LOCAL_PATH)/../common.mk
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE := gralloc.$(TARGET_BOARD_PLATFORM)
|
||||
LOCAL_MODULE_RELATIVE_PATH := hw
|
||||
LOCAL_MODULE_TAGS := optional
|
||||
LOCAL_C_INCLUDES := $(common_includes) \
|
||||
external/libcxx/include/
|
||||
|
||||
LOCAL_SHARED_LIBRARIES := $(common_libs) libqdMetaData libsync libqdutils
|
||||
LOCAL_CFLAGS := $(common_flags) -DLOG_TAG=\"qdgralloc\" -Wall -std=c++11 -Werror
|
||||
LOCAL_CFLAGS += -isystem $(kernel_includes)
|
||||
LOCAL_CLANG := true
|
||||
LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) $(kernel_deps)
|
||||
LOCAL_SRC_FILES := gr_utils.cpp \
|
||||
gr_ion_alloc.cpp \
|
||||
gr_adreno_info.cpp \
|
||||
gr_allocator.cpp \
|
||||
gr_buf_mgr.cpp \
|
||||
gr_device_impl.cpp
|
||||
LOCAL_COPY_HEADERS_TO := $(common_header_export_path)
|
||||
LOCAL_COPY_HEADERS := gr_device_impl.h gralloc_priv.h gr_priv_handle.h
|
||||
include $(BUILD_SHARED_LIBRARY)
|
|
@ -0,0 +1,198 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cutils/log.h>
|
||||
#include <cutils/properties.h>
|
||||
#include <dlfcn.h>
|
||||
|
||||
#include "gralloc_priv.h"
|
||||
#include "gr_adreno_info.h"
|
||||
#include "gr_utils.h"
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
AdrenoMemInfo::AdrenoMemInfo() {
|
||||
}
|
||||
|
||||
bool AdrenoMemInfo::Init() {
|
||||
libadreno_utils_ = ::dlopen("libadreno_utils.so", RTLD_NOW);
|
||||
if (libadreno_utils_) {
|
||||
*reinterpret_cast<void **>(&LINK_adreno_compute_aligned_width_and_height) =
|
||||
::dlsym(libadreno_utils_, "compute_aligned_width_and_height");
|
||||
*reinterpret_cast<void **>(&LINK_adreno_compute_padding) =
|
||||
::dlsym(libadreno_utils_, "compute_surface_padding");
|
||||
*reinterpret_cast<void **>(&LINK_adreno_isMacroTilingSupportedByGpu) =
|
||||
::dlsym(libadreno_utils_, "isMacroTilingSupportedByGpu");
|
||||
*reinterpret_cast<void **>(&LINK_adreno_compute_compressedfmt_aligned_width_and_height) =
|
||||
::dlsym(libadreno_utils_, "compute_compressedfmt_aligned_width_and_height");
|
||||
*reinterpret_cast<void **>(&LINK_adreno_isUBWCSupportedByGpu) =
|
||||
::dlsym(libadreno_utils_, "isUBWCSupportedByGpu");
|
||||
*reinterpret_cast<void **>(&LINK_adreno_get_gpu_pixel_alignment) =
|
||||
::dlsym(libadreno_utils_, "get_gpu_pixel_alignment");
|
||||
} else {
|
||||
ALOGE(" Failed to load libadreno_utils.so");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Check if the overriding property debug.gralloc.gfx_ubwc_disable_
|
||||
// that disables UBWC allocations for the graphics stack is set
|
||||
char property[PROPERTY_VALUE_MAX];
|
||||
property_get("debug.gralloc.gfx_ubwc_disable_", property, "0");
|
||||
if (!(strncmp(property, "1", PROPERTY_VALUE_MAX)) ||
|
||||
!(strncmp(property, "true", PROPERTY_VALUE_MAX))) {
|
||||
gfx_ubwc_disable_ = true;
|
||||
}
|
||||
|
||||
if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
|
||||
(!strncmp(property, "1", PROPERTY_VALUE_MAX) ||
|
||||
(!strncasecmp(property, "true", PROPERTY_VALUE_MAX)))) {
|
||||
map_fb_ = true;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
AdrenoMemInfo::~AdrenoMemInfo() {
|
||||
if (libadreno_utils_) {
|
||||
::dlclose(libadreno_utils_);
|
||||
}
|
||||
}
|
||||
|
||||
bool AdrenoMemInfo::IsMacroTilingSupportedByGPU() {
|
||||
if (LINK_adreno_isMacroTilingSupportedByGpu) {
|
||||
return LINK_adreno_isMacroTilingSupportedByGpu();
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void AdrenoMemInfo::AlignUnCompressedRGB(int width, int height, int format, int tile_enabled,
|
||||
unsigned int *aligned_w, unsigned int *aligned_h) {
|
||||
*aligned_w = (unsigned int)ALIGN(width, 32);
|
||||
*aligned_h = (unsigned int)ALIGN(height, 32);
|
||||
|
||||
// Don't add any additional padding if debug.gralloc.map_fb_memory
|
||||
// is enabled
|
||||
if (map_fb_) {
|
||||
return;
|
||||
}
|
||||
|
||||
int bpp = 4;
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_RGB_888:
|
||||
bpp = 3;
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RGB_565:
|
||||
case HAL_PIXEL_FORMAT_BGR_565:
|
||||
case HAL_PIXEL_FORMAT_RGBA_5551:
|
||||
case HAL_PIXEL_FORMAT_RGBA_4444:
|
||||
bpp = 2;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
int raster_mode = 0; // Adreno unknown raster mode.
|
||||
int padding_threshold = 512; // Threshold for padding surfaces.
|
||||
// the function below computes aligned width and aligned height
|
||||
// based on linear or macro tile mode selected.
|
||||
if (LINK_adreno_compute_aligned_width_and_height) {
|
||||
LINK_adreno_compute_aligned_width_and_height(
|
||||
width, height, bpp, tile_enabled, raster_mode, padding_threshold,
|
||||
reinterpret_cast<int *>(aligned_w), reinterpret_cast<int *>(aligned_h));
|
||||
} else if (LINK_adreno_compute_padding) {
|
||||
int surface_tile_height = 1; // Linear surface
|
||||
*aligned_w = UINT(LINK_adreno_compute_padding(width, bpp, surface_tile_height, raster_mode,
|
||||
padding_threshold));
|
||||
ALOGW("%s: Warning!! Old GFX API is used to calculate stride", __FUNCTION__);
|
||||
} else {
|
||||
ALOGW(
|
||||
"%s: Warning!! Symbols compute_surface_padding and "
|
||||
"compute_aligned_width_and_height not found",
|
||||
__FUNCTION__);
|
||||
}
|
||||
}
|
||||
|
||||
void AdrenoMemInfo::AlignCompressedRGB(int width, int height, int format, unsigned int *aligned_w,
|
||||
unsigned int *aligned_h) {
|
||||
if (LINK_adreno_compute_compressedfmt_aligned_width_and_height) {
|
||||
int bytesPerPixel = 0;
|
||||
int raster_mode = 0; // Adreno unknown raster mode.
|
||||
int padding_threshold = 512; // Threshold for padding
|
||||
// surfaces.
|
||||
|
||||
LINK_adreno_compute_compressedfmt_aligned_width_and_height(
|
||||
width, height, format, 0, raster_mode, padding_threshold,
|
||||
reinterpret_cast<int *>(aligned_w), reinterpret_cast<int *>(aligned_h), &bytesPerPixel);
|
||||
} else {
|
||||
ALOGW("%s: Warning!! compute_compressedfmt_aligned_width_and_height not found", __FUNCTION__);
|
||||
}
|
||||
}
|
||||
|
||||
bool AdrenoMemInfo::IsUBWCSupportedByGPU(int format) {
|
||||
if (!gfx_ubwc_disable_ && LINK_adreno_isUBWCSupportedByGpu) {
|
||||
ADRENOPIXELFORMAT gpu_format = GetGpuPixelFormat(format);
|
||||
return LINK_adreno_isUBWCSupportedByGpu(gpu_format);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t AdrenoMemInfo::GetGpuPixelAlignment() {
|
||||
if (LINK_adreno_get_gpu_pixel_alignment) {
|
||||
return LINK_adreno_get_gpu_pixel_alignment();
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
ADRENOPIXELFORMAT AdrenoMemInfo::GetGpuPixelFormat(int hal_format) {
|
||||
switch (hal_format) {
|
||||
case HAL_PIXEL_FORMAT_RGBA_8888:
|
||||
return ADRENO_PIXELFORMAT_R8G8B8A8;
|
||||
case HAL_PIXEL_FORMAT_RGBX_8888:
|
||||
return ADRENO_PIXELFORMAT_R8G8B8X8;
|
||||
case HAL_PIXEL_FORMAT_RGB_565:
|
||||
return ADRENO_PIXELFORMAT_B5G6R5;
|
||||
case HAL_PIXEL_FORMAT_BGR_565:
|
||||
return ADRENO_PIXELFORMAT_R5G6B5;
|
||||
case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
|
||||
return ADRENO_PIXELFORMAT_NV12;
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
|
||||
return ADRENO_PIXELFORMAT_NV12_EXT;
|
||||
default:
|
||||
ALOGE("%s: No map for format: 0x%x", __FUNCTION__, hal_format);
|
||||
break;
|
||||
}
|
||||
|
||||
return ADRENO_PIXELFORMAT_UNKNOWN;
|
||||
}
|
||||
|
||||
} // namespace gralloc1
|
|
@ -0,0 +1,156 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __GR_ADRENO_INFO_H__
|
||||
#define __GR_ADRENO_INFO_H__
|
||||
|
||||
#ifdef VENUS_COLOR_FORMAT
|
||||
#include <media/msm_media_info.h>
|
||||
#else
|
||||
#define VENUS_Y_STRIDE(args...) 0
|
||||
#define VENUS_Y_SCANLINES(args...) 0
|
||||
#define VENUS_BUFFER_SIZE(args...) 0
|
||||
#endif
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
// Adreno Pixel Formats
|
||||
typedef enum {
|
||||
ADRENO_PIXELFORMAT_UNKNOWN = 0,
|
||||
ADRENO_PIXELFORMAT_R8G8B8A8 = 28,
|
||||
ADRENO_PIXELFORMAT_R8G8B8A8_SRGB = 29,
|
||||
ADRENO_PIXELFORMAT_B5G6R5 = 85,
|
||||
ADRENO_PIXELFORMAT_B5G5R5A1 = 86,
|
||||
ADRENO_PIXELFORMAT_B8G8R8A8 = 90,
|
||||
ADRENO_PIXELFORMAT_B8G8R8A8_SRGB = 91,
|
||||
ADRENO_PIXELFORMAT_B8G8R8X8_SRGB = 93,
|
||||
ADRENO_PIXELFORMAT_NV12 = 103,
|
||||
ADRENO_PIXELFORMAT_YUY2 = 107,
|
||||
ADRENO_PIXELFORMAT_B4G4R4A4 = 115,
|
||||
ADRENO_PIXELFORMAT_NV12_EXT = 506, // NV12 with non-std alignment and offsets
|
||||
ADRENO_PIXELFORMAT_R8G8B8X8 = 507, // GL_RGB8 (Internal)
|
||||
ADRENO_PIXELFORMAT_R8G8B8 = 508, // GL_RGB8
|
||||
ADRENO_PIXELFORMAT_A1B5G5R5 = 519, // GL_RGB5_A1
|
||||
ADRENO_PIXELFORMAT_R8G8B8X8_SRGB = 520, // GL_SRGB8
|
||||
ADRENO_PIXELFORMAT_R8G8B8_SRGB = 521, // GL_SRGB8
|
||||
ADRENO_PIXELFORMAT_R5G6B5 = 610, // RGBA version of B5G6R5
|
||||
ADRENO_PIXELFORMAT_R5G5B5A1 = 611, // RGBA version of B5G5R5A1
|
||||
ADRENO_PIXELFORMAT_R4G4B4A4 = 612, // RGBA version of B4G4R4A4
|
||||
ADRENO_PIXELFORMAT_UYVY = 614, // YUV 4:2:2 packed progressive (1 plane)
|
||||
ADRENO_PIXELFORMAT_NV21 = 619,
|
||||
ADRENO_PIXELFORMAT_Y8U8V8A8 = 620, // YUV 4:4:4 packed (1 plane)
|
||||
ADRENO_PIXELFORMAT_Y8 = 625, // Single 8-bit luma only channel YUV format
|
||||
} ADRENOPIXELFORMAT;
|
||||
|
||||
class AdrenoMemInfo {
|
||||
public:
|
||||
AdrenoMemInfo();
|
||||
|
||||
~AdrenoMemInfo();
|
||||
|
||||
bool Init();
|
||||
|
||||
/*
|
||||
* Function to compute aligned width and aligned height based on
|
||||
* width, height, format and usage flags.
|
||||
*
|
||||
* @return aligned width, aligned height
|
||||
*/
|
||||
void GetAlignedWidthAndHeight(int width, int height, int format, int usage,
|
||||
unsigned int *aligned_w, unsigned int *aligned_h, bool ubwc_enabled,
|
||||
bool tile_enabled);
|
||||
|
||||
/*
|
||||
* Function to compute the adreno aligned width and aligned height
|
||||
* based on the width and format.
|
||||
*
|
||||
* @return aligned width, aligned height
|
||||
*/
|
||||
void AlignUnCompressedRGB(int width, int height, int format, int tileEnabled,
|
||||
unsigned int *aligned_w, unsigned int *aligned_h);
|
||||
|
||||
/*
|
||||
* Function to compute the adreno aligned width and aligned height
|
||||
* based on the width and format.
|
||||
*
|
||||
* @return aligned width, aligned height
|
||||
*/
|
||||
void AlignCompressedRGB(int width, int height, int format, unsigned int *aligned_w,
|
||||
unsigned int *aligned_h);
|
||||
|
||||
/*
|
||||
* Function to compute the pixel alignment requirement.
|
||||
*
|
||||
* @return alignment
|
||||
*/
|
||||
uint32_t GetGpuPixelAlignment();
|
||||
|
||||
/*
|
||||
* Function to return whether GPU support MacroTile feature
|
||||
*
|
||||
* @return >0 : supported
|
||||
* 0 : not supported
|
||||
*/
|
||||
bool IsMacroTilingSupportedByGPU();
|
||||
|
||||
/*
|
||||
* Function to query whether GPU supports UBWC for given HAL format
|
||||
* @return > 0 : supported
|
||||
* 0 : not supported
|
||||
*/
|
||||
bool IsUBWCSupportedByGPU(int format);
|
||||
|
||||
/*
|
||||
* Function to get the corresponding Adreno format for given HAL format
|
||||
*/
|
||||
ADRENOPIXELFORMAT GetGpuPixelFormat(int hal_format);
|
||||
|
||||
private:
|
||||
// link(s)to adreno surface padding library.
|
||||
int (*LINK_adreno_compute_padding)(int width, int bpp, int surface_tile_height,
|
||||
int screen_tile_height, int padding_threshold) = NULL;
|
||||
void (*LINK_adreno_compute_aligned_width_and_height)(int width, int height, int bpp,
|
||||
int tile_mode, int raster_mode,
|
||||
int padding_threshold, int *aligned_w,
|
||||
int *aligned_h) = NULL;
|
||||
int (*LINK_adreno_isMacroTilingSupportedByGpu)(void) = NULL;
|
||||
void (*LINK_adreno_compute_compressedfmt_aligned_width_and_height)(
|
||||
int width, int height, int format, int tile_mode, int raster_mode, int padding_threshold,
|
||||
int *aligned_w, int *aligned_h, int *bpp) = NULL;
|
||||
int (*LINK_adreno_isUBWCSupportedByGpu)(ADRENOPIXELFORMAT format) = NULL;
|
||||
unsigned int (*LINK_adreno_get_gpu_pixel_alignment)() = NULL;
|
||||
|
||||
bool gfx_ubwc_disable_ = false;
|
||||
bool map_fb_ = false;
|
||||
void *libadreno_utils_ = NULL;
|
||||
};
|
||||
|
||||
} // namespace gralloc1
|
||||
|
||||
#endif // __GR_ADRENO_INFO_H__
|
|
@ -0,0 +1,871 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cutils/log.h>
|
||||
#include <algorithm>
|
||||
|
||||
#include "gr_utils.h"
|
||||
#include "gr_allocator.h"
|
||||
#include "gr_adreno_info.h"
|
||||
#include "gralloc_priv.h"
|
||||
|
||||
#include "qd_utils.h"
|
||||
#include "qdMetaData.h"
|
||||
|
||||
#define ASTC_BLOCK_SIZE 16
|
||||
|
||||
#ifndef ION_FLAG_CP_PIXEL
|
||||
#define ION_FLAG_CP_PIXEL 0
|
||||
#endif
|
||||
|
||||
#ifndef ION_FLAG_ALLOW_NON_CONTIG
|
||||
#define ION_FLAG_ALLOW_NON_CONTIG 0
|
||||
#endif
|
||||
|
||||
#ifdef MASTER_SIDE_CP
|
||||
#define CP_HEAP_ID ION_SECURE_HEAP_ID
|
||||
#define SD_HEAP_ID ION_SECURE_DISPLAY_HEAP_ID
|
||||
#define ION_CP_FLAGS (ION_SECURE | ION_FLAG_CP_PIXEL)
|
||||
#define ION_SD_FLAGS (ION_SECURE | ION_FLAG_CP_SEC_DISPLAY)
|
||||
#else // SLAVE_SIDE_CP
|
||||
#define CP_HEAP_ID ION_CP_MM_HEAP_ID
|
||||
#define SD_HEAP_ID CP_HEAP_ID
|
||||
#define ION_CP_FLAGS (ION_SECURE | ION_FLAG_ALLOW_NON_CONTIG)
|
||||
#define ION_SD_FLAGS ION_SECURE
|
||||
#endif
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
Allocator::Allocator() : ion_allocator_(NULL), adreno_helper_(NULL) {
|
||||
}
|
||||
|
||||
bool Allocator::Init() {
|
||||
ion_allocator_ = new IonAlloc();
|
||||
if (!ion_allocator_->Init()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
adreno_helper_ = new AdrenoMemInfo();
|
||||
if (!adreno_helper_->Init()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
gpu_support_macrotile = adreno_helper_->IsMacroTilingSupportedByGPU();
|
||||
int supports_macrotile = 0;
|
||||
qdutils::querySDEInfo(qdutils::HAS_MACRO_TILE, &supports_macrotile);
|
||||
display_support_macrotile = !!supports_macrotile;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Allocator::~Allocator() {
|
||||
if (ion_allocator_) {
|
||||
delete ion_allocator_;
|
||||
}
|
||||
|
||||
if (adreno_helper_) {
|
||||
delete adreno_helper_;
|
||||
}
|
||||
}
|
||||
|
||||
int Allocator::AllocateMem(AllocData *alloc_data, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage) {
|
||||
int ret;
|
||||
alloc_data->uncached = UseUncached(prod_usage);
|
||||
|
||||
// After this point we should have the right heap set, there is no fallback
|
||||
GetIonHeapInfo(prod_usage, cons_usage, &alloc_data->heap_id, &alloc_data->alloc_type,
|
||||
&alloc_data->flags);
|
||||
|
||||
ret = ion_allocator_->AllocBuffer(alloc_data);
|
||||
if (ret >= 0) {
|
||||
alloc_data->alloc_type |= private_handle_t::PRIV_FLAGS_USES_ION;
|
||||
} else {
|
||||
ALOGE("%s: Failed to allocate buffer - heap: 0x%x flags: 0x%x", __FUNCTION__,
|
||||
alloc_data->heap_id, alloc_data->flags);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
// Allocates buffer from width, height and format into a
|
||||
// private_handle_t. It is the responsibility of the caller
|
||||
// to free the buffer using the FreeBuffer function
|
||||
int Allocator::AllocateBuffer(const BufferDescriptor &descriptor, private_handle_t **pHnd) {
|
||||
AllocData data;
|
||||
unsigned int aligned_w, aligned_h;
|
||||
data.base = 0;
|
||||
data.fd = -1;
|
||||
data.offset = 0;
|
||||
data.align = (unsigned int)getpagesize();
|
||||
int format = descriptor.GetFormat();
|
||||
gralloc1_producer_usage_t prod_usage = descriptor.GetProducerUsage();
|
||||
gralloc1_consumer_usage_t cons_usage = descriptor.GetConsumerUsage();
|
||||
GetBufferSizeAndDimensions(descriptor, &data.size, &aligned_w, &aligned_h);
|
||||
|
||||
int err = AllocateMem(&data, prod_usage, cons_usage);
|
||||
if (0 != err) {
|
||||
ALOGE("%s: allocate failed", __FUNCTION__);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (IsUBwcEnabled(format, prod_usage, cons_usage)) {
|
||||
data.alloc_type |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
|
||||
}
|
||||
|
||||
// Metadata is not allocated. would be empty
|
||||
private_handle_t *hnd = new private_handle_t(
|
||||
data.fd, data.size, INT(data.alloc_type), 0, INT(format), INT(aligned_w), INT(aligned_h), -1,
|
||||
0, 0, descriptor.GetWidth(), descriptor.GetHeight(), prod_usage, cons_usage);
|
||||
hnd->base = (uint64_t)data.base;
|
||||
hnd->offset = data.offset;
|
||||
hnd->gpuaddr = 0;
|
||||
*pHnd = hnd;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int Allocator::MapBuffer(void **base, unsigned int size, unsigned int offset, int fd) {
|
||||
if (ion_allocator_) {
|
||||
return ion_allocator_->MapBuffer(base, size, offset, fd);
|
||||
}
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int Allocator::FreeBuffer(void *base, unsigned int size, unsigned int offset, int fd) {
|
||||
if (ion_allocator_) {
|
||||
return ion_allocator_->FreeBuffer(base, size, offset, fd);
|
||||
}
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
int Allocator::CleanBuffer(void *base, unsigned int size, unsigned int offset, int fd, int op) {
|
||||
if (ion_allocator_) {
|
||||
return ion_allocator_->CleanBuffer(base, size, offset, fd, op);
|
||||
}
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
bool Allocator::CheckForBufferSharing(uint32_t num_descriptors, const BufferDescriptor *descriptors,
|
||||
int *max_index) {
|
||||
unsigned int cur_heap_id = 0, prev_heap_id = 0;
|
||||
unsigned int cur_alloc_type = 0, prev_alloc_type = 0;
|
||||
unsigned int cur_ion_flags = 0, prev_ion_flags = 0;
|
||||
bool cur_uncached = false, prev_uncached = false;
|
||||
unsigned int alignedw, alignedh;
|
||||
unsigned int max_size = 0;
|
||||
|
||||
*max_index = -1;
|
||||
for (uint32_t i = 0; i < num_descriptors; i++) {
|
||||
// Check Cached vs non-cached and all the ION flags
|
||||
cur_uncached = UseUncached(descriptors[i].GetProducerUsage());
|
||||
GetIonHeapInfo(descriptors[i].GetProducerUsage(), descriptors[i].GetConsumerUsage(),
|
||||
&cur_heap_id, &cur_alloc_type, &cur_ion_flags);
|
||||
|
||||
if (i > 0 && (cur_heap_id != prev_heap_id || cur_alloc_type != prev_alloc_type ||
|
||||
cur_ion_flags != prev_ion_flags)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// For same format type, find the descriptor with bigger size
|
||||
GetAlignedWidthAndHeight(descriptors[i], &alignedw, &alignedh);
|
||||
unsigned int size = GetSize(descriptors[i], alignedw, alignedh);
|
||||
if (max_size < size) {
|
||||
*max_index = INT(i);
|
||||
max_size = size;
|
||||
}
|
||||
|
||||
prev_heap_id = cur_heap_id;
|
||||
prev_uncached = cur_uncached;
|
||||
prev_ion_flags = cur_ion_flags;
|
||||
prev_alloc_type = cur_alloc_type;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Allocator::IsMacroTileEnabled(int format, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage) {
|
||||
bool tile_enabled = false;
|
||||
|
||||
// Check whether GPU & MDSS supports MacroTiling feature
|
||||
if (!adreno_helper_->IsMacroTilingSupportedByGPU() || !display_support_macrotile) {
|
||||
return tile_enabled;
|
||||
}
|
||||
|
||||
// check the format
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_RGBA_8888:
|
||||
case HAL_PIXEL_FORMAT_RGBX_8888:
|
||||
case HAL_PIXEL_FORMAT_BGRA_8888:
|
||||
case HAL_PIXEL_FORMAT_RGB_565:
|
||||
case HAL_PIXEL_FORMAT_BGR_565:
|
||||
if (!CpuCanAccess(prod_usage, cons_usage)) {
|
||||
// not touched by CPU
|
||||
tile_enabled = true;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return tile_enabled;
|
||||
}
|
||||
|
||||
// helper function
|
||||
unsigned int Allocator::GetSize(const BufferDescriptor &descriptor, unsigned int alignedw,
|
||||
unsigned int alignedh) {
|
||||
unsigned int size = 0;
|
||||
int format = descriptor.GetFormat();
|
||||
int width = descriptor.GetWidth();
|
||||
int height = descriptor.GetHeight();
|
||||
gralloc1_producer_usage_t prod_usage = descriptor.GetProducerUsage();
|
||||
gralloc1_consumer_usage_t cons_usage = descriptor.GetConsumerUsage();
|
||||
|
||||
if (IsUBwcEnabled(format, prod_usage, cons_usage)) {
|
||||
return GetUBwcSize(width, height, format, alignedw, alignedh);
|
||||
}
|
||||
|
||||
if (IsUncompressedRGBFormat(format)) {
|
||||
uint32_t bpp = GetBppForUncompressedRGB(format);
|
||||
size = alignedw * alignedh * bpp;
|
||||
return size;
|
||||
}
|
||||
|
||||
if (IsCompressedRGBFormat(format)) {
|
||||
size = alignedw * alignedh * ASTC_BLOCK_SIZE;
|
||||
return size;
|
||||
}
|
||||
|
||||
// Below switch should be for only YUV/custom formats
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_RAW16:
|
||||
size = alignedw * alignedh * 2;
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RAW10:
|
||||
size = ALIGN(alignedw * alignedh, SIZE_4K);
|
||||
break;
|
||||
|
||||
// adreno formats
|
||||
case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO: // NV21
|
||||
size = ALIGN(alignedw * alignedh, SIZE_4K);
|
||||
size += (unsigned int)ALIGN(2 * ALIGN(width / 2, 32) * ALIGN(height / 2, 32), SIZE_4K);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED: // NV12
|
||||
// The chroma plane is subsampled,
|
||||
// but the pitch in bytes is unchanged
|
||||
// The GPU needs 4K alignment, but the video decoder needs 8K
|
||||
size = ALIGN(alignedw * alignedh, SIZE_8K);
|
||||
size += ALIGN(alignedw * (unsigned int)ALIGN(height / 2, 32), SIZE_8K);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YV12:
|
||||
if ((format == HAL_PIXEL_FORMAT_YV12) && ((width & 1) || (height & 1))) {
|
||||
ALOGE("w or h is odd for the YV12 format");
|
||||
return 0;
|
||||
}
|
||||
size = alignedw * alignedh + (ALIGN(alignedw / 2, 16) * (alignedh / 2)) * 2;
|
||||
size = ALIGN(size, (unsigned int)SIZE_4K);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP:
|
||||
case HAL_PIXEL_FORMAT_YCrCb_420_SP:
|
||||
size = ALIGN((alignedw * alignedh) + (alignedw * alignedh) / 2 + 1, SIZE_4K);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCbCr_422_SP:
|
||||
case HAL_PIXEL_FORMAT_YCrCb_422_SP:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_422_I:
|
||||
case HAL_PIXEL_FORMAT_YCrCb_422_I:
|
||||
if (width & 1) {
|
||||
ALOGE("width is odd for the YUV422_SP format");
|
||||
return 0;
|
||||
}
|
||||
size = ALIGN(alignedw * alignedh * 2, SIZE_4K);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
|
||||
case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
|
||||
size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
|
||||
size = VENUS_BUFFER_SIZE(COLOR_FMT_NV21, width, height);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_BLOB:
|
||||
case HAL_PIXEL_FORMAT_RAW_OPAQUE:
|
||||
if (height != 1) {
|
||||
ALOGE("%s: Buffers with HAL_PIXEL_FORMAT_BLOB must have height 1 ", __FUNCTION__);
|
||||
return 0;
|
||||
}
|
||||
size = (unsigned int)width;
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_NV21_ZSL:
|
||||
size = ALIGN((alignedw * alignedh) + (alignedw * alignedh) / 2, SIZE_4K);
|
||||
break;
|
||||
default:
|
||||
ALOGE("%s: Unrecognized pixel format: 0x%x", __FUNCTION__, format);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
void Allocator::GetBufferSizeAndDimensions(int width, int height, int format, unsigned int *size,
|
||||
unsigned int *alignedw, unsigned int *alignedh) {
|
||||
BufferDescriptor descriptor = BufferDescriptor(width, height, format);
|
||||
GetAlignedWidthAndHeight(descriptor, alignedw, alignedh);
|
||||
|
||||
*size = GetSize(descriptor, *alignedw, *alignedh);
|
||||
}
|
||||
|
||||
void Allocator::GetBufferSizeAndDimensions(const BufferDescriptor &descriptor, unsigned int *size,
|
||||
unsigned int *alignedw, unsigned int *alignedh) {
|
||||
GetAlignedWidthAndHeight(descriptor, alignedw, alignedh);
|
||||
|
||||
*size = GetSize(descriptor, *alignedw, *alignedh);
|
||||
}
|
||||
|
||||
void Allocator::GetBufferAttributes(const BufferDescriptor &descriptor, unsigned int *alignedw,
|
||||
unsigned int *alignedh, int *tiled, unsigned int *size) {
|
||||
int format = descriptor.GetFormat();
|
||||
gralloc1_producer_usage_t prod_usage = descriptor.GetProducerUsage();
|
||||
gralloc1_consumer_usage_t cons_usage = descriptor.GetConsumerUsage();
|
||||
|
||||
*tiled = false;
|
||||
if (IsUBwcEnabled(format, prod_usage, cons_usage) ||
|
||||
IsMacroTileEnabled(format, prod_usage, cons_usage)) {
|
||||
*tiled = true;
|
||||
}
|
||||
|
||||
GetAlignedWidthAndHeight(descriptor, alignedw, alignedh);
|
||||
*size = GetSize(descriptor, *alignedw, *alignedh);
|
||||
}
|
||||
|
||||
void Allocator::GetYuvUbwcSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height,
|
||||
int color_format, struct android_ycbcr *ycbcr) {
|
||||
// UBWC buffer has these 4 planes in the following sequence:
|
||||
// Y_Meta_Plane, Y_Plane, UV_Meta_Plane, UV_Plane
|
||||
unsigned int y_meta_stride, y_meta_height, y_meta_size;
|
||||
unsigned int y_stride, y_height, y_size;
|
||||
unsigned int c_meta_stride, c_meta_height, c_meta_size;
|
||||
unsigned int alignment = 4096;
|
||||
|
||||
y_meta_stride = VENUS_Y_META_STRIDE(color_format, INT(width));
|
||||
y_meta_height = VENUS_Y_META_SCANLINES(color_format, INT(height));
|
||||
y_meta_size = ALIGN((y_meta_stride * y_meta_height), alignment);
|
||||
|
||||
y_stride = VENUS_Y_STRIDE(color_format, INT(width));
|
||||
y_height = VENUS_Y_SCANLINES(color_format, INT(height));
|
||||
y_size = ALIGN((y_stride * y_height), alignment);
|
||||
|
||||
c_meta_stride = VENUS_UV_META_STRIDE(color_format, INT(width));
|
||||
c_meta_height = VENUS_UV_META_SCANLINES(color_format, INT(height));
|
||||
c_meta_size = ALIGN((c_meta_stride * c_meta_height), alignment);
|
||||
|
||||
ycbcr->y = reinterpret_cast<void *>(base + y_meta_size);
|
||||
ycbcr->cb = reinterpret_cast<void *>(base + y_meta_size + y_size + c_meta_size);
|
||||
ycbcr->cr = reinterpret_cast<void *>(base + y_meta_size + y_size + c_meta_size + 1);
|
||||
ycbcr->ystride = y_stride;
|
||||
ycbcr->cstride = VENUS_UV_STRIDE(color_format, INT(width));
|
||||
}
|
||||
|
||||
void Allocator::GetYuvSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height, uint32_t bpp,
|
||||
struct android_ycbcr *ycbcr) {
|
||||
unsigned int ystride, cstride;
|
||||
|
||||
ystride = cstride = UINT(width) * bpp;
|
||||
ycbcr->y = reinterpret_cast<void *>(base);
|
||||
ycbcr->cb = reinterpret_cast<void *>(base + ystride * UINT(height));
|
||||
ycbcr->cr = reinterpret_cast<void *>(base + ystride * UINT(height) + 1);
|
||||
ycbcr->ystride = ystride;
|
||||
ycbcr->cstride = cstride;
|
||||
ycbcr->chroma_step = 2 * bpp;
|
||||
}
|
||||
|
||||
int Allocator::GetYUVPlaneInfo(const private_handle_t *hnd, struct android_ycbcr *ycbcr) {
|
||||
int err = 0;
|
||||
uint32_t width = UINT(hnd->width);
|
||||
uint32_t height = UINT(hnd->height);
|
||||
int format = hnd->format;
|
||||
gralloc1_producer_usage_t prod_usage = hnd->GetProducerUsage();
|
||||
gralloc1_consumer_usage_t cons_usage = hnd->GetConsumerUsage();
|
||||
unsigned int ystride, cstride;
|
||||
|
||||
memset(ycbcr->reserved, 0, sizeof(ycbcr->reserved));
|
||||
MetaData_t *metadata = reinterpret_cast<MetaData_t *>(hnd->base_metadata);
|
||||
|
||||
// Check if UBWC buffer has been rendered in linear format.
|
||||
if (metadata && (metadata->operation & LINEAR_FORMAT)) {
|
||||
format = INT(metadata->linearFormat);
|
||||
}
|
||||
|
||||
// Check metadata if the geometry has been updated.
|
||||
if (metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
|
||||
int usage = 0;
|
||||
|
||||
if (hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
|
||||
usage = GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC;
|
||||
}
|
||||
|
||||
BufferDescriptor descriptor =
|
||||
BufferDescriptor(metadata->bufferDim.sliceWidth, metadata->bufferDim.sliceHeight, format,
|
||||
prod_usage, cons_usage);
|
||||
GetAlignedWidthAndHeight(descriptor, &width, &height);
|
||||
}
|
||||
|
||||
// Get the chroma offsets from the handle width/height. We take advantage
|
||||
// of the fact the width _is_ the stride
|
||||
switch (format) {
|
||||
// Semiplanar
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_422_SP:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
|
||||
case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
|
||||
// Same as YCbCr_420_SP_VENUS
|
||||
GetYuvSPPlaneInfo(hnd->base, width, height, 1, ycbcr);
|
||||
break;
|
||||
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_P010:
|
||||
GetYuvSPPlaneInfo(hnd->base, width, height, 2, ycbcr);
|
||||
break;
|
||||
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
|
||||
GetYuvUbwcSPPlaneInfo(hnd->base, width, height, COLOR_FMT_NV12_UBWC, ycbcr);
|
||||
ycbcr->chroma_step = 2;
|
||||
break;
|
||||
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
|
||||
GetYuvUbwcSPPlaneInfo(hnd->base, width, height, COLOR_FMT_NV12_BPP10_UBWC, ycbcr);
|
||||
ycbcr->chroma_step = 3;
|
||||
break;
|
||||
|
||||
case HAL_PIXEL_FORMAT_YCrCb_420_SP:
|
||||
case HAL_PIXEL_FORMAT_YCrCb_422_SP:
|
||||
case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
|
||||
case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
|
||||
case HAL_PIXEL_FORMAT_NV21_ZSL:
|
||||
case HAL_PIXEL_FORMAT_RAW16:
|
||||
case HAL_PIXEL_FORMAT_RAW10:
|
||||
GetYuvSPPlaneInfo(hnd->base, width, height, 1, ycbcr);
|
||||
std::swap(ycbcr->cb, ycbcr->cr);
|
||||
break;
|
||||
|
||||
// Planar
|
||||
case HAL_PIXEL_FORMAT_YV12:
|
||||
ystride = width;
|
||||
cstride = ALIGN(width / 2, 16);
|
||||
ycbcr->y = reinterpret_cast<void *>(hnd->base);
|
||||
ycbcr->cr = reinterpret_cast<void *>(hnd->base + ystride * height);
|
||||
ycbcr->cb = reinterpret_cast<void *>(hnd->base + ystride * height + cstride * height / 2);
|
||||
ycbcr->ystride = ystride;
|
||||
ycbcr->cstride = cstride;
|
||||
ycbcr->chroma_step = 1;
|
||||
break;
|
||||
|
||||
// Unsupported formats
|
||||
case HAL_PIXEL_FORMAT_YCbCr_422_I:
|
||||
case HAL_PIXEL_FORMAT_YCrCb_422_I:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
|
||||
default:
|
||||
ALOGD("%s: Invalid format passed: 0x%x", __FUNCTION__, format);
|
||||
err = -EINVAL;
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int Allocator::GetImplDefinedFormat(gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage, int format) {
|
||||
int gr_format = format;
|
||||
|
||||
// If input format is HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED then based on
|
||||
// the usage bits, gralloc assigns a format.
|
||||
if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
|
||||
format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
|
||||
if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC) {
|
||||
gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
|
||||
} else if (cons_usage & GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER) {
|
||||
gr_format = HAL_PIXEL_FORMAT_NV12_ENCODEABLE; // NV12
|
||||
} else if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_CAMERA_ZSL) {
|
||||
gr_format = HAL_PIXEL_FORMAT_NV21_ZSL; // NV21 ZSL
|
||||
} else if (cons_usage & GRALLOC1_CONSUMER_USAGE_CAMERA) {
|
||||
gr_format = HAL_PIXEL_FORMAT_YCrCb_420_SP; // NV21
|
||||
} else if (prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) {
|
||||
if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
|
||||
gr_format = HAL_PIXEL_FORMAT_NV21_ZSL; // NV21
|
||||
} else {
|
||||
gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS; // NV12 preview
|
||||
}
|
||||
} else if (cons_usage & GRALLOC1_CONSUMER_USAGE_HWCOMPOSER) {
|
||||
// XXX: If we still haven't set a format, default to RGBA8888
|
||||
gr_format = HAL_PIXEL_FORMAT_RGBA_8888;
|
||||
} else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
|
||||
// If no other usage flags are detected, default the
|
||||
// flexible YUV format to NV21_ZSL
|
||||
gr_format = HAL_PIXEL_FORMAT_NV21_ZSL;
|
||||
}
|
||||
}
|
||||
|
||||
return gr_format;
|
||||
}
|
||||
|
||||
// Explicitly defined UBWC formats
|
||||
bool Allocator::IsUBwcFormat(int format) {
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool Allocator::IsUBwcSupported(int format) {
|
||||
// Existing HAL formats with UBWC support
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_BGR_565:
|
||||
case HAL_PIXEL_FORMAT_RGBA_8888:
|
||||
case HAL_PIXEL_FORMAT_RGBX_8888:
|
||||
case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
|
||||
return true;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/* The default policy is to return cached buffers unless the client explicity
|
||||
* sets the PRIVATE_UNCACHED flag or indicates that the buffer will be rarely
|
||||
* read or written in software. */
|
||||
// TODO(user) : As of now relying only on producer usage
|
||||
bool Allocator::UseUncached(gralloc1_producer_usage_t usage) {
|
||||
if ((usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_UNCACHED) ||
|
||||
(usage & GRALLOC1_PRODUCER_USAGE_PROTECTED)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// CPU read rarely
|
||||
if ((usage & GRALLOC1_PRODUCER_USAGE_CPU_READ) &&
|
||||
!(usage & GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// CPU write rarely
|
||||
if ((usage & GRALLOC1_PRODUCER_USAGE_CPU_WRITE) &&
|
||||
!(usage & GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void Allocator::GetIonHeapInfo(gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage, unsigned int *ion_heap_id,
|
||||
unsigned int *alloc_type, unsigned int *ion_flags) {
|
||||
unsigned int heap_id = 0;
|
||||
unsigned int type = 0;
|
||||
int flags = 0;
|
||||
if (prod_usage & GRALLOC1_PRODUCER_USAGE_PROTECTED) {
|
||||
if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY) {
|
||||
heap_id = ION_HEAP(SD_HEAP_ID);
|
||||
/*
|
||||
* There is currently no flag in ION for Secure Display
|
||||
* VM. Please add it to the define once available.
|
||||
*/
|
||||
flags |= ION_SD_FLAGS;
|
||||
} else {
|
||||
heap_id = ION_HEAP(CP_HEAP_ID);
|
||||
flags |= ION_CP_FLAGS;
|
||||
}
|
||||
} else if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_MM_HEAP) {
|
||||
// MM Heap is exclusively a secure heap.
|
||||
// If it is used for non secure cases, fallback to IOMMU heap
|
||||
ALOGW("MM_HEAP cannot be used as an insecure heap. Using system heap instead!!");
|
||||
heap_id |= ION_HEAP(ION_SYSTEM_HEAP_ID);
|
||||
}
|
||||
|
||||
if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_CAMERA_HEAP) {
|
||||
heap_id |= ION_HEAP(ION_CAMERA_HEAP_ID);
|
||||
}
|
||||
|
||||
if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_ADSP_HEAP) {
|
||||
heap_id |= ION_HEAP(ION_ADSP_HEAP_ID);
|
||||
}
|
||||
|
||||
if (flags & ION_SECURE) {
|
||||
type |= private_handle_t::PRIV_FLAGS_SECURE_BUFFER;
|
||||
}
|
||||
|
||||
// if no ion heap flags are set, default to system heap
|
||||
if (!heap_id) {
|
||||
heap_id = ION_HEAP(ION_SYSTEM_HEAP_ID);
|
||||
}
|
||||
|
||||
*alloc_type = type;
|
||||
*ion_flags = (unsigned int)flags;
|
||||
*ion_heap_id = heap_id;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
bool Allocator::IsUBwcEnabled(int format, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage) {
|
||||
// Allow UBWC, if client is using an explicitly defined UBWC pixel format.
|
||||
if (IsUBwcFormat(format)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Allow UBWC, if an OpenGL client sets UBWC usage flag and GPU plus MDP
|
||||
// support the format. OR if a non-OpenGL client like Rotator, sets UBWC
|
||||
// usage flag and MDP supports the format.
|
||||
if ((prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC) && IsUBwcSupported(format)) {
|
||||
bool enable = true;
|
||||
// Query GPU for UBWC only if buffer is intended to be used by GPU.
|
||||
if ((cons_usage & GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE) ||
|
||||
(prod_usage & GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET)) {
|
||||
enable = adreno_helper_->IsUBWCSupportedByGPU(format);
|
||||
}
|
||||
|
||||
// Allow UBWC, only if CPU usage flags are not set
|
||||
if (enable && !(CpuCanAccess(prod_usage, cons_usage))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void Allocator::GetYuvUBwcWidthAndHeight(int width, int height, int format, unsigned int *aligned_w,
|
||||
unsigned int *aligned_h) {
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
|
||||
*aligned_w = VENUS_Y_STRIDE(COLOR_FMT_NV12_UBWC, width);
|
||||
*aligned_h = VENUS_Y_SCANLINES(COLOR_FMT_NV12_UBWC, height);
|
||||
break;
|
||||
default:
|
||||
ALOGE("%s: Unsupported pixel format: 0x%x", __FUNCTION__, format);
|
||||
*aligned_w = 0;
|
||||
*aligned_h = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Allocator::GetRgbUBwcBlockSize(uint32_t bpp, int *block_width, int *block_height) {
|
||||
*block_width = 0;
|
||||
*block_height = 0;
|
||||
|
||||
switch (bpp) {
|
||||
case 2:
|
||||
case 4:
|
||||
*block_width = 16;
|
||||
*block_height = 4;
|
||||
break;
|
||||
case 8:
|
||||
*block_width = 8;
|
||||
*block_height = 4;
|
||||
break;
|
||||
case 16:
|
||||
*block_width = 4;
|
||||
*block_height = 4;
|
||||
break;
|
||||
default:
|
||||
ALOGE("%s: Unsupported bpp: %d", __FUNCTION__, bpp);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned int Allocator::GetRgbUBwcMetaBufferSize(int width, int height, uint32_t bpp) {
|
||||
unsigned int size = 0;
|
||||
int meta_width, meta_height;
|
||||
int block_width, block_height;
|
||||
|
||||
GetRgbUBwcBlockSize(bpp, &block_width, &block_height);
|
||||
if (!block_width || !block_height) {
|
||||
ALOGE("%s: Unsupported bpp: %d", __FUNCTION__, bpp);
|
||||
return size;
|
||||
}
|
||||
|
||||
// Align meta buffer height to 16 blocks
|
||||
meta_height = ALIGN(((height + block_height - 1) / block_height), 16);
|
||||
|
||||
// Align meta buffer width to 64 blocks
|
||||
meta_width = ALIGN(((width + block_width - 1) / block_width), 64);
|
||||
|
||||
// Align meta buffer size to 4K
|
||||
size = (unsigned int)ALIGN((meta_width * meta_height), 4096);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
unsigned int Allocator::GetUBwcSize(int width, int height, int format, unsigned int alignedw,
|
||||
unsigned int alignedh) {
|
||||
unsigned int size = 0;
|
||||
uint32_t bpp = 0;
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_BGR_565:
|
||||
case HAL_PIXEL_FORMAT_RGBA_8888:
|
||||
case HAL_PIXEL_FORMAT_RGBX_8888:
|
||||
case HAL_PIXEL_FORMAT_RGBA_1010102:
|
||||
case HAL_PIXEL_FORMAT_RGBX_1010102:
|
||||
bpp = GetBppForUncompressedRGB(format);
|
||||
size = alignedw * alignedh * bpp;
|
||||
size += GetRgbUBwcMetaBufferSize(width, height, bpp);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
|
||||
size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_UBWC, width, height);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC:
|
||||
size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12_BPP10_UBWC, width, height);
|
||||
break;
|
||||
default:
|
||||
ALOGE("%s: Unsupported pixel format: 0x%x", __FUNCTION__, format);
|
||||
break;
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
int Allocator::GetRgbDataAddress(private_handle_t *hnd, void **rgb_data) {
|
||||
int err = 0;
|
||||
|
||||
// This api is for RGB* formats
|
||||
if (!gralloc1::IsUncompressedRGBFormat(hnd->format)) {
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
// linear buffer, nothing to do further
|
||||
if (!(hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED)) {
|
||||
*rgb_data = reinterpret_cast<void *>(hnd->base);
|
||||
return err;
|
||||
}
|
||||
|
||||
unsigned int meta_size = 0;
|
||||
uint32_t bpp = GetBppForUncompressedRGB(hnd->format);
|
||||
switch (hnd->format) {
|
||||
case HAL_PIXEL_FORMAT_BGR_565:
|
||||
case HAL_PIXEL_FORMAT_RGBA_8888:
|
||||
case HAL_PIXEL_FORMAT_RGBX_8888:
|
||||
meta_size = GetRgbUBwcMetaBufferSize(hnd->width, hnd->height, bpp);
|
||||
break;
|
||||
default:
|
||||
ALOGE("%s:Unsupported RGB format: 0x%x", __FUNCTION__, hnd->format);
|
||||
err = -EINVAL;
|
||||
break;
|
||||
}
|
||||
*rgb_data = reinterpret_cast<void *>(hnd->base + meta_size);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
void Allocator::GetAlignedWidthAndHeight(const BufferDescriptor &descriptor, unsigned int *alignedw,
|
||||
unsigned int *alignedh) {
|
||||
int width = descriptor.GetWidth();
|
||||
int height = descriptor.GetHeight();
|
||||
int format = descriptor.GetFormat();
|
||||
gralloc1_producer_usage_t prod_usage = descriptor.GetProducerUsage();
|
||||
gralloc1_consumer_usage_t cons_usage = descriptor.GetConsumerUsage();
|
||||
|
||||
// Currently surface padding is only computed for RGB* surfaces.
|
||||
bool ubwc_enabled = IsUBwcEnabled(format, prod_usage, cons_usage);
|
||||
int tile = ubwc_enabled || IsMacroTileEnabled(format, prod_usage, cons_usage);
|
||||
|
||||
if (IsUncompressedRGBFormat(format)) {
|
||||
adreno_helper_->AlignUnCompressedRGB(width, height, format, tile, alignedw, alignedh);
|
||||
return;
|
||||
}
|
||||
|
||||
if (ubwc_enabled) {
|
||||
GetYuvUBwcWidthAndHeight(width, height, format, alignedw, alignedh);
|
||||
return;
|
||||
}
|
||||
|
||||
if (IsCompressedRGBFormat(format)) {
|
||||
adreno_helper_->AlignCompressedRGB(width, height, format, alignedw, alignedh);
|
||||
return;
|
||||
}
|
||||
|
||||
int aligned_w = width;
|
||||
int aligned_h = height;
|
||||
unsigned int alignment = 32;
|
||||
|
||||
// Below should be only YUV family
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_YCrCb_420_SP:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP:
|
||||
alignment = adreno_helper_->GetGpuPixelAlignment();
|
||||
aligned_w = ALIGN(width, alignment);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
|
||||
aligned_w = ALIGN(width, alignment);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RAW16:
|
||||
aligned_w = ALIGN(width, 16);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RAW10:
|
||||
aligned_w = ALIGN(width * 10 / 8, 16);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:
|
||||
aligned_w = ALIGN(width, 128);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YV12:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_422_SP:
|
||||
case HAL_PIXEL_FORMAT_YCrCb_422_SP:
|
||||
case HAL_PIXEL_FORMAT_YCbCr_422_I:
|
||||
case HAL_PIXEL_FORMAT_YCrCb_422_I:
|
||||
aligned_w = ALIGN(width, 16);
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
|
||||
case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
|
||||
aligned_w = INT(VENUS_Y_STRIDE(COLOR_FMT_NV12, width));
|
||||
aligned_h = INT(VENUS_Y_SCANLINES(COLOR_FMT_NV12, height));
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
|
||||
aligned_w = INT(VENUS_Y_STRIDE(COLOR_FMT_NV21, width));
|
||||
aligned_h = INT(VENUS_Y_SCANLINES(COLOR_FMT_NV21, height));
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_BLOB:
|
||||
case HAL_PIXEL_FORMAT_RAW_OPAQUE:
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_NV21_ZSL:
|
||||
aligned_w = ALIGN(width, 64);
|
||||
aligned_h = ALIGN(height, 64);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
*alignedw = (unsigned int)aligned_w;
|
||||
*alignedh = (unsigned int)aligned_h;
|
||||
}
|
||||
|
||||
} // namespace gralloc1
|
|
@ -0,0 +1,103 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __GR_ALLOCATOR_H__
|
||||
#define __GR_ALLOCATOR_H__
|
||||
|
||||
#ifdef MASTER_SIDE_CP
|
||||
#define SECURE_ALIGN SZ_4K
|
||||
#else
|
||||
#define SECURE_ALIGN SZ_1M
|
||||
#endif
|
||||
|
||||
#include "gralloc_priv.h"
|
||||
#include "gr_buf_descriptor.h"
|
||||
#include "gr_adreno_info.h"
|
||||
#include "gr_ion_alloc.h"
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
class Allocator {
|
||||
public:
|
||||
Allocator();
|
||||
~Allocator();
|
||||
bool Init();
|
||||
int AllocateBuffer(const BufferDescriptor &descriptor, private_handle_t **pHnd);
|
||||
int MapBuffer(void **base, unsigned int size, unsigned int offset, int fd);
|
||||
int FreeBuffer(void *base, unsigned int size, unsigned int offset, int fd);
|
||||
int CleanBuffer(void *base, unsigned int size, unsigned int offset, int fd, int op);
|
||||
int AllocateMem(AllocData *data, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage);
|
||||
bool IsMacroTileEnabled(int format, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage);
|
||||
// @return : index of the descriptor with maximum buffer size req
|
||||
bool CheckForBufferSharing(uint32_t num_descriptors, const BufferDescriptor *descriptors,
|
||||
int *max_index);
|
||||
int GetImplDefinedFormat(gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage, int format);
|
||||
unsigned int GetSize(const BufferDescriptor &d, unsigned int alignedw, unsigned int alignedh);
|
||||
void GetBufferSizeAndDimensions(const BufferDescriptor &d, unsigned int *size,
|
||||
unsigned int *alignedw, unsigned int *alignedh);
|
||||
void GetBufferSizeAndDimensions(int width, int height, int format, unsigned int *size,
|
||||
unsigned int *alignedw, unsigned int *alignedh);
|
||||
void GetAlignedWidthAndHeight(const BufferDescriptor &d, unsigned int *aligned_w,
|
||||
unsigned int *aligned_h);
|
||||
void GetBufferAttributes(const BufferDescriptor &d, unsigned int *alignedw,
|
||||
unsigned int *alignedh, int *tiled, unsigned int *size);
|
||||
int GetYUVPlaneInfo(const private_handle_t *hnd, struct android_ycbcr *ycbcr);
|
||||
int GetRgbDataAddress(private_handle_t *hnd, void **rgb_data);
|
||||
bool UseUncached(gralloc1_producer_usage_t usage);
|
||||
bool IsUBwcFormat(int format);
|
||||
bool IsUBwcSupported(int format);
|
||||
bool IsUBwcEnabled(int format, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage);
|
||||
|
||||
private:
|
||||
void GetYuvUBwcWidthAndHeight(int width, int height, int format, unsigned int *aligned_w,
|
||||
unsigned int *aligned_h);
|
||||
void GetYuvSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height, uint32_t bpp,
|
||||
struct android_ycbcr *ycbcr);
|
||||
void GetYuvUbwcSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height, int color_format,
|
||||
struct android_ycbcr *ycbcr);
|
||||
void GetRgbUBwcBlockSize(uint32_t bpp, int *block_width, int *block_height);
|
||||
unsigned int GetRgbUBwcMetaBufferSize(int width, int height, uint32_t bpp);
|
||||
unsigned int GetUBwcSize(int width, int height, int format, unsigned int alignedw,
|
||||
unsigned int alignedh);
|
||||
void GetIonHeapInfo(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage,
|
||||
unsigned int *ion_heap_id, unsigned int *alloc_type, unsigned int *ion_flags);
|
||||
|
||||
bool gpu_support_macrotile = false;
|
||||
bool display_support_macrotile = false;
|
||||
IonAlloc *ion_allocator_ = NULL;
|
||||
AdrenoMemInfo *adreno_helper_ = NULL;
|
||||
};
|
||||
|
||||
} // namespace gralloc1
|
||||
|
||||
#endif // __GR_ALLOCATOR_H__
|
|
@ -0,0 +1,90 @@
|
|||
/*
|
||||
* Copyright (c) 2016, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __GR_BUF_DESCRIPTOR_H__
|
||||
#define __GR_BUF_DESCRIPTOR_H__
|
||||
|
||||
#include <hardware/gralloc1.h>
|
||||
|
||||
#define BUF_DESCRIPTOR(exp) reinterpret_cast<BufferDescriptor *>(exp)
|
||||
|
||||
class BufferDescriptor {
|
||||
public:
|
||||
BufferDescriptor() {}
|
||||
|
||||
BufferDescriptor(int w, int h, int f)
|
||||
: width_(w),
|
||||
height_(h),
|
||||
format_(f),
|
||||
producer_usage_(GRALLOC1_PRODUCER_USAGE_NONE),
|
||||
consumer_usage_(GRALLOC1_CONSUMER_USAGE_NONE) {}
|
||||
|
||||
BufferDescriptor(int w, int h, int f, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage)
|
||||
: width_(w),
|
||||
height_(h),
|
||||
format_(f),
|
||||
producer_usage_(prod_usage),
|
||||
consumer_usage_(cons_usage) {}
|
||||
|
||||
bool IsValid() { return (magic == kMagic); }
|
||||
|
||||
void SetConsumerUsage(gralloc1_consumer_usage_t usage) { consumer_usage_ = usage; }
|
||||
|
||||
void SetProducerUsage(gralloc1_producer_usage_t usage) { producer_usage_ = usage; }
|
||||
|
||||
void SetDimensions(int w, int h) {
|
||||
width_ = w;
|
||||
height_ = h;
|
||||
}
|
||||
|
||||
void SetColorFormat(int format) { format_ = format; }
|
||||
|
||||
gralloc1_consumer_usage_t GetConsumerUsage() const { return consumer_usage_; }
|
||||
|
||||
gralloc1_producer_usage_t GetProducerUsage() const { return producer_usage_; }
|
||||
|
||||
int GetWidth() const { return width_; }
|
||||
|
||||
int GetHeight() const { return height_; }
|
||||
|
||||
int GetFormat() const { return format_; }
|
||||
|
||||
private:
|
||||
static const int kMagic = 'gr1d';
|
||||
|
||||
int magic = kMagic;
|
||||
int width_ = -1;
|
||||
int height_ = -1;
|
||||
int format_ = -1;
|
||||
gralloc1_producer_usage_t producer_usage_ = GRALLOC1_PRODUCER_USAGE_NONE;
|
||||
gralloc1_consumer_usage_t consumer_usage_ = GRALLOC1_CONSUMER_USAGE_NONE;
|
||||
};
|
||||
|
||||
#endif // __GR_BUF_DESCRIPTOR_H__
|
|
@ -0,0 +1,641 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016 The Linux Foundation. All rights reserved.
|
||||
* Not a Contribution
|
||||
*
|
||||
* Copyright (C) 2010 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include <utility>
|
||||
|
||||
#include "qd_utils.h"
|
||||
#include "gr_priv_handle.h"
|
||||
#include "gr_buf_descriptor.h"
|
||||
#include "gr_utils.h"
|
||||
#include "gr_buf_mgr.h"
|
||||
#include "qdMetaData.h"
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
BufferManager::BufferManager() {
|
||||
char property[PROPERTY_VALUE_MAX];
|
||||
|
||||
// Map framebuffer memory
|
||||
if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
|
||||
(!strncmp(property, "1", PROPERTY_VALUE_MAX) ||
|
||||
(!strncasecmp(property, "true", PROPERTY_VALUE_MAX)))) {
|
||||
map_fb_mem_ = true;
|
||||
}
|
||||
|
||||
// Enable UBWC for framebuffer
|
||||
if ((property_get("debug.gralloc.enable_fb_ubwc", property, NULL) > 0) &&
|
||||
(!strncmp(property, "1", PROPERTY_VALUE_MAX) ||
|
||||
(!strncasecmp(property, "true", PROPERTY_VALUE_MAX)))) {
|
||||
ubwc_for_fb_ = true;
|
||||
}
|
||||
|
||||
handles_map_.clear();
|
||||
}
|
||||
|
||||
BufferManager::~BufferManager() {
|
||||
if (allocator_) {
|
||||
delete allocator_;
|
||||
}
|
||||
}
|
||||
|
||||
bool BufferManager::Init() {
|
||||
allocator_ = new Allocator();
|
||||
|
||||
return allocator_->Init();
|
||||
}
|
||||
|
||||
gralloc1_error_t BufferManager::AllocateBuffers(uint32_t num_descriptors,
|
||||
const BufferDescriptor *descriptors,
|
||||
buffer_handle_t *out_buffers) {
|
||||
bool shared = true;
|
||||
gralloc1_error_t status = GRALLOC1_ERROR_NONE;
|
||||
|
||||
// since GRALLOC1_CAPABILITY_TEST_ALLOCATE capability is supported
|
||||
// client can ask to test the allocation by passing NULL out_buffers
|
||||
bool test_allocate = !out_buffers;
|
||||
|
||||
// Check if input descriptors can be supported AND
|
||||
// Find out if a single buffer can be shared for all the given input descriptors
|
||||
uint32_t i = 0;
|
||||
int max_buf_index = -1;
|
||||
shared = allocator_->CheckForBufferSharing(num_descriptors, descriptors, &max_buf_index);
|
||||
|
||||
if (test_allocate) {
|
||||
status = shared ? GRALLOC1_ERROR_NOT_SHARED : status;
|
||||
return status;
|
||||
}
|
||||
|
||||
if (shared && (max_buf_index >= 0)) {
|
||||
// Allocate one and duplicate/copy the handles for each descriptor
|
||||
if (AllocateBuffer(descriptors[max_buf_index], &out_buffers[max_buf_index])) {
|
||||
return GRALLOC1_ERROR_NO_RESOURCES;
|
||||
}
|
||||
|
||||
for (i = 0; i < num_descriptors; i++) {
|
||||
// Create new handle for a given descriptor.
|
||||
// Current assumption is even MetaData memory would be same
|
||||
// Need to revisit if there is a need for own metadata memory
|
||||
if (i != UINT(max_buf_index)) {
|
||||
CreateSharedHandle(out_buffers[max_buf_index], descriptors[i], &out_buffers[i]);
|
||||
|
||||
// since we just created handle out of existing handle add it to map
|
||||
locker_.lock();
|
||||
handles_map_.insert(std::pair<private_handle_t const *, int>(
|
||||
reinterpret_cast<private_handle_t const *>(out_buffers[i]), 1));
|
||||
locker_.unlock();
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Buffer sharing is not feasible.
|
||||
// Allocate seperate buffer for each descriptor
|
||||
for (i = 0; i < num_descriptors; i++) {
|
||||
if (AllocateBuffer(descriptors[i], &out_buffers[i])) {
|
||||
return GRALLOC1_ERROR_NO_RESOURCES;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Allocation is successful. If backstore is not shared inform the client.
|
||||
if (!shared) {
|
||||
return GRALLOC1_ERROR_NOT_SHARED;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
void BufferManager::CreateSharedHandle(buffer_handle_t inbuffer, const BufferDescriptor &descriptor,
|
||||
buffer_handle_t *outbuffer) {
|
||||
private_handle_t const *input = reinterpret_cast<private_handle_t const *>(inbuffer);
|
||||
|
||||
// Get Buffer attributes or dimension
|
||||
unsigned int alignedw = 0, alignedh = 0;
|
||||
allocator_->GetAlignedWidthAndHeight(descriptor, &alignedw, &alignedh);
|
||||
|
||||
// create new handle from input reference handle and given descriptor
|
||||
int flags = GetHandleFlags(descriptor.GetFormat(), descriptor.GetProducerUsage(),
|
||||
descriptor.GetConsumerUsage());
|
||||
int buffer_type = GetBufferType(descriptor.GetFormat());
|
||||
|
||||
// Duplicate the fds
|
||||
private_handle_t *out_hnd = new private_handle_t(
|
||||
dup(input->fd), input->size, flags, buffer_type, descriptor.GetFormat(), INT(alignedw),
|
||||
INT(alignedh), dup(input->fd_metadata), input->offset_metadata, input->base_metadata,
|
||||
descriptor.GetWidth(), descriptor.GetHeight(), descriptor.GetProducerUsage(),
|
||||
descriptor.GetConsumerUsage());
|
||||
|
||||
*outbuffer = out_hnd;
|
||||
}
|
||||
|
||||
gralloc1_error_t BufferManager::FreeBuffer(private_handle_t const *hnd) {
|
||||
if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
|
||||
hnd->fd) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
|
||||
unsigned int meta_size = ALIGN((unsigned int)sizeof(MetaData_t), PAGE_SIZE);
|
||||
if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base_metadata), meta_size,
|
||||
hnd->offset_metadata, hnd->fd_metadata) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
|
||||
// delete handle also
|
||||
private_handle_t *handle = const_cast<private_handle_t *>(hnd);
|
||||
delete handle;
|
||||
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t BufferManager::MapBuffer(private_handle_t const *handle) {
|
||||
private_handle_t *hnd = const_cast<private_handle_t *>(handle);
|
||||
|
||||
hnd->base = 0;
|
||||
hnd->base_metadata = 0;
|
||||
if (allocator_->MapBuffer(reinterpret_cast<void **>(&hnd->base), hnd->size, hnd->offset,
|
||||
hnd->fd) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
|
||||
unsigned int size = ALIGN((unsigned int)sizeof(MetaData_t), PAGE_SIZE);
|
||||
if (allocator_->MapBuffer(reinterpret_cast<void **>(&hnd->base_metadata), size,
|
||||
hnd->offset_metadata, hnd->fd_metadata) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t BufferManager::RetainBuffer(private_handle_t const *hnd) {
|
||||
locker_.lock();
|
||||
|
||||
// find if this handle is already in map
|
||||
auto it = handles_map_.find(hnd);
|
||||
if (it != handles_map_.end()) {
|
||||
// It's already in map, Just increment refcnt
|
||||
// No need to mmap the memory.
|
||||
it->second = it->second + 1;
|
||||
} else {
|
||||
// not present in the map. mmap and then add entry to map
|
||||
if (MapBuffer(hnd) == GRALLOC1_ERROR_NONE) {
|
||||
handles_map_.insert(std::pair<private_handle_t const *, int>(hnd, 1));
|
||||
}
|
||||
}
|
||||
|
||||
locker_.unlock();
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t BufferManager::ReleaseBuffer(private_handle_t const *hnd) {
|
||||
locker_.lock();
|
||||
|
||||
// find if this handle is already in map
|
||||
auto it = handles_map_.find(hnd);
|
||||
if (it == handles_map_.end()) {
|
||||
// Corrupt handle or map.
|
||||
locker_.unlock();
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
} else {
|
||||
it->second = it->second - 1;
|
||||
}
|
||||
|
||||
if (!it->second) {
|
||||
handles_map_.erase(it);
|
||||
FreeBuffer(hnd);
|
||||
}
|
||||
|
||||
locker_.unlock();
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t BufferManager::LockBuffer(const private_handle_t *hnd,
|
||||
gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage) {
|
||||
gralloc1_error_t err = GRALLOC1_ERROR_NONE;
|
||||
|
||||
// If buffer is not meant for CPU return err
|
||||
if (!CpuCanAccess(prod_usage, cons_usage)) {
|
||||
return GRALLOC1_ERROR_BAD_VALUE;
|
||||
}
|
||||
|
||||
if (hnd->base == 0) {
|
||||
// we need to map for real
|
||||
locker_.lock();
|
||||
err = MapBuffer(hnd);
|
||||
locker_.unlock();
|
||||
}
|
||||
|
||||
// Invalidate if CPU reads in software and there are non-CPU
|
||||
// writers. No need to do this for the metadata buffer as it is
|
||||
// only read/written in software.
|
||||
if (!err && (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) &&
|
||||
(hnd->flags & private_handle_t::PRIV_FLAGS_CACHED)) {
|
||||
if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
|
||||
hnd->fd, CACHE_INVALIDATE)) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
}
|
||||
|
||||
// Mark the buffer to be flushed after CPU write.
|
||||
if (!err && CpuCanWrite(prod_usage)) {
|
||||
private_handle_t *handle = const_cast<private_handle_t *>(hnd);
|
||||
handle->flags |= private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
gralloc1_error_t BufferManager::UnlockBuffer(const private_handle_t *handle) {
|
||||
gralloc1_error_t status = GRALLOC1_ERROR_NONE;
|
||||
|
||||
locker_.lock();
|
||||
private_handle_t *hnd = const_cast<private_handle_t *>(handle);
|
||||
|
||||
if (hnd->flags & private_handle_t::PRIV_FLAGS_NEEDS_FLUSH) {
|
||||
if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
|
||||
hnd->fd, CACHE_CLEAN) != 0) {
|
||||
status = GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
hnd->flags &= ~private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
|
||||
}
|
||||
|
||||
locker_.unlock();
|
||||
return status;
|
||||
}
|
||||
|
||||
int BufferManager::GetDataAlignment(int format, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage) {
|
||||
int align = getpagesize();
|
||||
if (format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED) {
|
||||
align = 8192;
|
||||
}
|
||||
|
||||
if (prod_usage & GRALLOC1_PRODUCER_USAGE_PROTECTED) {
|
||||
if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY) {
|
||||
// The alignment here reflects qsee mmu V7L/V8L requirement
|
||||
align = SZ_2M;
|
||||
} else {
|
||||
align = SECURE_ALIGN;
|
||||
}
|
||||
}
|
||||
|
||||
return align;
|
||||
}
|
||||
|
||||
int BufferManager::GetHandleFlags(int format, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage) {
|
||||
int flags = 0;
|
||||
if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_EXTERNAL_ONLY) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_EXTERNAL_ONLY;
|
||||
}
|
||||
|
||||
if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_INTERNAL_ONLY) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_INTERNAL_ONLY;
|
||||
}
|
||||
|
||||
if (cons_usage & GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER;
|
||||
}
|
||||
|
||||
if (prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_CAMERA_WRITE;
|
||||
}
|
||||
|
||||
if (prod_usage & GRALLOC1_CONSUMER_USAGE_CAMERA) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_CAMERA_READ;
|
||||
}
|
||||
|
||||
if (cons_usage & GRALLOC1_CONSUMER_USAGE_HWCOMPOSER) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_HW_COMPOSER;
|
||||
}
|
||||
|
||||
if (prod_usage & GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_HW_TEXTURE;
|
||||
}
|
||||
|
||||
if (prod_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_SECURE_DISPLAY;
|
||||
}
|
||||
|
||||
if (allocator_->IsMacroTileEnabled(format, prod_usage, cons_usage)) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_TILE_RENDERED;
|
||||
}
|
||||
|
||||
if (allocator_->IsUBwcEnabled(format, prod_usage, cons_usage)) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
|
||||
}
|
||||
|
||||
if (prod_usage & (GRALLOC1_PRODUCER_USAGE_CPU_READ | GRALLOC1_PRODUCER_USAGE_CPU_WRITE)) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED;
|
||||
}
|
||||
|
||||
// TODO(user): is this correct???
|
||||
if ((cons_usage &
|
||||
(GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER | GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET)) ||
|
||||
(prod_usage & (GRALLOC1_PRODUCER_USAGE_CAMERA | GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET))) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_NON_CPU_WRITER;
|
||||
}
|
||||
|
||||
if (cons_usage & GRALLOC1_CONSUMER_USAGE_HWCOMPOSER) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_DISP_CONSUMER;
|
||||
}
|
||||
|
||||
if (!allocator_->UseUncached(prod_usage)) {
|
||||
flags |= private_handle_t::PRIV_FLAGS_CACHED;
|
||||
}
|
||||
|
||||
return flags;
|
||||
}
|
||||
|
||||
int BufferManager::AllocateBuffer(unsigned int size, int aligned_w, int aligned_h, int real_w,
|
||||
int real_h, int format, int bufferType,
|
||||
gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage, buffer_handle_t *handle) {
|
||||
int err = 0;
|
||||
int flags = 0;
|
||||
size = ALIGN(size, PAGE_SIZE);
|
||||
AllocData data;
|
||||
data.align = (unsigned int)GetDataAlignment(format, prod_usage, cons_usage);
|
||||
size = ALIGN(size, data.align);
|
||||
data.size = size;
|
||||
data.handle = (uintptr_t)handle;
|
||||
|
||||
// Allocate memory
|
||||
data.uncached = allocator_->UseUncached(prod_usage);
|
||||
err = allocator_->AllocateMem(&data, prod_usage, cons_usage);
|
||||
if (err) {
|
||||
ALOGE("gralloc failed to allocate err=%s", strerror(-err));
|
||||
*handle = 0;
|
||||
return err;
|
||||
}
|
||||
|
||||
// allocate memory for MetaData
|
||||
AllocData e_data;
|
||||
e_data.size = ALIGN((unsigned int)sizeof(MetaData_t), PAGE_SIZE);
|
||||
e_data.handle = data.handle;
|
||||
e_data.align = (unsigned int)getpagesize();
|
||||
|
||||
ColorSpace_t colorSpace = ITU_R_601;
|
||||
if (prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) {
|
||||
colorSpace = ITU_R_601_FR;
|
||||
}
|
||||
|
||||
err =
|
||||
allocator_->AllocateMem(&e_data, GRALLOC1_PRODUCER_USAGE_NONE, GRALLOC1_CONSUMER_USAGE_NONE);
|
||||
ALOGE_IF(err, "gralloc failed for e_daata error=%s", strerror(-err));
|
||||
|
||||
flags = GetHandleFlags(format, prod_usage, cons_usage);
|
||||
flags |= data.alloc_type;
|
||||
|
||||
// Create handle
|
||||
uint64_t eBaseAddr = (uint64_t)(e_data.base) + e_data.offset;
|
||||
private_handle_t *hnd = new private_handle_t(data.fd, size, flags, bufferType, format, aligned_w,
|
||||
aligned_h, e_data.fd, e_data.offset, eBaseAddr,
|
||||
real_w, real_h, prod_usage, cons_usage);
|
||||
|
||||
hnd->offset = data.offset;
|
||||
hnd->base = (uint64_t)(data.base) + data.offset;
|
||||
hnd->gpuaddr = 0;
|
||||
|
||||
setMetaData(hnd, UPDATE_COLOR_SPACE, reinterpret_cast<void *>(&colorSpace));
|
||||
|
||||
*handle = hnd;
|
||||
|
||||
// we have just allocated the buffer & mmapped. Add to map
|
||||
locker_.lock();
|
||||
handles_map_.insert(std::pair<private_handle_t const *, int>(hnd, 1));
|
||||
locker_.unlock();
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int BufferManager::GetBufferType(int inputFormat) {
|
||||
int buffer_type = BUFFER_TYPE_VIDEO;
|
||||
if (IsUncompressedRGBFormat(inputFormat)) {
|
||||
// RGB formats
|
||||
buffer_type = BUFFER_TYPE_UI;
|
||||
}
|
||||
|
||||
return buffer_type;
|
||||
}
|
||||
|
||||
int BufferManager::AllocateBuffer(const BufferDescriptor &descriptor, buffer_handle_t *handle,
|
||||
unsigned int bufferSize) {
|
||||
if (!handle)
|
||||
return -EINVAL;
|
||||
|
||||
int format = descriptor.GetFormat();
|
||||
gralloc1_producer_usage_t prod_usage = descriptor.GetProducerUsage();
|
||||
gralloc1_consumer_usage_t cons_usage = descriptor.GetConsumerUsage();
|
||||
|
||||
// Get implementation defined format
|
||||
int gralloc_format = allocator_->GetImplDefinedFormat(prod_usage, cons_usage, format);
|
||||
|
||||
bool use_fb_mem = false;
|
||||
if ((cons_usage & GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET) && map_fb_mem_) {
|
||||
use_fb_mem = true;
|
||||
}
|
||||
|
||||
if ((cons_usage & GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET) && ubwc_for_fb_) {
|
||||
prod_usage =
|
||||
(gralloc1_producer_usage_t)(prod_usage | GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC);
|
||||
}
|
||||
|
||||
unsigned int size;
|
||||
unsigned int alignedw, alignedh;
|
||||
int buffer_type = GetBufferType(gralloc_format);
|
||||
allocator_->GetBufferSizeAndDimensions(descriptor, &size, &alignedw, &alignedh);
|
||||
|
||||
size = (bufferSize >= size) ? bufferSize : size;
|
||||
|
||||
int err = 0;
|
||||
if (use_fb_mem) {
|
||||
// TODO(user): TBD Framebuffer specific implementation in a seperate file/class
|
||||
} else {
|
||||
err = AllocateBuffer(size, INT(alignedw), INT(alignedh), descriptor.GetWidth(),
|
||||
descriptor.GetHeight(), format, buffer_type, descriptor.GetProducerUsage(),
|
||||
descriptor.GetConsumerUsage(), handle);
|
||||
}
|
||||
|
||||
if (err < 0) {
|
||||
return err;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
gralloc1_error_t BufferManager::Perform(int operation, va_list args) {
|
||||
switch (operation) {
|
||||
case GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER: {
|
||||
int fd = va_arg(args, int);
|
||||
unsigned int size = va_arg(args, unsigned int);
|
||||
unsigned int offset = va_arg(args, unsigned int);
|
||||
void *base = va_arg(args, void *);
|
||||
int width = va_arg(args, int);
|
||||
int height = va_arg(args, int);
|
||||
int format = va_arg(args, int);
|
||||
|
||||
native_handle_t **handle = va_arg(args, native_handle_t **);
|
||||
private_handle_t *hnd = reinterpret_cast<private_handle_t *>(
|
||||
native_handle_create(private_handle_t::kNumFds, private_handle_t::NumInts()));
|
||||
if (hnd) {
|
||||
hnd->magic = private_handle_t::kMagic;
|
||||
hnd->fd = fd;
|
||||
hnd->flags = private_handle_t::PRIV_FLAGS_USES_ION;
|
||||
hnd->size = size;
|
||||
hnd->offset = offset;
|
||||
hnd->base = uint64_t(base) + offset;
|
||||
hnd->gpuaddr = 0;
|
||||
hnd->width = width;
|
||||
hnd->height = height;
|
||||
hnd->format = format;
|
||||
*handle = reinterpret_cast<native_handle_t *>(hnd);
|
||||
}
|
||||
} break;
|
||||
|
||||
case GRALLOC_MODULE_PERFORM_GET_STRIDE: {
|
||||
int width = va_arg(args, int);
|
||||
int format = va_arg(args, int);
|
||||
int *stride = va_arg(args, int *);
|
||||
unsigned int alignedw = 0, alignedh = 0;
|
||||
BufferDescriptor descriptor(width, width, format);
|
||||
allocator_->GetAlignedWidthAndHeight(descriptor, &alignedw, &alignedh);
|
||||
*stride = INT(alignedw);
|
||||
} break;
|
||||
|
||||
case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_FROM_HANDLE: {
|
||||
private_handle_t *hnd = va_arg(args, private_handle_t *);
|
||||
int *stride = va_arg(args, int *);
|
||||
if (private_handle_t::validate(hnd) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
|
||||
MetaData_t *metadata = reinterpret_cast<MetaData_t *>(hnd->base_metadata);
|
||||
if (metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
|
||||
*stride = metadata->bufferDim.sliceWidth;
|
||||
} else {
|
||||
*stride = hnd->width;
|
||||
}
|
||||
} break;
|
||||
|
||||
// TODO(user) : this alone should be sufficient, ask gfx to get rid of above
|
||||
case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_AND_HEIGHT_FROM_HANDLE: {
|
||||
private_handle_t *hnd = va_arg(args, private_handle_t *);
|
||||
int *stride = va_arg(args, int *);
|
||||
int *height = va_arg(args, int *);
|
||||
if (private_handle_t::validate(hnd) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
|
||||
MetaData_t *metadata = reinterpret_cast<MetaData_t *>(hnd->base_metadata);
|
||||
if (metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
|
||||
*stride = metadata->bufferDim.sliceWidth;
|
||||
*height = metadata->bufferDim.sliceHeight;
|
||||
} else {
|
||||
*stride = hnd->width;
|
||||
*height = hnd->height;
|
||||
}
|
||||
} break;
|
||||
|
||||
case GRALLOC_MODULE_PERFORM_GET_ATTRIBUTES: {
|
||||
// TODO(user): Usage is split now. take care of it from Gfx client.
|
||||
// see if we can directly expect descriptor from gfx client.
|
||||
int width = va_arg(args, int);
|
||||
int height = va_arg(args, int);
|
||||
int format = va_arg(args, int);
|
||||
uint64_t producer_usage = va_arg(args, uint64_t);
|
||||
uint64_t consumer_usage = va_arg(args, uint64_t);
|
||||
gralloc1_producer_usage_t prod_usage = static_cast<gralloc1_producer_usage_t>(producer_usage);
|
||||
gralloc1_consumer_usage_t cons_usage = static_cast<gralloc1_consumer_usage_t>(consumer_usage);
|
||||
|
||||
int *aligned_width = va_arg(args, int *);
|
||||
int *aligned_height = va_arg(args, int *);
|
||||
int *tile_enabled = va_arg(args, int *);
|
||||
unsigned int alignedw, alignedh;
|
||||
BufferDescriptor descriptor(width, height, format, prod_usage, cons_usage);
|
||||
*tile_enabled = allocator_->IsUBwcEnabled(format, prod_usage, cons_usage) ||
|
||||
allocator_->IsMacroTileEnabled(format, prod_usage, cons_usage);
|
||||
|
||||
allocator_->GetAlignedWidthAndHeight(descriptor, &alignedw, &alignedh);
|
||||
*aligned_width = INT(alignedw);
|
||||
*aligned_height = INT(alignedh);
|
||||
} break;
|
||||
|
||||
case GRALLOC_MODULE_PERFORM_GET_COLOR_SPACE_FROM_HANDLE: {
|
||||
private_handle_t *hnd = va_arg(args, private_handle_t *);
|
||||
int *color_space = va_arg(args, int *);
|
||||
if (private_handle_t::validate(hnd) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
MetaData_t *metadata = reinterpret_cast<MetaData_t *>(hnd->base_metadata);
|
||||
if (metadata && metadata->operation & UPDATE_COLOR_SPACE) {
|
||||
*color_space = metadata->colorSpace;
|
||||
}
|
||||
} break;
|
||||
case GRALLOC_MODULE_PERFORM_GET_YUV_PLANE_INFO: {
|
||||
private_handle_t *hnd = va_arg(args, private_handle_t *);
|
||||
android_ycbcr *ycbcr = va_arg(args, struct android_ycbcr *);
|
||||
if (private_handle_t::validate(hnd) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
if (allocator_->GetYUVPlaneInfo(hnd, ycbcr)) {
|
||||
return GRALLOC1_ERROR_UNDEFINED;
|
||||
}
|
||||
} break;
|
||||
|
||||
case GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO: {
|
||||
private_handle_t *hnd = va_arg(args, private_handle_t *);
|
||||
int *map_secure_buffer = va_arg(args, int *);
|
||||
if (private_handle_t::validate(hnd) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
MetaData_t *metadata = reinterpret_cast<MetaData_t *>(hnd->base_metadata);
|
||||
if (metadata && metadata->operation & MAP_SECURE_BUFFER) {
|
||||
*map_secure_buffer = metadata->mapSecureBuffer;
|
||||
} else {
|
||||
*map_secure_buffer = 0;
|
||||
}
|
||||
} break;
|
||||
|
||||
case GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG: {
|
||||
private_handle_t *hnd = va_arg(args, private_handle_t *);
|
||||
int *flag = va_arg(args, int *);
|
||||
if (private_handle_t::validate(hnd) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
*flag = hnd->flags &private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
|
||||
} break;
|
||||
|
||||
case GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS: {
|
||||
private_handle_t *hnd = va_arg(args, private_handle_t *);
|
||||
void **rgb_data = va_arg(args, void **);
|
||||
if (private_handle_t::validate(hnd) != 0) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
if (allocator_->GetRgbDataAddress(hnd, rgb_data)) {
|
||||
return GRALLOC1_ERROR_UNDEFINED;
|
||||
}
|
||||
} break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
} // namespace gralloc1
|
|
@ -0,0 +1,71 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
|
||||
* Not a Contribution
|
||||
*
|
||||
* Copyright (C) 2008 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef __GR_BUF_MGR_H__
|
||||
#define __GR_BUF_MGR_H__
|
||||
|
||||
#include <pthread.h>
|
||||
#include <unordered_map>
|
||||
#include <mutex>
|
||||
|
||||
#include "gralloc_priv.h"
|
||||
#include "gr_allocator.h"
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
class BufferManager {
|
||||
public:
|
||||
BufferManager();
|
||||
~BufferManager();
|
||||
bool Init();
|
||||
gralloc1_error_t AllocateBuffers(uint32_t numDescriptors, const BufferDescriptor *descriptors,
|
||||
buffer_handle_t *outBuffers);
|
||||
gralloc1_error_t RetainBuffer(private_handle_t const *hnd);
|
||||
gralloc1_error_t ReleaseBuffer(private_handle_t const *hnd);
|
||||
gralloc1_error_t LockBuffer(const private_handle_t *hnd, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage);
|
||||
gralloc1_error_t UnlockBuffer(const private_handle_t *hnd);
|
||||
gralloc1_error_t Perform(int operation, va_list args);
|
||||
|
||||
private:
|
||||
gralloc1_error_t MapBuffer(private_handle_t const *hnd);
|
||||
gralloc1_error_t FreeBuffer(private_handle_t const *hnd);
|
||||
int GetBufferType(int format);
|
||||
int AllocateBuffer(const BufferDescriptor &descriptor, buffer_handle_t *handle,
|
||||
unsigned int bufferSize = 0);
|
||||
int AllocateBuffer(unsigned int size, int aligned_w, int aligned_h, int real_w, int real_h,
|
||||
int format, int bufferType, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage, buffer_handle_t *handle);
|
||||
int GetDataAlignment(int format, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage);
|
||||
int GetHandleFlags(int format, gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage);
|
||||
void CreateSharedHandle(buffer_handle_t inbuffer, const BufferDescriptor &descriptor,
|
||||
buffer_handle_t *out_buffer);
|
||||
|
||||
bool map_fb_mem_ = false;
|
||||
bool ubwc_for_fb_ = false;
|
||||
Allocator *allocator_ = NULL;
|
||||
std::mutex locker_;
|
||||
std::unordered_map<private_handle_t const *, int> handles_map_ = {};
|
||||
};
|
||||
|
||||
} // namespace gralloc1
|
||||
|
||||
#endif // __GR_BUF_MGR_H__
|
|
@ -0,0 +1,458 @@
|
|||
/*
|
||||
* Copyright (c) 2016, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <cutils/log.h>
|
||||
#include <sync/sync.h>
|
||||
|
||||
#include "gr_device_impl.h"
|
||||
#include "gr_buf_descriptor.h"
|
||||
#include "gralloc_priv.h"
|
||||
#include "qd_utils.h"
|
||||
#include "qdMetaData.h"
|
||||
#include "gr_utils.h"
|
||||
|
||||
int gralloc_device_open(const struct hw_module_t *module, const char *name, hw_device_t **device);
|
||||
|
||||
int gralloc_device_close(struct hw_device_t *device);
|
||||
|
||||
static struct hw_module_methods_t gralloc_module_methods = {.open = gralloc_device_open};
|
||||
|
||||
struct hw_module_t gralloc_module = {};
|
||||
|
||||
struct private_module_t HAL_MODULE_INFO_SYM = {
|
||||
.base = {
|
||||
.tag = HARDWARE_MODULE_TAG,
|
||||
.version_major = 1,
|
||||
.version_minor = 0,
|
||||
.id = GRALLOC_HARDWARE_MODULE_ID,
|
||||
.name = "Graphics Memory Module",
|
||||
.author = "Code Aurora Forum",
|
||||
.methods = &gralloc_module_methods,
|
||||
.dso = 0,
|
||||
.reserved = {0},
|
||||
},
|
||||
};
|
||||
|
||||
int gralloc_device_open(const struct hw_module_t *module, const char *name, hw_device_t **device) {
|
||||
int status = -EINVAL;
|
||||
if (!strcmp(name, GRALLOC_HARDWARE_MODULE_ID)) {
|
||||
const private_module_t *m = reinterpret_cast<const private_module_t *>(module);
|
||||
gralloc1::GrallocImpl * /*gralloc1_device_t*/ dev = new gralloc1::GrallocImpl(m);
|
||||
*device = reinterpret_cast<hw_device_t *>(dev);
|
||||
|
||||
if (dev->Init()) {
|
||||
status = 0;
|
||||
} else {
|
||||
ALOGE(" Error in opening gralloc1 device");
|
||||
return status;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
GrallocImpl::GrallocImpl(const private_module_t *module) {
|
||||
common.tag = HARDWARE_DEVICE_TAG;
|
||||
common.version = 1; // TODO(user): cross check version
|
||||
common.module = const_cast<hw_module_t *>(&module->base);
|
||||
common.close = CloseDevice;
|
||||
getFunction = GetFunction;
|
||||
getCapabilities = GetCapabilities;
|
||||
}
|
||||
|
||||
bool GrallocImpl::Init() {
|
||||
buf_mgr_ = new BufferManager();
|
||||
|
||||
return buf_mgr_->Init();
|
||||
}
|
||||
|
||||
GrallocImpl::~GrallocImpl() {
|
||||
if (buf_mgr_) {
|
||||
delete buf_mgr_;
|
||||
}
|
||||
}
|
||||
|
||||
int GrallocImpl::CloseDevice(hw_device_t *device) {
|
||||
GrallocImpl *impl = reinterpret_cast<GrallocImpl *>(device);
|
||||
delete impl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void GrallocImpl::GetCapabilities(struct gralloc1_device *device, uint32_t *out_count,
|
||||
int32_t /*gralloc1_capability_t*/ *out_capabilities) {
|
||||
if (!device) {
|
||||
// Need to plan for adding more capabilities
|
||||
if (out_capabilities == NULL) {
|
||||
*out_count = 1;
|
||||
} else {
|
||||
*out_capabilities = GRALLOC1_CAPABILITY_TEST_ALLOCATE;
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
gralloc1_function_pointer_t GrallocImpl::GetFunction(gralloc1_device_t *device, int32_t function) {
|
||||
if (!device) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
switch (function) {
|
||||
case GRALLOC1_FUNCTION_CREATE_DESCRIPTOR:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(CreateBufferDescriptor);
|
||||
case GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(DestroyBufferDescriptor);
|
||||
case GRALLOC1_FUNCTION_SET_CONSUMER_USAGE:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(SetConsumerUsage);
|
||||
case GRALLOC1_FUNCTION_SET_DIMENSIONS:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(SetBufferDimensions);
|
||||
case GRALLOC1_FUNCTION_SET_FORMAT:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(SetColorFormat);
|
||||
case GRALLOC1_FUNCTION_SET_PRODUCER_USAGE:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(SetProducerUsage);
|
||||
case GRALLOC1_FUNCTION_GET_BACKING_STORE:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(GetBackingStore);
|
||||
case GRALLOC1_FUNCTION_GET_CONSUMER_USAGE:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(GetConsumerUsage);
|
||||
case GRALLOC1_FUNCTION_GET_DIMENSIONS:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(GetBufferDimensions);
|
||||
case GRALLOC1_FUNCTION_GET_FORMAT:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(GetColorFormat);
|
||||
case GRALLOC1_FUNCTION_GET_PRODUCER_USAGE:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(GetProducerUsage);
|
||||
case GRALLOC1_FUNCTION_GET_STRIDE:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(GetBufferStride);
|
||||
case GRALLOC1_FUNCTION_ALLOCATE:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(AllocateBuffers);
|
||||
case GRALLOC1_FUNCTION_RETAIN:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(RetainBuffer);
|
||||
case GRALLOC1_FUNCTION_RELEASE:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(ReleaseBuffer);
|
||||
/* TODO(user) :definition of flex plane is not known yet
|
||||
* Need to implement after clarification from Google.
|
||||
* case GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t> (; */
|
||||
case GRALLOC1_FUNCTION_LOCK:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(LockBuffer);
|
||||
/* TODO(user) : LOCK_YCBCR changed to LOCK_FLEX but structure is not known yet.
|
||||
* Need to implement after clarification from Google.
|
||||
case GRALLOC1_PFN_LOCK_FLEX:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t> (LockYCbCrBuffer;
|
||||
*/
|
||||
case GRALLOC1_FUNCTION_UNLOCK:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(UnlockBuffer);
|
||||
case GRALLOC1_FUNCTION_PERFORM:
|
||||
return reinterpret_cast<gralloc1_function_pointer_t>(Gralloc1Perform);
|
||||
default:
|
||||
ALOGE("%s:Gralloc Error. Client Requested for unsupported function", __FUNCTION__);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::CheckDeviceAndDescriptor(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor) {
|
||||
if (!device || !BUF_DESCRIPTOR(descriptor)->IsValid()) {
|
||||
ALOGE("Gralloc Error : device=%p, descriptor=%p", (void *)device, (void *)descriptor);
|
||||
return GRALLOC1_ERROR_BAD_DESCRIPTOR;
|
||||
}
|
||||
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::CheckDeviceAndHandle(gralloc1_device_t *device,
|
||||
buffer_handle_t buffer) {
|
||||
const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
|
||||
if (!device || (private_handle_t::validate(hnd) != 0)) {
|
||||
ALOGE("Gralloc Error : device= %p, buffer-handle=%p", (void *)device, (void *)buffer);
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::CreateBufferDescriptor(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t *out_descriptor) {
|
||||
if (!device) {
|
||||
return GRALLOC1_ERROR_BAD_DESCRIPTOR;
|
||||
}
|
||||
|
||||
BufferDescriptor *descriptor = new BufferDescriptor();
|
||||
if (descriptor == NULL) {
|
||||
return GRALLOC1_ERROR_NO_RESOURCES;
|
||||
}
|
||||
|
||||
*out_descriptor = reinterpret_cast<gralloc1_buffer_descriptor_t>(descriptor);
|
||||
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::DestroyBufferDescriptor(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor) {
|
||||
gralloc1_error_t status = CheckDeviceAndDescriptor(device, descriptor);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
delete reinterpret_cast<BufferDescriptor *>(descriptor);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::SetConsumerUsage(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor,
|
||||
gralloc1_consumer_usage_t usage) {
|
||||
gralloc1_error_t status = CheckDeviceAndDescriptor(device, descriptor);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
BUF_DESCRIPTOR(descriptor)->SetConsumerUsage(usage);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::SetBufferDimensions(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor,
|
||||
uint32_t width, uint32_t height) {
|
||||
gralloc1_error_t status = CheckDeviceAndDescriptor(device, descriptor);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
BUF_DESCRIPTOR(descriptor)->SetDimensions(INT(width), INT(height));
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::SetColorFormat(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor,
|
||||
int32_t format) {
|
||||
gralloc1_error_t status = CheckDeviceAndDescriptor(device, descriptor);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
BUF_DESCRIPTOR(descriptor)->SetColorFormat(format);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::SetProducerUsage(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor,
|
||||
gralloc1_producer_usage_t usage) {
|
||||
gralloc1_error_t status = CheckDeviceAndDescriptor(device, descriptor);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
BUF_DESCRIPTOR(descriptor)->SetProducerUsage(usage);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::GetBackingStore(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
gralloc1_backing_store_t *out_backstore) {
|
||||
if (!device || !buffer) {
|
||||
return GRALLOC1_ERROR_BAD_HANDLE;
|
||||
}
|
||||
|
||||
*out_backstore =
|
||||
static_cast<gralloc1_backing_store_t>(PRIV_HANDLE_CONST(buffer)->GetBackingstore());
|
||||
|
||||
return GRALLOC1_ERROR_NONE;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::GetConsumerUsage(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
gralloc1_consumer_usage_t *outUsage) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
*outUsage = PRIV_HANDLE_CONST(buffer)->GetConsumerUsage();
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::GetBufferDimensions(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
uint32_t *outWidth, uint32_t *outHeight) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
|
||||
*outWidth = UINT(hnd->GetRealWidth());
|
||||
*outHeight = UINT(hnd->GetRealHeight());
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::GetColorFormat(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
int32_t *outFormat) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
*outFormat = PRIV_HANDLE_CONST(buffer)->GetColorFormat();
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::GetProducerUsage(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
gralloc1_producer_usage_t *outUsage) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
|
||||
*outUsage = hnd->GetProducerUsage();
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::GetBufferStride(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
uint32_t *outStride) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
*outStride = UINT(PRIV_HANDLE_CONST(buffer)->GetStride());
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::AllocateBuffers(gralloc1_device_t *device, uint32_t num_dptors,
|
||||
const gralloc1_buffer_descriptor_t *dptors,
|
||||
buffer_handle_t *outBuffers) {
|
||||
if (!num_dptors || !dptors) {
|
||||
return GRALLOC1_ERROR_BAD_DESCRIPTOR;
|
||||
}
|
||||
|
||||
GrallocImpl const *dev = GRALLOC_IMPL(device);
|
||||
const BufferDescriptor *descriptors = reinterpret_cast<const BufferDescriptor *>(dptors);
|
||||
gralloc1_error_t status = dev->buf_mgr_->AllocateBuffers(num_dptors, descriptors, outBuffers);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::RetainBuffer(gralloc1_device_t *device, buffer_handle_t buffer) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
|
||||
GrallocImpl const *dev = GRALLOC_IMPL(device);
|
||||
status = dev->buf_mgr_->RetainBuffer(hnd);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::ReleaseBuffer(gralloc1_device_t *device, buffer_handle_t buffer) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
|
||||
GrallocImpl const *dev = GRALLOC_IMPL(device);
|
||||
status = dev->buf_mgr_->ReleaseBuffer(hnd);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::LockBuffer(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage,
|
||||
const gralloc1_rect_t *region, void **out_data,
|
||||
int32_t acquire_fence) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
if (status == GRALLOC1_ERROR_NONE && (acquire_fence > 0)) {
|
||||
int error = sync_wait(acquire_fence, 1000);
|
||||
if (error < 0) {
|
||||
ALOGE("%s: sync_wait timedout! error = %s", __FUNCTION__, strerror(errno));
|
||||
return GRALLOC1_ERROR_UNDEFINED;
|
||||
}
|
||||
}
|
||||
|
||||
const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
|
||||
GrallocImpl const *dev = GRALLOC_IMPL(device);
|
||||
|
||||
// Either producer usage or consumer usage must be *_USAGE_NONE
|
||||
if ((prod_usage != GRALLOC1_PRODUCER_USAGE_NONE) &&
|
||||
(cons_usage != GRALLOC1_CONSUMER_USAGE_NONE)) {
|
||||
return GRALLOC1_ERROR_BAD_VALUE;
|
||||
}
|
||||
|
||||
// currently we ignore the region/rect client wants to lock
|
||||
if (region == NULL) {
|
||||
return GRALLOC1_ERROR_BAD_VALUE;
|
||||
}
|
||||
|
||||
status = dev->buf_mgr_->LockBuffer(hnd, prod_usage, cons_usage);
|
||||
|
||||
*out_data = reinterpret_cast<void *>(hnd->base);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/* TODO(user) : LOCK_YCBCR changed to LOCK_FLEX but structure definition is not known yet.
|
||||
* Need to implement after clarification from Google.
|
||||
gralloc1_error_t GrallocImpl::LockYCbCrBuffer(gralloc1_device_t* device, buffer_handle_t buffer,
|
||||
gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage,
|
||||
const gralloc1_rect_t* region, struct android_ycbcr* outYCbCr, int32_t* outAcquireFence) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
void **outData = 0;
|
||||
status = LockBuffer(device, buffer, prod_usage, cons_usage, region, outData, outAcquireFence);
|
||||
}
|
||||
|
||||
if (status == GRALLOC1_ERROR_NONE) {
|
||||
const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
|
||||
GrallocImpl const *dev = GRALLOC_IMPL(device);
|
||||
dev->allocator_->GetYUVPlaneInfo(hnd, outYCbCr);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
*/
|
||||
|
||||
gralloc1_error_t GrallocImpl::UnlockBuffer(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
int32_t *release_fence) {
|
||||
gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
|
||||
|
||||
if (status != GRALLOC1_ERROR_NONE) {
|
||||
return status;
|
||||
}
|
||||
|
||||
const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
|
||||
GrallocImpl const *dev = GRALLOC_IMPL(device);
|
||||
|
||||
*release_fence = -1;
|
||||
|
||||
return dev->buf_mgr_->UnlockBuffer(hnd);
|
||||
}
|
||||
|
||||
gralloc1_error_t GrallocImpl::Gralloc1Perform(gralloc1_device_t *device, int operation, ...) {
|
||||
va_list args;
|
||||
va_start(args, operation);
|
||||
GrallocImpl const *dev = GRALLOC_IMPL(device);
|
||||
gralloc1_error_t err = dev->buf_mgr_->Perform(operation, args);
|
||||
va_end(args);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
} // namespace gralloc1
|
|
@ -0,0 +1,121 @@
|
|||
/*
|
||||
* Copyright (c) 2016, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __GR_DEVICE_IMPL_H__
|
||||
#define __GR_DEVICE_IMPL_H__
|
||||
|
||||
#include <hardware/hardware.h>
|
||||
#include <hardware/gralloc1.h>
|
||||
#include "gr_buf_mgr.h"
|
||||
|
||||
struct private_module_t {
|
||||
hw_module_t base;
|
||||
};
|
||||
|
||||
#define GRALLOC_IMPL(exp) reinterpret_cast<GrallocImpl const *>(exp)
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
class GrallocImpl : public gralloc1_device_t {
|
||||
public:
|
||||
explicit GrallocImpl(const private_module_t *module);
|
||||
~GrallocImpl();
|
||||
bool Init();
|
||||
static int CloseDevice(hw_device_t *device);
|
||||
static void GetCapabilities(struct gralloc1_device *device, uint32_t *out_count,
|
||||
int32_t * /*gralloc1_capability_t*/ out_capabilities);
|
||||
static gralloc1_function_pointer_t GetFunction(
|
||||
struct gralloc1_device *device, int32_t /*gralloc1_function_descriptor_t*/ descriptor);
|
||||
|
||||
private:
|
||||
static inline gralloc1_error_t CheckDeviceAndDescriptor(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor);
|
||||
static inline gralloc1_error_t CheckDeviceAndHandle(gralloc1_device_t *device,
|
||||
buffer_handle_t buffer);
|
||||
static gralloc1_error_t CreateBufferDescriptor(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t *out_descriptor);
|
||||
static gralloc1_error_t DestroyBufferDescriptor(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor);
|
||||
static gralloc1_error_t SetConsumerUsage(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor,
|
||||
gralloc1_consumer_usage_t usage);
|
||||
static gralloc1_error_t SetBufferDimensions(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor,
|
||||
uint32_t width, uint32_t height);
|
||||
static gralloc1_error_t SetColorFormat(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor, int32_t format);
|
||||
static gralloc1_error_t SetProducerUsage(gralloc1_device_t *device,
|
||||
gralloc1_buffer_descriptor_t descriptor,
|
||||
gralloc1_producer_usage_t usage);
|
||||
static gralloc1_error_t GetBackingStore(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
gralloc1_backing_store_t *out_store);
|
||||
static gralloc1_error_t GetConsumerUsage(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
gralloc1_consumer_usage_t *out_usage);
|
||||
static gralloc1_error_t GetBufferDimensions(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
uint32_t *out_width, uint32_t *out_height);
|
||||
static gralloc1_error_t GetColorFormat(gralloc1_device_t *device, buffer_handle_t descriptor,
|
||||
int32_t *outFormat);
|
||||
static gralloc1_error_t GetProducerUsage(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
gralloc1_producer_usage_t *out_usage);
|
||||
static gralloc1_error_t GetBufferStride(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
uint32_t *out_stride);
|
||||
static gralloc1_error_t AllocateBuffers(gralloc1_device_t *device, uint32_t num_dptors,
|
||||
const gralloc1_buffer_descriptor_t *descriptors,
|
||||
buffer_handle_t *out_buffers);
|
||||
static gralloc1_error_t RetainBuffer(gralloc1_device_t *device, buffer_handle_t buffer);
|
||||
static gralloc1_error_t ReleaseBuffer(gralloc1_device_t *device, buffer_handle_t buffer);
|
||||
static gralloc1_error_t getNumFlexPlanes(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
uint32_t *out_num_planes);
|
||||
static gralloc1_error_t LockBuffer(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage,
|
||||
const gralloc1_rect_t *access_region, void **out_data,
|
||||
int32_t acquire_fence);
|
||||
static gralloc1_error_t LockFlex(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
gralloc1_producer_usage_t prod_usage,
|
||||
gralloc1_consumer_usage_t cons_usage,
|
||||
const gralloc1_rect_t *access_region,
|
||||
struct android_flex_layout *out_flex_layout,
|
||||
int32_t acquireFence);
|
||||
/* TODO(user) : LOCK_YCBCR changed to LOCK_FLEX but structure is not known yet.
|
||||
* Need to implement after clarification from Google.
|
||||
static gralloc1_error_t LockYCbCrBuffer(gralloc1_device_t* device, buffer_handle_t buffer,
|
||||
gralloc1_producer_usage_t producerUsage, gralloc1_consumer_usage_t consumerUsage,
|
||||
const gralloc1_rect_t* Region, struct android_ycbcr* outYCbCr, int32_t* outAcquireFence);
|
||||
*/
|
||||
static gralloc1_error_t UnlockBuffer(gralloc1_device_t *device, buffer_handle_t buffer,
|
||||
int32_t *release_fence);
|
||||
static gralloc1_error_t Gralloc1Perform(gralloc1_device_t *device, int operation, ...);
|
||||
|
||||
BufferManager *buf_mgr_ = NULL;
|
||||
};
|
||||
|
||||
} // namespace gralloc1
|
||||
|
||||
#endif // __GR_DEVICE_IMPL_H__
|
|
@ -0,0 +1,209 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#define DEBUG 0
|
||||
#define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/mman.h>
|
||||
#include <stdlib.h>
|
||||
#include <fcntl.h>
|
||||
#include <cutils/log.h>
|
||||
#include <errno.h>
|
||||
#include <utils/Trace.h>
|
||||
|
||||
#include "gralloc_priv.h"
|
||||
#include "gr_utils.h"
|
||||
#include "gr_ion_alloc.h"
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
bool IonAlloc::Init() {
|
||||
if (ion_dev_fd_ == FD_INIT) {
|
||||
ion_dev_fd_ = open(kIonDevice, O_RDONLY);
|
||||
}
|
||||
|
||||
if (ion_dev_fd_ < 0) {
|
||||
ALOGE("%s: Failed to open ion device - %s", __FUNCTION__, strerror(errno));
|
||||
ion_dev_fd_ = FD_INIT;
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void IonAlloc::CloseIonDevice() {
|
||||
if (ion_dev_fd_ > FD_INIT) {
|
||||
close(ion_dev_fd_);
|
||||
}
|
||||
|
||||
ion_dev_fd_ = FD_INIT;
|
||||
}
|
||||
|
||||
int IonAlloc::AllocBuffer(AllocData *data) {
|
||||
ATRACE_CALL();
|
||||
int err = 0;
|
||||
struct ion_handle_data handle_data;
|
||||
struct ion_fd_data fd_data;
|
||||
struct ion_allocation_data ion_alloc_data;
|
||||
void *base = NULL;
|
||||
|
||||
ion_alloc_data.len = data->size;
|
||||
ion_alloc_data.align = data->align;
|
||||
ion_alloc_data.heap_id_mask = data->heap_id;
|
||||
ion_alloc_data.flags = data->flags;
|
||||
ion_alloc_data.flags |= data->uncached ? 0 : ION_FLAG_CACHED;
|
||||
|
||||
if (ioctl(ion_dev_fd_, INT(ION_IOC_ALLOC), &ion_alloc_data)) {
|
||||
err = -errno;
|
||||
ALOGE("ION_IOC_ALLOC failed with error - %s", strerror(errno));
|
||||
return err;
|
||||
}
|
||||
|
||||
fd_data.handle = ion_alloc_data.handle;
|
||||
handle_data.handle = ion_alloc_data.handle;
|
||||
if (ioctl(ion_dev_fd_, INT(ION_IOC_MAP), &fd_data)) {
|
||||
err = -errno;
|
||||
ALOGE("%s: ION_IOC_MAP failed with error - %s", __FUNCTION__, strerror(errno));
|
||||
ioctl(ion_dev_fd_, INT(ION_IOC_FREE), &handle_data);
|
||||
return err;
|
||||
}
|
||||
|
||||
if (!(INT(data->flags) & INT(ION_SECURE))) {
|
||||
base = mmap(0, ion_alloc_data.len, PROT_READ | PROT_WRITE, MAP_SHARED, fd_data.fd, 0);
|
||||
if (base == MAP_FAILED) {
|
||||
err = -errno;
|
||||
ALOGE("%s: Failed to map the allocated memory: %s", __FUNCTION__, strerror(errno));
|
||||
ioctl(ion_dev_fd_, INT(ION_IOC_FREE), &handle_data);
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
data->base = base;
|
||||
data->fd = fd_data.fd;
|
||||
ioctl(ion_dev_fd_, INT(ION_IOC_FREE), &handle_data);
|
||||
ALOGD_IF(DEBUG, "ion: Allocated buffer base:%p size:%zu fd:%d", data->base, ion_alloc_data.len,
|
||||
data->fd);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int IonAlloc::FreeBuffer(void *base, unsigned int size, unsigned int offset, int fd) {
|
||||
ATRACE_CALL();
|
||||
int err = 0;
|
||||
ALOGD_IF(DEBUG, "ion: Freeing buffer base:%p size:%u fd:%d", base, size, fd);
|
||||
|
||||
if (base) {
|
||||
err = UnmapBuffer(base, size, offset);
|
||||
}
|
||||
close(fd);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int IonAlloc::MapBuffer(void **base, unsigned int size, unsigned int offset, int fd) {
|
||||
ATRACE_CALL();
|
||||
int err = 0;
|
||||
void *addr = 0;
|
||||
|
||||
// It is a (quirky) requirement of ION to have opened the
|
||||
// ion fd in the process that is doing the mapping
|
||||
addr = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
||||
*base = addr;
|
||||
if (addr == MAP_FAILED) {
|
||||
err = -errno;
|
||||
ALOGE("ion: Failed to map memory in the client: %s", strerror(errno));
|
||||
} else {
|
||||
ALOGD_IF(DEBUG, "ion: Mapped buffer base:%p size:%u offset:%u fd:%d", addr, size, offset, fd);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int IonAlloc::UnmapBuffer(void *base, unsigned int size, unsigned int /*offset*/) {
|
||||
ATRACE_CALL();
|
||||
ALOGD_IF(DEBUG, "ion: Unmapping buffer base:%p size:%u", base, size);
|
||||
|
||||
int err = 0;
|
||||
if (munmap(base, size)) {
|
||||
err = -errno;
|
||||
ALOGE("ion: Failed to unmap memory at %p : %s", base, strerror(errno));
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int IonAlloc::CleanBuffer(void *base, unsigned int size, unsigned int offset, int fd, int op) {
|
||||
ATRACE_CALL();
|
||||
ATRACE_INT("operation id", op);
|
||||
struct ion_flush_data flush_data;
|
||||
struct ion_fd_data fd_data;
|
||||
struct ion_handle_data handle_data;
|
||||
int err = 0;
|
||||
|
||||
fd_data.fd = fd;
|
||||
if (ioctl(ion_dev_fd_, INT(ION_IOC_IMPORT), &fd_data)) {
|
||||
err = -errno;
|
||||
ALOGE("%s: ION_IOC_IMPORT failed with error - %s", __FUNCTION__, strerror(errno));
|
||||
return err;
|
||||
}
|
||||
|
||||
handle_data.handle = fd_data.handle;
|
||||
flush_data.handle = fd_data.handle;
|
||||
flush_data.vaddr = base;
|
||||
// offset and length are unsigned int
|
||||
flush_data.offset = offset;
|
||||
flush_data.length = size;
|
||||
|
||||
struct ion_custom_data d;
|
||||
switch (op) {
|
||||
case CACHE_CLEAN:
|
||||
d.cmd = ION_IOC_CLEAN_CACHES;
|
||||
break;
|
||||
case CACHE_INVALIDATE:
|
||||
d.cmd = ION_IOC_INV_CACHES;
|
||||
break;
|
||||
case CACHE_CLEAN_AND_INVALIDATE:
|
||||
default:
|
||||
d.cmd = ION_IOC_CLEAN_INV_CACHES;
|
||||
}
|
||||
|
||||
d.arg = (unsigned long)(&flush_data); // NOLINT
|
||||
if (ioctl(ion_dev_fd_, INT(ION_IOC_CUSTOM), &d)) {
|
||||
err = -errno;
|
||||
ALOGE("%s: ION_IOC_CLEAN_INV_CACHES failed with error - %s", __FUNCTION__, strerror(errno));
|
||||
ioctl(ion_dev_fd_, INT(ION_IOC_FREE), &handle_data);
|
||||
return err;
|
||||
}
|
||||
|
||||
ioctl(ion_dev_fd_, INT(ION_IOC_FREE), &handle_data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
} // namespace gralloc1
|
|
@ -0,0 +1,82 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2015, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __GR_ION_ALLOC_H__
|
||||
#define __GR_ION_ALLOC_H__
|
||||
|
||||
#include <linux/msm_ion.h>
|
||||
|
||||
#define FD_INIT -1
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
enum {
|
||||
CACHE_CLEAN = 0x1,
|
||||
CACHE_INVALIDATE,
|
||||
CACHE_CLEAN_AND_INVALIDATE,
|
||||
};
|
||||
|
||||
struct AllocData {
|
||||
void *base = NULL;
|
||||
int fd = -1;
|
||||
unsigned int offset = 0;
|
||||
unsigned int size = 0;
|
||||
unsigned int align = 1;
|
||||
uintptr_t handle = 0;
|
||||
bool uncached = false;
|
||||
unsigned int flags = 0x0;
|
||||
unsigned int heap_id = 0x0;
|
||||
unsigned int alloc_type = 0x0;
|
||||
};
|
||||
|
||||
class IonAlloc {
|
||||
public:
|
||||
IonAlloc() { ion_dev_fd_ = FD_INIT; }
|
||||
|
||||
~IonAlloc() { CloseIonDevice(); }
|
||||
|
||||
bool Init();
|
||||
int AllocBuffer(AllocData *data);
|
||||
int FreeBuffer(void *base, unsigned int size, unsigned int offset, int fd);
|
||||
int MapBuffer(void **base, unsigned int size, unsigned int offset, int fd);
|
||||
int UnmapBuffer(void *base, unsigned int size, unsigned int offset);
|
||||
int CleanBuffer(void *base, unsigned int size, unsigned int offset, int fd, int op);
|
||||
|
||||
private:
|
||||
const char *kIonDevice = "/dev/ion";
|
||||
|
||||
int OpenIonDevice();
|
||||
void CloseIonDevice();
|
||||
|
||||
int ion_dev_fd_;
|
||||
};
|
||||
|
||||
} // namespace gralloc1
|
||||
|
||||
#endif // __GR_ION_ALLOC_H__
|
|
@ -0,0 +1,173 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
|
||||
* Not a Contribution
|
||||
*
|
||||
* Copyright (C) 2008 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef __GR_PRIV_HANDLE_H__
|
||||
#define __GR_PRIV_HANDLE_H__
|
||||
|
||||
#include <cutils/log.h>
|
||||
#include <hardware/gralloc1.h>
|
||||
|
||||
#define GRALLOC1_FUNCTION_PERFORM 0x00001000
|
||||
|
||||
#define DBG_HANDLE false
|
||||
|
||||
typedef gralloc1_error_t (*GRALLOC1_PFN_PERFORM)(gralloc1_device_t *device, int operation, ...);
|
||||
|
||||
typedef int BackStoreFd;
|
||||
|
||||
#define PRIV_HANDLE_CONST(exp) static_cast<const private_handle_t *>(exp)
|
||||
|
||||
struct private_handle_t : public native_handle_t {
|
||||
// TODO(user): Moving PRIV_FLAGS to #defs & check for each PRIV_FLAG and remove unused.
|
||||
enum {
|
||||
PRIV_FLAGS_FRAMEBUFFER = 0x00000001,
|
||||
PRIV_FLAGS_USES_ION = 0x00000008,
|
||||
PRIV_FLAGS_USES_ASHMEM = 0x00000010,
|
||||
PRIV_FLAGS_NEEDS_FLUSH = 0x00000020,
|
||||
PRIV_FLAGS_INTERNAL_ONLY = 0x00000040,
|
||||
PRIV_FLAGS_NON_CPU_WRITER = 0x00000080,
|
||||
PRIV_FLAGS_NONCONTIGUOUS_MEM = 0x00000100,
|
||||
PRIV_FLAGS_CACHED = 0x00000200,
|
||||
PRIV_FLAGS_SECURE_BUFFER = 0x00000400,
|
||||
PRIV_FLAGS_EXTERNAL_ONLY = 0x00002000,
|
||||
PRIV_FLAGS_PROTECTED_BUFFER = 0x00004000,
|
||||
PRIV_FLAGS_VIDEO_ENCODER = 0x00010000,
|
||||
PRIV_FLAGS_CAMERA_WRITE = 0x00020000,
|
||||
PRIV_FLAGS_CAMERA_READ = 0x00040000,
|
||||
PRIV_FLAGS_HW_COMPOSER = 0x00080000,
|
||||
PRIV_FLAGS_HW_TEXTURE = 0x00100000,
|
||||
PRIV_FLAGS_ITU_R_601 = 0x00200000, // Unused from display
|
||||
PRIV_FLAGS_ITU_R_601_FR = 0x00400000, // Unused from display
|
||||
PRIV_FLAGS_ITU_R_709 = 0x00800000, // Unused from display
|
||||
PRIV_FLAGS_SECURE_DISPLAY = 0x01000000,
|
||||
PRIV_FLAGS_TILE_RENDERED = 0x02000000,
|
||||
PRIV_FLAGS_CPU_RENDERED = 0x04000000,
|
||||
PRIV_FLAGS_UBWC_ALIGNED = 0x08000000,
|
||||
PRIV_FLAGS_DISP_CONSUMER = 0x10000000
|
||||
};
|
||||
|
||||
// file-descriptors
|
||||
int fd;
|
||||
int fd_metadata;
|
||||
|
||||
// ints
|
||||
int magic;
|
||||
int flags;
|
||||
unsigned int size;
|
||||
unsigned int offset;
|
||||
int buffer_type;
|
||||
uint64_t base __attribute__((aligned(8)));
|
||||
unsigned int offset_metadata;
|
||||
|
||||
// The gpu address mapped into the mmu.
|
||||
uint64_t gpuaddr __attribute__((aligned(8)));
|
||||
|
||||
int format;
|
||||
int width; // holds width of the actual buffer allocated
|
||||
int height; // holds height of the actual buffer allocated
|
||||
|
||||
int stride;
|
||||
uint64_t base_metadata __attribute__((aligned(8)));
|
||||
|
||||
// added for gralloc1
|
||||
int real_width; // holds width client asked to allocate
|
||||
int real_height; // holds height client asked to allocate// holds width client asked to allocate
|
||||
gralloc1_producer_usage_t producer_usage __attribute__((aligned(8)));
|
||||
gralloc1_consumer_usage_t consumer_usage __attribute__((aligned(8)));
|
||||
|
||||
static const int kNumFds = 2;
|
||||
static const int kMagic = 'gmsm';
|
||||
|
||||
static inline int NumInts() {
|
||||
return ((sizeof(private_handle_t) - sizeof(native_handle_t)) / sizeof(int)) - kNumFds;
|
||||
}
|
||||
|
||||
private_handle_t(int fd, unsigned int size, int flags, int buf_type, int format, int width,
|
||||
int height, int meta_fd = -1, unsigned int meta_offset = 0,
|
||||
uint64_t meta_base = 0, int rw = 0, int rh = 0,
|
||||
gralloc1_producer_usage_t prod_usage = GRALLOC1_PRODUCER_USAGE_NONE,
|
||||
gralloc1_consumer_usage_t cons_usage = GRALLOC1_CONSUMER_USAGE_NONE)
|
||||
: fd(fd),
|
||||
fd_metadata(meta_fd),
|
||||
magic(kMagic),
|
||||
flags(flags),
|
||||
size(size),
|
||||
offset(0),
|
||||
buffer_type(buf_type),
|
||||
base(0),
|
||||
offset_metadata(meta_offset),
|
||||
gpuaddr(0),
|
||||
format(format),
|
||||
width(width),
|
||||
height(height),
|
||||
base_metadata(meta_base),
|
||||
real_width(rw),
|
||||
real_height(rh),
|
||||
producer_usage(prod_usage),
|
||||
consumer_usage(cons_usage) {
|
||||
version = static_cast<int>(sizeof(native_handle));
|
||||
numInts = NumInts();
|
||||
numFds = kNumFds;
|
||||
}
|
||||
|
||||
~private_handle_t() {
|
||||
magic = 0;
|
||||
ALOGE_IF(DBG_HANDLE, "deleting buffer handle %p", this);
|
||||
}
|
||||
|
||||
static int validate(const native_handle *h) {
|
||||
const private_handle_t *hnd = (const private_handle_t *)h;
|
||||
if (!h || h->version != sizeof(native_handle) || h->numInts != NumInts() ||
|
||||
h->numFds != kNumFds || hnd->magic != kMagic) {
|
||||
ALOGE(
|
||||
"Invalid gralloc handle (at %p): ver(%d/%zu) ints(%d/%d) fds(%d/%d) "
|
||||
"magic(%c%c%c%c/%c%c%c%c)",
|
||||
h, h ? h->version : -1, sizeof(native_handle), h ? h->numInts : -1, NumInts(),
|
||||
h ? h->numFds : -1, kNumFds,
|
||||
hnd ? (((hnd->magic >> 24) & 0xFF) ? ((hnd->magic >> 24) & 0xFF) : '-') : '?',
|
||||
hnd ? (((hnd->magic >> 16) & 0xFF) ? ((hnd->magic >> 16) & 0xFF) : '-') : '?',
|
||||
hnd ? (((hnd->magic >> 8) & 0xFF) ? ((hnd->magic >> 8) & 0xFF) : '-') : '?',
|
||||
hnd ? (((hnd->magic >> 0) & 0xFF) ? ((hnd->magic >> 0) & 0xFF) : '-') : '?',
|
||||
(kMagic >> 24) & 0xFF, (kMagic >> 16) & 0xFF, (kMagic >> 8) & 0xFF, (kMagic >> 0) & 0xFF);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int GetRealWidth() const { return real_width; }
|
||||
|
||||
int GetRealHeight() const { return real_height; }
|
||||
|
||||
int GetColorFormat() const { return format; }
|
||||
|
||||
int GetStride() const {
|
||||
// In handle we are storing aligned width after allocation.
|
||||
// Why GetWidth & GetStride?? Are we supposed to maintain unaligned values??
|
||||
return width;
|
||||
}
|
||||
|
||||
gralloc1_consumer_usage_t GetConsumerUsage() const { return consumer_usage; }
|
||||
|
||||
gralloc1_producer_usage_t GetProducerUsage() const { return producer_usage; }
|
||||
|
||||
BackStoreFd GetBackingstore() const { return fd; }
|
||||
};
|
||||
|
||||
#endif // __GR_PRIV_HANDLE_H__
|
|
@ -0,0 +1,152 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include "gr_utils.h"
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
bool IsUncompressedRGBFormat(int format) {
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_RGBA_8888:
|
||||
case HAL_PIXEL_FORMAT_RGBX_8888:
|
||||
case HAL_PIXEL_FORMAT_RGB_888:
|
||||
case HAL_PIXEL_FORMAT_RGB_565:
|
||||
case HAL_PIXEL_FORMAT_BGR_565:
|
||||
case HAL_PIXEL_FORMAT_BGRA_8888:
|
||||
case HAL_PIXEL_FORMAT_RGBA_5551:
|
||||
case HAL_PIXEL_FORMAT_RGBA_4444:
|
||||
case HAL_PIXEL_FORMAT_R_8:
|
||||
case HAL_PIXEL_FORMAT_RG_88:
|
||||
case HAL_PIXEL_FORMAT_BGRX_8888:
|
||||
case HAL_PIXEL_FORMAT_RGBA_1010102:
|
||||
case HAL_PIXEL_FORMAT_ARGB_2101010:
|
||||
case HAL_PIXEL_FORMAT_RGBX_1010102:
|
||||
case HAL_PIXEL_FORMAT_XRGB_2101010:
|
||||
case HAL_PIXEL_FORMAT_BGRA_1010102:
|
||||
case HAL_PIXEL_FORMAT_ABGR_2101010:
|
||||
case HAL_PIXEL_FORMAT_BGRX_1010102:
|
||||
case HAL_PIXEL_FORMAT_XBGR_2101010:
|
||||
return true;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool IsCompressedRGBFormat(int format) {
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_4x4_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x4_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x5_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x5_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x6_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x5_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x6_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x8_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x5_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x6_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x8_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x10_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x10_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x12_KHR:
|
||||
case HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
|
||||
return true;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t GetBppForUncompressedRGB(int format) {
|
||||
uint32_t bpp = 0;
|
||||
switch (format) {
|
||||
case HAL_PIXEL_FORMAT_RGBA_8888:
|
||||
case HAL_PIXEL_FORMAT_RGBX_8888:
|
||||
case HAL_PIXEL_FORMAT_BGRA_8888:
|
||||
case HAL_PIXEL_FORMAT_BGRX_8888:
|
||||
bpp = 4;
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RGB_888:
|
||||
bpp = 3;
|
||||
break;
|
||||
case HAL_PIXEL_FORMAT_RGB_565:
|
||||
case HAL_PIXEL_FORMAT_BGR_565:
|
||||
case HAL_PIXEL_FORMAT_RGBA_5551:
|
||||
case HAL_PIXEL_FORMAT_RGBA_4444:
|
||||
bpp = 2;
|
||||
break;
|
||||
default:
|
||||
ALOGE("Error : %s New format request", __FUNCTION__);
|
||||
break;
|
||||
}
|
||||
|
||||
return bpp;
|
||||
}
|
||||
|
||||
bool CpuCanAccess(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage) {
|
||||
return CpuCanRead(prod_usage, cons_usage) || CpuCanWrite(prod_usage);
|
||||
}
|
||||
|
||||
bool CpuCanRead(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage) {
|
||||
if (prod_usage & GRALLOC1_PRODUCER_USAGE_CPU_READ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (cons_usage & GRALLOC1_CONSUMER_USAGE_CPU_READ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CpuCanWrite(gralloc1_producer_usage_t prod_usage) {
|
||||
if (prod_usage & GRALLOC1_PRODUCER_USAGE_CPU_WRITE) {
|
||||
// Application intends to use CPU for rendering
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
} // namespace gralloc1
|
|
@ -0,0 +1,61 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
|
||||
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
* met:
|
||||
* * Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* * Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the following
|
||||
* disclaimer in the documentation and/or other materials provided
|
||||
* with the distribution.
|
||||
* * Neither the name of The Linux Foundation nor the names of its
|
||||
* contributors may be used to endorse or promote products derived
|
||||
* from this software without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
|
||||
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
|
||||
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
|
||||
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
|
||||
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
|
||||
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef __GR_UTILS_H__
|
||||
#define __GR_UTILS_H__
|
||||
|
||||
#include "gralloc_priv.h"
|
||||
|
||||
#define SZ_2M 0x200000
|
||||
#define SZ_1M 0x100000
|
||||
#define SZ_4K 0x1000
|
||||
|
||||
#define SIZE_4K 4096
|
||||
#define SIZE_8K 4096
|
||||
|
||||
#define INT(exp) static_cast<int>(exp)
|
||||
#define UINT(exp) static_cast<unsigned int>(exp)
|
||||
|
||||
namespace gralloc1 {
|
||||
|
||||
template <class Type1, class Type2>
|
||||
inline Type1 ALIGN(Type1 x, Type2 align) {
|
||||
return (Type1)((x + (Type1)align - 1) & ~((Type1)align - 1));
|
||||
}
|
||||
|
||||
bool IsCompressedRGBFormat(int format);
|
||||
bool IsUncompressedRGBFormat(int format);
|
||||
uint32_t GetBppForUncompressedRGB(int format);
|
||||
bool CpuCanAccess(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage);
|
||||
bool CpuCanRead(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage);
|
||||
bool CpuCanWrite(gralloc1_producer_usage_t prod_usage);
|
||||
|
||||
} // namespace gralloc1
|
||||
|
||||
#endif // __GR_UTILS_H__
|
|
@ -0,0 +1,169 @@
|
|||
/*
|
||||
* Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
|
||||
* Not a Contribution
|
||||
*
|
||||
* Copyright (C) 2008 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef __GRALLOC_PRIV_H__
|
||||
#define __GRALLOC_PRIV_H__
|
||||
|
||||
#include "gr_priv_handle.h"
|
||||
|
||||
#define ROUND_UP_PAGESIZE(x) ((((unsigned int)(x)) + PAGE_SIZE - 1) & (~(PAGE_SIZE - 1)))
|
||||
|
||||
/* Gralloc usage bits indicating the type of allocation that should be used */
|
||||
/* Refer gralloc1_producer_usage_t & gralloc1_consumer_usage-t in gralloc1.h */
|
||||
|
||||
/* GRALLOC_USAGE_PRIVATE_0 is unused */
|
||||
|
||||
/* Non linear, Universal Bandwidth Compression */
|
||||
#define GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC GRALLOC1_PRODUCER_USAGE_PRIVATE_1
|
||||
|
||||
/* IOMMU heap comes from manually allocated pages, can be cached/uncached, is not secured */
|
||||
#define GRALLOC1_PRODUCER_USAGE_PRIVATE_IOMMU_HEAP GRALLOC1_PRODUCER_USAGE_PRIVATE_2
|
||||
|
||||
/* MM heap is a carveout heap for video, can be secured */
|
||||
#define GRALLOC1_PRODUCER_USAGE_PRIVATE_MM_HEAP GRALLOC1_PRODUCER_USAGE_PRIVATE_3
|
||||
|
||||
/* ADSP heap is a carveout heap, is not secured */
|
||||
#define GRALLOC1_PRODUCER_USAGE_PRIVATE_ADSP_HEAP GRALLOC1_PRODUCER_USAGE_PRIVATE_4
|
||||
|
||||
/* CAMERA heap is a carveout heap for camera, is not secured */
|
||||
#define GRALLOC1_PRODUCER_USAGE_PRIVATE_CAMERA_HEAP GRALLOC1_PRODUCER_USAGE_PRIVATE_5
|
||||
|
||||
/* Set this for allocating uncached memory (using O_DSYNC),
|
||||
* cannot be used with noncontiguous heaps */
|
||||
#define GRALLOC1_PRODUCER_USAGE_PRIVATE_UNCACHED GRALLOC1_PRODUCER_USAGE_PRIVATE_6
|
||||
|
||||
#define GRALLOC1_PRODUCER_USAGE_PRIVATE_CAMERA_ZSL GRALLOC1_PRODUCER_USAGE_PRIVATE_7
|
||||
|
||||
/* Buffer content should be displayed on a primary display only */
|
||||
#define GRALLOC1_CONSUMER_USAGE_PRIVATE_INTERNAL_ONLY GRALLOC1_CONSUMER_USAGE_PRIVATE_1
|
||||
|
||||
/* Buffer content should be displayed on an external display only */
|
||||
#define GRALLOC1_CONSUMER_USAGE_PRIVATE_EXTERNAL_ONLY GRALLOC1_CONSUMER_USAGE_PRIVATE_2
|
||||
|
||||
/* This flag is set for WFD usecase */
|
||||
#define GRALLOC1_CONSUMER_USAGE_PRIVATE_WFD GRALLOC1_CONSUMER_USAGE_PRIVATE_3
|
||||
|
||||
/* This flag is used for SECURE display usecase */
|
||||
#define GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY GRALLOC1_CONSUMER_USAGE_PRIVATE_4
|
||||
|
||||
// for PERFORM API :
|
||||
// TODO(user): Move it to enum if it's ookay for gfx
|
||||
#define GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER 1
|
||||
#define GRALLOC_MODULE_PERFORM_GET_STRIDE 2
|
||||
#define GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_FROM_HANDLE 3
|
||||
#define GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_AND_HEIGHT_FROM_HANDLE 4
|
||||
#define GRALLOC_MODULE_PERFORM_GET_ATTRIBUTES 5
|
||||
#define GRALLOC_MODULE_PERFORM_GET_COLOR_SPACE_FROM_HANDLE 6
|
||||
#define GRALLOC_MODULE_PERFORM_GET_YUV_PLANE_INFO 7
|
||||
#define GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO 8
|
||||
#define GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG 9
|
||||
#define GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS 10
|
||||
#define GRALLOC_MODULE_PERFORM_GET_IGC 11
|
||||
#define GRALLOC_MODULE_PERFORM_SET_IGC 12
|
||||
#define GRALLOC_MODULE_PERFORM_SET_SINGLE_BUFFER_MODE 13
|
||||
|
||||
// OEM specific HAL formats
|
||||
#define HAL_PIXEL_FORMAT_RGBA_5551 6
|
||||
#define HAL_PIXEL_FORMAT_RGBA_4444 7
|
||||
#define HAL_PIXEL_FORMAT_NV12_ENCODEABLE 0x102
|
||||
#define HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS 0x7FA30C04
|
||||
#define HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED 0x7FA30C03
|
||||
#define HAL_PIXEL_FORMAT_YCbCr_420_SP 0x109
|
||||
#define HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO 0x7FA30C01
|
||||
#define HAL_PIXEL_FORMAT_YCrCb_422_SP 0x10B
|
||||
#define HAL_PIXEL_FORMAT_R_8 0x10D
|
||||
#define HAL_PIXEL_FORMAT_RG_88 0x10E
|
||||
#define HAL_PIXEL_FORMAT_YCbCr_444_SP 0x10F
|
||||
#define HAL_PIXEL_FORMAT_YCrCb_444_SP 0x110
|
||||
#define HAL_PIXEL_FORMAT_YCrCb_422_I 0x111
|
||||
#define HAL_PIXEL_FORMAT_BGRX_8888 0x112
|
||||
#define HAL_PIXEL_FORMAT_NV21_ZSL 0x113
|
||||
#define HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS 0x114
|
||||
#define HAL_PIXEL_FORMAT_BGR_565 0x115
|
||||
|
||||
// 10 bit
|
||||
#define HAL_PIXEL_FORMAT_RGBA_1010102 0x116
|
||||
#define HAL_PIXEL_FORMAT_ARGB_2101010 0x117
|
||||
#define HAL_PIXEL_FORMAT_RGBX_1010102 0x118
|
||||
#define HAL_PIXEL_FORMAT_XRGB_2101010 0x119
|
||||
#define HAL_PIXEL_FORMAT_BGRA_1010102 0x11A
|
||||
#define HAL_PIXEL_FORMAT_ABGR_2101010 0x11B
|
||||
#define HAL_PIXEL_FORMAT_BGRX_1010102 0x11C
|
||||
#define HAL_PIXEL_FORMAT_XBGR_2101010 0x11D
|
||||
#define HAL_PIXEL_FORMAT_YCbCr_420_P010 0x11F
|
||||
#define HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC 0x120
|
||||
|
||||
#define HAL_PIXEL_FORMAT_INTERLACE 0x180
|
||||
|
||||
// v4l2_fourcc('Y', 'U', 'Y', 'L'). 24 bpp YUYV 4:2:2 10 bit per component
|
||||
#define HAL_PIXEL_FORMAT_YCbCr_422_I_10BIT 0x4C595559
|
||||
|
||||
// v4l2_fourcc('Y', 'B', 'W', 'C'). 10 bit per component. This compressed
|
||||
// format reduces the memory access bandwidth
|
||||
#define HAL_PIXEL_FORMAT_YCbCr_422_I_10BIT_COMPRESSED 0x43574259
|
||||
|
||||
// UBWC aligned Venus format
|
||||
#define HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC 0x7FA30C06
|
||||
|
||||
// Khronos ASTC formats
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93B0
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x4_KHR 0x93B1
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x5_KHR 0x93B2
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x5_KHR 0x93B3
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x6_KHR 0x93B4
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x5_KHR 0x93B5
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x6_KHR 0x93B6
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93B7
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x5_KHR 0x93B8
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x6_KHR 0x93B9
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x8_KHR 0x93BA
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR 0x93D3
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR 0x93D4
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR 0x93D5
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR 0x93D6
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR 0x93D7
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR 0x93D8
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR 0x93D9
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR 0x93DA
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC
|
||||
#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD
|
||||
|
||||
/* possible values for inverse gamma correction */
|
||||
#define HAL_IGC_NOT_SPECIFIED 0
|
||||
#define HAL_IGC_s_RGB 1
|
||||
|
||||
/* possible formats for 3D content*/
|
||||
enum {
|
||||
HAL_NO_3D = 0x0,
|
||||
HAL_3D_SIDE_BY_SIDE_L_R = 0x1,
|
||||
HAL_3D_SIDE_BY_SIDE_R_L = 0x2,
|
||||
HAL_3D_TOP_BOTTOM = 0x4,
|
||||
HAL_3D_IN_SIDE_BY_SIDE_L_R = 0x10000, // unused legacy format
|
||||
};
|
||||
|
||||
enum { BUFFER_TYPE_UI = 0, BUFFER_TYPE_VIDEO };
|
||||
|
||||
#endif // __GRALLOC_PRIV_H__
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2013-2014 The Linux Foundation. All rights reserved.
|
||||
* Copyright (c) 2013-2014, 2016, The Linux Foundation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
|
@ -253,6 +253,7 @@ DisplayAttributes getDisplayAttributes(int configIndex, int /*dpy*/) {
|
|||
dpyattr.xdpi = outParcel.readFloat();
|
||||
dpyattr.ydpi = outParcel.readFloat();
|
||||
dpyattr.panel_type = (char) outParcel.readInt32();
|
||||
dpyattr.is_yuv = outParcel.readInt32();
|
||||
ALOGI("%s() Received attrs for index %d: xres %d, yres %d",
|
||||
__FUNCTION__, configIndex, dpyattr.xres, dpyattr.yres);
|
||||
} else {
|
||||
|
|
|
@ -85,8 +85,9 @@ typedef struct DisplayAttributes {
|
|||
float xdpi;
|
||||
float ydpi;
|
||||
char panel_type;
|
||||
bool is_yuv;
|
||||
DisplayAttributes() : vsync_period(0), xres(0), yres(0), xdpi(0.0f),
|
||||
ydpi(0.0f), panel_type(0) {}
|
||||
ydpi(0.0f), panel_type(0), is_yuv(false) {}
|
||||
} DisplayAttributes_t;
|
||||
|
||||
//=============================================================================
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
|
||||
* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
|
@ -67,7 +67,7 @@ int setMetaData(private_handle_t *handle, DispParamType paramType,
|
|||
data->bufferDim = *((BufferDim_t *)param);
|
||||
break;
|
||||
case UPDATE_REFRESH_RATE:
|
||||
data->refreshrate = *((uint32_t *)param);
|
||||
data->refreshrate = *((float *)param);
|
||||
break;
|
||||
case UPDATE_COLOR_SPACE:
|
||||
data->colorSpace = *((ColorSpace_t *)param);
|
||||
|
@ -96,3 +96,106 @@ int setMetaData(private_handle_t *handle, DispParamType paramType,
|
|||
errno);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int getMetaData(private_handle_t *handle, DispFetchParamType paramType,
|
||||
void *param) {
|
||||
if (!handle) {
|
||||
ALOGE("%s: Private handle is null!", __func__);
|
||||
return -1;
|
||||
}
|
||||
if (handle->fd_metadata == -1) {
|
||||
ALOGE("%s: Bad fd for extra data!", __func__);
|
||||
return -1;
|
||||
}
|
||||
if (!param) {
|
||||
ALOGE("%s: input param is null!", __func__);
|
||||
return -1;
|
||||
}
|
||||
unsigned long size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
|
||||
void *base = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED,
|
||||
handle->fd_metadata, 0);
|
||||
if (base == reinterpret_cast<void*>(MAP_FAILED)) {
|
||||
ALOGE("%s: mmap() failed: error is %s!", __func__, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
MetaData_t *data = reinterpret_cast <MetaData_t *>(base);
|
||||
data->operation |= paramType;
|
||||
switch (paramType) {
|
||||
case GET_PP_PARAM_INTERLACED:
|
||||
*((int32_t *)param) = data->interlaced;
|
||||
break;
|
||||
case GET_BUFFER_GEOMETRY:
|
||||
*((BufferDim_t *)param) = data->bufferDim;
|
||||
break;
|
||||
case GET_REFRESH_RATE:
|
||||
*((float *)param) = data->refreshrate;
|
||||
break;
|
||||
case GET_COLOR_SPACE:
|
||||
*((ColorSpace_t *)param) = data->colorSpace;
|
||||
break;
|
||||
case GET_MAP_SECURE_BUFFER:
|
||||
*((int32_t *)param) = data->mapSecureBuffer;
|
||||
break;
|
||||
case GET_S3D_FORMAT:
|
||||
*((uint32_t *)param) = data->s3dFormat;
|
||||
break;
|
||||
case GET_LINEAR_FORMAT:
|
||||
*((uint32_t *)param) = data->linearFormat;
|
||||
break;
|
||||
case GET_IGC:
|
||||
*((IGC_t *)param) = data->igc;
|
||||
break;
|
||||
case GET_SINGLE_BUFFER_MODE:
|
||||
*((uint32_t *)param) = data->isSingleBufferMode ;
|
||||
break;
|
||||
default:
|
||||
ALOGE("Unknown paramType %d", paramType);
|
||||
break;
|
||||
}
|
||||
if(munmap(base, size))
|
||||
ALOGE("%s: failed to unmap ptr %p, err %d", __func__, (void*)base,
|
||||
errno);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int copyMetaData(struct private_handle_t *src, struct private_handle_t *dst) {
|
||||
if (!src || !dst) {
|
||||
ALOGE("%s: Private handle is null!", __func__);
|
||||
return -1;
|
||||
}
|
||||
if (src->fd_metadata == -1) {
|
||||
ALOGE("%s: Bad fd for src extra data!", __func__);
|
||||
return -1;
|
||||
}
|
||||
if (dst->fd_metadata == -1) {
|
||||
ALOGE("%s: Bad fd for dst extra data!", __func__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
unsigned long size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
|
||||
|
||||
void *base_src = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED,
|
||||
src->fd_metadata, 0);
|
||||
if (base_src == reinterpret_cast<void*>(MAP_FAILED)) {
|
||||
ALOGE("%s: src mmap() failed: error is %s!", __func__, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
void *base_dst = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED,
|
||||
dst->fd_metadata, 0);
|
||||
if (base_dst == reinterpret_cast<void*>(MAP_FAILED)) {
|
||||
ALOGE("%s: dst mmap() failed: error is %s!", __func__, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
memcpy(base_dst, base_src, size);
|
||||
|
||||
if(munmap(base_src, size))
|
||||
ALOGE("%s: failed to unmap src ptr %p, err %d", __func__, (void*)base_src,
|
||||
errno);
|
||||
if(munmap(base_dst, size))
|
||||
ALOGE("%s: failed to unmap src ptr %p, err %d", __func__, (void*)base_dst,
|
||||
errno);
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2012-2015, The Linux Foundation. All rights reserved.
|
||||
* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
|
@ -61,7 +61,7 @@ struct MetaData_t {
|
|||
int32_t operation;
|
||||
int32_t interlaced;
|
||||
struct BufferDim_t bufferDim;
|
||||
uint32_t refreshrate;
|
||||
float refreshrate;
|
||||
enum ColorSpace_t colorSpace;
|
||||
enum IGC_t igc;
|
||||
/* Gralloc sets PRIV_SECURE_BUFFER flag to inform that the buffers are from
|
||||
|
@ -99,10 +99,26 @@ enum DispParamType {
|
|||
SET_SINGLE_BUFFER_MODE = 0x4000,
|
||||
};
|
||||
|
||||
enum DispFetchParamType {
|
||||
GET_PP_PARAM_INTERLACED = 0x0004,
|
||||
GET_BUFFER_GEOMETRY = 0x0080,
|
||||
GET_REFRESH_RATE = 0x0100,
|
||||
GET_COLOR_SPACE = 0x0200,
|
||||
GET_MAP_SECURE_BUFFER = 0x400,
|
||||
GET_S3D_FORMAT = 0x800,
|
||||
GET_LINEAR_FORMAT = 0x1000,
|
||||
GET_IGC = 0x2000,
|
||||
GET_SINGLE_BUFFER_MODE = 0x4000,
|
||||
};
|
||||
|
||||
struct private_handle_t;
|
||||
int setMetaData(struct private_handle_t *handle, enum DispParamType paramType,
|
||||
void *param);
|
||||
|
||||
int getMetaData(struct private_handle_t *handle, enum DispFetchParamType paramType,
|
||||
void *param);
|
||||
|
||||
int copyMetaData(struct private_handle_t *src, struct private_handle_t *dst);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -79,8 +79,6 @@ IMPLEMENT_META_INTERFACE(QService, "android.display.IQService");
|
|||
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
static void getProcName(int pid, char *buf, int size);
|
||||
|
||||
status_t BnQService::onTransact(
|
||||
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
|
||||
{
|
||||
|
@ -89,10 +87,6 @@ status_t BnQService::onTransact(
|
|||
IPCThreadState* ipc = IPCThreadState::self();
|
||||
const int callerPid = ipc->getCallingPid();
|
||||
const int callerUid = ipc->getCallingUid();
|
||||
const int MAX_BUF_SIZE = 1024;
|
||||
char callingProcName[MAX_BUF_SIZE] = {0};
|
||||
|
||||
getProcName(callerPid, callingProcName, MAX_BUF_SIZE);
|
||||
|
||||
const bool permission = (callerUid == AID_MEDIA ||
|
||||
callerUid == AID_GRAPHICS ||
|
||||
|
@ -103,9 +97,8 @@ status_t BnQService::onTransact(
|
|||
if (code == CONNECT_HWC_CLIENT) {
|
||||
CHECK_INTERFACE(IQService, data, reply);
|
||||
if(callerUid != AID_GRAPHICS) {
|
||||
ALOGE("display.qservice CONNECT_HWC_CLIENT access denied: \
|
||||
pid=%d uid=%d process=%s",
|
||||
callerPid, callerUid, callingProcName);
|
||||
ALOGE("display.qservice CONNECT_HWC_CLIENT access denied: pid=%d uid=%d",
|
||||
callerPid, callerUid);
|
||||
return PERMISSION_DENIED;
|
||||
}
|
||||
sp<IQClient> client =
|
||||
|
@ -115,9 +108,8 @@ status_t BnQService::onTransact(
|
|||
} else if(code == CONNECT_HDMI_CLIENT) {
|
||||
CHECK_INTERFACE(IQService, data, reply);
|
||||
if(callerUid != AID_SYSTEM && callerUid != AID_ROOT) {
|
||||
ALOGE("display.qservice CONNECT_HDMI_CLIENT access denied: \
|
||||
pid=%d uid=%d process=%s",
|
||||
callerPid, callerUid, callingProcName);
|
||||
ALOGE("display.qservice CONNECT_HDMI_CLIENT access denied: pid=%d uid=%d",
|
||||
callerPid, callerUid);
|
||||
return PERMISSION_DENIED;
|
||||
}
|
||||
sp<IQHDMIClient> client =
|
||||
|
@ -126,9 +118,8 @@ status_t BnQService::onTransact(
|
|||
return NO_ERROR;
|
||||
} else if (code > COMMAND_LIST_START && code < COMMAND_LIST_END) {
|
||||
if(!permission) {
|
||||
ALOGE("display.qservice access denied: command=%d\
|
||||
pid=%d uid=%d process=%s", code, callerPid,
|
||||
callerUid, callingProcName);
|
||||
ALOGE("display.qservice access denied: command=%d pid=%d uid=%d",
|
||||
code, callerPid, callerUid);
|
||||
return PERMISSION_DENIED;
|
||||
}
|
||||
CHECK_INTERFACE(IQService, data, reply);
|
||||
|
@ -139,20 +130,4 @@ status_t BnQService::onTransact(
|
|||
}
|
||||
}
|
||||
|
||||
//Helper
|
||||
static void getProcName(int pid, char *buf, int size) {
|
||||
int fd = -1;
|
||||
snprintf(buf, size, "/proc/%d/cmdline", pid);
|
||||
fd = open(buf, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
strlcpy(buf, "Unknown", size);
|
||||
} else {
|
||||
ssize_t len = read(fd, buf, size - 1);
|
||||
if (len >= 0)
|
||||
buf[len] = 0;
|
||||
|
||||
close(fd);
|
||||
}
|
||||
}
|
||||
|
||||
}; // namespace qService
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2015, The Linux Foundation. All rights reserved.
|
||||
* Copyright (c) 2015 - 2016, The Linux Foundation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
|
@ -127,6 +127,15 @@ class DebugHandler {
|
|||
*/
|
||||
virtual DisplayError GetProperty(const char *property_name, char *value) = 0;
|
||||
|
||||
/*! @brief Method to set a property to a given string value.
|
||||
|
||||
@param[in] property_name name of the property
|
||||
@param[in] value new value of the property name
|
||||
|
||||
@return \link DisplayError \endlink
|
||||
*/
|
||||
virtual DisplayError SetProperty(const char *property_name, const char *value) = 0;
|
||||
|
||||
protected:
|
||||
virtual ~DebugHandler() { }
|
||||
};
|
||||
|
|
|
@ -34,6 +34,8 @@
|
|||
#define __DISPLAY_INTERFACE_H__
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "layer_stack.h"
|
||||
#include "sdm_types.h"
|
||||
|
@ -96,6 +98,7 @@ struct DisplayConfigVariableInfo {
|
|||
float y_dpi = 0.0f; //!< Dots per inch in Y-direction.
|
||||
uint32_t fps = 0; //!< Frame rate per second.
|
||||
uint32_t vsync_period_ns = 0; //!< VSync period in nanoseconds.
|
||||
bool is_yuv = false; //!< If the display output is in YUV format.
|
||||
};
|
||||
|
||||
/*! @brief Event data associated with VSync event.
|
||||
|
@ -406,6 +409,41 @@ class DisplayInterface {
|
|||
PPDisplayAPIPayload *out_payload,
|
||||
PPPendingParams *pending_action) = 0;
|
||||
|
||||
/*! @brief Method to request the number of color modes supported.
|
||||
|
||||
@param[out] mode_count Number of modes
|
||||
|
||||
@return \link DisplayError \endlink
|
||||
*/
|
||||
virtual DisplayError GetColorModeCount(uint32_t *mode_count) = 0;
|
||||
|
||||
/*! @brief Method to request the information of supported color modes.
|
||||
|
||||
@param[inout] mode_count Number of updated modes
|
||||
@param[out] vector of mode strings
|
||||
|
||||
@return \link DisplayError \endlink
|
||||
*/
|
||||
virtual DisplayError GetColorModes(uint32_t *mode_count,
|
||||
std::vector<std::string> *color_modes) = 0;
|
||||
|
||||
/*! @brief Method to set the color mode
|
||||
|
||||
@param[in] mode_name Mode name which needs to be set
|
||||
|
||||
@return \link DisplayError \endlink
|
||||
*/
|
||||
virtual DisplayError SetColorMode(const std::string &color_mode) = 0;
|
||||
|
||||
/*! @brief Method to set the color transform
|
||||
|
||||
@param[in] length Mode name which needs to be set
|
||||
@param[in] color_transform 4x4 Matrix for color transform
|
||||
|
||||
@return \link DisplayError \endlink
|
||||
*/
|
||||
virtual DisplayError SetColorTransform(const uint32_t length, const double *color_transform) = 0;
|
||||
|
||||
/*! @brief Method to request applying default display mode.
|
||||
|
||||
@return \link DisplayError \endlink
|
||||
|
|
|
@ -297,7 +297,7 @@ struct Layer {
|
|||
//!< applied to the layer buffer during
|
||||
//!< composition.
|
||||
|
||||
uint8_t plane_alpha = 0; //!< Alpha value applied to the whole layer.
|
||||
uint8_t plane_alpha = 0xff; //!< Alpha value applied to the whole layer.
|
||||
//!< Value of each pixel is computed as:
|
||||
//!< if(kBlendingPremultiplied) {
|
||||
//!< pixel.RGB = pixel.RGB * planeAlpha/255
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (c) 2015, The Linux Foundataion. All rights reserved.
|
||||
/* Copyright (c) 2015-2016, The Linux Foundataion. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
|
@ -60,6 +60,20 @@ class ColorInterface {
|
|||
|
||||
virtual DisplayError ApplyDefaultDisplayMode(PPFeaturesConfig *out_features) = 0;
|
||||
|
||||
virtual DisplayError ColorIntfSetColorTransform(PPFeaturesConfig *out_features,
|
||||
uint32_t disp_id, uint32_t length,
|
||||
const double *trans_data) = 0;
|
||||
|
||||
virtual DisplayError ColorIntfSetDisplayMode(PPFeaturesConfig *out_features,
|
||||
uint32_t disp_id, int32_t mode_id) = 0;
|
||||
|
||||
virtual DisplayError ColorIntfGetNumDisplayModes(PPFeaturesConfig *out_features,
|
||||
uint32_t disp_id, uint32_t *mode_cnt) = 0;
|
||||
|
||||
virtual DisplayError ColorIntfEnumerateDisplayModes(PPFeaturesConfig *out_features,
|
||||
uint32_t disp_id, SDEDisplayMode *modes,
|
||||
uint32_t *mode_cnt) = 0;
|
||||
|
||||
protected:
|
||||
virtual ~ColorInterface() {}
|
||||
};
|
||||
|
|
|
@ -315,6 +315,13 @@ struct SDEPgcLUTData {
|
|||
uint32_t *c2_data = NULL;
|
||||
};
|
||||
|
||||
struct SDEDisplayMode {
|
||||
static const int kMaxModeNameSize = 256;
|
||||
int32_t id = -1;
|
||||
uint32_t type = 0;
|
||||
char name[kMaxModeNameSize] = {0};
|
||||
};
|
||||
|
||||
// Wrapper on HW block config data structure to encapsulate the details of allocating
|
||||
// and destroying from the caller.
|
||||
class SDEGamutCfgWrapper : private SDEGamutCfg {
|
||||
|
|
|
@ -417,6 +417,7 @@ struct HWLayersInfo {
|
|||
// programmed on hardware.
|
||||
LayerRect updated_src_rect[kMaxSDELayers]; // Updated layer src rects in s3d mode
|
||||
LayerRect updated_dst_rect[kMaxSDELayers]; // Updated layer dst rects in s3d mode
|
||||
bool updating[kMaxSDELayers] = {0}; // Updated by strategy, considering plane_alpha+updating
|
||||
|
||||
uint32_t count = 0; // Total number of layers which need to be set on hardware.
|
||||
|
||||
|
@ -455,7 +456,8 @@ struct HWDisplayAttributes : DisplayConfigVariableInfo {
|
|||
(vsync_period_ns != attributes.vsync_period_ns) ||
|
||||
(v_front_porch != attributes.v_front_porch) ||
|
||||
(v_back_porch != attributes.v_back_porch) ||
|
||||
(v_pulse_width != attributes.v_pulse_width));
|
||||
(v_pulse_width != attributes.v_pulse_width) ||
|
||||
(is_yuv != attributes.is_yuv));
|
||||
}
|
||||
|
||||
bool operator ==(const HWDisplayAttributes &attributes) {
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
|
||||
* Copyright (c) 2014 - 2016, The Linux Foundation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are permitted
|
||||
* provided that the following conditions are met:
|
||||
|
@ -48,6 +48,7 @@ class StrategyInterface {
|
|||
virtual DisplayError Start(HWLayersInfo *hw_layers_info, uint32_t *max_attempts) = 0;
|
||||
virtual DisplayError GetNextStrategy(StrategyConstraints *constraints) = 0;
|
||||
virtual DisplayError Stop() = 0;
|
||||
virtual DisplayError Reconfigure(HWDisplayMode mode, HWS3DMode s3d_mode) = 0;
|
||||
|
||||
protected:
|
||||
virtual ~StrategyInterface() { }
|
||||
|
|
|
@ -75,6 +75,7 @@ class Debug {
|
|||
static bool IsScalarDisabled();
|
||||
static bool IsUbwcTiledFrameBuffer();
|
||||
static bool GetProperty(const char *property_name, char *value);
|
||||
static bool SetProperty(const char *property_name, const char *value);
|
||||
|
||||
private:
|
||||
Debug();
|
||||
|
@ -97,6 +98,9 @@ class Debug {
|
|||
virtual DisplayError GetProperty(const char */*property_name*/, char */*value*/) {
|
||||
return kErrorNotSupported;
|
||||
}
|
||||
virtual DisplayError SetProperty(const char */*property_name*/, const char */*value*/) {
|
||||
return kErrorNotSupported;
|
||||
}
|
||||
};
|
||||
|
||||
DefaultDebugHandler default_debug_handler_;
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
|
||||
* Copyright (c) 2014 - 2016, The Linux Foundation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are permitted
|
||||
* provided that the following conditions are met:
|
||||
|
@ -89,7 +89,7 @@ class Locker {
|
|||
explicit SequenceWaitScopeLock(Locker& locker) : locker_(locker), error_(false) {
|
||||
locker_.Lock();
|
||||
|
||||
if (locker_.sequence_wait_ == 1) {
|
||||
while (locker_.sequence_wait_ == 1) {
|
||||
locker_.Wait();
|
||||
error_ = (locker_.sequence_wait_ == -1);
|
||||
}
|
||||
|
|
|
@ -219,4 +219,22 @@ void PPHWAttributes::Set(const HWResourceInfo &hw_res,
|
|||
}
|
||||
}
|
||||
|
||||
DisplayError ColorManagerProxy::ColorMgrGetNumOfModes(uint32_t *mode_cnt) {
|
||||
return color_intf_->ColorIntfGetNumDisplayModes(&pp_features_, 0, mode_cnt);
|
||||
}
|
||||
|
||||
DisplayError ColorManagerProxy::ColorMgrGetModes(uint32_t *mode_cnt,
|
||||
SDEDisplayMode *modes) {
|
||||
return color_intf_->ColorIntfEnumerateDisplayModes(&pp_features_, 0, modes, mode_cnt);
|
||||
}
|
||||
|
||||
DisplayError ColorManagerProxy::ColorMgrSetMode(int32_t color_mode_id) {
|
||||
return color_intf_->ColorIntfSetDisplayMode(&pp_features_, 0, color_mode_id);
|
||||
}
|
||||
|
||||
DisplayError ColorManagerProxy::ColorMgrSetColorTransform(uint32_t length,
|
||||
const double *trans_data) {
|
||||
return color_intf_->ColorIntfSetColorTransform(&pp_features_, 0, length, trans_data);
|
||||
}
|
||||
|
||||
} // namespace sdm
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
/* Copyright (c) 2015, The Linux Foundataion. All rights reserved.
|
||||
/* Copyright (c) 2015-2016, The Linux Foundataion. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions are
|
||||
|
@ -65,6 +65,10 @@ class ColorManagerProxy {
|
|||
PPDisplayAPIPayload *out_payload,
|
||||
PPPendingParams *pending_action);
|
||||
DisplayError ApplyDefaultDisplayMode();
|
||||
DisplayError ColorMgrGetNumOfModes(uint32_t *mode_cnt);
|
||||
DisplayError ColorMgrGetModes(uint32_t *mode_cnt, SDEDisplayMode *modes);
|
||||
DisplayError ColorMgrSetMode(int32_t color_mode_id);
|
||||
DisplayError ColorMgrSetColorTransform(uint32_t length, const double *trans_data);
|
||||
bool NeedsPartialUpdateDisable();
|
||||
DisplayError Commit();
|
||||
|
||||
|
|
|
@ -164,25 +164,14 @@ DisplayError CompManager::ReconfigureDisplay(Handle comp_handle,
|
|||
|
||||
DisplayError error = kErrorNone;
|
||||
if (display_comp_ctx->strategy) {
|
||||
display_comp_ctx->strategy->Deinit();
|
||||
delete display_comp_ctx->strategy;
|
||||
display_comp_ctx->strategy = NULL;
|
||||
}
|
||||
|
||||
Strategy *&new_strategy = display_comp_ctx->strategy;
|
||||
display_comp_ctx->strategy = new Strategy(extension_intf_, display_comp_ctx->display_type,
|
||||
hw_res_info_, hw_panel_info, attributes);
|
||||
if (!display_comp_ctx->strategy) {
|
||||
DLOGE("Unable to create strategy.");
|
||||
return kErrorMemory;
|
||||
}
|
||||
|
||||
error = new_strategy->Init();
|
||||
if (error != kErrorNone) {
|
||||
DLOGE("Unable to initialize strategy.");
|
||||
delete display_comp_ctx->strategy;
|
||||
display_comp_ctx->strategy = NULL;
|
||||
return error;
|
||||
error = display_comp_ctx->strategy->Reconfigure(hw_panel_info, attributes);
|
||||
if (error != kErrorNone) {
|
||||
DLOGE("Unable to Reconfigure strategy.");
|
||||
display_comp_ctx->strategy->Deinit();
|
||||
delete display_comp_ctx->strategy;
|
||||
display_comp_ctx->strategy = NULL;
|
||||
return error;
|
||||
}
|
||||
}
|
||||
|
||||
// For HDMI S3D mode, set max_layers_ to 0 so that primary display would fall back
|
||||
|
|
|
@ -28,6 +28,7 @@
|
|||
#include <utils/formats.h>
|
||||
#include <utils/rect.h>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "display_base.h"
|
||||
|
@ -52,10 +53,9 @@ DisplayError DisplayBase::Init() {
|
|||
hw_panel_info_ = HWPanelInfo();
|
||||
hw_intf_->GetHWPanelInfo(&hw_panel_info_);
|
||||
|
||||
HWDisplayAttributes display_attrib;
|
||||
uint32_t active_index = 0;
|
||||
hw_intf_->GetActiveConfig(&active_index);
|
||||
hw_intf_->GetDisplayAttributes(active_index, &display_attrib);
|
||||
hw_intf_->GetDisplayAttributes(active_index, &display_attributes_);
|
||||
|
||||
HWScaleLutInfo lut_info = {};
|
||||
error = comp_manager_->GetScaleLutConfig(&lut_info);
|
||||
|
@ -67,7 +67,7 @@ DisplayError DisplayBase::Init() {
|
|||
goto CleanupOnError;
|
||||
}
|
||||
|
||||
error = comp_manager_->RegisterDisplay(display_type_, display_attrib,
|
||||
error = comp_manager_->RegisterDisplay(display_type_, display_attributes_,
|
||||
hw_panel_info_, &display_comp_ctx_);
|
||||
if (error != kErrorNone) {
|
||||
goto CleanupOnError;
|
||||
|
@ -92,7 +92,7 @@ DisplayError DisplayBase::Init() {
|
|||
}
|
||||
|
||||
color_mgr_ = ColorManagerProxy::CreateColorManagerProxy(display_type_, hw_intf_,
|
||||
display_attrib, hw_panel_info_);
|
||||
display_attributes_, hw_panel_info_);
|
||||
if (!color_mgr_) {
|
||||
DLOGW("Unable to create ColorManagerProxy for display = %d", display_type_);
|
||||
}
|
||||
|
@ -112,6 +112,10 @@ DisplayError DisplayBase::Deinit() {
|
|||
rotator_intf_->UnregisterDisplay(display_rotator_ctx_);
|
||||
}
|
||||
|
||||
if (color_modes_) {
|
||||
delete[] color_modes_;
|
||||
}
|
||||
|
||||
if (color_mgr_) {
|
||||
delete color_mgr_;
|
||||
color_mgr_ = NULL;
|
||||
|
@ -202,6 +206,10 @@ DisplayError DisplayBase::Prepare(LayerStack *layer_stack) {
|
|||
}
|
||||
}
|
||||
|
||||
if (one_frame_full_roi_) {
|
||||
ControlPartialUpdate(false, &pending);
|
||||
}
|
||||
|
||||
// Clean hw layers for reuse.
|
||||
hw_layers_ = HWLayers();
|
||||
hw_layers_.info.stack = layer_stack;
|
||||
|
@ -245,6 +253,11 @@ DisplayError DisplayBase::Prepare(LayerStack *layer_stack) {
|
|||
ControlPartialUpdate(true, &pending);
|
||||
}
|
||||
|
||||
if (one_frame_full_roi_) {
|
||||
ControlPartialUpdate(true, &pending);
|
||||
one_frame_full_roi_ = false;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
@ -467,6 +480,8 @@ DisplayError DisplayBase::SetActiveConfig(uint32_t index) {
|
|||
return error;
|
||||
}
|
||||
|
||||
hw_intf_->GetHWPanelInfo(&hw_panel_info_);
|
||||
|
||||
if (display_comp_ctx_) {
|
||||
comp_manager_->UnregisterDisplay(display_comp_ctx_);
|
||||
}
|
||||
|
@ -474,6 +489,10 @@ DisplayError DisplayBase::SetActiveConfig(uint32_t index) {
|
|||
error = comp_manager_->RegisterDisplay(display_type_, attrib, hw_panel_info_,
|
||||
&display_comp_ctx_);
|
||||
|
||||
if (error == kErrorNone && partial_update_control_) {
|
||||
one_frame_full_roi_ = true;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
@ -707,6 +726,105 @@ DisplayError DisplayBase::ColorSVCRequestRoute(const PPDisplayAPIPayload &in_pay
|
|||
return kErrorParameters;
|
||||
}
|
||||
|
||||
DisplayError DisplayBase::GetColorModeCount(uint32_t *mode_count) {
|
||||
if (!mode_count) {
|
||||
return kErrorParameters;
|
||||
}
|
||||
|
||||
if (!color_mgr_) {
|
||||
return kErrorNotSupported;
|
||||
}
|
||||
|
||||
DisplayError error = color_mgr_->ColorMgrGetNumOfModes(&num_color_modes_);
|
||||
if (error != kErrorNone || !num_color_modes_) {
|
||||
return kErrorNotSupported;
|
||||
}
|
||||
|
||||
DLOGI("Number of color modes = %d", num_color_modes_);
|
||||
*mode_count = num_color_modes_;
|
||||
|
||||
return kErrorNone;
|
||||
}
|
||||
|
||||
DisplayError DisplayBase::GetColorModes(uint32_t *mode_count,
|
||||
std::vector<std::string> *color_modes) {
|
||||
if (!mode_count || !color_modes) {
|
||||
return kErrorParameters;
|
||||
}
|
||||
|
||||
if (!color_mgr_) {
|
||||
return kErrorNotSupported;
|
||||
}
|
||||
|
||||
if (color_modes_ == NULL) {
|
||||
color_modes_ = new SDEDisplayMode[num_color_modes_];
|
||||
|
||||
DisplayError error = color_mgr_->ColorMgrGetModes(&num_color_modes_, color_modes_);
|
||||
if (error != kErrorNone) {
|
||||
DLOGE("Failed");
|
||||
return error;
|
||||
}
|
||||
for (uint32_t i = 0; i < num_color_modes_; i++) {
|
||||
DLOGV_IF(kTagQDCM, "Color Mode[%d]: Name = %s mode_id = %d", i, color_modes_[i].name,
|
||||
color_modes_[i].id);
|
||||
color_mode_map_.insert(std::make_pair(color_modes_[i].name, &color_modes_[i]));
|
||||
}
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < num_color_modes_; i++) {
|
||||
DLOGV_IF(kTagQDCM, "Color Mode[%d]: Name = %s mode_id = %d", i, color_modes_[i].name,
|
||||
color_modes_[i].id);
|
||||
color_modes->at(i) = color_modes_[i].name;
|
||||
}
|
||||
|
||||
return kErrorNone;
|
||||
}
|
||||
|
||||
DisplayError DisplayBase::SetColorMode(const std::string &color_mode) {
|
||||
if (!color_mgr_) {
|
||||
return kErrorNotSupported;
|
||||
}
|
||||
|
||||
DLOGV_IF(kTagQDCM, "Color Mode = %s", color_mode.c_str());
|
||||
|
||||
ColorModeMap::iterator it = color_mode_map_.find(color_mode);
|
||||
if (it == color_mode_map_.end()) {
|
||||
DLOGE("Failed: Unknown Mode : %s", color_mode.c_str());
|
||||
return kErrorNotSupported;
|
||||
}
|
||||
|
||||
SDEDisplayMode *sde_display_mode = it->second;
|
||||
if (color_mode_ == sde_display_mode->id) {
|
||||
DLOGV_IF(kTagQDCM, "Same mode requested");
|
||||
return kErrorNone;
|
||||
}
|
||||
|
||||
DLOGV_IF(kTagQDCM, "Color Mode Name = %s corresponding mode_id = %d", sde_display_mode->name,
|
||||
sde_display_mode->id);
|
||||
DisplayError error = kErrorNone;
|
||||
error = color_mgr_->ColorMgrSetMode(sde_display_mode->id);
|
||||
if (error != kErrorNone) {
|
||||
DLOGE("Failed for mode id = %d", sde_display_mode->id);
|
||||
return error;
|
||||
}
|
||||
|
||||
color_mode_ = sde_display_mode->id;
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
DisplayError DisplayBase::SetColorTransform(const uint32_t length, const double *color_transform) {
|
||||
if (!color_mgr_) {
|
||||
return kErrorNotSupported;
|
||||
}
|
||||
|
||||
if (!color_transform) {
|
||||
return kErrorParameters;
|
||||
}
|
||||
|
||||
return color_mgr_->ColorMgrSetColorTransform(length, color_transform);
|
||||
}
|
||||
|
||||
DisplayError DisplayBase::ApplyDefaultDisplayMode() {
|
||||
if (color_mgr_)
|
||||
return color_mgr_->ApplyDefaultDisplayMode();
|
||||
|
|
|
@ -31,6 +31,10 @@
|
|||
#include <private/color_interface.h>
|
||||
#include <utils/locker.h>
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "hw_interface.h"
|
||||
#include "comp_manager.h"
|
||||
#include "color_manager.h"
|
||||
|
@ -70,6 +74,10 @@ class DisplayBase : public DisplayInterface {
|
|||
virtual DisplayError ColorSVCRequestRoute(const PPDisplayAPIPayload &in_payload,
|
||||
PPDisplayAPIPayload *out_payload,
|
||||
PPPendingParams *pending_action);
|
||||
virtual DisplayError GetColorModeCount(uint32_t *mode_count);
|
||||
virtual DisplayError GetColorModes(uint32_t *mode_count, std::vector<std::string> *color_modes);
|
||||
virtual DisplayError SetColorMode(const std::string &color_mode);
|
||||
virtual DisplayError SetColorTransform(const uint32_t length, const double *color_transform);
|
||||
virtual DisplayError ApplyDefaultDisplayMode(void);
|
||||
virtual DisplayError SetCursorPosition(int x, int y);
|
||||
virtual DisplayError GetRefreshRateRange(uint32_t *min_refresh_rate, uint32_t *max_refresh_rate);
|
||||
|
@ -89,6 +97,7 @@ class DisplayBase : public DisplayInterface {
|
|||
HWDeviceType hw_device_type_;
|
||||
HWInterface *hw_intf_ = NULL;
|
||||
HWPanelInfo hw_panel_info_;
|
||||
HWDisplayAttributes display_attributes_;
|
||||
BufferSyncHandler *buffer_sync_handler_ = NULL;
|
||||
CompManager *comp_manager_ = NULL;
|
||||
RotatorInterface *rotator_intf_ = NULL;
|
||||
|
@ -106,8 +115,14 @@ class DisplayBase : public DisplayInterface {
|
|||
ColorManagerProxy *color_mgr_ = NULL; // each display object owns its ColorManagerProxy
|
||||
bool partial_update_control_ = true;
|
||||
HWEventsInterface *hw_events_intf_ = NULL;
|
||||
uint32_t num_color_modes_ = 0;
|
||||
SDEDisplayMode *color_modes_ = NULL;
|
||||
int32_t color_mode_ = 0;
|
||||
typedef std::map<std::string, SDEDisplayMode *> ColorModeMap;
|
||||
ColorModeMap color_mode_map_ = {};
|
||||
|
||||
private:
|
||||
bool one_frame_full_roi_ = false;
|
||||
// Unused
|
||||
virtual DisplayError GetConfig(DisplayConfigFixedInfo *variable_info) {
|
||||
return kErrorNone;
|
||||
|
|
|
@ -190,12 +190,31 @@ DisplayError DisplayHDMI::IsScalingValid(const LayerRect &crop, const LayerRect
|
|||
DisplayError DisplayHDMI::GetRefreshRateRange(uint32_t *min_refresh_rate,
|
||||
uint32_t *max_refresh_rate) {
|
||||
SCOPE_LOCK(locker_);
|
||||
return DisplayBase::GetRefreshRateRange(min_refresh_rate, max_refresh_rate);
|
||||
DisplayError error = kErrorNone;
|
||||
|
||||
if (hw_panel_info_.min_fps && hw_panel_info_.max_fps) {
|
||||
*min_refresh_rate = hw_panel_info_.min_fps;
|
||||
*max_refresh_rate = hw_panel_info_.max_fps;
|
||||
} else {
|
||||
error = DisplayBase::GetRefreshRateRange(min_refresh_rate, max_refresh_rate);
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
DisplayError DisplayHDMI::SetRefreshRate(uint32_t refresh_rate) {
|
||||
SCOPE_LOCK(locker_);
|
||||
return kErrorNotSupported;
|
||||
|
||||
if (!active_) {
|
||||
return kErrorPermission;
|
||||
}
|
||||
|
||||
DisplayError error = hw_intf_->SetRefreshRate(refresh_rate);
|
||||
if (error != kErrorNone) {
|
||||
return error;
|
||||
}
|
||||
|
||||
return kErrorNone;
|
||||
}
|
||||
|
||||
bool DisplayHDMI::IsUnderscanSupported() {
|
||||
|
@ -358,9 +377,10 @@ void DisplayHDMI::SetS3DMode(LayerStack *layer_stack) {
|
|||
hw_intf_->GetActiveConfig(&active_index);
|
||||
hw_intf_->GetDisplayAttributes(active_index, &display_attributes);
|
||||
|
||||
if (panel_info != hw_panel_info_) {
|
||||
if (panel_info != hw_panel_info_ || display_attributes != display_attributes_) {
|
||||
comp_manager_->ReconfigureDisplay(display_comp_ctx_, display_attributes, panel_info);
|
||||
hw_panel_info_ = panel_info;
|
||||
display_attributes_ = display_attributes;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -260,6 +260,7 @@ DisplayError HWHDMI::GetDisplayAttributes(uint32_t index,
|
|||
}
|
||||
|
||||
GetDisplayS3DSupport(index, display_attributes);
|
||||
display_attributes->is_yuv = IS_BIT_SET(timing_mode->pixel_formats, 1);
|
||||
|
||||
return kErrorNone;
|
||||
}
|
||||
|
@ -317,6 +318,8 @@ DisplayError HWHDMI::SetDisplayAttributes(uint32_t index) {
|
|||
|
||||
active_config_index_ = index;
|
||||
|
||||
frame_rate_ = timing_mode->refresh_rate;
|
||||
|
||||
// Get the supported s3d modes for current active config index
|
||||
HWDisplayAttributes attrib;
|
||||
GetDisplayS3DSupport(index, &attrib);
|
||||
|
@ -696,5 +699,61 @@ DisplayError HWHDMI::SetS3DMode(HWS3DMode s3d_mode) {
|
|||
return kErrorNone;
|
||||
}
|
||||
|
||||
DisplayError HWHDMI::SetRefreshRate(uint32_t refresh_rate) {
|
||||
char mode_path[kMaxStringLength] = {0};
|
||||
char node_path[kMaxStringLength] = {0};
|
||||
uint32_t mode = kModeHFP;
|
||||
|
||||
if (refresh_rate == frame_rate_) {
|
||||
return kErrorNone;
|
||||
}
|
||||
|
||||
snprintf(mode_path, sizeof(mode_path), "%s%d/msm_fb_dfps_mode", fb_path_, fb_node_index_);
|
||||
snprintf(node_path, sizeof(node_path), "%s%d/dynamic_fps", fb_path_, fb_node_index_);
|
||||
|
||||
int fd_mode = Sys::open_(mode_path, O_WRONLY);
|
||||
if (fd_mode < 0) {
|
||||
DLOGE("Failed to open %s with error %s", node_path, strerror(errno));
|
||||
return kErrorFileDescriptor;
|
||||
}
|
||||
|
||||
char dfps_mode[kMaxStringLength];
|
||||
snprintf(dfps_mode, sizeof(dfps_mode), "%d", mode);
|
||||
DLOGI_IF(kTagDriverConfig, "Setting dfps_mode = %d", mode);
|
||||
ssize_t len = Sys::pwrite_(fd_mode, dfps_mode, strlen(dfps_mode), 0);
|
||||
if (len < 0) {
|
||||
DLOGE("Failed to enable dfps mode %d with error %s", mode, strerror(errno));
|
||||
Sys::close_(fd_mode);
|
||||
return kErrorUndefined;
|
||||
}
|
||||
Sys::close_(fd_mode);
|
||||
|
||||
int fd_node = Sys::open_(node_path, O_WRONLY);
|
||||
if (fd_node < 0) {
|
||||
DLOGE("Failed to open %s with error %s", node_path, strerror(errno));
|
||||
return kErrorFileDescriptor;
|
||||
}
|
||||
|
||||
char refresh_rate_string[kMaxStringLength];
|
||||
snprintf(refresh_rate_string, sizeof(refresh_rate_string), "%d", refresh_rate);
|
||||
DLOGI_IF(kTagDriverConfig, "Setting refresh rate = %d", refresh_rate);
|
||||
len = Sys::pwrite_(fd_node, refresh_rate_string, strlen(refresh_rate_string), 0);
|
||||
if (len < 0) {
|
||||
DLOGE("Failed to write %d with error %s", refresh_rate, strerror(errno));
|
||||
Sys::close_(fd_node);
|
||||
return kErrorUndefined;
|
||||
}
|
||||
Sys::close_(fd_node);
|
||||
|
||||
DisplayError error = ReadTimingInfo();
|
||||
if (error != kErrorNone) {
|
||||
return error;
|
||||
}
|
||||
|
||||
frame_rate_ = refresh_rate;
|
||||
|
||||
return kErrorNone;
|
||||
}
|
||||
|
||||
} // namespace sdm
|
||||
|
||||
|
|
|
@ -40,6 +40,18 @@ class HWHDMI : public HWDevice {
|
|||
static DisplayError Destroy(HWInterface *intf);
|
||||
|
||||
protected:
|
||||
enum HWFramerateUpdate {
|
||||
// Switch framerate by switch to other standard modes though panel blank/unblank
|
||||
kModeSuspendResume,
|
||||
// Switch framerate by tuning pixel clock
|
||||
kModeClock,
|
||||
// Switch framerate by tuning vertical front porch
|
||||
kModeVFP,
|
||||
// Switch framerate by tuning horizontal front porch
|
||||
kModeHFP,
|
||||
kModeMAX
|
||||
};
|
||||
|
||||
HWHDMI(BufferSyncHandler *buffer_sync_handler, HWInfoInterface *hw_info_intf);
|
||||
virtual DisplayError Init();
|
||||
virtual DisplayError Deinit();
|
||||
|
@ -56,6 +68,7 @@ class HWHDMI : public HWDevice {
|
|||
virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index);
|
||||
virtual DisplayError Validate(HWLayers *hw_layers);
|
||||
virtual DisplayError SetS3DMode(HWS3DMode s3d_mode);
|
||||
virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
|
||||
|
||||
private:
|
||||
DisplayError ReadEDIDInfo();
|
||||
|
@ -80,6 +93,7 @@ class HWHDMI : public HWDevice {
|
|||
std::map<HWS3DMode, msm_hdmi_s3d_mode> s3d_mode_sdm_to_mdp_;
|
||||
std::vector<HWS3DMode> supported_s3d_modes_;
|
||||
int active_mdp_s3d_mode_ = HDMI_S3D_NONE;
|
||||
uint32_t frame_rate_ = 0;
|
||||
};
|
||||
|
||||
} // namespace sdm
|
||||
|
|
|
@ -110,7 +110,7 @@ DisplayError Strategy::Start(HWLayersInfo *hw_layers_info, uint32_t *max_attempt
|
|||
}
|
||||
|
||||
DisplayError Strategy::Stop() {
|
||||
if (extn_start_success_) {
|
||||
if (strategy_intf_) {
|
||||
return strategy_intf_->Stop();
|
||||
}
|
||||
|
||||
|
@ -186,5 +186,26 @@ void Strategy::GenerateROI() {
|
|||
}
|
||||
}
|
||||
|
||||
} // namespace sdm
|
||||
DisplayError Strategy::Reconfigure(const HWPanelInfo &hw_panel_info,
|
||||
const HWDisplayAttributes &hw_display_attributes) {
|
||||
hw_panel_info_ = hw_panel_info;
|
||||
hw_display_attributes_ = hw_display_attributes;
|
||||
|
||||
if (!extension_intf_) {
|
||||
return kErrorNone;
|
||||
}
|
||||
|
||||
// TODO(user): PU Intf will not be created for video mode panels, hence re-evaluate if
|
||||
// reconfigure is needed.
|
||||
if (partial_update_intf_) {
|
||||
extension_intf_->DestroyPartialUpdate(partial_update_intf_);
|
||||
partial_update_intf_ = NULL;
|
||||
}
|
||||
|
||||
extension_intf_->CreatePartialUpdate(display_type_, hw_resource_info_,
|
||||
hw_panel_info_, &partial_update_intf_);
|
||||
|
||||
return strategy_intf_->Reconfigure(hw_panel_info_.mode, hw_panel_info_.s3d_mode);
|
||||
}
|
||||
|
||||
} // namespace sdm
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright (c) 2014 - 2015, The Linux Foundation. All rights reserved.
|
||||
* Copyright (c) 2014 - 2016, The Linux Foundation. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without modification, are permitted
|
||||
* provided that the following conditions are met:
|
||||
|
@ -43,11 +43,13 @@ class Strategy {
|
|||
bool partial_update_enable);
|
||||
DisplayError GetNextStrategy(StrategyConstraints *constraints);
|
||||
DisplayError Stop();
|
||||
DisplayError Reconfigure(const HWPanelInfo &hw_panel_info,
|
||||
const HWDisplayAttributes &hw_display_attributes);
|
||||
|
||||
private:
|
||||
void GenerateROI();
|
||||
|
||||
ExtensionInterface *extension_intf_;
|
||||
ExtensionInterface *extension_intf_ = NULL;
|
||||
StrategyInterface *strategy_intf_ = NULL;
|
||||
PartialUpdateInterface *partial_update_intf_ = NULL;
|
||||
DisplayType display_type_;
|
||||
|
|
|
@ -181,5 +181,13 @@ DisplayError HWCDebugHandler::GetProperty(const char *property_name, char *value
|
|||
return kErrorNotSupported;
|
||||
}
|
||||
|
||||
DisplayError HWCDebugHandler::SetProperty(const char *property_name, const char *value) {
|
||||
if (property_set(property_name, value) == 0) {
|
||||
return kErrorNone;
|
||||
}
|
||||
|
||||
return kErrorNotSupported;
|
||||
}
|
||||
|
||||
} // namespace sdm
|
||||
|
||||
|
|
|
@ -62,6 +62,7 @@ class HWCDebugHandler : public DebugHandler {
|
|||
virtual void EndTrace();
|
||||
virtual DisplayError GetProperty(const char *property_name, int *value);
|
||||
virtual DisplayError GetProperty(const char *property_name, char *value);
|
||||
virtual DisplayError SetProperty(const char *property_name, const char *value);
|
||||
|
||||
private:
|
||||
static HWCDebugHandler debug_handler_;
|
||||
|
|
|
@ -39,6 +39,7 @@
|
|||
#include <cutils/properties.h>
|
||||
#include <map>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "hwc_display.h"
|
||||
#include "hwc_debugger.h"
|
||||
|
@ -522,7 +523,7 @@ int HWCDisplay::PrePrepareLayerStack(hwc_display_contents_1_t *content_list) {
|
|||
layer->flags.updating = true;
|
||||
|
||||
if (num_hw_layers <= kMaxLayerCount) {
|
||||
layer->flags.updating = IsLayerUpdating(content_list, INT32(i));
|
||||
layer->flags.updating = IsLayerUpdating(content_list, layer);
|
||||
}
|
||||
#ifdef QTI_BSP
|
||||
if (hwc_layer.flags & HWC_SCREENSHOT_ANIMATOR_LAYER) {
|
||||
|
@ -537,11 +538,7 @@ int HWCDisplay::PrePrepareLayerStack(hwc_display_contents_1_t *content_list) {
|
|||
layer_stack_.flags.cursor_present = true;
|
||||
}
|
||||
|
||||
if (layer->frame_rate > metadata_refresh_rate_) {
|
||||
metadata_refresh_rate_ = SanitizeRefreshRate(layer->frame_rate);
|
||||
} else {
|
||||
layer->frame_rate = current_refresh_rate_;
|
||||
}
|
||||
PrepareDynamicRefreshRate(layer);
|
||||
|
||||
layer->input_buffer->buffer_id = reinterpret_cast<uint64_t>(hwc_layer.handle);
|
||||
}
|
||||
|
@ -597,13 +594,6 @@ int HWCDisplay::PrepareLayerStack(hwc_display_contents_1_t *content_list) {
|
|||
flush_ = true;
|
||||
}
|
||||
|
||||
// If current draw cycle has different set of layers updating in comparison to previous cycle,
|
||||
// cache content using GPU again.
|
||||
// If set of updating layers remains same, use cached buffer and replace layers marked for GPU
|
||||
// composition with SDE so that SurfaceFlinger does not compose them. Set cache inuse here.
|
||||
bool needs_fb_refresh = NeedsFrameBufferRefresh(content_list);
|
||||
layer_stack_cache_.in_use = false;
|
||||
|
||||
for (size_t i = 0; i < num_hw_layers; i++) {
|
||||
hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
|
||||
Layer *layer = layer_stack_.layers.at(i);
|
||||
|
@ -613,16 +603,9 @@ int HWCDisplay::PrepareLayerStack(hwc_display_contents_1_t *content_list) {
|
|||
(composition == kCompositionBlit)) {
|
||||
hwc_layer.hints |= HWC_HINT_CLEAR_FB;
|
||||
}
|
||||
|
||||
if (!needs_fb_refresh && composition == kCompositionGPU) {
|
||||
composition = kCompositionSDE;
|
||||
layer_stack_cache_.in_use = true;
|
||||
}
|
||||
SetComposition(composition, &hwc_layer.compositionType);
|
||||
}
|
||||
|
||||
CacheLayerStackInfo(content_list);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -716,7 +699,7 @@ int HWCDisplay::PostCommitLayerStack(hwc_display_contents_1_t *content_list) {
|
|||
// framebuffer layer throughout animation and do not allow framework to do eglswapbuffer on
|
||||
// framebuffer target. So graphics doesn't close the release fence fd of framebuffer target,
|
||||
// Hence close the release fencefd of framebuffer target here.
|
||||
if (layer->composition == kCompositionGPUTarget && layer_stack_cache_.animating) {
|
||||
if (layer->composition == kCompositionGPUTarget && animating_) {
|
||||
close(hwc_layer.releaseFenceFd);
|
||||
hwc_layer.releaseFenceFd = -1;
|
||||
}
|
||||
|
@ -729,8 +712,7 @@ int HWCDisplay::PostCommitLayerStack(hwc_display_contents_1_t *content_list) {
|
|||
}
|
||||
|
||||
if (!flush_) {
|
||||
layer_stack_cache_.animating = layer_stack_.flags.animating;
|
||||
|
||||
animating_ = layer_stack_.flags.animating;
|
||||
// if swapinterval property is set to 0 then close and reset the list retire fence
|
||||
if (swap_interval_zero_) {
|
||||
close(layer_stack_.retire_fence_fd);
|
||||
|
@ -749,98 +731,13 @@ int HWCDisplay::PostCommitLayerStack(hwc_display_contents_1_t *content_list) {
|
|||
return status;
|
||||
}
|
||||
|
||||
|
||||
bool HWCDisplay::NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list) {
|
||||
uint32_t num_hw_layers = UINT32(content_list->numHwLayers);
|
||||
|
||||
// Handle ongoing animation and end here, start is handled below
|
||||
if (layer_stack_cache_.animating) {
|
||||
if (!layer_stack_.flags.animating) {
|
||||
// Animation is ending.
|
||||
return true;
|
||||
} else {
|
||||
// Animation is going on.
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Frame buffer needs to be refreshed for the following reasons:
|
||||
// 1. Any layer is marked skip in the current layer stack.
|
||||
// 2. Any layer is added/removed/layer properties changes in the current layer stack.
|
||||
// 3. Any layer handle is changed and it is marked for GPU composition
|
||||
// 4. Any layer's current composition is different from previous composition.
|
||||
if (layer_stack_.flags.skip_present || layer_stack_.flags.geometry_changed) {
|
||||
return true;
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < num_hw_layers; i++) {
|
||||
Layer *layer = layer_stack_.layers.at(i);
|
||||
LayerCache &layer_cache = layer_stack_cache_.layer_cache[i];
|
||||
|
||||
// need FB refresh for s3d case
|
||||
if (layer->input_buffer->s3d_format != kS3dFormatNone) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (layer->composition == kCompositionGPUTarget ||
|
||||
layer->composition == kCompositionBlitTarget) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (layer_cache.composition != layer->composition) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if ((layer->composition == kCompositionGPU) && IsLayerUpdating(content_list, INT32(i))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool HWCDisplay::IsLayerUpdating(hwc_display_contents_1_t *content_list, int layer_index) {
|
||||
hwc_layer_1_t &hwc_layer = content_list->hwLayers[layer_index];
|
||||
LayerCache &layer_cache = layer_stack_cache_.layer_cache[layer_index];
|
||||
|
||||
const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer.handle);
|
||||
const MetaData_t *meta_data = pvt_handle ?
|
||||
reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata) : NULL;
|
||||
|
||||
bool HWCDisplay::IsLayerUpdating(hwc_display_contents_1_t *content_list, const Layer *layer) {
|
||||
// Layer should be considered updating if
|
||||
// a) layer is in single buffer mode, or
|
||||
// b) layer handle has changed, or
|
||||
// c) layer plane alpha has changed, or
|
||||
// d) layer stack geometry has changed
|
||||
return ((meta_data && (meta_data->operation & SET_SINGLE_BUFFER_MODE) &&
|
||||
meta_data->isSingleBufferMode) ||
|
||||
(layer_cache.handle != hwc_layer.handle) ||
|
||||
(layer_cache.plane_alpha != hwc_layer.planeAlpha) ||
|
||||
(content_list->flags & HWC_GEOMETRY_CHANGED));
|
||||
}
|
||||
|
||||
void HWCDisplay::CacheLayerStackInfo(hwc_display_contents_1_t *content_list) {
|
||||
uint32_t layer_count = UINT32(layer_stack_.layers.size());
|
||||
|
||||
if (layer_count > kMaxLayerCount || layer_stack_.flags.animating) {
|
||||
ResetLayerCacheStack();
|
||||
return;
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < layer_count; i++) {
|
||||
Layer *layer = layer_stack_.layers.at(i);
|
||||
if (layer->composition == kCompositionGPUTarget ||
|
||||
layer->composition == kCompositionBlitTarget) {
|
||||
continue;
|
||||
}
|
||||
|
||||
LayerCache &layer_cache = layer_stack_cache_.layer_cache[i];
|
||||
layer_cache.handle = content_list->hwLayers[i].handle;
|
||||
layer_cache.plane_alpha = content_list->hwLayers[i].planeAlpha;
|
||||
layer_cache.composition = layer->composition;
|
||||
}
|
||||
|
||||
layer_stack_cache_.layer_count = layer_count;
|
||||
// b) valid dirty_regions(android specific hint for updating status), or
|
||||
// c) layer stack geometry has changed
|
||||
return (layer->flags.single_buffer || IsSurfaceUpdated(layer->dirty_regions) ||
|
||||
(layer_stack_.flags.geometry_changed));
|
||||
}
|
||||
|
||||
void HWCDisplay::SetRect(const hwc_rect_t &source, LayerRect *target) {
|
||||
|
@ -1314,21 +1211,6 @@ void HWCDisplay::MarkLayersForGPUBypass(hwc_display_contents_1_t *content_list)
|
|||
}
|
||||
}
|
||||
|
||||
uint32_t HWCDisplay::RoundToStandardFPS(uint32_t fps) {
|
||||
static const uint32_t standard_fps[4] = {30, 24, 48, 60};
|
||||
|
||||
int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
|
||||
for (int i = 0; i < count; i++) {
|
||||
if ((standard_fps[i] - fps) < 2) {
|
||||
// Most likely used for video, the fps can fluctuate
|
||||
// Ex: b/w 29 and 30 for 30 fps clip
|
||||
return standard_fps[i];
|
||||
}
|
||||
}
|
||||
|
||||
return fps;
|
||||
}
|
||||
|
||||
void HWCDisplay::ApplyScanAdjustment(hwc_rect_t *display_frame) {
|
||||
}
|
||||
|
||||
|
@ -1466,16 +1348,6 @@ int HWCDisplay::GetVisibleDisplayRect(hwc_rect_t* visible_rect) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
void HWCDisplay::ResetLayerCacheStack() {
|
||||
uint32_t layer_count = layer_stack_cache_.layer_count;
|
||||
for (uint32_t i = 0; i < layer_count; i++) {
|
||||
layer_stack_cache_.layer_cache[i] = LayerCache();
|
||||
}
|
||||
layer_stack_cache_.layer_count = 0;
|
||||
layer_stack_cache_.animating = false;
|
||||
layer_stack_cache_.in_use = false;
|
||||
}
|
||||
|
||||
void HWCDisplay::SetSecureDisplay(bool secure_display_active) {
|
||||
secure_display_active_ = secure_display_active;
|
||||
return;
|
||||
|
@ -1497,6 +1369,8 @@ int HWCDisplay::GetDisplayAttributesForConfig(int config, DisplayConfigVariableI
|
|||
return display_intf_->GetConfig(UINT32(config), attributes) == kErrorNone ? 0 : -1;
|
||||
}
|
||||
|
||||
// TODO(user): HWC needs to know updating for dyn_fps, cpu hint features,
|
||||
// once the features are moved to SDM, the two functions below can be removed.
|
||||
bool HWCDisplay::SingleLayerUpdating(uint32_t app_layer_count) {
|
||||
uint32_t updating_count = 0;
|
||||
|
||||
|
@ -1510,6 +1384,35 @@ bool HWCDisplay::SingleLayerUpdating(uint32_t app_layer_count) {
|
|||
return (updating_count == 1);
|
||||
}
|
||||
|
||||
bool HWCDisplay::SingleVideoLayerUpdating(uint32_t app_layer_count) {
|
||||
uint32_t updating_count = 0;
|
||||
|
||||
for (uint i = 0; i < app_layer_count; i++) {
|
||||
Layer *layer = layer_stack_.layers[i];
|
||||
if (layer->flags.updating && (layer->input_buffer->flags.video == true)) {
|
||||
updating_count++;
|
||||
}
|
||||
}
|
||||
|
||||
return (updating_count == 1);
|
||||
}
|
||||
|
||||
uint32_t HWCDisplay::RoundToStandardFPS(float fps) {
|
||||
static const uint32_t standard_fps[4] = {30, 24, 48, 60};
|
||||
uint32_t frame_rate = (uint32_t)(fps);
|
||||
|
||||
int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
|
||||
for (int i = 0; i < count; i++) {
|
||||
if ((standard_fps[i] - frame_rate) < 2) {
|
||||
// Most likely used for video, the fps can fluctuate
|
||||
// Ex: b/w 29 and 30 for 30 fps clip
|
||||
return standard_fps[i];
|
||||
}
|
||||
}
|
||||
|
||||
return frame_rate;
|
||||
}
|
||||
|
||||
uint32_t HWCDisplay::SanitizeRefreshRate(uint32_t req_refresh_rate) {
|
||||
uint32_t refresh_rate = req_refresh_rate;
|
||||
|
||||
|
@ -1530,4 +1433,20 @@ DisplayClass HWCDisplay::GetDisplayClass() {
|
|||
return display_class_;
|
||||
}
|
||||
|
||||
void HWCDisplay::PrepareDynamicRefreshRate(Layer *layer) {
|
||||
if (layer->frame_rate > metadata_refresh_rate_) {
|
||||
metadata_refresh_rate_ = SanitizeRefreshRate(layer->frame_rate);
|
||||
} else {
|
||||
layer->frame_rate = current_refresh_rate_;
|
||||
}
|
||||
}
|
||||
|
||||
bool HWCDisplay::IsSurfaceUpdated(const std::vector<LayerRect> &dirty_regions) {
|
||||
// based on dirty_regions determine if its updating
|
||||
// dirty_rect count = 0 - whole layer - updating.
|
||||
// dirty_rect count = 1 or more valid rects - updating.
|
||||
// dirty_rect count = 1 with (0,0,0,0) - not updating.
|
||||
return (dirty_regions.empty() || IsValid(dirty_regions.at(0)));
|
||||
}
|
||||
|
||||
} // namespace sdm
|
||||
|
|
|
@ -31,6 +31,7 @@
|
|||
#include <QService.h>
|
||||
#include <private/color_params.h>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
namespace sdm {
|
||||
|
||||
|
@ -117,23 +118,6 @@ class HWCDisplay : public DisplayEventHandler {
|
|||
// Maximum number of layers supported by display manager.
|
||||
static const uint32_t kMaxLayerCount = 32;
|
||||
|
||||
struct LayerCache {
|
||||
buffer_handle_t handle;
|
||||
uint8_t plane_alpha;
|
||||
LayerComposition composition;
|
||||
|
||||
LayerCache() : handle(NULL), plane_alpha(0xff), composition(kCompositionGPU) { }
|
||||
};
|
||||
|
||||
struct LayerStackCache {
|
||||
LayerCache layer_cache[kMaxLayerCount];
|
||||
uint32_t layer_count;
|
||||
bool animating;
|
||||
bool in_use;
|
||||
|
||||
LayerStackCache() : layer_count(0), animating(false), in_use(false) { }
|
||||
};
|
||||
|
||||
HWCDisplay(CoreInterface *core_intf, hwc_procs_t const **hwc_procs, DisplayType type, int id,
|
||||
bool needs_blit, qService::QService *qservice, DisplayClass display_class);
|
||||
|
||||
|
@ -149,6 +133,9 @@ class HWCDisplay : public DisplayEventHandler {
|
|||
virtual int CommitLayerStack(hwc_display_contents_1_t *content_list);
|
||||
virtual int PostCommitLayerStack(hwc_display_contents_1_t *content_list);
|
||||
virtual void DumpOutputBuffer(const BufferInfo& buffer_info, void *base, int fence);
|
||||
virtual uint32_t RoundToStandardFPS(float fps);
|
||||
virtual uint32_t SanitizeRefreshRate(uint32_t req_refresh_rate);
|
||||
virtual void PrepareDynamicRefreshRate(Layer *layer);
|
||||
inline void SetRect(const hwc_rect_t &source, LayerRect *target);
|
||||
inline void SetRect(const hwc_frect_t &source, LayerRect *target);
|
||||
inline void SetComposition(const int32_t &source, LayerComposition *target);
|
||||
|
@ -160,16 +147,15 @@ class HWCDisplay : public DisplayEventHandler {
|
|||
const char *GetDisplayString();
|
||||
void ScaleDisplayFrame(hwc_rect_t *display_frame);
|
||||
void MarkLayersForGPUBypass(hwc_display_contents_1_t *content_list);
|
||||
uint32_t RoundToStandardFPS(uint32_t fps);
|
||||
virtual void ApplyScanAdjustment(hwc_rect_t *display_frame);
|
||||
DisplayError SetCSC(ColorSpace_t source, LayerCSC *target);
|
||||
DisplayError SetIGC(IGC_t source, LayerIGC *target);
|
||||
DisplayError SetMetaData(const private_handle_t *pvt_handle, Layer *layer);
|
||||
bool NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list);
|
||||
void CacheLayerStackInfo(hwc_display_contents_1_t *content_list);
|
||||
bool IsLayerUpdating(hwc_display_contents_1_t *content_list, int layer_index);
|
||||
bool IsLayerUpdating(hwc_display_contents_1_t *content_list, const Layer *layer);
|
||||
bool SingleLayerUpdating(uint32_t app_layer_count);
|
||||
uint32_t SanitizeRefreshRate(uint32_t req_refresh_rate);
|
||||
bool SingleVideoLayerUpdating(uint32_t app_layer_count);
|
||||
bool IsSurfaceUpdated(const std::vector<LayerRect> &dirty_regions);
|
||||
|
||||
enum {
|
||||
INPUT_LAYER_DUMP,
|
||||
|
@ -183,7 +169,6 @@ class HWCDisplay : public DisplayEventHandler {
|
|||
bool needs_blit_ = false;
|
||||
DisplayInterface *display_intf_ = NULL;
|
||||
LayerStack layer_stack_;
|
||||
LayerStackCache layer_stack_cache_;
|
||||
bool flush_on_error_ = false;
|
||||
bool flush_ = false;
|
||||
uint32_t dump_frame_count_ = 0;
|
||||
|
@ -208,13 +193,13 @@ class HWCDisplay : public DisplayEventHandler {
|
|||
uint32_t solid_fill_color_ = 0;
|
||||
LayerRect display_rect_;
|
||||
std::map<int, LayerBufferS3DFormat> s3d_format_hwc_to_sdm_;
|
||||
bool animating_ = false;
|
||||
|
||||
private:
|
||||
bool IsFrameBufferScaled();
|
||||
void DumpInputBuffers(hwc_display_contents_1_t *content_list);
|
||||
int PrepareLayerParams(hwc_layer_1_t *hwc_layer, Layer *layer);
|
||||
void CommitLayerParams(hwc_layer_1_t *hwc_layer, Layer *layer);
|
||||
void ResetLayerCacheStack();
|
||||
BlitEngine *blit_engine_ = NULL;
|
||||
qService::QService *qservice_ = NULL;
|
||||
DisplayClass display_class_;
|
||||
|
|
|
@ -49,6 +49,7 @@ int HWCDisplayExternal::Create(CoreInterface *core_intf, hwc_procs_t const **hwc
|
|||
HWCDisplay **hwc_display) {
|
||||
uint32_t external_width = 0;
|
||||
uint32_t external_height = 0;
|
||||
int drc_enabled = 0;
|
||||
|
||||
HWCDisplay *hwc_display_external = new HWCDisplayExternal(core_intf, hwc_procs, qservice);
|
||||
int status = hwc_display_external->Init();
|
||||
|
@ -80,6 +81,9 @@ int HWCDisplayExternal::Create(CoreInterface *core_intf, hwc_procs_t const **hwc
|
|||
return status;
|
||||
}
|
||||
|
||||
HWCDebugHandler::Get()->GetProperty("sdm.hdmi.drc_enabled", &(drc_enabled));
|
||||
reinterpret_cast<HWCDisplayExternal *>(hwc_display_external)->drc_enabled_ = drc_enabled;
|
||||
|
||||
*hwc_display = hwc_display_external;
|
||||
|
||||
return status;
|
||||
|
@ -98,6 +102,7 @@ HWCDisplayExternal::HWCDisplayExternal(CoreInterface *core_intf, hwc_procs_t con
|
|||
|
||||
int HWCDisplayExternal::Prepare(hwc_display_contents_1_t *content_list) {
|
||||
int status = 0;
|
||||
DisplayError error = kErrorNone;
|
||||
|
||||
if (secure_display_active_) {
|
||||
MarkLayersForGPUBypass(content_list);
|
||||
|
@ -119,6 +124,18 @@ int HWCDisplayExternal::Prepare(hwc_display_contents_1_t *content_list) {
|
|||
return 0;
|
||||
}
|
||||
|
||||
bool one_video_updating_layer = SingleVideoLayerUpdating(UINT32(content_list->numHwLayers - 1));
|
||||
|
||||
if (current_refresh_rate_ != metadata_refresh_rate_ && one_video_updating_layer && drc_enabled_) {
|
||||
error = display_intf_->SetRefreshRate(metadata_refresh_rate_);
|
||||
}
|
||||
|
||||
if (error == kErrorNone) {
|
||||
// On success, set current refresh rate to new refresh rate
|
||||
current_refresh_rate_ = metadata_refresh_rate_;
|
||||
}
|
||||
|
||||
|
||||
status = PrepareLayerStack(content_list);
|
||||
if (status) {
|
||||
return status;
|
||||
|
@ -221,5 +238,36 @@ void HWCDisplayExternal::GetDownscaleResolution(uint32_t primary_width, uint32_t
|
|||
}
|
||||
}
|
||||
|
||||
uint32_t HWCDisplayExternal::RoundToStandardFPS(float fps) {
|
||||
static const uint32_t standard_fps[] = {23976, 24000, 25000, 29970, 30000, 50000, 59940, 60000};
|
||||
static const uint32_t mapping_fps[] = {59940, 60000, 60000, 59940, 60000, 50000, 59940, 60000};
|
||||
uint32_t frame_rate = (uint32_t)(fps * 1000);
|
||||
|
||||
int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
|
||||
for (int i = 0; i < count; i++) {
|
||||
// Most likely used for video, the fps for frames should be stable from video side.
|
||||
if (standard_fps[i] > frame_rate) {
|
||||
if (i > 0) {
|
||||
if ((standard_fps[i] - frame_rate) > (frame_rate - standard_fps[i-1])) {
|
||||
return mapping_fps[i-1];
|
||||
} else {
|
||||
return mapping_fps[i];
|
||||
}
|
||||
} else {
|
||||
return mapping_fps[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return standard_fps[count - 1];
|
||||
}
|
||||
|
||||
void HWCDisplayExternal::PrepareDynamicRefreshRate(Layer *layer) {
|
||||
if (layer->input_buffer->flags.video) {
|
||||
metadata_refresh_rate_ = SanitizeRefreshRate(layer->frame_rate);
|
||||
layer->frame_rate = current_refresh_rate_;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace sdm
|
||||
|
||||
|
|
|
@ -41,6 +41,11 @@ class HWCDisplayExternal : public HWCDisplay {
|
|||
virtual int Commit(hwc_display_contents_1_t *content_list);
|
||||
virtual void SetSecureDisplay(bool secure_display_active);
|
||||
|
||||
protected:
|
||||
virtual uint32_t RoundToStandardFPS(float fps);
|
||||
virtual void PrepareDynamicRefreshRate(Layer *layer);
|
||||
int drc_enabled_ = 0;
|
||||
|
||||
private:
|
||||
HWCDisplayExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs,
|
||||
qService::QService *qservice);
|
||||
|
|
|
@ -154,9 +154,12 @@ int HWCSession::Init() {
|
|||
if (hw_disp_info.type == kHDMI) {
|
||||
// HDMI is primary display. If already connected, then create it and store in
|
||||
// primary display slot. If not connected, create a NULL display for now.
|
||||
HWCDebugHandler::Get()->SetProperty("persist.sys.is_hdmi_primary", "1");
|
||||
is_hdmi_primary_ = true;
|
||||
if (hw_disp_info.is_connected) {
|
||||
status = HWCDisplayExternal::Create(core_intf_, &hwc_procs_, qservice_,
|
||||
&hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
is_hdmi_yuv_ = IsDisplayYUV(HWC_DISPLAY_PRIMARY);
|
||||
} else {
|
||||
// NullDisplay simply closes all its fences, and advertizes a standard
|
||||
// resolution to SurfaceFlinger
|
||||
|
@ -164,14 +167,14 @@ int HWCSession::Init() {
|
|||
&hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
}
|
||||
} else {
|
||||
// Create and power on primary display
|
||||
status = HWCDisplayPrimary::Create(core_intf_, buffer_allocator_, &hwc_procs_, qservice_,
|
||||
&hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
// Create and power on primary display
|
||||
status = HWCDisplayPrimary::Create(core_intf_, buffer_allocator_, &hwc_procs_, qservice_,
|
||||
&hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
}
|
||||
} else {
|
||||
// Create and power on primary display
|
||||
status = HWCDisplayPrimary::Create(core_intf_, buffer_allocator_, &hwc_procs_, qservice_,
|
||||
&hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
// Create and power on primary display
|
||||
status = HWCDisplayPrimary::Create(core_intf_, buffer_allocator_, &hwc_procs_, qservice_,
|
||||
&hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
}
|
||||
|
||||
if (status) {
|
||||
|
@ -300,8 +303,11 @@ int HWCSession::Prepare(hwc_composer_device_1 *device, size_t num_displays,
|
|||
// If virtual display content list is invalid, disconnect virtual display if connected.
|
||||
// If external display connection is pending, connect external display when virtual
|
||||
// display is destroyed.
|
||||
// If HDMI is primary and the output format is YUV then ignore the virtual display
|
||||
// content list.
|
||||
if (dpy == HWC_DISPLAY_VIRTUAL) {
|
||||
if (hwc_session->hwc_display_[HWC_DISPLAY_EXTERNAL]) {
|
||||
if (hwc_session->hwc_display_[HWC_DISPLAY_EXTERNAL] ||
|
||||
(hwc_session->is_hdmi_primary_ && hwc_session->is_hdmi_yuv_)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
@ -431,6 +437,30 @@ void HWCSession::CloseAcquireFds(hwc_display_contents_1_t *content_list) {
|
|||
}
|
||||
}
|
||||
|
||||
bool HWCSession::IsDisplayYUV(int disp) {
|
||||
int error = -EINVAL;
|
||||
bool is_yuv = false;
|
||||
DisplayConfigVariableInfo attributes = {};
|
||||
|
||||
if (disp < 0 || disp >= HWC_NUM_DISPLAY_TYPES || !hwc_display_[disp]) {
|
||||
DLOGE("Invalid input parameters. Display = %d", disp);
|
||||
return is_yuv;
|
||||
}
|
||||
|
||||
uint32_t active_config = 0;
|
||||
error = hwc_display_[disp]->GetActiveDisplayConfig(&active_config);
|
||||
if (!error) {
|
||||
error = hwc_display_[disp]->GetDisplayAttributesForConfig(INT(active_config), &attributes);
|
||||
if (error == 0) {
|
||||
is_yuv = attributes.is_yuv;
|
||||
} else {
|
||||
DLOGW("Error querying display attributes. Display = %d, Config = %d", disp, active_config);
|
||||
}
|
||||
}
|
||||
|
||||
return is_yuv;
|
||||
}
|
||||
|
||||
int HWCSession::EventControl(hwc_composer_device_1 *device, int disp, int event, int enable) {
|
||||
if (!device) {
|
||||
return -EINVAL;
|
||||
|
@ -932,6 +962,7 @@ android::status_t HWCSession::HandleGetDisplayAttributesForConfig(const android:
|
|||
output_parcel->writeFloat(attributes.x_dpi);
|
||||
output_parcel->writeFloat(attributes.y_dpi);
|
||||
output_parcel->writeInt32(0); // Panel type, unsupported.
|
||||
output_parcel->writeInt32(attributes.is_yuv);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1325,7 +1356,6 @@ void HWCSession::ResetPanel() {
|
|||
int HWCSession::HotPlugHandler(bool connected) {
|
||||
int status = 0;
|
||||
bool notify_hotplug = false;
|
||||
bool hdmi_primary = false;
|
||||
|
||||
// To prevent sending events to client while a lock is held, acquire scope locks only within
|
||||
// below scope so that those get automatically unlocked after the scope ends.
|
||||
|
@ -1343,20 +1373,15 @@ int HWCSession::HotPlugHandler(bool connected) {
|
|||
HWCDisplay *null_display = NULL;
|
||||
|
||||
if (primary_display->GetDisplayClass() == DISPLAY_CLASS_EXTERNAL) {
|
||||
external_display = static_cast<HWCDisplayExternal *>(hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
external_display = static_cast<HWCDisplayExternal *>(hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
} else if (primary_display->GetDisplayClass() == DISPLAY_CLASS_NULL) {
|
||||
null_display = static_cast<HWCDisplayNull *>(hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
}
|
||||
|
||||
if (external_display || null_display) {
|
||||
hdmi_primary = true;
|
||||
null_display = static_cast<HWCDisplayNull *>(hwc_display_[HWC_DISPLAY_PRIMARY]);
|
||||
}
|
||||
|
||||
// If primary display connected is a NULL display, then replace it with the external display
|
||||
if (connected) {
|
||||
// If we are in HDMI as primary and the primary display just got plugged in
|
||||
if (null_display) {
|
||||
assert(hdmi_primary);
|
||||
if (is_hdmi_primary_ && null_display) {
|
||||
uint32_t primary_width, primary_height;
|
||||
null_display->GetFrameBufferResolution(&primary_width, &primary_height);
|
||||
delete null_display;
|
||||
|
@ -1374,6 +1399,8 @@ int HWCSession::HotPlugHandler(bool connected) {
|
|||
return -1;
|
||||
}
|
||||
|
||||
is_hdmi_yuv_ = IsDisplayYUV(HWC_DISPLAY_PRIMARY);
|
||||
|
||||
// Next, go ahead and enable vsync on external display. This is expliclity required
|
||||
// because in HDMI as primary case, SurfaceFlinger may not be aware of underlying
|
||||
// changing display. and thus may not explicitly enable vsync
|
||||
|
@ -1386,22 +1413,22 @@ int HWCSession::HotPlugHandler(bool connected) {
|
|||
notify_hotplug = false;
|
||||
} else {
|
||||
if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
|
||||
DLOGE("HDMI is already connected");
|
||||
return -1;
|
||||
DLOGE("HDMI is already connected");
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Connect external display if virtual display is not connected.
|
||||
// Else, defer external display connection and process it when virtual display
|
||||
// tears down; Do not notify SurfaceFlinger since connection is deferred now.
|
||||
if (!hwc_display_[HWC_DISPLAY_VIRTUAL]) {
|
||||
status = ConnectDisplay(HWC_DISPLAY_EXTERNAL, NULL);
|
||||
if (status) {
|
||||
status = ConnectDisplay(HWC_DISPLAY_EXTERNAL, NULL);
|
||||
if (status) {
|
||||
return status;
|
||||
}
|
||||
notify_hotplug = true;
|
||||
}
|
||||
notify_hotplug = true;
|
||||
} else {
|
||||
DLOGI("Virtual display is connected, pending connection");
|
||||
external_pending_connect_ = true;
|
||||
DLOGI("Virtual display is connected, pending connection");
|
||||
external_pending_connect_ = true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
|
@ -1409,8 +1436,7 @@ int HWCSession::HotPlugHandler(bool connected) {
|
|||
// Due to virtual display concurrency, external display connection might be still pending
|
||||
// but hdmi got disconnected before pending connection could be processed.
|
||||
|
||||
if (hdmi_primary) {
|
||||
assert(external_display != NULL);
|
||||
if (is_hdmi_primary_ && external_display) {
|
||||
uint32_t x_res, y_res;
|
||||
external_display->GetFrameBufferResolution(&x_res, &y_res);
|
||||
// Need to manually disable VSYNC as SF is not aware of connect/disconnect cases
|
||||
|
@ -1435,8 +1461,8 @@ int HWCSession::HotPlugHandler(bool connected) {
|
|||
notify_hotplug = false;
|
||||
} else {
|
||||
if (hwc_display_[HWC_DISPLAY_EXTERNAL]) {
|
||||
status = DisconnectDisplay(HWC_DISPLAY_EXTERNAL);
|
||||
notify_hotplug = true;
|
||||
status = DisconnectDisplay(HWC_DISPLAY_EXTERNAL);
|
||||
notify_hotplug = true;
|
||||
}
|
||||
external_pending_connect_ = false;
|
||||
}
|
||||
|
|
|
@ -73,6 +73,7 @@ class HWCSession : hwc_composer_device_1_t, public qClient::BnQClient {
|
|||
static int SetActiveConfig(hwc_composer_device_1 *device, int disp, int index);
|
||||
static int SetCursorPositionAsync(hwc_composer_device_1 *device, int disp, int x, int y);
|
||||
static void CloseAcquireFds(hwc_display_contents_1_t *content_list);
|
||||
bool IsDisplayYUV(int disp);
|
||||
|
||||
// Uevent thread
|
||||
static void* HWCUeventThread(void *context);
|
||||
|
@ -140,6 +141,8 @@ class HWCSession : hwc_composer_device_1_t, public qClient::BnQClient {
|
|||
bool need_invalidate_ = false;
|
||||
int bw_mode_release_fd_ = -1;
|
||||
qService::QService *qservice_ = NULL;
|
||||
bool is_hdmi_primary_ = false;
|
||||
bool is_hdmi_yuv_ = false;
|
||||
};
|
||||
|
||||
} // namespace sdm
|
||||
|
|
|
@ -17,19 +17,23 @@
|
|||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include <math.h>
|
||||
#include <cutils/properties.h>
|
||||
#include <errno.h>
|
||||
#include <gralloc_priv.h>
|
||||
#include <gr.h>
|
||||
#include <gralloc_priv.h>
|
||||
#include <math.h>
|
||||
#include <sync/sync.h>
|
||||
#include <utils/constants.h>
|
||||
#include <utils/debug.h>
|
||||
#include <utils/formats.h>
|
||||
#include <utils/rect.h>
|
||||
#include <utils/debug.h>
|
||||
#include <sync/sync.h>
|
||||
#include <cutils/properties.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "hwc_display.h"
|
||||
#include "hwc_debugger.h"
|
||||
|
@ -52,6 +56,155 @@ static void ApplyDeInterlaceAdjustment(Layer *layer) {
|
|||
}
|
||||
}
|
||||
|
||||
HWCColorMode::HWCColorMode(DisplayInterface *display_intf) : display_intf_(display_intf) {}
|
||||
|
||||
HWC2::Error HWCColorMode::Init() {
|
||||
PopulateColorModes();
|
||||
return HWC2::Error::None;
|
||||
}
|
||||
|
||||
HWC2::Error HWCColorMode::DeInit() {
|
||||
color_mode_transform_map_.clear();
|
||||
return HWC2::Error::None;
|
||||
}
|
||||
|
||||
uint32_t HWCColorMode::GetColorModeCount() {
|
||||
uint32_t count = UINT32(color_mode_transform_map_.size());
|
||||
DLOGI("Supported color mode count = %d", count);
|
||||
|
||||
return std::max(1U, count);
|
||||
}
|
||||
|
||||
HWC2::Error HWCColorMode::GetColorModes(uint32_t *out_num_modes,
|
||||
int32_t /*android_color_mode_t*/ *out_modes) {
|
||||
auto it = color_mode_transform_map_.begin();
|
||||
for (auto i = 0; it != color_mode_transform_map_.end(); it++, i++) {
|
||||
out_modes[i] = it->first;
|
||||
DLOGI("Supports color mode[%d] = %d", i, it->first);
|
||||
}
|
||||
*out_num_modes = UINT32(color_mode_transform_map_.size());
|
||||
return HWC2::Error::None;
|
||||
}
|
||||
|
||||
HWC2::Error HWCColorMode::SetColorMode(int32_t /*android_color_mode_t*/ mode) {
|
||||
// first mode in 2D matrix is the mode (identity)
|
||||
auto status = HandleColorModeTransform(mode, current_color_transform_, color_matrix_);
|
||||
if (status != HWC2::Error::None) {
|
||||
DLOGE("failed for mode = %d", mode);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
HWC2::Error HWCColorMode::SetColorTransform(const float *matrix, android_color_transform_t hint) {
|
||||
if (!matrix) {
|
||||
return HWC2::Error::BadParameter;
|
||||
}
|
||||
|
||||
double color_matrix[kColorTransformMatrixCount] = {0};
|
||||
CopyColorTransformMatrix(matrix, color_matrix);
|
||||
|
||||
auto status = HandleColorModeTransform(current_color_mode_, hint, color_matrix);
|
||||
if (status != HWC2::Error::None) {
|
||||
DLOGE("failed for hint = %d", hint);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
HWC2::Error HWCColorMode::HandleColorModeTransform(int32_t /*android_color_mode_t*/ mode,
|
||||
android_color_transform_t hint,
|
||||
const double *matrix) {
|
||||
android_color_transform_t transform_hint = hint;
|
||||
std::string color_mode_transform;
|
||||
bool use_matrix = false;
|
||||
if (hint != HAL_COLOR_TRANSFORM_ARBITRARY_MATRIX) {
|
||||
// if the mode + transfrom request from HWC matches one mode in SDM, set that
|
||||
color_mode_transform = color_mode_transform_map_[mode][hint];
|
||||
if (color_mode_transform.empty()) {
|
||||
transform_hint = HAL_COLOR_TRANSFORM_IDENTITY;
|
||||
use_matrix = true;
|
||||
}
|
||||
} else {
|
||||
use_matrix = true;
|
||||
transform_hint = HAL_COLOR_TRANSFORM_IDENTITY;
|
||||
}
|
||||
|
||||
color_mode_transform = color_mode_transform_map_[mode][transform_hint];
|
||||
DisplayError error = display_intf_->SetColorMode(color_mode_transform);
|
||||
if (error != kErrorNone) {
|
||||
DLOGE("Failed to set color_mode = %d transform_hint = %d", mode, hint);
|
||||
// TODO(user): make use client composition
|
||||
return HWC2::Error::Unsupported;
|
||||
}
|
||||
|
||||
if (use_matrix) {
|
||||
DisplayError error = display_intf_->SetColorTransform(kColorTransformMatrixCount, matrix);
|
||||
if (error != kErrorNone) {
|
||||
DLOGE("Failed to set Color Transform Matrix");
|
||||
// TODO(user): make use client composition
|
||||
return HWC2::Error::Unsupported;
|
||||
}
|
||||
}
|
||||
|
||||
current_color_mode_ = mode;
|
||||
current_color_transform_ = hint;
|
||||
CopyColorTransformMatrix(matrix, color_matrix_);
|
||||
DLOGI("Setting Color Mode = %d Transform Hint = %d Success", mode, hint);
|
||||
|
||||
return HWC2::Error::None;
|
||||
}
|
||||
|
||||
void HWCColorMode::PopulateColorModes() {
|
||||
uint32_t color_mode_count = 0;
|
||||
// SDM returns modes which is string combination of mode + transform.
|
||||
DisplayError error = display_intf_->GetColorModeCount(&color_mode_count);
|
||||
if (error != kErrorNone || (color_mode_count == 0)) {
|
||||
DLOGW("GetColorModeCount failed, use native color mode");
|
||||
PopulateTransform(0, "native_identity");
|
||||
return;
|
||||
}
|
||||
|
||||
DLOGI("Color Modes supported count = %d", color_mode_count);
|
||||
|
||||
std::vector<std::string> color_modes(color_mode_count);
|
||||
error = display_intf_->GetColorModes(&color_mode_count, &color_modes);
|
||||
|
||||
for (uint32_t i = 0; i < color_mode_count; i++) {
|
||||
std::string &mode_string = color_modes.at(i);
|
||||
DLOGI("Color Mode[%d] = %s", i, mode_string.c_str());
|
||||
if (mode_string.find("native") != std::string::npos) {
|
||||
// TODO(user): replace numbers(0,1..) with android_color_mode_t
|
||||
PopulateTransform(0, mode_string);
|
||||
} else if (mode_string.find("srgb") != std::string::npos) {
|
||||
PopulateTransform(1, mode_string);
|
||||
} else if (mode_string.find("adobe") != std::string::npos) {
|
||||
PopulateTransform(2, mode_string);
|
||||
} else if (mode_string.find("dci3") != std::string::npos) {
|
||||
PopulateTransform(3, mode_string);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void HWCColorMode::PopulateTransform(const int32_t &mode, const std::string &color_transform) {
|
||||
// TODO(user): Check the substring from QDCM
|
||||
if (color_transform.find("identity") != std::string::npos) {
|
||||
color_mode_transform_map_[mode][HAL_COLOR_TRANSFORM_IDENTITY] = color_transform;
|
||||
} else if (color_transform.find("artitrary") != std::string::npos) {
|
||||
// no color mode for arbitrary
|
||||
} else if (color_transform.find("inverse") != std::string::npos) {
|
||||
color_mode_transform_map_[mode][HAL_COLOR_TRANSFORM_VALUE_INVERSE] = color_transform;
|
||||
} else if (color_transform.find("grayscale") != std::string::npos) {
|
||||
color_mode_transform_map_[mode][HAL_COLOR_TRANSFORM_GRAYSCALE] = color_transform;
|
||||
} else if (color_transform.find("correct_protonopia") != std::string::npos) {
|
||||
color_mode_transform_map_[mode][HAL_COLOR_TRANSFORM_CORRECT_PROTANOPIA] = color_transform;
|
||||
} else if (color_transform.find("correct_deuteranopia") != std::string::npos) {
|
||||
color_mode_transform_map_[mode][HAL_COLOR_TRANSFORM_CORRECT_DEUTERANOPIA] = color_transform;
|
||||
} else if (color_transform.find("correct_tritanopia") != std::string::npos) {
|
||||
color_mode_transform_map_[mode][HAL_COLOR_TRANSFORM_CORRECT_TRITANOPIA] = color_transform;
|
||||
}
|
||||
}
|
||||
|
||||
HWCDisplay::HWCDisplay(CoreInterface *core_intf, HWCCallbacks *callbacks, DisplayType type,
|
||||
hwc2_display_t id, bool needs_blit, qService::QService *qservice,
|
||||
DisplayClass display_class)
|
||||
|
@ -123,6 +276,11 @@ int HWCDisplay::Deinit() {
|
|||
blit_engine_ = NULL;
|
||||
}
|
||||
|
||||
if (color_mode_) {
|
||||
color_mode_->DeInit();
|
||||
delete color_mode_;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -166,8 +324,6 @@ HWC2::Error HWCDisplay::DestroyLayer(hwc2_layer_t layer_id) {
|
|||
}
|
||||
|
||||
void HWCDisplay::BuildLayerStack() {
|
||||
// TODO(user): Validate
|
||||
validated_ = true;
|
||||
layer_stack_ = LayerStack();
|
||||
display_rect_ = LayerRect();
|
||||
metadata_refresh_rate_ = 0;
|
||||
|
@ -354,6 +510,15 @@ HWC2::Error HWCDisplay::GetClientTargetSupport(uint32_t width, uint32_t height,
|
|||
}
|
||||
}
|
||||
|
||||
HWC2::Error HWCDisplay::GetColorModes(uint32_t *out_num_modes, int32_t *out_modes) {
|
||||
if (out_modes) {
|
||||
out_modes[0] = 0; // TODO(user): Change to android_color_mode_t
|
||||
}
|
||||
*out_num_modes = 1;
|
||||
|
||||
return HWC2::Error::None;
|
||||
}
|
||||
|
||||
HWC2::Error HWCDisplay::GetDisplayConfigs(uint32_t *out_num_configs, hwc2_config_t *out_configs) {
|
||||
// TODO(user): Actually handle multiple configs
|
||||
if (out_configs == nullptr) {
|
||||
|
@ -362,6 +527,7 @@ HWC2::Error HWCDisplay::GetDisplayConfigs(uint32_t *out_num_configs, hwc2_config
|
|||
*out_num_configs = 1;
|
||||
out_configs[0] = 0;
|
||||
}
|
||||
|
||||
return HWC2::Error::None;
|
||||
}
|
||||
|
||||
|
@ -444,6 +610,13 @@ HWC2::Error HWCDisplay::GetActiveConfig(hwc2_config_t *out_config) {
|
|||
|
||||
HWC2::Error HWCDisplay::SetClientTarget(buffer_handle_t target, int32_t acquire_fence,
|
||||
int32_t dataspace) {
|
||||
// TODO(user): SurfaceFlinger gives us a null pointer here when doing full SDE composition
|
||||
// The error is problematic for layer caching as it would overwrite our cached client target.
|
||||
// Reported bug 28569722 to resolve this.
|
||||
// For now, continue to use the last valid buffer reported to us for layer caching.
|
||||
if (target == nullptr) {
|
||||
return HWC2::Error::None;
|
||||
}
|
||||
client_target_->SetLayerBuffer(target, acquire_fence);
|
||||
// Ignoring dataspace for now
|
||||
return HWC2::Error::None;
|
||||
|
@ -591,6 +764,10 @@ HWC2::Error HWCDisplay::GetDisplayRequests(int32_t *out_display_requests,
|
|||
// Use for sharing blit buffers and
|
||||
// writing wfd buffer directly to output if there is full GPU composition
|
||||
// and no color conversion needed
|
||||
if (!validated_) {
|
||||
DLOGW("Display is not validated");
|
||||
return HWC2::Error::NotValidated;
|
||||
}
|
||||
*out_display_requests = 0;
|
||||
*out_num_elements = UINT32(layer_requests_.size());
|
||||
if (out_layers != nullptr && out_layer_requests != nullptr) {
|
||||
|
@ -619,6 +796,7 @@ HWC2::Error HWCDisplay::CommitLayerStack(void) {
|
|||
if (!flush_) {
|
||||
DisplayError error = kErrorUndefined;
|
||||
error = display_intf_->Commit(&layer_stack_);
|
||||
validated_ = false;
|
||||
|
||||
if (error == kErrorNone) {
|
||||
// A commit is successfully submitted, start flushing on failure now onwards.
|
||||
|
@ -1249,6 +1427,16 @@ void HWCDisplay::MarkLayersForGPUBypass() {
|
|||
}
|
||||
}
|
||||
|
||||
void HWCDisplay::MarkLayersForClientComposition() {
|
||||
// ClientComposition - GPU comp, to acheive this, set skip flag so that
|
||||
// SDM does not handle this layer and hwc_layer composition will be
|
||||
// set correctly at the end of Prepare.
|
||||
for (auto hwc_layer : layer_set_) {
|
||||
Layer *layer = hwc_layer->GetSDMLayer();
|
||||
layer->flags.skip = true;
|
||||
}
|
||||
}
|
||||
|
||||
void HWCDisplay::ApplyScanAdjustment(hwc_rect_t *display_frame) {
|
||||
}
|
||||
|
||||
|
@ -1371,4 +1559,22 @@ void HWCDisplay::CloseAcquireFds() {
|
|||
}
|
||||
}
|
||||
|
||||
std::string HWCDisplay::Dump() {
|
||||
std::ostringstream os;
|
||||
os << "-------------------------------" << std::endl;
|
||||
os << "HWC2 LayerDump:" << std::endl;
|
||||
for (auto layer : layer_set_) {
|
||||
auto sdm_layer = layer->GetSDMLayer();
|
||||
os << "-------------------------------" << std::endl;
|
||||
os << "layer_id: " << layer->GetId() << std::endl;
|
||||
os << "\tz: " << layer->GetZ() << std::endl;
|
||||
os << "\tcomposition: " << to_string(layer->GetCompositionType()).c_str() << std::endl;
|
||||
os << "\tplane_alpha: " << std::to_string(sdm_layer->plane_alpha).c_str() << std::endl;
|
||||
os << "\tformat: " << GetFormatString(sdm_layer->input_buffer->format) << std::endl;
|
||||
os << "\tbuffer_id: " << std::hex << "0x" << sdm_layer->input_buffer->buffer_id << std::dec
|
||||
<< std::endl;
|
||||
}
|
||||
os << "-------------------------------" << std::endl;
|
||||
return os.str();
|
||||
}
|
||||
} // namespace sdm
|
||||
|
|
|
@ -20,15 +20,18 @@
|
|||
#ifndef __HWC_DISPLAY_H__
|
||||
#define __HWC_DISPLAY_H__
|
||||
|
||||
#include <hardware/hwcomposer.h>
|
||||
#include <core/core_interface.h>
|
||||
#include <qdMetaData.h>
|
||||
#include <QService.h>
|
||||
#include <core/core_interface.h>
|
||||
#include <hardware/hwcomposer.h>
|
||||
#include <private/color_params.h>
|
||||
#include <qdMetaData.h>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "hwc_callbacks.h"
|
||||
#include "hwc_layers.h"
|
||||
|
||||
|
@ -45,6 +48,40 @@ enum DisplayClass {
|
|||
DISPLAY_CLASS_NULL
|
||||
};
|
||||
|
||||
class HWCColorMode {
|
||||
public:
|
||||
explicit HWCColorMode(DisplayInterface *display_intf);
|
||||
~HWCColorMode() {}
|
||||
HWC2::Error Init();
|
||||
HWC2::Error DeInit();
|
||||
uint32_t GetColorModeCount();
|
||||
HWC2::Error GetColorModes(uint32_t *out_num_modes, int32_t /*android_color_mode_t*/ *out_modes);
|
||||
HWC2::Error SetColorMode(int32_t /*android_color_mode_t*/ mode);
|
||||
HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint);
|
||||
|
||||
private:
|
||||
static const uint32_t kColorTransformMatrixCount = 16;
|
||||
|
||||
HWC2::Error HandleColorModeTransform(int32_t /*android_color_mode_t*/ mode,
|
||||
android_color_transform_t hint, const double *matrix);
|
||||
void PopulateColorModes();
|
||||
void PopulateTransform(const int32_t &mode, const std::string &color_mode);
|
||||
template <class T>
|
||||
void CopyColorTransformMatrix(const T *input_matrix, double *output_matrix) {
|
||||
for (uint32_t i = 0; i < kColorTransformMatrixCount; i++) {
|
||||
output_matrix[i] = static_cast<double>(input_matrix[i]);
|
||||
}
|
||||
}
|
||||
|
||||
DisplayInterface *display_intf_ = NULL;
|
||||
int32_t current_color_mode_ = 0; // android_color_mode_t
|
||||
android_color_transform_t current_color_transform_ = HAL_COLOR_TRANSFORM_IDENTITY;
|
||||
typedef std::map<android_color_transform_t, std::string> TransformMap;
|
||||
// TODO(user): change int32_t to android_color_mode_t when defined
|
||||
std::map<int32_t, TransformMap> color_mode_transform_map_ = {};
|
||||
double color_matrix_[kColorTransformMatrixCount] = {0};
|
||||
};
|
||||
|
||||
class HWCDisplay : public DisplayEventHandler {
|
||||
public:
|
||||
virtual ~HWCDisplay() {}
|
||||
|
@ -64,6 +101,7 @@ class HWCDisplay : public DisplayEventHandler {
|
|||
virtual int OnMinHdcpEncryptionLevelChange(uint32_t min_enc_level);
|
||||
virtual int Perform(uint32_t operation, ...);
|
||||
virtual void SetSecureDisplay(bool secure_display_active);
|
||||
virtual std::string Dump(void);
|
||||
|
||||
// Captures frame output in the buffer specified by output_buffer_info. The API is
|
||||
// non-blocking and the client is expected to check operation status later on.
|
||||
|
@ -99,11 +137,23 @@ class HWCDisplay : public DisplayEventHandler {
|
|||
virtual HWC2::Error SetActiveConfig(hwc2_config_t config);
|
||||
virtual HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence,
|
||||
int32_t dataspace);
|
||||
virtual HWC2::Error SetColorMode(int32_t /*android_color_mode_t*/ mode) {
|
||||
return HWC2::Error::Unsupported;
|
||||
}
|
||||
virtual HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint) {
|
||||
return HWC2::Error::Unsupported;
|
||||
}
|
||||
virtual HWC2::Error HandleColorModeTransform(int32_t /*android_color_mode_t*/ mode,
|
||||
android_color_transform_t hint,
|
||||
const double *matrix) {
|
||||
return HWC2::Error::Unsupported;
|
||||
}
|
||||
virtual HWC2::Error GetDisplayConfigs(uint32_t *out_num_configs, hwc2_config_t *out_configs);
|
||||
virtual HWC2::Error GetDisplayAttribute(hwc2_config_t config, HWC2::Attribute attribute,
|
||||
int32_t *out_value);
|
||||
virtual HWC2::Error GetClientTargetSupport(uint32_t width, uint32_t height, int32_t format,
|
||||
int32_t dataspace);
|
||||
virtual HWC2::Error GetColorModes(uint32_t *outNumModes, int32_t *outModes);
|
||||
virtual HWC2::Error GetChangedCompositionTypes(uint32_t *out_num_elements,
|
||||
hwc2_layer_t *out_layers, int32_t *out_types);
|
||||
virtual HWC2::Error GetDisplayRequests(int32_t *out_display_requests, uint32_t *out_num_elements,
|
||||
|
@ -148,6 +198,7 @@ class HWCDisplay : public DisplayEventHandler {
|
|||
const char *GetDisplayString();
|
||||
void ScaleDisplayFrame(hwc_rect_t *display_frame);
|
||||
void MarkLayersForGPUBypass(void);
|
||||
void MarkLayersForClientComposition(void);
|
||||
virtual void ApplyScanAdjustment(hwc_rect_t *display_frame);
|
||||
bool NeedsFrameBufferRefresh(void);
|
||||
bool SingleLayerUpdating(void);
|
||||
|
@ -195,6 +246,8 @@ class HWCDisplay : public DisplayEventHandler {
|
|||
uint32_t solid_fill_color_ = 0;
|
||||
LayerRect display_rect_;
|
||||
bool validated_ = false;
|
||||
bool color_tranform_failed_ = false;
|
||||
HWCColorMode *color_mode_ = NULL;
|
||||
|
||||
private:
|
||||
bool IsFrameBufferScaled();
|
||||
|
|
|
@ -34,6 +34,10 @@
|
|||
#include <stdarg.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "hwc_display_primary.h"
|
||||
#include "hwc_debugger.h"
|
||||
|
||||
|
@ -103,7 +107,13 @@ int HWCDisplayPrimary::Init() {
|
|||
use_metadata_refresh_rate_ = false;
|
||||
}
|
||||
|
||||
return HWCDisplay::Init();
|
||||
int status = HWCDisplay::Init();
|
||||
if (status) {
|
||||
return status;
|
||||
}
|
||||
color_mode_ = new HWCColorMode(display_intf_);
|
||||
|
||||
return INT(color_mode_->Init());
|
||||
}
|
||||
|
||||
void HWCDisplayPrimary::ProcessBootAnimCompleted() {
|
||||
|
@ -153,6 +163,11 @@ HWC2::Error HWCDisplayPrimary::Validate(uint32_t *out_num_types, uint32_t *out_n
|
|||
return status;
|
||||
}
|
||||
|
||||
if (color_tranform_failed_) {
|
||||
// Must fall back to client composition
|
||||
MarkLayersForClientComposition();
|
||||
}
|
||||
|
||||
// Fill in the remaining blanks in the layers and add them to the SDM layerstack
|
||||
BuildLayerStack();
|
||||
|
||||
|
@ -213,6 +228,48 @@ HWC2::Error HWCDisplayPrimary::Present(int32_t *out_retire_fence) {
|
|||
return status;
|
||||
}
|
||||
|
||||
HWC2::Error HWCDisplayPrimary::GetColorModes(uint32_t *out_num_modes,
|
||||
int32_t /*android_color_mode_t*/ *out_modes) {
|
||||
if (out_modes == nullptr) {
|
||||
*out_num_modes = color_mode_->GetColorModeCount();
|
||||
} else {
|
||||
color_mode_->GetColorModes(out_num_modes, out_modes);
|
||||
}
|
||||
|
||||
return HWC2::Error::None;
|
||||
}
|
||||
|
||||
HWC2::Error HWCDisplayPrimary::SetColorMode(int32_t /*android_color_mode_t*/ mode) {
|
||||
auto status = color_mode_->SetColorMode(mode);
|
||||
if (status != HWC2::Error::None) {
|
||||
DLOGE("failed for mode = %d", mode);
|
||||
return status;
|
||||
}
|
||||
|
||||
callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
HWC2::Error HWCDisplayPrimary::SetColorTransform(const float *matrix,
|
||||
android_color_transform_t hint) {
|
||||
if (!matrix) {
|
||||
return HWC2::Error::BadParameter;
|
||||
}
|
||||
|
||||
auto status = color_mode_->SetColorTransform(matrix, hint);
|
||||
if (status != HWC2::Error::None) {
|
||||
DLOGE("failed for hint = %d", hint);
|
||||
color_tranform_failed_ = true;
|
||||
return status;
|
||||
}
|
||||
|
||||
callbacks_->Refresh(HWC_DISPLAY_PRIMARY);
|
||||
color_tranform_failed_ = false;
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
int HWCDisplayPrimary::Perform(uint32_t operation, ...) {
|
||||
va_list args;
|
||||
va_start(args, operation);
|
||||
|
|
|
@ -30,6 +30,8 @@
|
|||
#ifndef __HWC_DISPLAY_PRIMARY_H__
|
||||
#define __HWC_DISPLAY_PRIMARY_H__
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "cpuhint.h"
|
||||
#include "hwc_display.h"
|
||||
|
||||
|
@ -52,6 +54,9 @@ class HWCDisplayPrimary : public HWCDisplay {
|
|||
virtual int Init();
|
||||
virtual HWC2::Error Validate(uint32_t *out_num_types, uint32_t *out_num_requests);
|
||||
virtual HWC2::Error Present(int32_t *out_retire_fence);
|
||||
virtual HWC2::Error GetColorModes(uint32_t *out_num_modes, int32_t *out_modes);
|
||||
virtual HWC2::Error SetColorMode(int32_t /*android_color_mode_t*/ mode);
|
||||
virtual HWC2::Error SetColorTransform(const float *matrix, android_color_transform_t hint);
|
||||
virtual int Perform(uint32_t operation, ...);
|
||||
virtual void SetSecureDisplay(bool secure_display_active);
|
||||
virtual DisplayError Refresh();
|
||||
|
|
|
@ -474,19 +474,20 @@ DisplayError HWCLayer::SetIGC(IGC_t source, LayerIGC *target) {
|
|||
return kErrorNone;
|
||||
}
|
||||
|
||||
uint32_t HWCLayer::RoundToStandardFPS(uint32_t fps) {
|
||||
static const uint32_t standard_fps[4] = {30, 24, 48, 60};
|
||||
uint32_t HWCLayer::RoundToStandardFPS(float fps) {
|
||||
static const uint32_t standard_fps[4] = {24, 30, 48, 60};
|
||||
uint32_t frame_rate = (uint32_t)(fps);
|
||||
|
||||
int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
|
||||
for (int i = 0; i < count; i++) {
|
||||
if ((standard_fps[i] - fps) < 2) {
|
||||
if ((standard_fps[i] - frame_rate) < 2) {
|
||||
// Most likely used for video, the fps can fluctuate
|
||||
// Ex: b/w 29 and 30 for 30 fps clip
|
||||
return standard_fps[i];
|
||||
}
|
||||
}
|
||||
|
||||
return fps;
|
||||
return frame_rate;
|
||||
}
|
||||
|
||||
void HWCLayer::SetComposition(const LayerComposition &source) {
|
||||
|
|
|
@ -96,7 +96,7 @@ class HWCLayer {
|
|||
DisplayError SetMetaData(const private_handle_t *pvt_handle, Layer *layer);
|
||||
DisplayError SetCSC(ColorSpace_t source, LayerCSC *target);
|
||||
DisplayError SetIGC(IGC_t source, LayerIGC *target);
|
||||
uint32_t RoundToStandardFPS(uint32_t fps);
|
||||
uint32_t RoundToStandardFPS(float fps);
|
||||
};
|
||||
|
||||
struct SortLayersByZ {
|
||||
|
|
|
@ -34,6 +34,7 @@
|
|||
#include <utils/debug.h>
|
||||
#include <sync/sync.h>
|
||||
#include <profiler.h>
|
||||
#include <string>
|
||||
|
||||
#include "hwc_buffer_allocator.h"
|
||||
#include "hwc_buffer_sync_handler.h"
|
||||
|
@ -228,9 +229,10 @@ static int32_t AcceptDisplayChanges(hwc2_device_t *device, hwc2_display_t displa
|
|||
return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::AcceptDisplayChanges);
|
||||
}
|
||||
|
||||
static int32_t CreateLayer(hwc2_device_t *device, hwc2_display_t display,
|
||||
hwc2_layer_t *out_layer_id) {
|
||||
return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::CreateLayer, out_layer_id);
|
||||
int32_t HWCSession::CreateLayer(hwc2_device_t *device, hwc2_display_t display,
|
||||
hwc2_layer_t *out_layer_id) {
|
||||
SCOPE_LOCK(locker_);
|
||||
return CallDisplayFunction(device, display, &HWCDisplay::CreateLayer, out_layer_id);
|
||||
}
|
||||
|
||||
int32_t HWCSession::CreateVirtualDisplay(hwc2_device_t *device, uint32_t width, uint32_t height,
|
||||
|
@ -246,8 +248,10 @@ int32_t HWCSession::CreateVirtualDisplay(hwc2_device_t *device, uint32_t width,
|
|||
return INT32(status);
|
||||
}
|
||||
|
||||
static int32_t DestroyLayer(hwc2_device_t *device, hwc2_display_t display, hwc2_layer_t layer) {
|
||||
return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::DestroyLayer, layer);
|
||||
int32_t HWCSession::DestroyLayer(hwc2_device_t *device, hwc2_display_t display,
|
||||
hwc2_layer_t layer) {
|
||||
SCOPE_LOCK(locker_);
|
||||
return CallDisplayFunction(device, display, &HWCDisplay::DestroyLayer, layer);
|
||||
}
|
||||
|
||||
int32_t HWCSession::DestroyVirtualDisplay(hwc2_device_t *device, hwc2_display_t display) {
|
||||
|
@ -265,15 +269,22 @@ int32_t HWCSession::DestroyVirtualDisplay(hwc2_device_t *device, hwc2_display_t
|
|||
}
|
||||
}
|
||||
|
||||
static void Dump(hwc2_device_t *device, uint32_t *out_size, char *out_buffer) {
|
||||
void HWCSession::Dump(hwc2_device_t *device, uint32_t *out_size, char *out_buffer) {
|
||||
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
||||
|
||||
if (!device) {
|
||||
return;
|
||||
}
|
||||
auto *hwc_session = static_cast<HWCSession *>(device);
|
||||
|
||||
if (out_buffer == nullptr) {
|
||||
*out_size = 4096; // TODO(user): Adjust required dump size
|
||||
*out_size = 8192; // TODO(user): Adjust required dump size
|
||||
} else {
|
||||
DumpInterface::GetDump(out_buffer, 4096); // TODO(user): Fix this workaround
|
||||
char sdm_dump[4096];
|
||||
DumpInterface::GetDump(sdm_dump, 4096); // TODO(user): Fix this workaround
|
||||
std::string s = hwc_session->hwc_display_[HWC_DISPLAY_PRIMARY]->Dump();
|
||||
s += sdm_dump;
|
||||
s.copy(out_buffer, s.size(), 0);
|
||||
*out_size = sizeof(out_buffer);
|
||||
}
|
||||
}
|
||||
|
@ -296,7 +307,11 @@ static int32_t GetClientTargetSupport(hwc2_device_t *device, hwc2_display_t disp
|
|||
width, height, format, dataspace);
|
||||
}
|
||||
|
||||
// TODO(user): GetColorModes
|
||||
static int32_t GetColorModes(hwc2_device_t *device, hwc2_display_t display, uint32_t *out_num_modes,
|
||||
int32_t /*android_color_mode_t*/ *out_modes) {
|
||||
return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::GetColorModes, out_num_modes,
|
||||
out_modes);
|
||||
}
|
||||
|
||||
static int32_t GetDisplayAttribute(hwc2_device_t *device, hwc2_display_t display,
|
||||
hwc2_config_t config, int32_t int_attribute,
|
||||
|
@ -407,7 +422,20 @@ static int32_t SetClientTarget(hwc2_device_t *device, hwc2_display_t display,
|
|||
acquire_fence, dataspace);
|
||||
}
|
||||
|
||||
// TODO(user): SetColorMode, SetColorTransform
|
||||
int32_t HWCSession::SetColorMode(hwc2_device_t *device, hwc2_display_t display,
|
||||
int32_t /*android_color_mode_t*/ mode) {
|
||||
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
||||
return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetColorMode, mode);
|
||||
}
|
||||
|
||||
int32_t HWCSession::SetColorTransform(hwc2_device_t *device, hwc2_display_t display,
|
||||
const float *matrix,
|
||||
int32_t /*android_color_transform_t*/ hint) {
|
||||
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
||||
android_color_transform_t transform_hint = static_cast<android_color_transform_t>(hint);
|
||||
return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetColorTransform, matrix,
|
||||
transform_hint);
|
||||
}
|
||||
|
||||
static int32_t SetCursorPosition(hwc2_device_t *device, hwc2_display_t display, hwc2_layer_t layer,
|
||||
int32_t x, int32_t y) {
|
||||
|
@ -481,9 +509,10 @@ static int32_t SetLayerVisibleRegion(hwc2_device_t *device, hwc2_display_t displ
|
|||
visible);
|
||||
}
|
||||
|
||||
static int32_t SetLayerZOrder(hwc2_device_t *device, hwc2_display_t display, hwc2_layer_t layer,
|
||||
uint32_t z) {
|
||||
return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetLayerZOrder, layer, z);
|
||||
int32_t HWCSession::SetLayerZOrder(hwc2_device_t *device, hwc2_display_t display,
|
||||
hwc2_layer_t layer, uint32_t z) {
|
||||
SCOPE_LOCK(locker_);
|
||||
return CallDisplayFunction(device, display, &HWCDisplay::SetLayerZOrder, layer, z);
|
||||
}
|
||||
|
||||
int32_t HWCSession::SetOutputBuffer(hwc2_device_t *device, hwc2_display_t display,
|
||||
|
@ -502,9 +531,10 @@ int32_t HWCSession::SetOutputBuffer(hwc2_device_t *device, hwc2_display_t displa
|
|||
}
|
||||
}
|
||||
|
||||
static int32_t SetPowerMode(hwc2_device_t *device, hwc2_display_t display, int32_t int_mode) {
|
||||
int32_t HWCSession::SetPowerMode(hwc2_device_t *device, hwc2_display_t display, int32_t int_mode) {
|
||||
auto mode = static_cast<HWC2::PowerMode>(int_mode);
|
||||
return HWCSession::CallDisplayFunction(device, display, &HWCDisplay::SetPowerMode, mode);
|
||||
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
|
||||
return CallDisplayFunction(device, display, &HWCDisplay::SetPowerMode, mode);
|
||||
}
|
||||
|
||||
static int32_t SetVsyncEnabled(hwc2_device_t *device, hwc2_display_t display, int32_t int_enabled) {
|
||||
|
@ -539,6 +569,11 @@ int32_t HWCSession::ValidateDisplay(hwc2_device_t *device, hwc2_display_t displa
|
|||
|
||||
status = hwc_session->hwc_display_[display]->Validate(out_num_types, out_num_requests);
|
||||
}
|
||||
// If validate fails, cancel the sequence lock so that other operations
|
||||
// (such as Dump or SetPowerMode) may succeed without blocking on the condition
|
||||
if (status != HWC2::Error::None) {
|
||||
SEQUENCE_CANCEL_SCOPE_LOCK(locker_);
|
||||
}
|
||||
return INT32(status);
|
||||
}
|
||||
|
||||
|
@ -558,15 +593,15 @@ hwc2_function_pointer_t HWCSession::GetFunction(struct hwc2_device *device,
|
|||
case HWC2::FunctionDescriptor::DestroyVirtualDisplay:
|
||||
return AsFP<HWC2_PFN_DESTROY_VIRTUAL_DISPLAY>(HWCSession::DestroyVirtualDisplay);
|
||||
case HWC2::FunctionDescriptor::Dump:
|
||||
return AsFP<HWC2_PFN_DUMP>(Dump);
|
||||
return AsFP<HWC2_PFN_DUMP>(HWCSession::Dump);
|
||||
case HWC2::FunctionDescriptor::GetActiveConfig:
|
||||
return AsFP<HWC2_PFN_GET_ACTIVE_CONFIG>(GetActiveConfig);
|
||||
case HWC2::FunctionDescriptor::GetChangedCompositionTypes:
|
||||
return AsFP<HWC2_PFN_GET_CHANGED_COMPOSITION_TYPES>(GetChangedCompositionTypes);
|
||||
case HWC2::FunctionDescriptor::GetClientTargetSupport:
|
||||
return AsFP<HWC2_PFN_GET_CLIENT_TARGET_SUPPORT>(GetClientTargetSupport);
|
||||
// case HWC2::FunctionDescriptor::GetColorModes:
|
||||
// TODO(user): Support later
|
||||
case HWC2::FunctionDescriptor::GetColorModes:
|
||||
return AsFP<HWC2_PFN_GET_COLOR_MODES>(GetColorModes);
|
||||
case HWC2::FunctionDescriptor::GetDisplayAttribute:
|
||||
return AsFP<HWC2_PFN_GET_DISPLAY_ATTRIBUTE>(GetDisplayAttribute);
|
||||
case HWC2::FunctionDescriptor::GetDisplayConfigs:
|
||||
|
@ -593,10 +628,10 @@ hwc2_function_pointer_t HWCSession::GetFunction(struct hwc2_device *device,
|
|||
return AsFP<HWC2_PFN_SET_ACTIVE_CONFIG>(SetActiveConfig);
|
||||
case HWC2::FunctionDescriptor::SetClientTarget:
|
||||
return AsFP<HWC2_PFN_SET_CLIENT_TARGET>(SetClientTarget);
|
||||
// TODO(user): Support later
|
||||
// case HWC2::FunctionDescriptor::SetColorMode:
|
||||
// case HWC2::FunctionDescriptor::SetColorTransform:
|
||||
// break;
|
||||
case HWC2::FunctionDescriptor::SetColorMode:
|
||||
return AsFP<HWC2_PFN_SET_COLOR_MODE>(SetColorMode);
|
||||
case HWC2::FunctionDescriptor::SetColorTransform:
|
||||
return AsFP<HWC2_PFN_SET_COLOR_TRANSFORM>(SetColorTransform);
|
||||
case HWC2::FunctionDescriptor::SetCursorPosition:
|
||||
return AsFP<HWC2_PFN_SET_CURSOR_POSITION>(SetCursorPosition);
|
||||
case HWC2::FunctionDescriptor::SetLayerBlendMode:
|
||||
|
|
|
@ -82,9 +82,13 @@ class HWCSession : hwc2_device_t, public qClient::BnQClient {
|
|||
|
||||
// HWC2 Functions that require a concrete implementation in hwc session
|
||||
// and hence need to be member functions
|
||||
static int32_t CreateLayer(hwc2_device_t *device, hwc2_display_t display,
|
||||
hwc2_layer_t *out_layer_id);
|
||||
static int32_t CreateVirtualDisplay(hwc2_device_t *device, uint32_t width, uint32_t height,
|
||||
hwc2_display_t *out_display_id);
|
||||
static int32_t DestroyLayer(hwc2_device_t *device, hwc2_display_t display, hwc2_layer_t layer);
|
||||
static int32_t DestroyVirtualDisplay(hwc2_device_t *device, hwc2_display_t display);
|
||||
static void Dump(hwc2_device_t *device, uint32_t *out_size, char *out_buffer);
|
||||
static int32_t PresentDisplay(hwc2_device_t *device, hwc2_display_t display,
|
||||
int32_t *out_retire_fence);
|
||||
static int32_t RegisterCallback(hwc2_device_t *device, int32_t descriptor,
|
||||
|
@ -92,8 +96,15 @@ class HWCSession : hwc2_device_t, public qClient::BnQClient {
|
|||
hwc2_function_pointer_t pointer);
|
||||
static int32_t SetOutputBuffer(hwc2_device_t *device, hwc2_display_t display,
|
||||
buffer_handle_t buffer, int32_t releaseFence);
|
||||
static int32_t SetLayerZOrder(hwc2_device_t *device, hwc2_display_t display, hwc2_layer_t layer,
|
||||
uint32_t z);
|
||||
static int32_t SetPowerMode(hwc2_device_t *device, hwc2_display_t display, int32_t int_mode);
|
||||
static int32_t ValidateDisplay(hwc2_device_t *device, hwc2_display_t display,
|
||||
uint32_t *out_num_types, uint32_t *out_num_requests);
|
||||
static int32_t SetColorMode(hwc2_device_t *device, hwc2_display_t display,
|
||||
int32_t /*android_color_mode_t*/ mode);
|
||||
static int32_t SetColorTransform(hwc2_device_t *device, hwc2_display_t display,
|
||||
const float *matrix, int32_t /*android_color_transform_t*/ hint);
|
||||
|
||||
private:
|
||||
static const int kExternalConnectionTimeoutMs = 500;
|
||||
|
|
|
@ -148,5 +148,13 @@ bool Debug::GetProperty(const char* property_name, char* value) {
|
|||
return true;
|
||||
}
|
||||
|
||||
bool Debug::SetProperty(const char* property_name, const char* value) {
|
||||
if (debug_.debug_handler_->SetProperty(property_name, value) != kErrorNone) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace sdm
|
||||
|
||||
|
|
Loading…
Reference in New Issue