From 68f7040b1c5566482c0144bf81601240c563a123 Mon Sep 17 00:00:00 2001 From: Ping Li Date: Tue, 24 Jan 2017 15:38:54 -0800 Subject: [PATCH 1/3] sdm: color-manager: Add new PP versions to color manager This change adds a new gamut version to color manager to support the newly introduced gamut version in hardware. An new value kSDEPpVersionInvalid is also added to indicate invalid PP feature version for error cases. CRs-Fixed: 2007376 Change-Id: Ib1a738fdf39fa28f163c5d7fa08260c36451f3fc --- sdm/include/private/color_params.h | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/sdm/include/private/color_params.h b/sdm/include/private/color_params.h index 91499f96..a3ecd50c 100644 --- a/sdm/include/private/color_params.h +++ b/sdm/include/private/color_params.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2015-2016, The Linux Foundataion. All rights reserved. +/* Copyright (c) 2015-2017, 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 @@ -55,6 +55,26 @@ enum PendingAction { kNoAction = BITMAP(31), }; +static const uint32_t kOpsEnable = BITMAP(0); +static const uint32_t kOpsRead = BITMAP(1); +static const uint32_t kOpsWrite = BITMAP(2); +static const uint32_t kOpsDisable = BITMAP(3); + +static const uint32_t kOpsGc8BitRoundEnable = BITMAP(4); + +static const uint32_t kPaHueEnable = BITMAP(4); +static const uint32_t kPaSatEnable = BITMAP(5); +static const uint32_t kPaValEnable = BITMAP(6); +static const uint32_t kPaContEnable = BITMAP(7); + +static const uint32_t kPaSixZoneEnable = BITMAP(8); +static const uint32_t kPaSkinEnable = BITMAP(9); +static const uint32_t kPaSkyEnable = BITMAP(10); +static const uint32_t kPaFoliageEnable = BITMAP(11); + +static const uint32_t kLeftSplitMode = BITMAP(28); // 0x10000000 +static const uint32_t kRightSplitMode = BITMAP(29); // 0x20000000 + // ENUM to identify different Postprocessing feature block to program. // Note: For each new entry added here, also need update hw_interface::GetPPFeaturesVersion<> // AND HWPrimary::SetPPFeatures<>. @@ -98,6 +118,7 @@ struct PPColorFillParams { struct PPFeatureVersion { // SDE ASIC versioning its PP block at each specific feature level. + static const uint32_t kSDEPpVersionInvalid = 0; static const uint32_t kSDEIgcV17 = 1; static const uint32_t kSDEPgcV17 = 5; static const uint32_t kSDEDitherV17 = 7; @@ -107,6 +128,7 @@ struct PPFeatureVersion { static const uint32_t kSDELegacyPP = 15; static const uint32_t kSDEPADitherV17 = 16; static const uint32_t kSDEIgcV30 = 17; + static const uint32_t kSDEGamutV4 = 18; uint32_t version[kMaxNumPPFeatures]; PPFeatureVersion() { memset(version, 0, sizeof(version)); } @@ -382,6 +404,7 @@ class SDEGamutCfgWrapper : private SDEGamutCfg { enum GamutMode { GAMUT_FINE_MODE = 0x01, GAMUT_COARSE_MODE, + GAMUT_COARSE_MODE_13, }; // This factory method will be used by libsdm-color.so data producer to be populated with From 281f48de8a04d5d2c9dec16232fcf9a2a5b0d60a Mon Sep 17 00:00:00 2001 From: Ping Li Date: Mon, 16 Jan 2017 12:45:40 -0800 Subject: [PATCH 2/3] sdm: drm: Add post-processing support in SDM SDM added support for the DRM driver recently. This change adds the similar support in the SDM to enable/disable post-processing features via DRM driver for QDCM. CRs-Fixed: 2007376 Change-Id: I39d8d2c76a28aac0675c559dceb6dcf74eb170fb --- libdrmutils/drm_interface.h | 38 +++++ sdm/libs/core/Android.mk | 7 +- sdm/libs/core/drm/hw_color_manager_drm.cpp | 173 +++++++++++++++++++++ sdm/libs/core/drm/hw_color_manager_drm.h | 64 ++++++++ sdm/libs/core/drm/hw_device_drm.cpp | 43 ++++- 5 files changed, 322 insertions(+), 3 deletions(-) create mode 100644 sdm/libs/core/drm/hw_color_manager_drm.cpp create mode 100644 sdm/libs/core/drm/hw_color_manager_drm.h diff --git a/libdrmutils/drm_interface.h b/libdrmutils/drm_interface.h index 94a48e12..399972b8 100644 --- a/libdrmutils/drm_interface.h +++ b/libdrmutils/drm_interface.h @@ -135,6 +135,12 @@ enum struct DRMOps { * int * - Pointer to an integer that will hold the returned fence */ CRTC_GET_RELEASE_FENCE, + /* + * Op: Sets PP feature + * Arg: uint32_t - CRTC ID + * DRMPPFeatureInfo * - PP feature data pointer + */ + CRTC_SET_POST_PROC, /* * Op: Returns retire fence for this commit. Should be called after Commit() on * DRMAtomicReqInterface. @@ -262,6 +268,33 @@ struct DRMDisplayToken { uint32_t crtc_id; }; +enum DRMPPFeatureID { + kFeaturePcc, + kFeatureIgc, + kFeaturePgc, + kFeatureMixerGc, + kFeaturePaV2, + kFeatureDither, + kFeatureGamut, + kFeaturePADither, + kPPFeaturesMax, +}; + +enum DRMPPPropType { + kPropEnum, + kPropRange, + kPropBlob, + kPropTypeMax, +}; + +struct DRMPPFeatureInfo { + DRMPPFeatureID id; + DRMPPPropType type; + uint32_t version; + uint32_t payload_size; + void *payload; +}; + /* DRM Atomic Request Property Set. * * Helper class to create and populate atomic properties of DRM components @@ -330,6 +363,11 @@ class DRMManagerInterface { */ virtual void GetConnectorInfo(uint32_t conn_id, DRMConnectorInfo *info) = 0; + /* + * Will query post propcessing feature info of a CRTC. + * [output]: DRMPPFeatureInfo: CRTC post processing feature info + */ + virtual void GetCrtcPPInfo(uint32_t crtc_id, DRMPPFeatureInfo &info) = 0; /* * Register a logical display to receive a token. * Each display pipeline in DRM is identified by its CRTC and Connector(s). diff --git a/sdm/libs/core/Android.mk b/sdm/libs/core/Android.mk index cdf89256..114fcaf6 100644 --- a/sdm/libs/core/Android.mk +++ b/sdm/libs/core/Android.mk @@ -19,6 +19,10 @@ ifneq ($(TARGET_IS_HEADLESS), true) LOCAL_HW_INTF_PATH_2 := drm endif +ifeq ($(TARGET_USES_DRM_PP),true) + LOCAL_CFLAGS += -DPP_DRM_ENABLE +endif + LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) $(kernel_deps) LOCAL_SRC_FILES := core_interface.cpp \ core_impl.cpp \ @@ -46,7 +50,8 @@ LOCAL_SRC_FILES := core_interface.cpp \ ifneq ($(TARGET_IS_HEADLESS), true) LOCAL_SRC_FILES += $(LOCAL_HW_INTF_PATH_2)/hw_info_drm.cpp \ $(LOCAL_HW_INTF_PATH_2)/hw_device_drm.cpp \ - $(LOCAL_HW_INTF_PATH_2)/hw_events_drm.cpp + $(LOCAL_HW_INTF_PATH_2)/hw_events_drm.cpp \ + $(LOCAL_HW_INTF_PATH_2)/hw_color_manager_drm.cpp endif include $(BUILD_SHARED_LIBRARY) diff --git a/sdm/libs/core/drm/hw_color_manager_drm.cpp b/sdm/libs/core/drm/hw_color_manager_drm.cpp new file mode 100644 index 00000000..88e68aa4 --- /dev/null +++ b/sdm/libs/core/drm/hw_color_manager_drm.cpp @@ -0,0 +1,173 @@ +/* +* Copyright (c) 2017, 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 __CLASS__ "HWColorManagerDRM" + +#ifdef PP_DRM_ENABLE +#include +#endif +#include "hw_color_manager_drm.h" + +using sde_drm::kFeaturePcc; +using sde_drm::kFeatureIgc; +using sde_drm::kFeaturePgc; +using sde_drm::kFeatureMixerGc; +using sde_drm::kFeaturePaV2; +using sde_drm::kFeatureDither; +using sde_drm::kFeatureGamut; +using sde_drm::kFeaturePADither; +using sde_drm::kPPFeaturesMax; + +namespace sdm { + +DisplayError (*HWColorManagerDrm::GetDrmFeature[])(const PPFeatureInfo &, DRMPPFeatureInfo *) = { + [kGlobalColorFeaturePcc] = &HWColorManagerDrm::GetDrmPCC, + [kGlobalColorFeatureIgc] = &HWColorManagerDrm::GetDrmIGC, + [kGlobalColorFeaturePgc] = &HWColorManagerDrm::GetDrmPGC, + [kMixerColorFeatureGc] = &HWColorManagerDrm::GetDrmMixerGC, + [kGlobalColorFeaturePaV2] = &HWColorManagerDrm::GetDrmPAV2, + [kGlobalColorFeatureDither] = &HWColorManagerDrm::GetDrmDither, + [kGlobalColorFeatureGamut] = &HWColorManagerDrm::GetDrmGamut, + [kGlobalColorFeaturePADither] = &HWColorManagerDrm::GetDrmPADither, +}; + +void HWColorManagerDrm::FreeDrmFeatureData(DRMPPFeatureInfo *feature) { + if (feature->payload) + free(feature->payload); +} + +uint32_t HWColorManagerDrm::GetFeatureVersion(DRMPPFeatureInfo &feature) { + uint32_t version = PPFeatureVersion::kSDEPpVersionInvalid; + + switch (feature.id) { + case kFeaturePcc: + break; + case kFeatureIgc: + break; + case kFeaturePgc: + break; + case kFeatureMixerGc: + break; + case kFeaturePaV2: + break; + case kFeatureDither: + break; + case kFeatureGamut: + break; + case kFeaturePADither: + break; + default: + break; + } + return version; +} + +DRMPPFeatureID HWColorManagerDrm::ToDrmFeatureId(uint32_t id) { + DRMPPFeatureID ret = kPPFeaturesMax; + + switch (id) { + case kGlobalColorFeaturePcc: + ret = kFeaturePcc; + break; + case kGlobalColorFeatureIgc: + ret = kFeatureIgc; + break; + case kGlobalColorFeaturePgc: + ret = kFeaturePgc; + break; + case kMixerColorFeatureGc: + ret = kFeatureMixerGc; + break; + case kGlobalColorFeaturePaV2: + ret = kFeaturePaV2; + break; + case kGlobalColorFeatureDither: + ret = kFeatureDither; + break; + case kGlobalColorFeatureGamut: + ret = kFeatureGamut; + break; + case kGlobalColorFeaturePADither: + ret = kFeaturePADither; + break; + default: + break; + } + return ret; +} + +DisplayError HWColorManagerDrm::GetDrmPCC(const PPFeatureInfo &in_data, + DRMPPFeatureInfo *out_data) { + DisplayError ret = kErrorNone; + return ret; +} + +DisplayError HWColorManagerDrm::GetDrmIGC(const PPFeatureInfo &in_data, + DRMPPFeatureInfo *out_data) { + DisplayError ret = kErrorNone; + return ret; +} + +DisplayError HWColorManagerDrm::GetDrmPGC(const PPFeatureInfo &in_data, + DRMPPFeatureInfo *out_data) { + DisplayError ret = kErrorNone; + return ret; +} + +DisplayError HWColorManagerDrm::GetDrmMixerGC(const PPFeatureInfo &in_data, + DRMPPFeatureInfo *out_data) { + DisplayError ret = kErrorNone; + return ret; +} + +DisplayError HWColorManagerDrm::GetDrmPAV2(const PPFeatureInfo &in_data, + DRMPPFeatureInfo *out_data) { + DisplayError ret = kErrorNone; + return ret; +} + +DisplayError HWColorManagerDrm::GetDrmDither(const PPFeatureInfo &in_data, + DRMPPFeatureInfo *out_data) { + DisplayError ret = kErrorNone; + return ret; +} + +DisplayError HWColorManagerDrm::GetDrmGamut(const PPFeatureInfo &in_data, + DRMPPFeatureInfo *out_data) { + DisplayError ret = kErrorNone; + return ret; +} + +DisplayError HWColorManagerDrm::GetDrmPADither(const PPFeatureInfo &in_data, + DRMPPFeatureInfo *out_data) { + DisplayError ret = kErrorNone; + return ret; +} + +} // namespace sdm diff --git a/sdm/libs/core/drm/hw_color_manager_drm.h b/sdm/libs/core/drm/hw_color_manager_drm.h new file mode 100644 index 00000000..23b1ddeb --- /dev/null +++ b/sdm/libs/core/drm/hw_color_manager_drm.h @@ -0,0 +1,64 @@ +/* +* Copyright (c) 2017, 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 __HW_COLOR_MANAGER_DRM_H__ +#define __HW_COLOR_MANAGER_DRM_H__ + +#include +#include + +using sde_drm::DRMPPFeatureID; +using sde_drm::DRMPPFeatureInfo; + +namespace sdm { + +class HWColorManagerDrm { + public: + static DisplayError (*GetDrmFeature[kMaxNumPPFeatures])(const PPFeatureInfo &in_data, + DRMPPFeatureInfo *out_data); + static void FreeDrmFeatureData(DRMPPFeatureInfo *feature); + static uint32_t GetFeatureVersion(DRMPPFeatureInfo &feature); + static DRMPPFeatureID ToDrmFeatureId(uint32_t id); + protected: + HWColorManagerDrm() {} + + private: + static DisplayError GetDrmPCC(const PPFeatureInfo &in_data, DRMPPFeatureInfo *out_data); + static DisplayError GetDrmIGC(const PPFeatureInfo &in_data, DRMPPFeatureInfo *out_data); + static DisplayError GetDrmPGC(const PPFeatureInfo &in_data, DRMPPFeatureInfo *out_data); + static DisplayError GetDrmMixerGC(const PPFeatureInfo &in_data, DRMPPFeatureInfo *out_data); + static DisplayError GetDrmPAV2(const PPFeatureInfo &in_data, DRMPPFeatureInfo *out_data); + static DisplayError GetDrmDither(const PPFeatureInfo &in_data, DRMPPFeatureInfo *out_data); + static DisplayError GetDrmGamut(const PPFeatureInfo &in_data, DRMPPFeatureInfo *out_data); + static DisplayError GetDrmPADither(const PPFeatureInfo &in_data, DRMPPFeatureInfo *out_data); +}; + +} // namespace sdm + +#endif // __HW_COLOR_MANAGER_DRM_H__ diff --git a/sdm/libs/core/drm/hw_device_drm.cpp b/sdm/libs/core/drm/hw_device_drm.cpp index a72aae7b..b5d281b1 100644 --- a/sdm/libs/core/drm/hw_device_drm.cpp +++ b/sdm/libs/core/drm/hw_device_drm.cpp @@ -46,6 +46,7 @@ #include #include #include +#include #include #include @@ -54,6 +55,7 @@ #include "hw_device_drm.h" #include "hw_info_interface.h" +#include "hw_color_manager_drm.h" #define __CLASS__ "HWDeviceDRM" @@ -68,6 +70,7 @@ using sde_drm::DestroyDRMManager; using sde_drm::DRMDisplayType; using sde_drm::DRMDisplayToken; using sde_drm::DRMConnectorInfo; +using sde_drm::DRMPPFeatureInfo; using sde_drm::DRMRect; using sde_drm::DRMBlendType; using sde_drm::DRMOps; @@ -566,11 +569,47 @@ DisplayError HWDeviceDRM::SetCursorPosition(HWLayers *hw_layers, int x, int y) { } DisplayError HWDeviceDRM::GetPPFeaturesVersion(PPFeatureVersion *vers) { - return kErrorNotSupported; + struct DRMPPFeatureInfo info = {}; + + for (uint32_t i = 0; i < kMaxNumPPFeatures; i++) { + memset(&info, 0, sizeof(struct DRMPPFeatureInfo)); + info.id = HWColorManagerDrm::ToDrmFeatureId(i); + if (info.id >= sde_drm::kPPFeaturesMax) + continue; + // use crtc_id_ = 0 since PP features are same across all CRTCs + drm_mgr_intf_->GetCrtcPPInfo(0, info); + vers->version[i] = HWColorManagerDrm::GetFeatureVersion(info); + } + return kErrorNone; } DisplayError HWDeviceDRM::SetPPFeatures(PPFeaturesConfig *feature_list) { - return kErrorNotSupported; + int ret = 0; + PPFeatureInfo *feature = NULL; + DRMPPFeatureInfo kernel_params = {}; + + while (true) { + ret = feature_list->RetrieveNextFeature(&feature); + if (ret) + break; + + if (feature) { + DLOGV_IF(kTagDriverConfig, "feature_id = %d", feature->feature_id_); + if (!HWColorManagerDrm::GetDrmFeature[feature->feature_id_]) { + DLOGE("GetDrmFeature is not valid for feature %d", feature->feature_id_); + continue; + } + ret = HWColorManagerDrm::GetDrmFeature[feature->feature_id_](*feature, &kernel_params); + if (!ret) + drm_atomic_intf_->Perform(DRMOps::CRTC_SET_POST_PROC, token_.crtc_id, &kernel_params); + HWColorManagerDrm::FreeDrmFeatureData(&kernel_params); + } + } + + // Once all features were consumed, then destroy all feature instance from feature_list, + feature_list->Reset(); + + return kErrorNone; } DisplayError HWDeviceDRM::SetVSyncState(bool enable) { From 85d9c785a3b61f660b44e06e0c0636452e7df97c Mon Sep 17 00:00:00 2001 From: Ping Li Date: Fri, 17 Feb 2017 14:51:32 -0800 Subject: [PATCH 3/3] sdm: drm: Add user space to DRM driver struct conversion for gamut In order to support QDCM features with DRM driver, a layer of conversion from QDCM struct to DRM driver stuct is needed. This change adds the conversion for Gamut feature. CRs-Fixed: 2007376 Change-Id: Ic2209a92fac021722c51c64716c2dd5566ee17b6 --- sdm/libs/core/drm/hw_color_manager_drm.cpp | 70 ++++++++++++++++++++++ 1 file changed, 70 insertions(+) diff --git a/sdm/libs/core/drm/hw_color_manager_drm.cpp b/sdm/libs/core/drm/hw_color_manager_drm.cpp index 88e68aa4..c8318223 100644 --- a/sdm/libs/core/drm/hw_color_manager_drm.cpp +++ b/sdm/libs/core/drm/hw_color_manager_drm.cpp @@ -32,6 +32,7 @@ #ifdef PP_DRM_ENABLE #include #endif +#include #include "hw_color_manager_drm.h" using sde_drm::kFeaturePcc; @@ -79,6 +80,10 @@ uint32_t HWColorManagerDrm::GetFeatureVersion(DRMPPFeatureInfo &feature) { case kFeatureDither: break; case kFeatureGamut: + if (feature.version == 1) + version = PPFeatureVersion::kSDEGamutV17; + else if (feature.version == 4) + version = PPFeatureVersion::kSDEGamutV4; break; case kFeaturePADither: break; @@ -161,6 +166,71 @@ DisplayError HWColorManagerDrm::GetDrmDither(const PPFeatureInfo &in_data, DisplayError HWColorManagerDrm::GetDrmGamut(const PPFeatureInfo &in_data, DRMPPFeatureInfo *out_data) { DisplayError ret = kErrorNone; +#ifdef PP_DRM_ENABLE + struct SDEGamutCfg *sde_gamut = NULL; + struct drm_msm_3d_gamut *mdp_gamut = NULL; + uint32_t size = 0; + + if (!out_data) { + DLOGE("Invalid input parameter for gamut"); + return kErrorParameters; + } + sde_gamut = (struct SDEGamutCfg *)in_data.GetConfigData(); + out_data->id = kFeatureGamut; + out_data->type = sde_drm::kPropBlob; + out_data->version = in_data.feature_version_; + out_data->payload_size = sizeof(struct drm_msm_3d_gamut); + if (in_data.enable_flags_ & kOpsDisable) { + /* feature disable case */ + out_data->payload = NULL; + return ret; + } else if (!(in_data.enable_flags_ & kOpsEnable)) { + out_data->payload = NULL; + return kErrorParameters; + } + + mdp_gamut = new drm_msm_3d_gamut(); + if (!mdp_gamut) { + DLOGE("Failed to allocate memory for gamut"); + return kErrorMemory; + } + + if (sde_gamut->map_en) + mdp_gamut->flags = GAMUT_3D_MAP_EN; + else + mdp_gamut->flags = 0; + + switch (sde_gamut->mode) { + case SDEGamutCfgWrapper::GAMUT_FINE_MODE: + mdp_gamut->mode = GAMUT_3D_MODE_17; + size = GAMUT_3D_MODE17_TBL_SZ; + break; + case SDEGamutCfgWrapper::GAMUT_COARSE_MODE: + mdp_gamut->mode = GAMUT_3D_MODE_5; + size = GAMUT_3D_MODE5_TBL_SZ; + break; + case SDEGamutCfgWrapper::GAMUT_COARSE_MODE_13: + mdp_gamut->mode = GAMUT_3D_MODE_13; + size = GAMUT_3D_MODE13_TBL_SZ; + break; + default: + DLOGE("Invalid gamut mode %d", sde_gamut->mode); + free(mdp_gamut); + return kErrorParameters; + } + + if (sde_gamut->map_en) + std::memcpy(mdp_gamut->scale_off, sde_gamut->scale_off_data, + sizeof(uint32_t) * GAMUT_3D_SCALE_OFF_SZ * GAMUT_3D_SCALE_OFF_TBL_NUM); + + for (uint32_t row = 0; row < GAMUT_3D_TBL_NUM; row++) { + for (uint32_t col = 0; col < size; col++) { + mdp_gamut->col[row][col].c0 = sde_gamut->c0_data[row][col]; + mdp_gamut->col[row][col].c2_c1 = sde_gamut->c1_c2_data[row][col]; + } + } + out_data->payload = mdp_gamut; +#endif return ret; }