summaryrefslogtreecommitdiff
path: root/libhwc2.1
diff options
context:
space:
mode:
Diffstat (limited to 'libhwc2.1')
-rw-r--r--libhwc2.1/Android.mk1
-rw-r--r--libhwc2.1/ExynosHWCModule.h29
-rw-r--r--libhwc2.1/libcolormanager/ColorManager.cpp323
-rw-r--r--libhwc2.1/libcolormanager/ColorManager.h76
-rw-r--r--libhwc2.1/libdevice/ExynosDeviceModule.cpp19
-rw-r--r--libhwc2.1/libdevice/ExynosDeviceModule.h3
-rw-r--r--libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterfaceModule.cpp34
-rw-r--r--libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.cpp66
-rw-r--r--libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.h41
-rw-r--r--libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.cpp637
-rw-r--r--libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.h140
-rw-r--r--libhwc2.1/libresource/ExynosMPPModule.cpp17
12 files changed, 592 insertions, 794 deletions
diff --git a/libhwc2.1/Android.mk b/libhwc2.1/Android.mk
index a04375b..6b6354b 100644
--- a/libhwc2.1/Android.mk
+++ b/libhwc2.1/Android.mk
@@ -13,6 +13,7 @@
# limitations under the License.
LOCAL_SRC_FILES += \
+ ../../gs101/libhwc2.1/libcolormanager/ColorManager.cpp \
../../$(TARGET_BOARD_PLATFORM)/libhwc2.1/libcolormanager/DisplayColorModule.cpp \
../../$(TARGET_BOARD_PLATFORM)/libhwc2.1/libdevice/ExynosDeviceModule.cpp \
../../$(TARGET_BOARD_PLATFORM)/libhwc2.1/libdevice/HistogramController.cpp \
diff --git a/libhwc2.1/ExynosHWCModule.h b/libhwc2.1/ExynosHWCModule.h
index 170f66f..7a767fc 100644
--- a/libhwc2.1/ExynosHWCModule.h
+++ b/libhwc2.1/ExynosHWCModule.h
@@ -95,7 +95,8 @@ enum {
};
enum {
- HWC_DISPLAY_SECONDARY_BIT = 1 << (SECOND_DISPLAY_START_BIT + HWC_DISPLAY_PRIMARY),
+ HWC_RESERVE_DISPLAY_MAIN_BIT = 1,
+ HWC_RESERVE_DISPLAY_MINOR_BIT = 2
};
namespace gs101 {
@@ -117,13 +118,12 @@ static const dpp_channel_map_t idma_channel_map[] = {
};
static const exynos_mpp_t available_otf_mpp_units[] = {
- {MPP_DPP_GF, MPP_LOGICAL_DPP_GF, "DPP_GF0", 0, 0, HWC_DISPLAY_PRIMARY_BIT, 0, 0},
- {MPP_DPP_GF, MPP_LOGICAL_DPP_GF, "DPP_GF1", 1, 0, HWC_DISPLAY_PRIMARY_BIT, 0, 0},
- {MPP_DPP_GF, MPP_LOGICAL_DPP_GF, "DPP_GF2", 2, 0, HWC_DISPLAY_SECONDARY_BIT, 0, 0},
- {MPP_DPP_VGRFS, MPP_LOGICAL_DPP_VGRFS, "DPP_VGRFS0", 0, 0, HWC_DISPLAY_PRIMARY_BIT, 0, 0},
- {MPP_DPP_VGRFS, MPP_LOGICAL_DPP_VGRFS, "DPP_VGRFS1", 1, 0, HWC_DISPLAY_PRIMARY_BIT, 0, 0},
- {MPP_DPP_VGRFS, MPP_LOGICAL_DPP_VGRFS, "DPP_VGRFS2", 2, 0, HWC_DISPLAY_PRIMARY_BIT, 0, 0}
-};
+ {MPP_DPP_GF, MPP_LOGICAL_DPP_GF, "DPP_GF0", 0, 0, HWC_RESERVE_DISPLAY_MAIN_BIT, 0, 0},
+ {MPP_DPP_GF, MPP_LOGICAL_DPP_GF, "DPP_GF1", 1, 0, HWC_RESERVE_DISPLAY_MAIN_BIT, 0, 0},
+ {MPP_DPP_GF, MPP_LOGICAL_DPP_GF, "DPP_GF2", 2, 0, HWC_RESERVE_DISPLAY_MINOR_BIT, 0, 0},
+ {MPP_DPP_VGRFS, MPP_LOGICAL_DPP_VGRFS, "DPP_VGRFS0", 0, 0, HWC_RESERVE_DISPLAY_MAIN_BIT, 0, 0},
+ {MPP_DPP_VGRFS, MPP_LOGICAL_DPP_VGRFS, "DPP_VGRFS1", 1, 0, HWC_RESERVE_DISPLAY_MAIN_BIT, 0, 0},
+ {MPP_DPP_VGRFS, MPP_LOGICAL_DPP_VGRFS, "DPP_VGRFS2", 2, 0, HWC_RESERVE_DISPLAY_MAIN_BIT, 0, 0}};
static const std::array<exynos_display_t, 2> AVAILABLE_DISPLAY_UNITS = {{
{HWC_DISPLAY_PRIMARY, 0, "PrimaryDisplay", "/dev/dri/card0", ""},
@@ -132,15 +132,14 @@ static const std::array<exynos_display_t, 2> AVAILABLE_DISPLAY_UNITS = {{
} // namespace gs101
-
const exynos_mpp_t AVAILABLE_M2M_MPP_UNITS[] = {
#ifndef DISABLE_M2M_MPPS
- {MPP_G2D, MPP_LOGICAL_G2D_YUV, "G2D0-YUV_PRI", 0, 0, HWC_DISPLAY_PRIMARY_BIT, 0, 0},
- {MPP_G2D, MPP_LOGICAL_G2D_YUV, "G2D0-YUV_PRI", 0, 1, HWC_DISPLAY_PRIMARY_BIT, 0, 0},
- {MPP_G2D, MPP_LOGICAL_G2D_YUV, "G2D0-YUV_EXT", 0, 2, HWC_DISPLAY_EXTERNAL_BIT, 0, 0},
- {MPP_G2D, MPP_LOGICAL_G2D_RGB, "G2D0-RGB_PRI", 0, 3, HWC_DISPLAY_PRIMARY_BIT, 0, 0},
- {MPP_G2D, MPP_LOGICAL_G2D_RGB, "G2D0-RGB_EXT", 0, 4, HWC_DISPLAY_EXTERNAL_BIT, 0, 0},
- {MPP_G2D, MPP_LOGICAL_G2D_COMBO, "G2D0-COMBO_VIR", 0, 5, HWC_DISPLAY_VIRTUAL_BIT, 0, 0}
+ {MPP_G2D, MPP_LOGICAL_G2D_YUV, "G2D0-YUV_PRI", 0, 0, HWC_RESERVE_DISPLAY_MAIN_BIT, 0, 0},
+ {MPP_G2D, MPP_LOGICAL_G2D_YUV, "G2D0-YUV_PRI", 0, 1, HWC_RESERVE_DISPLAY_MAIN_BIT, 0, 0},
+ {MPP_G2D, MPP_LOGICAL_G2D_YUV, "G2D0-YUV_EXT", 0, 2, HWC_RESERVE_DISPLAY_MINOR_BIT, 0, 0},
+ {MPP_G2D, MPP_LOGICAL_G2D_RGB, "G2D0-RGB_PRI", 0, 3, HWC_RESERVE_DISPLAY_MAIN_BIT, 0, 0},
+ {MPP_G2D, MPP_LOGICAL_G2D_RGB, "G2D0-RGB_EXT", 0, 4, HWC_RESERVE_DISPLAY_MINOR_BIT, 0, 0},
+ {MPP_G2D, MPP_LOGICAL_G2D_COMBO, "G2D0-COMBO_VIR", 0, 5, HWC_RESERVE_DISPLAY_MINOR_BIT, 0, 0}
#endif
};
diff --git a/libhwc2.1/libcolormanager/ColorManager.cpp b/libhwc2.1/libcolormanager/ColorManager.cpp
new file mode 100644
index 0000000..e9590e7
--- /dev/null
+++ b/libhwc2.1/libcolormanager/ColorManager.cpp
@@ -0,0 +1,323 @@
+/*
+ * Copyright (C) 2023 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 "ColorManager.h"
+
+#include "BrightnessController.h"
+#include "ExynosDisplay.h"
+#include "ExynosHWCDebug.h"
+#include "ExynosLayer.h"
+
+namespace gs101 {
+
+#define CLR_LOGD(msg, ...) \
+ ALOGD("[%s] %s: " msg, mExynosDisplay->mDisplayName.c_str(), __func__, ##__VA_ARGS__);
+
+int32_t ColorManager::getColorModes(uint32_t* outNumModes, int32_t* outModes) {
+ GsInterfaceType* displayColorInterface = getDisplayColorInterface();
+ const DisplayType display = mExynosDisplay->getDcDisplayType();
+ const ColorModesMap colorModeMap = displayColorInterface == nullptr
+ ? ColorModesMap()
+ : displayColorInterface->ColorModesAndRenderIntents(display);
+ CLR_LOGD("size(%zu)", colorModeMap.size());
+ if (outNumModes == nullptr) {
+ DISPLAY_DRM_LOGE("%s: outNumModes is null", __func__);
+ return HWC2_ERROR_BAD_PARAMETER;
+ }
+ if (outModes == nullptr) {
+ *outNumModes = colorModeMap.size();
+ return HWC2_ERROR_NONE;
+ }
+ if (*outNumModes != colorModeMap.size()) {
+ DISPLAY_DRM_LOGE("%s: Invalid color mode size(%d), It should be(%zu)", __func__,
+ *outNumModes, colorModeMap.size());
+ return HWC2_ERROR_BAD_PARAMETER;
+ }
+
+ uint32_t index = 0;
+ for (const auto& it : colorModeMap) {
+ outModes[index] = static_cast<int32_t>(it.first);
+ CLR_LOGD("\tmode[%d] %d", index, outModes[index]);
+ index++;
+ }
+
+ return HWC2_ERROR_NONE;
+}
+
+int32_t ColorManager::setColorMode(int32_t mode) {
+ CLR_LOGD("mode(%d)", mode);
+ GsInterfaceType* displayColorInterface = getDisplayColorInterface();
+ const DisplayType display = mExynosDisplay->getDcDisplayType();
+ const ColorModesMap colorModeMap = displayColorInterface == nullptr
+ ? ColorModesMap()
+ : displayColorInterface->ColorModesAndRenderIntents(display);
+ hwc::ColorMode colorMode = static_cast<hwc::ColorMode>(mode);
+ const auto it = colorModeMap.find(colorMode);
+ if (it == colorModeMap.end()) {
+ DISPLAY_DRM_LOGE("%s: Invalid color mode(%d)", __func__, mode);
+ return HWC2_ERROR_BAD_PARAMETER;
+ }
+ mDisplaySceneInfo.setColorMode(colorMode);
+
+ if (mExynosDisplay->mColorMode != mode)
+ mExynosDisplay->setGeometryChanged(GEOMETRY_DISPLAY_COLOR_MODE_CHANGED);
+ mExynosDisplay->mColorMode = (android_color_mode_t)mode;
+
+ return HWC2_ERROR_NONE;
+}
+
+int32_t ColorManager::getRenderIntents(int32_t mode, uint32_t* outNumIntents, int32_t* outIntents) {
+ GsInterfaceType* displayColorInterface = getDisplayColorInterface();
+ const DisplayType display = mExynosDisplay->getDcDisplayType();
+ const ColorModesMap colorModeMap = displayColorInterface == nullptr
+ ? ColorModesMap()
+ : displayColorInterface->ColorModesAndRenderIntents(display);
+ CLR_LOGD("size(%zu)", colorModeMap.size());
+ hwc::ColorMode colorMode = static_cast<hwc::ColorMode>(mode);
+ const auto it = colorModeMap.find(colorMode);
+ if (it == colorModeMap.end()) {
+ DISPLAY_DRM_LOGE("%s: Invalid color mode(%d)", __func__, mode);
+ return HWC2_ERROR_BAD_PARAMETER;
+ }
+ auto& renderIntents = it->second;
+ if (outIntents == NULL) {
+ *outNumIntents = renderIntents.size();
+ CLR_LOGD("\tintent num(%zu)", renderIntents.size());
+ return HWC2_ERROR_NONE;
+ }
+ if (*outNumIntents != renderIntents.size()) {
+ DISPLAY_DRM_LOGE("%s: Invalid intent size(%d), It should be(%zu)", __func__, *outNumIntents,
+ renderIntents.size());
+ return HWC2_ERROR_BAD_PARAMETER;
+ }
+
+ for (uint32_t i = 0; i < renderIntents.size(); i++) {
+ outIntents[i] = static_cast<uint32_t>(renderIntents[i]);
+ CLR_LOGD("\tintent[%d] %d", i, outIntents[i]);
+ }
+
+ return HWC2_ERROR_NONE;
+}
+
+int32_t ColorManager::setColorModeWithRenderIntent(int32_t mode, int32_t intent) {
+ GsInterfaceType* displayColorInterface = getDisplayColorInterface();
+ const DisplayType display = mExynosDisplay->getDcDisplayType();
+ const ColorModesMap colorModeMap = displayColorInterface == nullptr
+ ? ColorModesMap()
+ : displayColorInterface->ColorModesAndRenderIntents(display);
+ hwc::ColorMode colorMode = static_cast<hwc::ColorMode>(mode);
+ hwc::RenderIntent renderIntent = static_cast<hwc::RenderIntent>(intent);
+
+ const auto mode_it = colorModeMap.find(colorMode);
+ if (mode_it == colorModeMap.end()) {
+ DISPLAY_DRM_LOGE("%s: Invalid color mode(%d)", __func__, mode);
+ return HWC2_ERROR_BAD_PARAMETER;
+ }
+
+ auto& renderIntents = mode_it->second;
+ auto intent_it = std::find(renderIntents.begin(), renderIntents.end(), renderIntent);
+ if (intent_it == renderIntents.end()) {
+ DISPLAY_DRM_LOGE("%s: Invalid render intent(%d)", __func__, intent);
+ return HWC2_ERROR_BAD_PARAMETER;
+ }
+
+ mDisplaySceneInfo.setColorMode(colorMode);
+ mDisplaySceneInfo.setRenderIntent(renderIntent);
+
+ if (mExynosDisplay->mColorMode != mode) {
+ CLR_LOGD("mode(%d), intent(%d)", mode, intent);
+ mExynosDisplay->setGeometryChanged(GEOMETRY_DISPLAY_COLOR_MODE_CHANGED);
+ }
+ mExynosDisplay->mColorMode = (android_color_mode_t)mode;
+
+ if (mExynosDisplay->mBrightnessController)
+ mExynosDisplay->mBrightnessController->updateColorRenderIntent(intent);
+
+ return HWC2_ERROR_NONE;
+}
+
+int32_t ColorManager::setColorTransform(const float* matrix, int32_t hint) {
+ if ((hint < HAL_COLOR_TRANSFORM_IDENTITY) || (hint > HAL_COLOR_TRANSFORM_CORRECT_TRITANOPIA))
+ return HWC2_ERROR_BAD_PARAMETER;
+ if (mExynosDisplay->mColorTransformHint != hint) {
+ ALOGI("[%s] %s:: %d -> %d", mExynosDisplay->mDisplayName.c_str(), __func__,
+ mExynosDisplay->mColorTransformHint, hint);
+ mExynosDisplay->setGeometryChanged(GEOMETRY_DISPLAY_COLOR_TRANSFORM_CHANGED);
+ }
+ mExynosDisplay->mColorTransformHint = hint;
+#ifdef HWC_SUPPORT_COLOR_TRANSFORM
+ mDisplaySceneInfo.setColorTransform(matrix);
+#endif
+ return HWC2_ERROR_NONE;
+}
+
+bool ColorManager::hasDppForLayer(ExynosMPPSource* layer) {
+ GsInterfaceType* displayColorInterface = getDisplayColorInterface();
+ if (displayColorInterface == nullptr) {
+ return false;
+ }
+
+ if (getDisplaySceneInfo().layerDataMappingInfo.count(layer) == 0) return false;
+
+ uint32_t index = getDisplaySceneInfo().layerDataMappingInfo[layer].dppIdx;
+ const DisplayType display = mExynosDisplay->getDcDisplayType();
+ auto size = displayColorInterface->GetPipelineData(display)->Dpp().size();
+ if (index >= size) {
+ DISPLAY_DRM_LOGE("%s: invalid dpp index(%d) dpp size(%zu)", __func__, index, size);
+ return false;
+ }
+
+ return true;
+}
+
+const ColorManager::GsInterfaceType::IDpp& ColorManager::getDppForLayer(ExynosMPPSource* layer) {
+ uint32_t index = getDisplaySceneInfo().layerDataMappingInfo[layer].dppIdx;
+ GsInterfaceType* displayColorInterface = getDisplayColorInterface();
+ const DisplayType display = mExynosDisplay->getDcDisplayType();
+ return displayColorInterface->GetPipelineData(display)->Dpp()[index].get();
+}
+
+int32_t ColorManager::getDppIndexForLayer(ExynosMPPSource* layer) {
+ if (getDisplaySceneInfo().layerDataMappingInfo.count(layer) == 0) return -1;
+ uint32_t index = getDisplaySceneInfo().layerDataMappingInfo[layer].dppIdx;
+
+ return static_cast<int32_t>(index);
+}
+
+const ColorManager::GsInterfaceType::IDqe& ColorManager::getDqe() {
+ GsInterfaceType* displayColorInterface = getDisplayColorInterface();
+ return displayColorInterface->GetPipelineData(mExynosDisplay->getDcDisplayType())->Dqe();
+}
+
+int32_t ColorManager::setLayersColorData() {
+ int32_t ret = 0;
+ uint32_t layerNum = 0;
+
+ // TODO: b/212616164 remove dimSdrRatio
+ float dimSdrRatio = 1;
+ if (mExynosDisplay->mBrightnessController)
+ dimSdrRatio = mExynosDisplay->mBrightnessController->getSdrDimRatioForInstantHbm();
+
+ // for client target
+ {
+ LayerColorData& layerColorData = getDisplaySceneInfo().getLayerColorDataInstance(layerNum);
+
+ /* set layer data mapping info */
+ if ((ret = getDisplaySceneInfo()
+ .setLayerDataMappingInfo(&mExynosDisplay->mClientCompositionInfo,
+ layerNum)) != NO_ERROR) {
+ DISPLAY_DRM_LOGE("%s: setLayerDataMappingInfo fail for client composition", __func__);
+ return ret;
+ }
+
+ if ((ret = getDisplaySceneInfo()
+ .setClientCompositionColorData(mExynosDisplay->mClientCompositionInfo,
+ layerColorData, dimSdrRatio)) !=
+ NO_ERROR) {
+ DISPLAY_DRM_LOGE("%s: setClientCompositionColorData fail", __func__);
+ return ret;
+ }
+
+ layerColorData.is_client_target = true;
+ layerNum++;
+ }
+
+ for (uint32_t i = 0; i < mExynosDisplay->mLayers.size(); i++) {
+ ExynosLayer* layer = mExynosDisplay->mLayers[i];
+
+ if (layer->mCompositionType == HWC2_COMPOSITION_CLIENT) continue;
+
+ LayerColorData& layerColorData = getDisplaySceneInfo().getLayerColorDataInstance(layerNum);
+
+ /* set layer data mapping info */
+ if ((ret = getDisplaySceneInfo().setLayerDataMappingInfo(layer, layerNum)) != NO_ERROR) {
+ DISPLAY_DRM_LOGE("%s: layer[%d] setLayerDataMappingInfo fail, layerNum(%d)", __func__,
+ i, layerNum);
+ return ret;
+ }
+
+ if ((ret = getDisplaySceneInfo().setLayerColorData(layerColorData, layer, dimSdrRatio)) !=
+ NO_ERROR) {
+ DISPLAY_DRM_LOGE("%s: layer[%d] setLayerColorData fail, layerNum(%d)", __func__, i,
+ layerNum);
+ return ret;
+ }
+
+ layerColorData.is_client_target = false;
+ layerNum++;
+ }
+
+ /* Resize layer_data when layers were destroyed */
+ if (layerNum < getDisplaySceneInfo().displayScene.layer_data.size())
+ getDisplaySceneInfo().displayScene.layer_data.resize(layerNum);
+
+ return NO_ERROR;
+}
+
+int32_t ColorManager::updateColorConversionInfo() {
+ int ret = 0;
+ GsInterfaceType* displayColorInterface = getDisplayColorInterface();
+ if (displayColorInterface == nullptr) {
+ return ret;
+ }
+
+ mExynosDisplay->updateBrightnessState();
+ /* clear flag and layer mapping info before setting */
+ getDisplaySceneInfo().reset();
+
+ if ((ret = setLayersColorData()) != NO_ERROR) return ret;
+
+ DisplayScene& displayScene = getDisplaySceneInfo().displayScene;
+ auto& brightnessController = mExynosDisplay->mBrightnessController;
+
+ displayScene.bm = displaycolor::BrightnessMode::BM_NOMINAL;
+ if (brightnessController && brightnessController->isGhbmOn())
+ displayScene.bm = displaycolor::BrightnessMode::BM_HBM;
+
+ displayScene.force_hdr = false;
+ displayScene.lhbm_on = false;
+ displayScene.hdr_layer_state = displaycolor::HdrLayerState::kHdrNone;
+ displayScene.dbv = 1000;
+
+ if (brightnessController) {
+ displayScene.force_hdr = brightnessController->isDimSdr();
+ displayScene.lhbm_on = brightnessController->isLhbmOn();
+ displayScene.hdr_layer_state = brightnessController->getHdrLayerState();
+ displayScene.dbv = brightnessController->getBrightnessLevel();
+ }
+
+ if (hwcCheckDebugMessages(eDebugColorManagement)) getDisplaySceneInfo().printDisplayScene();
+
+ const DisplayType display = mExynosDisplay->getDcDisplayType();
+ if ((ret = displayColorInterface->Update(display, getDisplaySceneInfo().displayScene)) != 0) {
+ DISPLAY_DRM_LOGE("Display Scene update error (%d)", ret);
+ return ret;
+ }
+
+ return ret;
+}
+
+int32_t ColorManager::resetColorMappingInfo(ExynosMPPSource* mppSrc) {
+ if (getDisplaySceneInfo().layerDataMappingInfo.count(mppSrc) == 0) {
+ return -EINVAL;
+ }
+
+ getDisplaySceneInfo().layerDataMappingInfo[mppSrc].planeId =
+ DisplaySceneInfo::LayerMappingInfo::kPlaneIdNone;
+
+ return NO_ERROR;
+}
+
+} // namespace gs101
diff --git a/libhwc2.1/libcolormanager/ColorManager.h b/libhwc2.1/libcolormanager/ColorManager.h
new file mode 100644
index 0000000..612ad5f
--- /dev/null
+++ b/libhwc2.1/libcolormanager/ColorManager.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2023 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 COLOR_MANAGER_H
+#define COLOR_MANAGER_H
+
+#include <displaycolor/displaycolor.h>
+
+#include "DisplaySceneInfo.h"
+#include "ExynosDeviceModule.h"
+#include "ExynosHwc3Types.h"
+
+using namespace displaycolor;
+class ExynosDisplay;
+
+namespace gs101 {
+
+class ExynosDeviceModule;
+
+class ColorManager {
+public:
+ ColorManager(ExynosDisplay* display, ExynosDeviceModule* device)
+ : mExynosDisplay(display), mDevice(device) {}
+
+ DisplaySceneInfo& getDisplaySceneInfo() { return mDisplaySceneInfo; }
+
+ using GsInterfaceType = gs::ColorDrmBlobFactory::GsInterfaceType;
+ GsInterfaceType* getDisplayColorInterface() { return mDevice->getDisplayColorInterface(); }
+
+ int32_t getColorModes(uint32_t* outNumModes, int32_t* outModes);
+ int32_t setColorMode(int32_t mode);
+ int32_t getRenderIntents(int32_t mode, uint32_t* outNumIntents, int32_t* outIntents);
+ int32_t setColorModeWithRenderIntent(int32_t mode, int32_t intent);
+ int32_t setColorTransform(const float* matrix, int32_t hint);
+
+ /* Call getDppForLayer() only if hasDppForLayer() is true */
+ bool hasDppForLayer(ExynosMPPSource* layer);
+ const GsInterfaceType::IDpp& getDppForLayer(ExynosMPPSource* layer);
+ int32_t getDppIndexForLayer(ExynosMPPSource* layer);
+ /* Check if layer's assigned plane id has changed, save the new planeId.
+ * call only if hasDppForLayer is true */
+ bool checkAndSaveLayerPlaneId(ExynosMPPSource* layer, uint32_t planeId) {
+ auto& info = getDisplaySceneInfo().layerDataMappingInfo[layer];
+ bool change = info.planeId != planeId;
+ info.planeId = planeId;
+ return change;
+ }
+
+ const GsInterfaceType::IDqe& getDqe();
+
+ int32_t updateColorConversionInfo();
+ int32_t resetColorMappingInfo(ExynosMPPSource* mppSrc);
+
+private:
+ int32_t setLayersColorData();
+
+ ExynosDisplay* mExynosDisplay;
+ ExynosDeviceModule* mDevice;
+ DisplaySceneInfo mDisplaySceneInfo;
+};
+
+} // namespace gs101
+
+#endif // COLOR_MANAGER_H
diff --git a/libhwc2.1/libdevice/ExynosDeviceModule.cpp b/libhwc2.1/libdevice/ExynosDeviceModule.cpp
index 99dd8ba..98b6c60 100644
--- a/libhwc2.1/libdevice/ExynosDeviceModule.cpp
+++ b/libhwc2.1/libdevice/ExynosDeviceModule.cpp
@@ -17,6 +17,7 @@
#include "ExynosDeviceModule.h"
#include "ExynosDisplayDrmInterfaceModule.h"
+#include "ExynosExternalDisplayModule.h"
#include "ExynosPrimaryDisplayModule.h"
extern struct exynos_hwc_control exynosHWCControl;
@@ -30,9 +31,7 @@ ExynosDeviceModule::ExynosDeviceModule(bool isVrrApiSupported)
std::vector<displaycolor::DisplayInfo> display_info;
for (uint32_t i = 0; i < mDisplays.size(); i++) {
ExynosDisplay* display = mDisplays[i];
- // TODO(b/288608645): Allow HWC_DISPLAY_EXTERNAL here when displaycolor
- // supports external displays.
- if (display->mType == HWC_DISPLAY_PRIMARY) {
+ if (display->mType == HWC_DISPLAY_PRIMARY || display->mType == HWC_DISPLAY_EXTERNAL) {
ExynosDisplayDrmInterfaceModule* moduleDisplayInterface =
(ExynosDisplayDrmInterfaceModule*)(display->mDisplayInterface.get());
moduleDisplayInterface->getDisplayInfo(display_info);
@@ -60,3 +59,17 @@ int ExynosDeviceModule::initDisplayColor(
return NO_ERROR;
}
+
+ColorManager* ExynosDeviceModule::getDisplayColorManager(ExynosDisplay* display) {
+ if (display->mType == HWC_DISPLAY_PRIMARY) {
+ ExynosPrimaryDisplayModule* primaryDisplay =
+ static_cast<ExynosPrimaryDisplayModule*>(display);
+ return primaryDisplay->getColorManager();
+ } else if (display->mType == HWC_DISPLAY_EXTERNAL) {
+ ExynosExternalDisplayModule* externaDisplay =
+ static_cast<ExynosExternalDisplayModule*>(display);
+ return externaDisplay->getColorManager();
+ }
+ ALOGW("%s: no color manager for display->mType=%d", __func__, display->mType);
+ return nullptr;
+}
diff --git a/libhwc2.1/libdevice/ExynosDeviceModule.h b/libhwc2.1/libdevice/ExynosDeviceModule.h
index 42c2e18..991ac93 100644
--- a/libhwc2.1/libdevice/ExynosDeviceModule.h
+++ b/libhwc2.1/libdevice/ExynosDeviceModule.h
@@ -23,6 +23,7 @@
using namespace displaycolor;
namespace gs101 {
+class ColorManager;
class ExynosDeviceModule : public ExynosDevice {
using GsInterfaceType = gs::ColorDrmBlobFactory::GsInterfaceType;
@@ -34,6 +35,8 @@ class ExynosDeviceModule : public ExynosDevice {
void setActiveDisplay(uint32_t index) { mActiveDisplay = index; }
uint32_t getActiveDisplay() const { return mActiveDisplay; }
+ ColorManager* getDisplayColorManager(ExynosDisplay* display);
+
private:
int initDisplayColor(const std::vector<displaycolor::DisplayInfo>& display_info);
diff --git a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterfaceModule.cpp b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterfaceModule.cpp
index 8190e3c..7431091 100644
--- a/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterfaceModule.cpp
+++ b/libhwc2.1/libdisplayinterface/ExynosDisplayDrmInterfaceModule.cpp
@@ -54,9 +54,6 @@ int32_t ExynosDisplayDrmInterfaceModule::initDrmDevice(DrmDevice *drmDevice)
if ((ret = ExynosDisplayDrmInterface::initDrmDevice(drmDevice)) != NO_ERROR)
return ret;
- if (isPrimary() == false)
- return ret;
-
mOldDqeBlobs.init(drmDevice);
initOldDppBlobs(drmDevice);
@@ -162,19 +159,17 @@ int32_t ExynosDisplayDrmInterfaceModule::setDisplayColorBlob(
return ret;
}
+
int32_t ExynosDisplayDrmInterfaceModule::setDisplayColorSetting(
- ExynosDisplayDrmInterface::DrmModeAtomicReq &drmReq)
-{
- if (isPrimary() == false)
- return NO_ERROR;
+ ExynosDisplayDrmInterface::DrmModeAtomicReq& drmReq) {
if (!mForceDisplayColorSetting && !mColorSettingChanged)
return NO_ERROR;
- ExynosPrimaryDisplayModule* display =
- (ExynosPrimaryDisplayModule*)mExynosDisplay;
+ ExynosDeviceModule* device = static_cast<ExynosDeviceModule*>(mExynosDisplay->mDevice);
+ gs101::ColorManager* colorManager = device->getDisplayColorManager(mExynosDisplay);
int ret = NO_ERROR;
- const typename GsInterfaceType::IDqe &dqe = display->getDqe();
+ const typename GsInterfaceType::IDqe& dqe = colorManager->getDqe();
if ((mDrmCrtc->cgc_lut_property().id() != 0) &&
(ret = setDisplayColorBlob(mDrmCrtc->cgc_lut_property(),
@@ -317,9 +312,7 @@ int32_t ExynosDisplayDrmInterfaceModule::setPlaneColorSetting(
const std::unique_ptr<DrmPlane> &plane,
const exynos_win_config_data &config, uint32_t &solidColor)
{
- if ((mColorSettingChanged == false) ||
- (isPrimary() == false))
- return NO_ERROR;
+ if (mColorSettingChanged == false) return NO_ERROR;
if ((config.assignedMPP == nullptr) ||
(config.assignedMPP->mAssignedSources.size() == 0)) {
@@ -334,7 +327,12 @@ int32_t ExynosDisplayDrmInterfaceModule::setPlaneColorSetting(
return -EINVAL;
}
- ExynosPrimaryDisplayModule* display = (ExynosPrimaryDisplayModule*)mExynosDisplay;
+ ExynosDeviceModule* device = static_cast<ExynosDeviceModule*>(mExynosDisplay->mDevice);
+ ColorManager* colorManager = device->getDisplayColorManager(mExynosDisplay);
+ if (!colorManager) {
+ HWC_LOGE(mExynosDisplay, "%s: no colorManager for this display", __func__);
+ return -EINVAL;
+ }
/*
* Color conversion of Client and Exynos composition buffer
@@ -342,7 +340,7 @@ int32_t ExynosDisplayDrmInterfaceModule::setPlaneColorSetting(
* supported by HWC/displaycolor, we need put client composition under
* control of HWC/displaycolor.
*/
- if (!display->hasDppForLayer(mppSource)) {
+ if (!colorManager->hasDppForLayer(mppSource)) {
if (mppSource->mSourceType == MPP_SOURCE_LAYER) {
HWC_LOGE(mExynosDisplay,
"%s: layer need color conversion but there is no IDpp",
@@ -367,9 +365,9 @@ int32_t ExynosDisplayDrmInterfaceModule::setPlaneColorSetting(
}
}
- const typename GsInterfaceType::IDpp &dpp = display->getDppForLayer(mppSource);
- const uint32_t dppIndex = static_cast<uint32_t>(display->getDppIndexForLayer(mppSource));
- bool planeChanged = display->checkAndSaveLayerPlaneId(mppSource, plane->id());
+ const typename GsInterfaceType::IDpp& dpp = colorManager->getDppForLayer(mppSource);
+ const uint32_t dppIndex = static_cast<uint32_t>(colorManager->getDppIndexForLayer(mppSource));
+ bool planeChanged = colorManager->checkAndSaveLayerPlaneId(mppSource, plane->id());
auto &color = dpp.SolidColor();
// exynos_win_config_data.color ARGB
diff --git a/libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.cpp b/libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.cpp
index c26c317..59844f4 100644
--- a/libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.cpp
+++ b/libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.cpp
@@ -21,6 +21,7 @@
#include "ExynosVirtualDisplayModule.h"
#endif
+#include "ExynosDisplayDrmInterfaceModule.h"
#include "ExynosHWCDebug.h"
#include "ExynosHWCHelper.h"
@@ -28,9 +29,11 @@
using namespace gs101;
-ExynosExternalDisplayModule::ExynosExternalDisplayModule(uint32_t index, ExynosDevice *device,
- const std::string &displayName)
- : ExynosExternalDisplay(index, device, displayName) {}
+ExynosExternalDisplayModule::ExynosExternalDisplayModule(uint32_t index, ExynosDevice* device,
+ const std::string& displayName)
+ : ExynosExternalDisplay(index, device, displayName) {
+ mColorManager = std::make_unique<ColorManager>(this, static_cast<ExynosDeviceModule*>(device));
+}
ExynosExternalDisplayModule::~ExynosExternalDisplayModule ()
{
@@ -70,3 +73,60 @@ int32_t ExynosExternalDisplayModule::validateWinConfigData()
else
return -EINVAL;
}
+
+int32_t ExynosExternalDisplayModule::getColorModes(uint32_t* outNumModes, int32_t* outModes) {
+ return mColorManager->getColorModes(outNumModes, outModes);
+}
+
+int32_t ExynosExternalDisplayModule::setColorMode(int32_t mode) {
+ return mColorManager->setColorMode(mode);
+}
+
+int32_t ExynosExternalDisplayModule::getRenderIntents(int32_t mode, uint32_t* outNumIntents,
+ int32_t* outIntents) {
+ return mColorManager->getRenderIntents(mode, outNumIntents, outIntents);
+}
+
+int32_t ExynosExternalDisplayModule::setColorModeWithRenderIntent(int32_t mode, int32_t intent) {
+ return mColorManager->setColorModeWithRenderIntent(mode, intent);
+}
+
+int32_t ExynosExternalDisplayModule::setColorTransform(const float* matrix, int32_t hint) {
+ return mColorManager->setColorTransform(matrix, hint);
+}
+
+int32_t ExynosExternalDisplayModule::updateColorConversionInfo() {
+ return mColorManager->updateColorConversionInfo();
+}
+
+int32_t ExynosExternalDisplayModule::resetColorMappingInfo(ExynosMPPSource* mppSrc) {
+ return mColorManager->resetColorMappingInfo(mppSrc);
+}
+
+int ExynosExternalDisplayModule::deliverWinConfigData() {
+ int ret = 0;
+ ExynosDisplayDrmInterfaceModule* moduleDisplayInterface =
+ (ExynosDisplayDrmInterfaceModule*)(mDisplayInterface.get());
+ GsInterfaceType* displayColorInterface = getDisplayColorInterface();
+
+ bool forceDisplayColorSetting = false;
+ if (!getDisplaySceneInfo().displaySettingDelivered || isForceColorUpdate())
+ forceDisplayColorSetting = true;
+
+ setForceColorUpdate(false);
+
+ if (displayColorInterface != nullptr) {
+ moduleDisplayInterface
+ ->setColorSettingChanged(getDisplaySceneInfo().needDisplayColorSetting(),
+ forceDisplayColorSetting);
+ }
+
+ ret = ExynosDisplay::deliverWinConfigData();
+
+ if (mDpuData.enable_readback && !mDpuData.readback_info.requested_from_service)
+ getDisplaySceneInfo().displaySettingDelivered = false;
+ else
+ getDisplaySceneInfo().displaySettingDelivered = true;
+
+ return ret;
+}
diff --git a/libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.h b/libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.h
index 3d2667d..fcffc44 100644
--- a/libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.h
+++ b/libhwc2.1/libexternaldisplay/ExynosExternalDisplayModule.h
@@ -16,17 +16,48 @@
#ifndef EXYNOS_EXTERNAL_DISPLAY_MODULE_H
#define EXYNOS_EXTERNAL_DISPLAY_MODULE_H
+#include "ColorManager.h"
#include "ExynosDisplay.h"
#include "ExynosExternalDisplay.h"
+#include "ExynosLayer.h"
namespace gs101 {
+class ColorManager;
+
class ExynosExternalDisplayModule : public ExynosExternalDisplay {
- public:
- ExynosExternalDisplayModule(uint32_t index, ExynosDevice* device,
- const std::string& displayName);
- ~ExynosExternalDisplayModule();
- virtual int32_t validateWinConfigData();
+ using GsInterfaceType = gs::ColorDrmBlobFactory::GsInterfaceType;
+
+public:
+ ExynosExternalDisplayModule(uint32_t index, ExynosDevice* device,
+ const std::string& displayName);
+ ~ExynosExternalDisplayModule();
+ virtual int32_t validateWinConfigData();
+
+ ColorManager* getColorManager() { return mColorManager.get(); }
+
+ int32_t getColorModes(uint32_t* outNumModes, int32_t* outModes) override;
+ int32_t setColorMode(int32_t mode) override;
+ int32_t getRenderIntents(int32_t mode, uint32_t* outNumIntents, int32_t* outIntents) override;
+ int32_t setColorModeWithRenderIntent(int32_t mode, int32_t intent) override;
+ int32_t setColorTransform(const float* matrix, int32_t hint) override;
+
+ int32_t updateColorConversionInfo() override;
+ int32_t resetColorMappingInfo(ExynosMPPSource* mppSrc) override;
+
+ bool mForceColorUpdate = false;
+ bool isForceColorUpdate() const { return mForceColorUpdate; }
+ void setForceColorUpdate(bool force) { mForceColorUpdate = force; }
+ int deliverWinConfigData() override;
+
+private:
+ std::unique_ptr<ColorManager> mColorManager;
+
+ GsInterfaceType* getDisplayColorInterface() {
+ return mColorManager->getDisplayColorInterface();
+ }
+
+ DisplaySceneInfo& getDisplaySceneInfo() { return mColorManager->getDisplaySceneInfo(); }
};
} // namespace gs101
diff --git a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.cpp b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.cpp
index f376447..2a273e6 100644
--- a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.cpp
+++ b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.cpp
@@ -42,18 +42,13 @@ mpp_phycal_type_t getMPPTypeFromDPPChannel(uint32_t channel) {
return MPP_P_TYPE_MAX;
}
-// enable map layerDataMappingInfo comparison in needDisplayColorSetting()
-inline bool operator==(const ExynosPrimaryDisplayModule::DisplaySceneInfo::LayerMappingInfo &lm1,
- const ExynosPrimaryDisplayModule::DisplaySceneInfo::LayerMappingInfo &lm2) {
- return lm1.dppIdx == lm2.dppIdx && lm1.planeId == lm2.planeId;
-}
-
ExynosPrimaryDisplayModule::ExynosPrimaryDisplayModule(uint32_t index, ExynosDevice* device,
const std::string& displayName)
- : ExynosPrimaryDisplay(index, device, displayName) {
+ : ExynosPrimaryDisplay(index, device, displayName), mAtcInit(false) {
#ifdef FORCE_GPU_COMPOSITION
exynosHWCControl.forceGpu = true;
#endif
+ mColorManager = std::make_unique<ColorManager>(this, static_cast<ExynosDeviceModule*>(device));
}
ExynosPrimaryDisplayModule::~ExynosPrimaryDisplayModule () {
@@ -124,151 +119,30 @@ void ExynosPrimaryDisplayModule::doPreProcessing() {
int32_t ExynosPrimaryDisplayModule::getColorModes(
uint32_t* outNumModes, int32_t* outModes)
{
- GsInterfaceType* displayColorInterface = getDisplayColorInterface();
- const DisplayType display = getDcDisplayType();
- const ColorModesMap colorModeMap = displayColorInterface == nullptr
- ? ColorModesMap()
- : displayColorInterface->ColorModesAndRenderIntents(display);
- ALOGD("%s: size(%zu)", __func__, colorModeMap.size());
- if (outModes == nullptr) {
- *outNumModes = colorModeMap.size();
- return HWC2_ERROR_NONE;
- }
- if (*outNumModes != colorModeMap.size()) {
- DISPLAY_LOGE("%s: Invalid color mode size(%d), It should be(%zu)",
- __func__, *outNumModes, colorModeMap.size());
- return HWC2_ERROR_BAD_PARAMETER;
- }
-
- uint32_t index = 0;
- for (const auto &it : colorModeMap)
- {
- outModes[index] = static_cast<int32_t>(it.first);
- ALOGD("\tmode[%d] %d", index, outModes[index]);
- index++;
- }
-
- return HWC2_ERROR_NONE;
+ return mColorManager->getColorModes(outNumModes, outModes);
}
int32_t ExynosPrimaryDisplayModule::setColorMode(int32_t mode)
{
- ALOGD("%s: mode(%d)", __func__, mode);
- GsInterfaceType* displayColorInterface = getDisplayColorInterface();
- const DisplayType display = getDcDisplayType();
- const ColorModesMap colorModeMap = displayColorInterface == nullptr
- ? ColorModesMap()
- : displayColorInterface->ColorModesAndRenderIntents(display);
- hwc::ColorMode colorMode =
- static_cast<hwc::ColorMode>(mode);
- const auto it = colorModeMap.find(colorMode);
- if (it == colorModeMap.end()) {
- DISPLAY_LOGE("%s: Invalid color mode(%d)", __func__, mode);
- return HWC2_ERROR_BAD_PARAMETER;
- }
- mDisplaySceneInfo.setColorMode(colorMode);
-
- if (mColorMode != mode)
- setGeometryChanged(GEOMETRY_DISPLAY_COLOR_MODE_CHANGED);
- mColorMode = (android_color_mode_t)mode;
-
- return HWC2_ERROR_NONE;
+ return mColorManager->setColorMode(mode);
}
int32_t ExynosPrimaryDisplayModule::getRenderIntents(int32_t mode,
uint32_t* outNumIntents, int32_t* outIntents)
{
- GsInterfaceType* displayColorInterface = getDisplayColorInterface();
- const DisplayType display = getDcDisplayType();
- const ColorModesMap colorModeMap = displayColorInterface == nullptr
- ? ColorModesMap()
- : displayColorInterface->ColorModesAndRenderIntents(display);
- ALOGD("%s, size(%zu)", __func__, colorModeMap.size());
- hwc::ColorMode colorMode =
- static_cast<hwc::ColorMode>(mode);
- const auto it = colorModeMap.find(colorMode);
- if (it == colorModeMap.end()) {
- DISPLAY_LOGE("%s: Invalid color mode(%d)", __func__, mode);
- return HWC2_ERROR_BAD_PARAMETER;
- }
- auto &renderIntents = it->second;
- if (outIntents == NULL) {
- *outNumIntents = renderIntents.size();
- ALOGD("\tintent num(%zu)", renderIntents.size());
- return HWC2_ERROR_NONE;
- }
- if (*outNumIntents != renderIntents.size()) {
- DISPLAY_LOGE("%s: Invalid intent size(%d), It should be(%zu)",
- __func__, *outNumIntents, renderIntents.size());
- return HWC2_ERROR_BAD_PARAMETER;
- }
-
- for (uint32_t i = 0; i < renderIntents.size(); i++)
- {
- outIntents[i] = static_cast<uint32_t>(renderIntents[i]);
- ALOGD("\tintent[%d] %d", i, outIntents[i]);
- }
-
- return HWC2_ERROR_NONE;
+ return mColorManager->getRenderIntents(mode, outNumIntents, outIntents);
}
int32_t ExynosPrimaryDisplayModule::setColorModeWithRenderIntent(int32_t mode,
int32_t intent)
{
- GsInterfaceType* displayColorInterface = getDisplayColorInterface();
- const DisplayType display = getDcDisplayType();
- const ColorModesMap colorModeMap = displayColorInterface == nullptr
- ? ColorModesMap()
- : displayColorInterface->ColorModesAndRenderIntents(display);
- hwc::ColorMode colorMode =
- static_cast<hwc::ColorMode>(mode);
- hwc::RenderIntent renderIntent =
- static_cast<hwc::RenderIntent>(intent);
-
- const auto mode_it = colorModeMap.find(colorMode);
- if (mode_it == colorModeMap.end()) {
- DISPLAY_LOGE("%s: Invalid color mode(%d)", __func__, mode);
- return HWC2_ERROR_BAD_PARAMETER;
- }
-
- auto &renderIntents = mode_it->second;
- auto intent_it = std::find(renderIntents.begin(),
- renderIntents.end(), renderIntent);
- if (intent_it == renderIntents.end()) {
- DISPLAY_LOGE("%s: Invalid render intent(%d)", __func__, intent);
- return HWC2_ERROR_BAD_PARAMETER;
- }
-
- mDisplaySceneInfo.setColorMode(colorMode);
- mDisplaySceneInfo.setRenderIntent(renderIntent);
-
- if (mColorMode != mode) {
- ALOGD("%s: mode(%d), intent(%d)", __func__, mode, intent);
- setGeometryChanged(GEOMETRY_DISPLAY_COLOR_MODE_CHANGED);
- }
- mColorMode = (android_color_mode_t)mode;
-
- mBrightnessController->updateColorRenderIntent(intent);
-
- return HWC2_ERROR_NONE;
+ return mColorManager->setColorModeWithRenderIntent(mode, intent);
}
int32_t ExynosPrimaryDisplayModule::setColorTransform(
const float* matrix, int32_t hint)
{
- if ((hint < HAL_COLOR_TRANSFORM_IDENTITY) ||
- (hint > HAL_COLOR_TRANSFORM_CORRECT_TRITANOPIA))
- return HWC2_ERROR_BAD_PARAMETER;
- if (mColorTransformHint != hint) {
- ALOGI("%s:: %d -> %d", __func__, mColorTransformHint, hint);
- setGeometryChanged(GEOMETRY_DISPLAY_COLOR_TRANSFORM_CHANGED);
- }
- mColorTransformHint = hint;
-#ifdef HWC_SUPPORT_COLOR_TRANSFORM
- mDisplaySceneInfo.setColorTransform(matrix);
-#endif
- return HWC2_ERROR_NONE;
-
+ return mColorManager->setColorTransform(matrix, hint);
}
int32_t ExynosPrimaryDisplayModule::getClientTargetProperty(
@@ -320,110 +194,6 @@ int32_t ExynosPrimaryDisplayModule::updateBrightnessTable() {
return HWC2_ERROR_NONE;
}
-int32_t ExynosPrimaryDisplayModule::setLayersColorData()
-{
- int32_t ret = 0;
- uint32_t layerNum = 0;
-
- // TODO: b/212616164 remove dimSdrRatio
- float dimSdrRatio = mBrightnessController->getSdrDimRatioForInstantHbm();
-
- // for client target
- {
- LayerColorData& layerColorData = mDisplaySceneInfo.getLayerColorDataInstance(layerNum);
-
- /* set layer data mapping info */
- if ((ret = mDisplaySceneInfo.setLayerDataMappingInfo(&mClientCompositionInfo, layerNum)) !=
- NO_ERROR) {
- DISPLAY_LOGE("%s: setLayerDataMappingInfo fail for client composition", __func__);
- return ret;
- }
-
- if ((ret = mDisplaySceneInfo.setClientCompositionColorData(mClientCompositionInfo,
- layerColorData, dimSdrRatio)) !=
- NO_ERROR) {
- DISPLAY_LOGE("%s: setClientCompositionColorData fail", __func__);
- return ret;
- }
-
- layerColorData.is_client_target = true;
- layerNum++;
- }
-
- for (uint32_t i = 0; i < mLayers.size(); i++)
- {
- ExynosLayer* layer = mLayers[i];
-
- if (layer->mCompositionType == HWC2_COMPOSITION_CLIENT) continue;
-
- LayerColorData& layerColorData =
- mDisplaySceneInfo.getLayerColorDataInstance(layerNum);
-
- /* set layer data mapping info */
- if ((ret = mDisplaySceneInfo.setLayerDataMappingInfo(layer, layerNum))
- != NO_ERROR) {
- DISPLAY_LOGE("%s: layer[%d] setLayerDataMappingInfo fail, layerNum(%d)",
- __func__, i, layerNum);
- return ret;
- }
-
-
- if ((ret = mDisplaySceneInfo.setLayerColorData(layerColorData, layer,
- dimSdrRatio)) != NO_ERROR) {
- DISPLAY_LOGE("%s: layer[%d] setLayerColorData fail, layerNum(%d)",
- __func__, i, layerNum);
- return ret;
- }
-
- layerColorData.is_client_target = false;
- layerNum++;
- }
-
- /* Resize layer_data when layers were destroyed */
- if (layerNum < mDisplaySceneInfo.displayScene.layer_data.size())
- mDisplaySceneInfo.displayScene.layer_data.resize(layerNum);
-
- return NO_ERROR;
-}
-
-bool ExynosPrimaryDisplayModule::hasDppForLayer(ExynosMPPSource* layer)
-{
- GsInterfaceType* displayColorInterface = getDisplayColorInterface();
- if (displayColorInterface == nullptr) {
- return false;
- }
-
- if (mDisplaySceneInfo.layerDataMappingInfo.count(layer) == 0)
- return false;
-
- uint32_t index = mDisplaySceneInfo.layerDataMappingInfo[layer].dppIdx;
- const DisplayType display = getDcDisplayType();
- auto size = displayColorInterface->GetPipelineData(display)->Dpp().size();
- if (index >= size) {
- DISPLAY_LOGE("%s: invalid dpp index(%d) dpp size(%zu)", __func__, index, size);
- return false;
- }
-
- return true;
-}
-
-const ExynosPrimaryDisplayModule::GsInterfaceType::IDpp& ExynosPrimaryDisplayModule::getDppForLayer(
- ExynosMPPSource* layer) {
- uint32_t index = mDisplaySceneInfo.layerDataMappingInfo[layer].dppIdx;
- GsInterfaceType* displayColorInterface = getDisplayColorInterface();
- const DisplayType display = getDcDisplayType();
- return displayColorInterface->GetPipelineData(display)->Dpp()[index].get();
-}
-
-int32_t ExynosPrimaryDisplayModule::getDppIndexForLayer(ExynosMPPSource* layer)
-{
- if (mDisplaySceneInfo.layerDataMappingInfo.count(layer) == 0)
- return -1;
- uint32_t index = mDisplaySceneInfo.layerDataMappingInfo[layer].dppIdx;
-
- return static_cast<int32_t>(index);
-}
-
int ExynosPrimaryDisplayModule::deliverWinConfigData()
{
int ret = 0;
@@ -432,15 +202,15 @@ int ExynosPrimaryDisplayModule::deliverWinConfigData()
GsInterfaceType* displayColorInterface = getDisplayColorInterface();
bool forceDisplayColorSetting = false;
- if (!mDisplaySceneInfo.displaySettingDelivered || isForceColorUpdate())
+ if (!getDisplaySceneInfo().displaySettingDelivered || isForceColorUpdate())
forceDisplayColorSetting = true;
setForceColorUpdate(false);
if (displayColorInterface != nullptr) {
- moduleDisplayInterface->setColorSettingChanged(
- mDisplaySceneInfo.needDisplayColorSetting(),
- forceDisplayColorSetting);
+ moduleDisplayInterface
+ ->setColorSettingChanged(getDisplaySceneInfo().needDisplayColorSetting(),
+ forceDisplayColorSetting);
}
ret = ExynosDisplay::deliverWinConfigData();
@@ -449,303 +219,22 @@ int ExynosPrimaryDisplayModule::deliverWinConfigData()
if (mDpuData.enable_readback &&
!mDpuData.readback_info.requested_from_service)
- mDisplaySceneInfo.displaySettingDelivered = false;
+ getDisplaySceneInfo().displaySettingDelivered = false;
else
- mDisplaySceneInfo.displaySettingDelivered = true;
+ getDisplaySceneInfo().displaySettingDelivered = true;
return ret;
}
-LayerColorData& ExynosPrimaryDisplayModule::DisplaySceneInfo::getLayerColorDataInstance(
- uint32_t index)
-{
- size_t currentSize = displayScene.layer_data.size();
- if (index >= currentSize) {
- displayScene.layer_data.resize(currentSize+1);
- colorSettingChanged = true;
- }
- return displayScene.layer_data[index];
-}
-
-int32_t ExynosPrimaryDisplayModule::DisplaySceneInfo::setLayerDataMappingInfo(
- ExynosMPPSource* layer, uint32_t index)
-{
- if (layerDataMappingInfo.count(layer) != 0) {
- ALOGE("layer mapping is already inserted (layer: %p, index:%d)",
- layer, index);
- return -EINVAL;
- }
- // if assigned displaycolor dppIdx changes, do not reuse it (force plane color update).
- uint32_t oldPlaneId = prev_layerDataMappingInfo.count(layer) != 0 &&
- prev_layerDataMappingInfo[layer].dppIdx == index
- ? prev_layerDataMappingInfo[layer].planeId
- : LayerMappingInfo::kPlaneIdNone;
- layerDataMappingInfo.insert(std::make_pair(layer, LayerMappingInfo{ index, oldPlaneId }));
-
- return NO_ERROR;
-}
-
-void ExynosPrimaryDisplayModule::DisplaySceneInfo::setLayerDataspace(
- LayerColorData& layerColorData,
- hwc::Dataspace dataspace)
-{
- if (layerColorData.dataspace != dataspace) {
- colorSettingChanged = true;
- layerColorData.dataspace = dataspace;
- }
-}
-
-void ExynosPrimaryDisplayModule::DisplaySceneInfo::disableLayerHdrStaticMetadata(
- LayerColorData& layerColorData)
-{
- if (layerColorData.static_metadata.is_valid) {
- colorSettingChanged = true;
- layerColorData.static_metadata.is_valid = false;
- }
-}
-
-void ExynosPrimaryDisplayModule::DisplaySceneInfo::setLayerHdrStaticMetadata(
- LayerColorData& layerColorData,
- const ExynosHdrStaticInfo &exynosHdrStaticInfo)
-{
- if (layerColorData.static_metadata.is_valid == false) {
- colorSettingChanged = true;
- layerColorData.static_metadata.is_valid = true;
- }
-
- updateInfoSingleVal(layerColorData.static_metadata.display_red_primary_x,
- exynosHdrStaticInfo.sType1.mR.x);
- updateInfoSingleVal(layerColorData.static_metadata.display_red_primary_y,
- exynosHdrStaticInfo.sType1.mR.y);
- updateInfoSingleVal(layerColorData.static_metadata.display_green_primary_x,
- exynosHdrStaticInfo.sType1.mG.x);
- updateInfoSingleVal(layerColorData.static_metadata.display_green_primary_y,
- exynosHdrStaticInfo.sType1.mG.y);
- updateInfoSingleVal(layerColorData.static_metadata.display_blue_primary_x,
- exynosHdrStaticInfo.sType1.mB.x);
- updateInfoSingleVal(layerColorData.static_metadata.display_blue_primary_y,
- exynosHdrStaticInfo.sType1.mB.y);
- updateInfoSingleVal(layerColorData.static_metadata.white_point_x,
- exynosHdrStaticInfo.sType1.mW.x);
- updateInfoSingleVal(layerColorData.static_metadata.white_point_y,
- exynosHdrStaticInfo.sType1.mW.y);
- updateInfoSingleVal(layerColorData.static_metadata.max_luminance,
- exynosHdrStaticInfo.sType1.mMaxDisplayLuminance);
- updateInfoSingleVal(layerColorData.static_metadata.min_luminance,
- exynosHdrStaticInfo.sType1.mMinDisplayLuminance);
- updateInfoSingleVal(layerColorData.static_metadata.max_content_light_level,
- exynosHdrStaticInfo.sType1.mMaxContentLightLevel);
- updateInfoSingleVal(
- layerColorData.static_metadata.max_frame_average_light_level,
- exynosHdrStaticInfo.sType1.mMaxFrameAverageLightLevel);
-}
-
-void ExynosPrimaryDisplayModule::DisplaySceneInfo::setLayerColorTransform(
- LayerColorData& layerColorData,
- std::array<float, TRANSFORM_MAT_SIZE> &matrix)
-{
- updateInfoSingleVal(layerColorData.matrix, matrix);
-}
-
-void ExynosPrimaryDisplayModule::DisplaySceneInfo::disableLayerHdrDynamicMetadata(
- LayerColorData& layerColorData)
-{
- if (layerColorData.dynamic_metadata.is_valid) {
- colorSettingChanged = true;
- layerColorData.dynamic_metadata.is_valid = false;
- }
-}
-
-void ExynosPrimaryDisplayModule::DisplaySceneInfo::setLayerHdrDynamicMetadata(
- LayerColorData& layerColorData,
- const ExynosHdrDynamicInfo &exynosHdrDynamicInfo)
-{
- if (layerColorData.dynamic_metadata.is_valid == false) {
- colorSettingChanged = true;
- layerColorData.dynamic_metadata.is_valid = true;
- }
- updateInfoSingleVal(layerColorData.dynamic_metadata.display_maximum_luminance,
- exynosHdrDynamicInfo.data.targeted_system_display_maximum_luminance);
-
- if (!std::equal(layerColorData.dynamic_metadata.maxscl.begin(),
- layerColorData.dynamic_metadata.maxscl.end(),
- exynosHdrDynamicInfo.data.maxscl[0])) {
- colorSettingChanged = true;
- for (uint32_t i = 0 ; i < layerColorData.dynamic_metadata.maxscl.size(); i++) {
- layerColorData.dynamic_metadata.maxscl[i] = exynosHdrDynamicInfo.data.maxscl[0][i];
- }
- }
- static constexpr uint32_t DYNAMIC_META_DAT_SIZE = 15;
-
- updateInfoVectorVal(layerColorData.dynamic_metadata.maxrgb_percentages,
- exynosHdrDynamicInfo.data.maxrgb_percentages[0], DYNAMIC_META_DAT_SIZE);
- updateInfoVectorVal(layerColorData.dynamic_metadata.maxrgb_percentiles,
- exynosHdrDynamicInfo.data.maxrgb_percentiles[0], DYNAMIC_META_DAT_SIZE);
- updateInfoSingleVal(layerColorData.dynamic_metadata.tm_flag,
- exynosHdrDynamicInfo.data.tone_mapping.tone_mapping_flag[0]);
- updateInfoSingleVal(layerColorData.dynamic_metadata.tm_knee_x,
- exynosHdrDynamicInfo.data.tone_mapping.knee_point_x[0]);
- updateInfoSingleVal(layerColorData.dynamic_metadata.tm_knee_y,
- exynosHdrDynamicInfo.data.tone_mapping.knee_point_y[0]);
- updateInfoVectorVal(layerColorData.dynamic_metadata.bezier_curve_anchors,
- exynosHdrDynamicInfo.data.tone_mapping.bezier_curve_anchors[0],
- DYNAMIC_META_DAT_SIZE);
-}
-
-int32_t ExynosPrimaryDisplayModule::DisplaySceneInfo::setClientCompositionColorData(
- const ExynosCompositionInfo &clientCompositionInfo, LayerColorData& layerData,
- float dimSdrRatio)
-{
- layerData.dim_ratio = 1.0f;
- setLayerDataspace(layerData,
- static_cast<hwc::Dataspace>(clientCompositionInfo.mDataSpace));
- disableLayerHdrStaticMetadata(layerData);
- disableLayerHdrDynamicMetadata(layerData);
-
- if (dimSdrRatio != 1.0) {
- std::array<float, TRANSFORM_MAT_SIZE> scaleMatrix = {
- dimSdrRatio, 0.0, 0.0, 0.0,
- 0.0, dimSdrRatio, 0.0, 0.0,
- 0.0, 0.0, dimSdrRatio, 0.0,
- 0.0, 0.0, 0.0, 1.0
- };
- setLayerColorTransform(layerData, scaleMatrix);
- } else {
- static std::array<float, TRANSFORM_MAT_SIZE> defaultMatrix {
- 1.0, 0.0, 0.0, 0.0,
- 0.0, 1.0, 0.0, 0.0,
- 0.0, 0.0, 1.0, 0.0,
- 0.0, 0.0, 0.0, 1.0
- };
- setLayerColorTransform(layerData, defaultMatrix);
- }
-
- return NO_ERROR;
-}
-
-int32_t ExynosPrimaryDisplayModule::DisplaySceneInfo::setLayerColorData(
- LayerColorData& layerData, ExynosLayer* layer, float dimSdrRatio)
-{
- layerData.is_solid_color_layer = layer->isDimLayer();
- layerData.solid_color.r = layer->mColor.r;
- layerData.solid_color.g = layer->mColor.g;
- layerData.solid_color.b = layer->mColor.b;
- layerData.solid_color.a = layer->mColor.a;
- layerData.dim_ratio = layer->mPreprocessedInfo.sdrDimRatio;
- setLayerDataspace(layerData,
- static_cast<hwc::Dataspace>(layer->mDataSpace));
- if (layer->mIsHdrLayer && layer->getMetaParcel() != nullptr) {
- if (layer->getMetaParcel()->eType & VIDEO_INFO_TYPE_HDR_STATIC)
- setLayerHdrStaticMetadata(layerData, layer->getMetaParcel()->sHdrStaticInfo);
- else
- disableLayerHdrStaticMetadata(layerData);
-
- if (layer->getMetaParcel()->eType & VIDEO_INFO_TYPE_HDR_DYNAMIC)
- setLayerHdrDynamicMetadata(layerData, layer->getMetaParcel()->sHdrDynamicInfo);
- else
- disableLayerHdrDynamicMetadata(layerData);
- } else {
- disableLayerHdrStaticMetadata(layerData);
- disableLayerHdrDynamicMetadata(layerData);
- }
-
- static std::array<float, TRANSFORM_MAT_SIZE> defaultMatrix {
- 1.0, 0.0, 0.0, 0.0,
- 0.0, 1.0, 0.0, 0.0,
- 0.0, 0.0, 1.0, 0.0,
- 0.0, 0.0, 0.0, 1.0
- };
-
- if (dimSdrRatio == 1.0 || layer->mIsHdrLayer) {
- if (layer->mLayerColorTransform.enable)
- setLayerColorTransform(layerData,
- layer->mLayerColorTransform.mat);
- else
- setLayerColorTransform(layerData,
- defaultMatrix);
- } else {
- if (layer->mLayerColorTransform.enable) {
- std::array<float, TRANSFORM_MAT_SIZE> scaleMatrix =
- layer->mLayerColorTransform.mat;
-
- // scale coeffs
- scaleMatrix[0] *= dimSdrRatio;
- scaleMatrix[1] *= dimSdrRatio;
- scaleMatrix[2] *= dimSdrRatio;
- scaleMatrix[4] *= dimSdrRatio;
- scaleMatrix[5] *= dimSdrRatio;
- scaleMatrix[6] *= dimSdrRatio;
- scaleMatrix[8] *= dimSdrRatio;
- scaleMatrix[9] *= dimSdrRatio;
- scaleMatrix[10] *= dimSdrRatio;
-
- // scale offsets
- scaleMatrix[12] *= dimSdrRatio;
- scaleMatrix[13] *= dimSdrRatio;
- scaleMatrix[14] *= dimSdrRatio;
-
- setLayerColorTransform(layerData, scaleMatrix);
- } else {
- std::array<float, TRANSFORM_MAT_SIZE> scaleMatrix = {
- dimSdrRatio, 0.0, 0.0, 0.0,
- 0.0, dimSdrRatio, 0.0, 0.0,
- 0.0, 0.0, dimSdrRatio, 0.0,
- 0.0, 0.0, 0.0, 1.0
- };
-
- setLayerColorTransform(layerData, scaleMatrix);
- }
- }
-
- return NO_ERROR;
-}
-
int32_t ExynosPrimaryDisplayModule::updateColorConversionInfo()
{
- int ret = 0;
- GsInterfaceType* displayColorInterface = getDisplayColorInterface();
- if (displayColorInterface == nullptr) {
- return ret;
- }
-
- updateBrightnessState();
- /* clear flag and layer mapping info before setting */
- mDisplaySceneInfo.reset();
-
- if ((ret = setLayersColorData()) != NO_ERROR)
- return ret;
-
- mDisplaySceneInfo.displayScene.bm = mBrightnessController->isGhbmOn()
- ? displaycolor::BrightnessMode::BM_HBM
- : displaycolor::BrightnessMode::BM_NOMINAL;
-
- mDisplaySceneInfo.displayScene.force_hdr = mBrightnessController->isDimSdr();
- mDisplaySceneInfo.displayScene.lhbm_on = mBrightnessController->isLhbmOn();
- mDisplaySceneInfo.displayScene.hdr_layer_state = mBrightnessController->getHdrLayerState();
- mDisplaySceneInfo.displayScene.dbv = mBrightnessController->getBrightnessLevel();
-
- if (hwcCheckDebugMessages(eDebugColorManagement))
- mDisplaySceneInfo.printDisplayScene();
-
- const DisplayType display = getDcDisplayType();
- if ((ret = displayColorInterface->Update(display, mDisplaySceneInfo.displayScene)) != 0) {
- DISPLAY_LOGE("Display Scene update error (%d)", ret);
- return ret;
- }
-
- return ret;
+ return mColorManager->updateColorConversionInfo();
}
int32_t ExynosPrimaryDisplayModule::resetColorMappingInfo(ExynosMPPSource* mppSrc) {
- if (mDisplaySceneInfo.layerDataMappingInfo.count(mppSrc) == 0) {
- return -EINVAL;
- }
-
- mDisplaySceneInfo.layerDataMappingInfo[mppSrc].planeId =
- DisplaySceneInfo::LayerMappingInfo::kPlaneIdNone;
-
- return NO_ERROR;
+ return mColorManager->resetColorMappingInfo(mppSrc);
}
+
int32_t ExynosPrimaryDisplayModule::updatePresentColorConversionInfo()
{
int ret = NO_ERROR;
@@ -758,17 +247,17 @@ int32_t ExynosPrimaryDisplayModule::updatePresentColorConversionInfo()
(ExynosDisplayDrmInterfaceModule*)(mDisplayInterface.get());
auto refresh_rate = moduleDisplayInterface->getDesiredRefreshRate();
if (refresh_rate > 0) {
- mDisplaySceneInfo.displayScene.refresh_rate = refresh_rate;
+ getDisplaySceneInfo().displayScene.refresh_rate = refresh_rate;
}
auto operation_rate = moduleDisplayInterface->getOperationRate();
if (operation_rate > 0) {
- mDisplaySceneInfo.displayScene.operation_rate = static_cast<uint32_t>(operation_rate);
+ getDisplaySceneInfo().displayScene.operation_rate = static_cast<uint32_t>(operation_rate);
}
- mDisplaySceneInfo.displayScene.lhbm_on = mBrightnessController->isLhbmOn();
- mDisplaySceneInfo.displayScene.dbv = mBrightnessController->getBrightnessLevel();
+ getDisplaySceneInfo().displayScene.lhbm_on = mBrightnessController->isLhbmOn();
+ getDisplaySceneInfo().displayScene.dbv = mBrightnessController->getBrightnessLevel();
const DisplayType display = getDcDisplayType();
- if ((ret = displayColorInterface->UpdatePresent(display, mDisplaySceneInfo.displayScene)) !=
+ if ((ret = displayColorInterface->UpdatePresent(display, getDisplaySceneInfo().displayScene)) !=
0) {
DISPLAY_LOGE("Display Scene update error (%d)", ret);
return ret;
@@ -788,84 +277,6 @@ int32_t ExynosPrimaryDisplayModule::getColorAdjustedDbv(uint32_t &dbv_adj) {
return NO_ERROR;
}
-bool ExynosPrimaryDisplayModule::DisplaySceneInfo::needDisplayColorSetting()
-{
- /* TODO: Check if we can skip color setting */
- /* For now, propage setting every frame */
- return true;
-
- if (colorSettingChanged)
- return true;
- if (prev_layerDataMappingInfo != layerDataMappingInfo)
- return true;
-
- return false;
-}
-
-void ExynosPrimaryDisplayModule::DisplaySceneInfo::printDisplayScene()
-{
- ALOGD("======================= DisplayScene info ========================");
- ALOGD("dpu_bit_depth: %d", static_cast<uint32_t>(displayScene.dpu_bit_depth));
- ALOGD("color_mode: %d", static_cast<uint32_t>(displayScene.color_mode));
- ALOGD("render_intent: %d", static_cast<uint32_t>(displayScene.render_intent));
- ALOGD("matrix");
- for (uint32_t i = 0; i < 16; (i += 4)) {
- ALOGD("%f, %f, %f, %f",
- displayScene.matrix[i], displayScene.matrix[i+1],
- displayScene.matrix[i+2], displayScene.matrix[i+3]);
- }
- ALOGD("layer: %zu ++++++",
- displayScene.layer_data.size());
- for (uint32_t i = 0; i < displayScene.layer_data.size(); i++) {
- ALOGD("layer[%d] info", i);
- printLayerColorData(displayScene.layer_data[i]);
- }
-
- ALOGD("layerDataMappingInfo: %zu ++++++",
- layerDataMappingInfo.size());
- for (auto layer : layerDataMappingInfo) {
- ALOGD("[layer: %p] [%d, %d]", layer.first, layer.second.dppIdx, layer.second.planeId);
- }
-}
-
-void ExynosPrimaryDisplayModule::DisplaySceneInfo::printLayerColorData(
- const LayerColorData& layerData)
-{
- ALOGD("dataspace: 0x%8x", static_cast<uint32_t>(layerData.dataspace));
- ALOGD("matrix");
- for (uint32_t i = 0; i < 16; (i += 4)) {
- ALOGD("%f, %f, %f, %f",
- layerData.matrix[i], layerData.matrix[i+1],
- layerData.matrix[i+2], layerData.matrix[i+3]);
- }
- ALOGD("static_metadata.is_valid(%d)", layerData.static_metadata.is_valid);
- if (layerData.static_metadata.is_valid) {
- ALOGD("\tdisplay_red_primary(%d, %d)",
- layerData.static_metadata.display_red_primary_x,
- layerData.static_metadata.display_red_primary_y);
- ALOGD("\tdisplay_green_primary(%d, %d)",
- layerData.static_metadata.display_green_primary_x,
- layerData.static_metadata.display_green_primary_y);
- ALOGD("\tdisplay_blue_primary(%d, %d)",
- layerData.static_metadata.display_blue_primary_x,
- layerData.static_metadata.display_blue_primary_y);
- ALOGD("\twhite_point(%d, %d)",
- layerData.static_metadata.white_point_x,
- layerData.static_metadata.white_point_y);
- }
- ALOGD("dynamic_metadata.is_valid(%d)", layerData.dynamic_metadata.is_valid);
- if (layerData.dynamic_metadata.is_valid) {
- ALOGD("\tdisplay_maximum_luminance: %d",
- layerData.dynamic_metadata.display_maximum_luminance);
- ALOGD("\tmaxscl(%d, %d, %d)", layerData.dynamic_metadata.maxscl[0],
- layerData.dynamic_metadata.maxscl[1],
- layerData.dynamic_metadata.maxscl[2]);
- ALOGD("\ttm_flag(%d)", layerData.dynamic_metadata.tm_flag);
- ALOGD("\ttm_knee_x(%d)", layerData.dynamic_metadata.tm_knee_x);
- ALOGD("\ttm_knee_y(%d)", layerData.dynamic_metadata.tm_knee_y);
- }
-}
-
bool ExynosPrimaryDisplayModule::parseAtcProfile() {
Json::Value root;
Json::CharReaderBuilder reader_builder;
@@ -1215,9 +626,3 @@ bool ExynosPrimaryDisplayModule::isDisplaySwitched(int32_t mode, int32_t prevMod
return (device->getActiveDisplay() != mIndex) && (prevMode == HWC_POWER_MODE_OFF) &&
(mode != HWC_POWER_MODE_OFF);
}
-
-bool ExynosPrimaryDisplayModule::isColorCalibratedByDevice() {
- const DisplayType display = getDcDisplayType();
- GsInterfaceType* displayColorInterface = getDisplayColorInterface();
- return displayColorInterface->GetCalibrationInfo(display).factory_cal_loaded;
-};
diff --git a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.h b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.h
index c6404d3..3adc9dc 100644
--- a/libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.h
+++ b/libhwc2.1/libmaindisplay/ExynosPrimaryDisplayModule.h
@@ -16,6 +16,8 @@
#ifndef EXYNOS_DISPLAY_MODULE_H
#define EXYNOS_DISPLAY_MODULE_H
+#include "ColorManager.h"
+#include "DisplaySceneInfo.h"
#include "ExynosDeviceModule.h"
#include "ExynosDisplay.h"
#include "ExynosLayer.h"
@@ -102,21 +104,18 @@ class ExynosPrimaryDisplayModule : public ExynosPrimaryDisplay {
void usePreDefinedWindow(bool use);
virtual int32_t validateWinConfigData();
void doPreProcessing();
- virtual int32_t getColorModes(
- uint32_t* outNumModes,
- int32_t* outModes);
- virtual int32_t setColorMode(int32_t mode);
+ virtual int32_t getColorModes(uint32_t* outNumModes, int32_t* outModes) override;
+ virtual int32_t setColorMode(int32_t mode) override;
virtual int32_t getRenderIntents(int32_t mode, uint32_t* outNumIntents,
- int32_t* outIntents);
- virtual int32_t setColorModeWithRenderIntent(int32_t mode,
- int32_t intent);
- virtual int32_t setColorTransform(const float* matrix, int32_t hint);
+ int32_t* outIntents) override;
+ virtual int32_t setColorModeWithRenderIntent(int32_t mode, int32_t intent) override;
+ virtual int32_t setColorTransform(const float* matrix, int32_t hint) override;
virtual int32_t getClientTargetProperty(
hwc_client_target_property_t* outClientTargetProperty,
HwcDimmingStage *outDimmingStage = nullptr) override;
virtual int deliverWinConfigData();
- virtual int32_t updateColorConversionInfo();
- virtual int32_t resetColorMappingInfo(ExynosMPPSource* mppSrc);
+ virtual int32_t updateColorConversionInfo() override;
+ virtual int32_t resetColorMappingInfo(ExynosMPPSource* mppSrc) override;
virtual int32_t updatePresentColorConversionInfo();
virtual bool checkRrCompensationEnabled() {
const DisplayType display = getDcDisplayType();
@@ -126,8 +125,6 @@ class ExynosPrimaryDisplayModule : public ExynosPrimaryDisplay {
: false;
}
- virtual bool isColorCalibratedByDevice();
-
virtual int32_t getColorAdjustedDbv(uint32_t &dbv_adj);
virtual void initLbe();
@@ -138,128 +135,19 @@ class ExynosPrimaryDisplayModule : public ExynosPrimaryDisplay {
virtual PanelCalibrationStatus getPanelCalibrationStatus();
- class DisplaySceneInfo {
- public:
- struct LayerMappingInfo {
- bool operator==(const LayerMappingInfo &rhs) const {
- return ((dppIdx == rhs.dppIdx) && (planeId == rhs.planeId));
- }
-
- // index in DisplayScene::layer_data
- uint32_t dppIdx;
- // assigned drm plane id in last color setting update
- uint32_t planeId;
- static constexpr uint32_t kPlaneIdNone = std::numeric_limits<uint32_t>::max();
- };
- bool colorSettingChanged = false;
- bool displaySettingDelivered = false;
- DisplayScene displayScene;
-
- /*
- * Index of LayerColorData in DisplayScene::layer_data
- * and assigned plane id in last color setting update.
- * for each layer, including client composition
- * key: ExynosMPPSource*
- * data: LayerMappingInfo
- */
- std::map<ExynosMPPSource*, LayerMappingInfo> layerDataMappingInfo;
- std::map<ExynosMPPSource*, LayerMappingInfo> prev_layerDataMappingInfo;
-
- void reset() {
- colorSettingChanged = false;
- prev_layerDataMappingInfo = layerDataMappingInfo;
- layerDataMappingInfo.clear();
- };
-
- template <typename T, typename M>
- void updateInfoSingleVal(T &dst, M &src) {
- if (src != dst) {
- colorSettingChanged = true;
- dst = src;
- }
- };
-
- template <typename T, typename M>
- void updateInfoVectorVal(std::vector<T> &dst, M *src, uint32_t size) {
- if ((dst.size() != size) ||
- !std::equal(dst.begin(), dst.end(), src)) {
- colorSettingChanged = true;
- dst.resize(size);
- for (uint32_t i = 0; i < size; i++) {
- dst[i] = src[i];
- }
- }
- };
-
- void setColorMode(hwc::ColorMode mode) {
- updateInfoSingleVal(displayScene.color_mode, mode);
- };
-
- void setRenderIntent(hwc::RenderIntent intent) {
- updateInfoSingleVal(displayScene.render_intent, intent);
- };
-
- void setColorTransform(const float* matrix) {
- for (uint32_t i = 0; i < displayScene.matrix.size(); i++) {
- if (displayScene.matrix[i] != matrix[i]) {
- colorSettingChanged = true;
- displayScene.matrix[i] = matrix[i];
- }
- }
- }
-
- LayerColorData& getLayerColorDataInstance(uint32_t index);
- int32_t setLayerDataMappingInfo(ExynosMPPSource* layer, uint32_t index);
- void setLayerDataspace(LayerColorData& layerColorData,
- hwc::Dataspace dataspace);
- void disableLayerHdrStaticMetadata(LayerColorData& layerColorData);
- void setLayerHdrStaticMetadata(LayerColorData& layerColorData,
- const ExynosHdrStaticInfo& exynosHdrStaticInfo);
- void setLayerColorTransform(LayerColorData& layerColorData,
- std::array<float, TRANSFORM_MAT_SIZE> &matrix);
- void disableLayerHdrDynamicMetadata(LayerColorData& layerColorData);
- void setLayerHdrDynamicMetadata(LayerColorData& layerColorData,
- const ExynosHdrDynamicInfo& exynosHdrDynamicInfo);
- int32_t setLayerColorData(LayerColorData& layerData,
- ExynosLayer* layer, float dimSdrRatio);
- int32_t setClientCompositionColorData(
- const ExynosCompositionInfo& clientCompositionInfo,
- LayerColorData& layerData, float dimSdrRatio);
- bool needDisplayColorSetting();
- void printDisplayScene();
- void printLayerColorData(const LayerColorData& layerData);
- };
-
bool hasDisplayColor() {
GsInterfaceType* displayColorInterface = getDisplayColorInterface();
return displayColorInterface != nullptr;
}
- /* Call getDppForLayer() only if hasDppForLayer() is true */
- bool hasDppForLayer(ExynosMPPSource* layer);
- const GsInterfaceType::IDpp& getDppForLayer(ExynosMPPSource* layer);
- int32_t getDppIndexForLayer(ExynosMPPSource* layer);
- /* Check if layer's assigned plane id has changed, save the new planeId.
- * call only if hasDppForLayer is true */
- bool checkAndSaveLayerPlaneId(ExynosMPPSource* layer, uint32_t planeId) {
- auto &info = mDisplaySceneInfo.layerDataMappingInfo[layer];
- bool change = info.planeId != planeId;
- info.planeId = planeId;
- return change;
- }
-
- const GsInterfaceType::IDqe& getDqe()
- {
- const DisplayType display = getDcDisplayType();
- GsInterfaceType* displayColorInterface = getDisplayColorInterface();
- return displayColorInterface->GetPipelineData(display)->Dqe();
- };
-
int32_t updateBrightnessTable();
+ ColorManager* getColorManager() { return mColorManager.get(); }
+
private:
- int32_t setLayersColorData();
- DisplaySceneInfo mDisplaySceneInfo;
+ std::unique_ptr<ColorManager> mColorManager;
+
+ DisplaySceneInfo& getDisplaySceneInfo() { return mColorManager->getDisplaySceneInfo(); }
struct atc_lux_map {
uint32_t lux;
diff --git a/libhwc2.1/libresource/ExynosMPPModule.cpp b/libhwc2.1/libresource/ExynosMPPModule.cpp
index 357c61a..474476e 100644
--- a/libhwc2.1/libresource/ExynosMPPModule.cpp
+++ b/libhwc2.1/libresource/ExynosMPPModule.cpp
@@ -47,13 +47,14 @@ int32_t ExynosMPPModule::setColorConversionInfo()
MPP_LOGE("%s: mAssignedDisplay is null", __func__);
return -EINVAL;
}
- if (mAssignedDisplay->mType != HWC_DISPLAY_PRIMARY)
- return NO_ERROR;
-
- ExynosPrimaryDisplayModule* primaryDisplay =
- (ExynosPrimaryDisplayModule*)mAssignedDisplay;
- if (!primaryDisplay->hasDisplayColor()) {
+ ExynosDeviceModule* device = static_cast<ExynosDeviceModule*>(mAssignedDisplay->mDevice);
+ ColorManager* colorManager = device->getDisplayColorManager(mAssignedDisplay);
+ if (colorManager == nullptr) {
+ MPP_LOGE("%s: colorManager is null", __func__);
+ return -EINVAL;
+ }
+ if (!colorManager->getDisplayColorInterface()) {
return NO_ERROR;
}
@@ -71,13 +72,13 @@ int32_t ExynosMPPModule::setColorConversionInfo()
mppLayer->setLayerData(nullptr, 0);
continue;
}
- if (primaryDisplay->hasDppForLayer(layer) == false) {
+ if (colorManager->hasDppForLayer(layer) == false) {
MPP_LOGE("%s: src[%zu] need color conversion but there is no IDpp", __func__, i);
return -EINVAL;
}
MPP_LOGD(eDebugColorManagement,
"%s, src: 0x%8x", __func__, mppSource->mSrcImg.dataSpace);
- const auto& dpp = primaryDisplay->getDppForLayer(layer);
+ const auto& dpp = colorManager->getDppForLayer(layer);
mppLayer->setLayerData((void *)&dpp, sizeof(dpp));
}
return NO_ERROR;
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-23 11:12:43 +0000