diff options
Diffstat (limited to 'services/surfaceflinger/DisplayDevice.cpp')
| -rw-r--r-- | services/surfaceflinger/DisplayDevice.cpp | 796 |
1 files changed, 183 insertions, 613 deletions
diff --git a/services/surfaceflinger/DisplayDevice.cpp b/services/surfaceflinger/DisplayDevice.cpp index 65c3839141..4a13bfb7ae 100644 --- a/services/surfaceflinger/DisplayDevice.cpp +++ b/services/surfaceflinger/DisplayDevice.cpp @@ -18,49 +18,28 @@ #undef LOG_TAG #define LOG_TAG "DisplayDevice" -#include <array> -#include <unordered_set> - -#include <stdlib.h> -#include <stdio.h> -#include <string.h> -#include <math.h> - -#include <cutils/properties.h> - -#include <utils/RefBase.h> -#include <utils/Log.h> - -#include <ui/DebugUtils.h> -#include <ui/DisplayInfo.h> -#include <ui/PixelFormat.h> - -#include <gui/Surface.h> - -#include <hardware/gralloc.h> - -#include "DisplayHardware/DisplaySurface.h" -#include "DisplayHardware/HWComposer.h" -#include "DisplayHardware/HWC2.h" -#include "RenderEngine/RenderEngine.h" +#include <android-base/stringprintf.h> +#include <compositionengine/CompositionEngine.h> +#include <compositionengine/Display.h> +#include <compositionengine/DisplayColorProfile.h> +#include <compositionengine/DisplayColorProfileCreationArgs.h> +#include <compositionengine/DisplayCreationArgs.h> +#include <compositionengine/DisplaySurface.h> +#include <compositionengine/RenderSurface.h> +#include <compositionengine/RenderSurfaceCreationArgs.h> +#include <compositionengine/impl/OutputCompositionState.h> +#include <configstore/Utils.h> +#include <log/log.h> +#include <system/window.h> +#include <ui/GraphicTypes.h> -#include "clz.h" #include "DisplayDevice.h" -#include "SurfaceFlinger.h" #include "Layer.h" - -#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h> -#include <configstore/Utils.h> +#include "SurfaceFlinger.h" namespace android { -// retrieve triple buffer setting from configstore -using namespace android::hardware::configstore; -using namespace android::hardware::configstore::V1_0; -using android::ui::ColorMode; -using android::ui::Dataspace; -using android::ui::Hdr; -using android::ui::RenderIntent; +using android::base::StringAppendF; /* * Initialize the display to the specified values. @@ -69,335 +48,72 @@ using android::ui::RenderIntent; uint32_t DisplayDevice::sPrimaryDisplayOrientation = 0; -namespace { - -// ordered list of known SDR color modes -const std::array<ColorMode, 2> sSdrColorModes = { - ColorMode::DISPLAY_P3, - ColorMode::SRGB, -}; - -// ordered list of known HDR color modes -const std::array<ColorMode, 2> sHdrColorModes = { - ColorMode::BT2100_PQ, - ColorMode::BT2100_HLG, -}; - -// ordered list of known SDR render intents -const std::array<RenderIntent, 2> sSdrRenderIntents = { - RenderIntent::ENHANCE, - RenderIntent::COLORIMETRIC, -}; - -// ordered list of known HDR render intents -const std::array<RenderIntent, 2> sHdrRenderIntents = { - RenderIntent::TONE_MAP_ENHANCE, - RenderIntent::TONE_MAP_COLORIMETRIC, -}; - -// map known color mode to dataspace -Dataspace colorModeToDataspace(ColorMode mode) { - switch (mode) { - case ColorMode::SRGB: - return Dataspace::SRGB; - case ColorMode::DISPLAY_P3: - return Dataspace::DISPLAY_P3; - case ColorMode::BT2100_HLG: - return Dataspace::BT2020_HLG; - case ColorMode::BT2100_PQ: - return Dataspace::BT2020_PQ; - default: - return Dataspace::UNKNOWN; - } -} - -// Return a list of candidate color modes. -std::vector<ColorMode> getColorModeCandidates(ColorMode mode) { - std::vector<ColorMode> candidates; - - // add mode itself - candidates.push_back(mode); - - // check if mode is HDR - bool isHdr = false; - for (auto hdrMode : sHdrColorModes) { - if (hdrMode == mode) { - isHdr = true; - break; - } - } - - // add other HDR candidates when mode is HDR - if (isHdr) { - for (auto hdrMode : sHdrColorModes) { - if (hdrMode != mode) { - candidates.push_back(hdrMode); - } - } - } - - // add other SDR candidates - for (auto sdrMode : sSdrColorModes) { - if (sdrMode != mode) { - candidates.push_back(sdrMode); - } - } - - return candidates; -} - -// Return a list of candidate render intents. -std::vector<RenderIntent> getRenderIntentCandidates(RenderIntent intent) { - std::vector<RenderIntent> candidates; - - // add intent itself - candidates.push_back(intent); - - // check if intent is HDR - bool isHdr = false; - for (auto hdrIntent : sHdrRenderIntents) { - if (hdrIntent == intent) { - isHdr = true; - break; - } - } - - if (isHdr) { - // add other HDR candidates when intent is HDR - for (auto hdrIntent : sHdrRenderIntents) { - if (hdrIntent != intent) { - candidates.push_back(hdrIntent); - } - } - } else { - // add other SDR candidates when intent is SDR - for (auto sdrIntent : sSdrRenderIntents) { - if (sdrIntent != intent) { - candidates.push_back(sdrIntent); - } - } - } - - return candidates; -} - -// Return the best color mode supported by HWC. -ColorMode getHwcColorMode( - const std::unordered_map<ColorMode, std::vector<RenderIntent>>& hwcColorModes, - ColorMode mode) { - std::vector<ColorMode> candidates = getColorModeCandidates(mode); - for (auto candidate : candidates) { - auto iter = hwcColorModes.find(candidate); - if (iter != hwcColorModes.end()) { - return candidate; - } - } - - return ColorMode::NATIVE; -} - -// Return the best render intent supported by HWC. -RenderIntent getHwcRenderIntent(const std::vector<RenderIntent>& hwcIntents, RenderIntent intent) { - std::vector<RenderIntent> candidates = getRenderIntentCandidates(intent); - for (auto candidate : candidates) { - for (auto hwcIntent : hwcIntents) { - if (candidate == hwcIntent) { - return candidate; - } - } - } - - return RenderIntent::COLORIMETRIC; -} - -} // anonymous namespace - -// clang-format off -DisplayDevice::DisplayDevice( - const sp<SurfaceFlinger>& flinger, - DisplayType type, - int32_t hwcId, - bool isSecure, - const wp<IBinder>& displayToken, - const sp<ANativeWindow>& nativeWindow, - const sp<DisplaySurface>& displaySurface, - std::unique_ptr<RE::Surface> renderSurface, - int displayWidth, - int displayHeight, - int displayInstallOrientation, - bool hasWideColorGamut, - const HdrCapabilities& hdrCapabilities, - const int32_t supportedPerFrameMetadata, - const std::unordered_map<ColorMode, std::vector<RenderIntent>>& hwcColorModes, - int initialPowerMode) - : lastCompositionHadVisibleLayers(false), - mFlinger(flinger), - mType(type), - mHwcDisplayId(hwcId), - mDisplayToken(displayToken), - mNativeWindow(nativeWindow), - mDisplaySurface(displaySurface), - mSurface{std::move(renderSurface)}, - mDisplayWidth(displayWidth), - mDisplayHeight(displayHeight), - mDisplayInstallOrientation(displayInstallOrientation), - mPageFlipCount(0), - mIsSecure(isSecure), - mLayerStack(NO_LAYER_STACK), - mOrientation(), - mViewport(Rect::INVALID_RECT), - mFrame(Rect::INVALID_RECT), - mPowerMode(initialPowerMode), - mActiveConfig(0), - mColorTransform(HAL_COLOR_TRANSFORM_IDENTITY), - mHasWideColorGamut(hasWideColorGamut), - mHasHdr10(false), - mHasHLG(false), - mHasDolbyVision(false), - mSupportedPerFrameMetadata(supportedPerFrameMetadata) -{ - // clang-format on - populateColorModes(hwcColorModes); - - std::vector<Hdr> types = hdrCapabilities.getSupportedHdrTypes(); - for (Hdr hdrType : types) { - switch (hdrType) { - case Hdr::HDR10: - mHasHdr10 = true; - break; - case Hdr::HLG: - mHasHLG = true; - break; - case Hdr::DOLBY_VISION: - mHasDolbyVision = true; - break; - default: - ALOGE("UNKNOWN HDR capability: %d", static_cast<int32_t>(hdrType)); - } - } - - float minLuminance = hdrCapabilities.getDesiredMinLuminance(); - float maxLuminance = hdrCapabilities.getDesiredMaxLuminance(); - float maxAverageLuminance = hdrCapabilities.getDesiredMaxAverageLuminance(); - - minLuminance = minLuminance <= 0.0 ? sDefaultMinLumiance : minLuminance; - maxLuminance = maxLuminance <= 0.0 ? sDefaultMaxLumiance : maxLuminance; - maxAverageLuminance = maxAverageLuminance <= 0.0 ? sDefaultMaxLumiance : maxAverageLuminance; - if (this->hasWideColorGamut()) { - // insert HDR10/HLG as we will force client composition for HDR10/HLG - // layers - if (!hasHDR10Support()) { - types.push_back(Hdr::HDR10); - } - - if (!hasHLGSupport()) { - types.push_back(Hdr::HLG); - } - } - mHdrCapabilities = HdrCapabilities(types, maxLuminance, maxAverageLuminance, minLuminance); +DisplayDeviceCreationArgs::DisplayDeviceCreationArgs(const sp<SurfaceFlinger>& flinger, + const wp<IBinder>& displayToken, + const std::optional<DisplayId>& displayId) + : flinger(flinger), displayToken(displayToken), displayId(displayId) {} + +DisplayDevice::DisplayDevice(DisplayDeviceCreationArgs&& args) + : mFlinger(args.flinger), + mDisplayToken(args.displayToken), + mSequenceId(args.sequenceId), + mDisplayInstallOrientation(args.displayInstallOrientation), + mCompositionDisplay{mFlinger->getCompositionEngine().createDisplay( + compositionengine::DisplayCreationArgs{args.isSecure, args.isVirtual, + args.displayId})}, + mIsVirtual(args.isVirtual), + mOrientation(), + mActiveConfig(0), + mIsPrimary(args.isPrimary) { + mCompositionDisplay->createRenderSurface( + compositionengine::RenderSurfaceCreationArgs{ANativeWindow_getWidth( + args.nativeWindow.get()), + ANativeWindow_getHeight( + args.nativeWindow.get()), + args.nativeWindow, args.displaySurface}); + + mCompositionDisplay->createDisplayColorProfile( + compositionengine::DisplayColorProfileCreationArgs{args.hasWideColorGamut, + std::move(args.hdrCapabilities), + args.supportedPerFrameMetadata, + args.hwcColorModes}); + + if (!mCompositionDisplay->isValid()) { + ALOGE("Composition Display did not validate!"); + } + + mCompositionDisplay->getRenderSurface()->initialize(); + + setPowerMode(args.initialPowerMode); // initialize the display orientation transform. - setProjection(DisplayState::eOrientationDefault, mViewport, mFrame); + setProjection(DisplayState::eOrientationDefault, Rect::INVALID_RECT, Rect::INVALID_RECT); } DisplayDevice::~DisplayDevice() = default; -void DisplayDevice::disconnect(HWComposer& hwc) { - if (mHwcDisplayId >= 0) { - hwc.disconnectDisplay(mHwcDisplayId); - mHwcDisplayId = -1; - } -} - -bool DisplayDevice::isValid() const { - return mFlinger != nullptr; +void DisplayDevice::disconnect() { + mCompositionDisplay->disconnect(); } int DisplayDevice::getWidth() const { - return mDisplayWidth; + return mCompositionDisplay->getState().bounds.getWidth(); } int DisplayDevice::getHeight() const { - return mDisplayHeight; + return mCompositionDisplay->getState().bounds.getHeight(); } -void DisplayDevice::setDisplayName(const String8& displayName) { - if (!displayName.isEmpty()) { +void DisplayDevice::setDisplayName(const std::string& displayName) { + if (!displayName.empty()) { // never override the name with an empty name mDisplayName = displayName; + mCompositionDisplay->setName(displayName); } } uint32_t DisplayDevice::getPageFlipCount() const { - return mPageFlipCount; -} - -void DisplayDevice::flip() const -{ - mFlinger->getRenderEngine().checkErrors(); - mPageFlipCount++; -} - -status_t DisplayDevice::beginFrame(bool mustRecompose) const { - return mDisplaySurface->beginFrame(mustRecompose); -} - -status_t DisplayDevice::prepareFrame(HWComposer& hwc) { - status_t error = hwc.prepare(*this); - if (error != NO_ERROR) { - return error; - } - - DisplaySurface::CompositionType compositionType; - bool hasClient = hwc.hasClientComposition(mHwcDisplayId); - bool hasDevice = hwc.hasDeviceComposition(mHwcDisplayId); - if (hasClient && hasDevice) { - compositionType = DisplaySurface::COMPOSITION_MIXED; - } else if (hasClient) { - compositionType = DisplaySurface::COMPOSITION_GLES; - } else if (hasDevice) { - compositionType = DisplaySurface::COMPOSITION_HWC; - } else { - // Nothing to do -- when turning the screen off we get a frame like - // this. Call it a HWC frame since we won't be doing any GLES work but - // will do a prepare/set cycle. - compositionType = DisplaySurface::COMPOSITION_HWC; - } - return mDisplaySurface->prepareFrame(compositionType); -} - -void DisplayDevice::swapBuffers(HWComposer& hwc) const { - if (hwc.hasClientComposition(mHwcDisplayId) || hwc.hasFlipClientTargetRequest(mHwcDisplayId)) { - mSurface->swapBuffers(); - } - - status_t result = mDisplaySurface->advanceFrame(); - if (result != NO_ERROR) { - ALOGE("[%s] failed pushing new frame to HWC: %d", - mDisplayName.string(), result); - } -} - -void DisplayDevice::onSwapBuffersCompleted() const { - mDisplaySurface->onFrameCommitted(); -} - -bool DisplayDevice::makeCurrent() const { - bool success = mFlinger->getRenderEngine().setCurrentSurface(*mSurface); - setViewportAndProjection(); - return success; -} - -void DisplayDevice::setViewportAndProjection() const { - size_t w = mDisplayWidth; - size_t h = mDisplayHeight; - Rect sourceCrop(0, 0, w, h); - mFlinger->getRenderEngine().setViewportAndProjection(w, h, sourceCrop, h, - false, Transform::ROT_0); -} - -const sp<Fence>& DisplayDevice::getClientTargetAcquireFence() const { - return mDisplaySurface->getClientTargetAcquireFence(); + return mCompositionDisplay->getRenderSurface()->getPageFlipCount(); } // ---------------------------------------------------------------------------- @@ -418,29 +134,18 @@ const Vector< sp<Layer> >& DisplayDevice::getLayersNeedingFences() const { return mLayersNeedingFences; } -Region DisplayDevice::getDirtyRegion(bool repaintEverything) const { - Region dirty; - if (repaintEverything) { - dirty.set(getBounds()); - } else { - const Transform& planeTransform(mGlobalTransform); - dirty = planeTransform.transform(this->dirtyRegion); - dirty.andSelf(getBounds()); - } - return dirty; -} - // ---------------------------------------------------------------------------- void DisplayDevice::setPowerMode(int mode) { mPowerMode = mode; + getCompositionDisplay()->setCompositionEnabled(mPowerMode != HWC_POWER_MODE_OFF); } int DisplayDevice::getPowerMode() const { return mPowerMode; } -bool DisplayDevice::isDisplayOn() const { - return (mPowerMode != HWC_POWER_MODE_OFF); +bool DisplayDevice::isPoweredOn() const { + return mPowerMode != HWC_POWER_MODE_OFF; } // ---------------------------------------------------------------------------- @@ -453,88 +158,37 @@ int DisplayDevice::getActiveConfig() const { } // ---------------------------------------------------------------------------- -void DisplayDevice::setActiveColorMode(ColorMode mode) { - mActiveColorMode = mode; -} - -ColorMode DisplayDevice::getActiveColorMode() const { - return mActiveColorMode; -} - -RenderIntent DisplayDevice::getActiveRenderIntent() const { - return mActiveRenderIntent; -} - -void DisplayDevice::setActiveRenderIntent(RenderIntent renderIntent) { - mActiveRenderIntent = renderIntent; -} - -void DisplayDevice::setColorTransform(const mat4& transform) { - const bool isIdentity = (transform == mat4()); - mColorTransform = - isIdentity ? HAL_COLOR_TRANSFORM_IDENTITY : HAL_COLOR_TRANSFORM_ARBITRARY_MATRIX; -} - -android_color_transform_t DisplayDevice::getColorTransform() const { - return mColorTransform; -} - -void DisplayDevice::setCompositionDataSpace(ui::Dataspace dataspace) { - mCompositionDataSpace = dataspace; - ANativeWindow* const window = mNativeWindow.get(); - native_window_set_buffers_data_space(window, static_cast<android_dataspace>(dataspace)); -} ui::Dataspace DisplayDevice::getCompositionDataSpace() const { - return mCompositionDataSpace; + return mCompositionDisplay->getState().dataspace; } // ---------------------------------------------------------------------------- void DisplayDevice::setLayerStack(uint32_t stack) { - mLayerStack = stack; - dirtyRegion.set(bounds()); + mCompositionDisplay->setLayerStackFilter(stack, isPrimary()); } // ---------------------------------------------------------------------------- -uint32_t DisplayDevice::getOrientationTransform() const { - uint32_t transform = 0; - switch (mOrientation) { - case DisplayState::eOrientationDefault: - transform = Transform::ROT_0; - break; - case DisplayState::eOrientation90: - transform = Transform::ROT_90; - break; - case DisplayState::eOrientation180: - transform = Transform::ROT_180; - break; - case DisplayState::eOrientation270: - transform = Transform::ROT_270; - break; - } - return transform; -} - -status_t DisplayDevice::orientationToTransfrom( - int orientation, int w, int h, Transform* tr) -{ - uint32_t flags = 0; +uint32_t DisplayDevice::displayStateOrientationToTransformOrientation(int orientation) { switch (orientation) { case DisplayState::eOrientationDefault: - flags = Transform::ROT_0; - break; + return ui::Transform::ROT_0; case DisplayState::eOrientation90: - flags = Transform::ROT_90; - break; + return ui::Transform::ROT_90; case DisplayState::eOrientation180: - flags = Transform::ROT_180; - break; + return ui::Transform::ROT_180; case DisplayState::eOrientation270: - flags = Transform::ROT_270; - break; + return ui::Transform::ROT_270; default: + return ui::Transform::ROT_INVALID; + } +} + +status_t DisplayDevice::orientationToTransfrom(int orientation, int w, int h, ui::Transform* tr) { + uint32_t flags = displayStateOrientationToTransformOrientation(orientation); + if (flags == ui::Transform::ROT_INVALID) { return BAD_VALUE; } tr->set(flags, w, h); @@ -542,21 +196,7 @@ status_t DisplayDevice::orientationToTransfrom( } void DisplayDevice::setDisplaySize(const int newWidth, const int newHeight) { - dirtyRegion.set(getBounds()); - - mSurface->setNativeWindow(nullptr); - - mDisplaySurface->resizeBuffers(newWidth, newHeight); - - ANativeWindow* const window = mNativeWindow.get(); - mSurface->setNativeWindow(window); - mDisplayWidth = mSurface->queryWidth(); - mDisplayHeight = mSurface->queryHeight(); - - LOG_FATAL_IF(mDisplayWidth != newWidth, - "Unable to set new width to %d", newWidth); - LOG_FATAL_IF(mDisplayHeight != newHeight, - "Unable to set new height to %d", newHeight); + mCompositionDisplay->setBounds(ui::Size(newWidth, newHeight)); } void DisplayDevice::setProjection(int orientation, @@ -564,10 +204,13 @@ void DisplayDevice::setProjection(int orientation, Rect viewport(newViewport); Rect frame(newFrame); - const int w = mDisplayWidth; - const int h = mDisplayHeight; + mOrientation = orientation; + + const Rect& displayBounds = getCompositionDisplay()->getState().bounds; + const int w = displayBounds.width(); + const int h = displayBounds.height(); - Transform R; + ui::Transform R; DisplayDevice::orientationToTransfrom(orientation, w, h, &R); if (!frame.isValid()) { @@ -582,16 +225,14 @@ void DisplayDevice::setProjection(int orientation, // it's also invalid to have an empty viewport, so we handle that // case in the same way. viewport = Rect(w, h); - if (R.getOrientation() & Transform::ROT_90) { + if (R.getOrientation() & ui::Transform::ROT_90) { // viewport is always specified in the logical orientation // of the display (ie: post-rotation). - swap(viewport.right, viewport.bottom); + std::swap(viewport.right, viewport.bottom); } } - dirtyRegion.set(getBounds()); - - Transform TL, TP, S; + ui::Transform TL, TP, S; float src_width = viewport.width(); float src_height = viewport.height(); float dst_width = frame.width(); @@ -609,9 +250,9 @@ void DisplayDevice::setProjection(int orientation, TL.set(-src_x, -src_y); TP.set(dst_x, dst_y); - // need to take care of primary display rotation for mGlobalTransform + // need to take care of primary display rotation for globalTransform // for case if the panel is not installed aligned with device orientation - if (mType == DisplayType::DISPLAY_PRIMARY) { + if (isPrimary()) { DisplayDevice::orientationToTransfrom( (orientation + mDisplayInstallOrientation) % (DisplayState::eOrientation270 + 1), w, h, &R); @@ -620,193 +261,122 @@ void DisplayDevice::setProjection(int orientation, // The viewport and frame are both in the logical orientation. // Apply the logical translation, scale to physical size, apply the // physical translation and finally rotate to the physical orientation. - mGlobalTransform = R * TP * S * TL; + ui::Transform globalTransform = R * TP * S * TL; - const uint8_t type = mGlobalTransform.getType(); - mNeedsFiltering = (!mGlobalTransform.preserveRects() || - (type >= Transform::SCALE)); + const uint8_t type = globalTransform.getType(); + const bool needsFiltering = + (!globalTransform.preserveRects() || (type >= ui::Transform::SCALE)); - mScissor = mGlobalTransform.transform(viewport); - if (mScissor.isEmpty()) { - mScissor = getBounds(); + Rect scissor = globalTransform.transform(viewport); + if (scissor.isEmpty()) { + scissor = displayBounds; } - mOrientation = orientation; - if (mType == DisplayType::DISPLAY_PRIMARY) { - uint32_t transform = 0; - switch (mOrientation) { - case DisplayState::eOrientationDefault: - transform = Transform::ROT_0; - break; - case DisplayState::eOrientation90: - transform = Transform::ROT_90; - break; - case DisplayState::eOrientation180: - transform = Transform::ROT_180; - break; - case DisplayState::eOrientation270: - transform = Transform::ROT_270; - break; - } - sPrimaryDisplayOrientation = transform; + if (isPrimary()) { + sPrimaryDisplayOrientation = displayStateOrientationToTransformOrientation(orientation); } - mViewport = viewport; - mFrame = frame; + + getCompositionDisplay()->setProjection(globalTransform, + displayStateOrientationToTransformOrientation( + orientation), + frame, viewport, scissor, needsFiltering); } uint32_t DisplayDevice::getPrimaryDisplayOrientationTransform() { return sPrimaryDisplayOrientation; } -void DisplayDevice::dump(String8& result) const { - const Transform& tr(mGlobalTransform); - ANativeWindow* const window = mNativeWindow.get(); - result.appendFormat("+ DisplayDevice: %s\n", mDisplayName.string()); - result.appendFormat(" type=%x, hwcId=%d, layerStack=%u, (%4dx%4d), ANativeWindow=%p " - "(%d:%d:%d:%d), orient=%2d (type=%08x), " - "flips=%u, isSecure=%d, powerMode=%d, activeConfig=%d, numLayers=%zu\n", - mType, mHwcDisplayId, mLayerStack, mDisplayWidth, mDisplayHeight, window, - mSurface->queryRedSize(), mSurface->queryGreenSize(), - mSurface->queryBlueSize(), mSurface->queryAlphaSize(), mOrientation, - tr.getType(), getPageFlipCount(), mIsSecure, mPowerMode, mActiveConfig, - mVisibleLayersSortedByZ.size()); - result.appendFormat(" v:[%d,%d,%d,%d], f:[%d,%d,%d,%d], s:[%d,%d,%d,%d]," - "transform:[[%0.3f,%0.3f,%0.3f][%0.3f,%0.3f,%0.3f][%0.3f,%0.3f,%0.3f]]\n", - mViewport.left, mViewport.top, mViewport.right, mViewport.bottom, - mFrame.left, mFrame.top, mFrame.right, mFrame.bottom, mScissor.left, - mScissor.top, mScissor.right, mScissor.bottom, tr[0][0], tr[1][0], tr[2][0], - tr[0][1], tr[1][1], tr[2][1], tr[0][2], tr[1][2], tr[2][2]); - auto const surface = static_cast<Surface*>(window); - ui::Dataspace dataspace = surface->getBuffersDataSpace(); - result.appendFormat(" wideColorGamut=%d, hdr10=%d, colorMode=%s, dataspace: %s (%d)\n", - mHasWideColorGamut, mHasHdr10, - decodeColorMode(mActiveColorMode).c_str(), - dataspaceDetails(static_cast<android_dataspace>(dataspace)).c_str(), dataspace); - - String8 surfaceDump; - mDisplaySurface->dumpAsString(surfaceDump); - result.append(surfaceDump); -} - -// Map dataspace/intent to the best matched dataspace/colorMode/renderIntent -// supported by HWC. -void DisplayDevice::addColorMode( - const std::unordered_map<ColorMode, std::vector<RenderIntent>>& hwcColorModes, - const ColorMode mode, const RenderIntent intent) { - // find the best color mode - const ColorMode hwcColorMode = getHwcColorMode(hwcColorModes, mode); - - // find the best render intent - auto iter = hwcColorModes.find(hwcColorMode); - const auto& hwcIntents = - iter != hwcColorModes.end() ? iter->second : std::vector<RenderIntent>(); - const RenderIntent hwcIntent = getHwcRenderIntent(hwcIntents, intent); - - const Dataspace dataspace = colorModeToDataspace(mode); - const Dataspace hwcDataspace = colorModeToDataspace(hwcColorMode); - - ALOGV("DisplayDevice %d/%d: map (%s, %s) to (%s, %s, %s)", mType, mHwcDisplayId, - dataspaceDetails(static_cast<android_dataspace_t>(dataspace)).c_str(), - decodeRenderIntent(intent).c_str(), - dataspaceDetails(static_cast<android_dataspace_t>(hwcDataspace)).c_str(), - decodeColorMode(hwcColorMode).c_str(), decodeRenderIntent(hwcIntent).c_str()); - - mColorModes[getColorModeKey(dataspace, intent)] = {hwcDataspace, hwcColorMode, hwcIntent}; -} - -void DisplayDevice::populateColorModes( - const std::unordered_map<ColorMode, std::vector<RenderIntent>>& hwcColorModes) { - if (!hasWideColorGamut()) { - return; - } +std::string DisplayDevice::getDebugName() const { + const auto id = getId() ? to_string(*getId()) + ", " : std::string(); + return base::StringPrintf("DisplayDevice{%s%s%s\"%s\"}", id.c_str(), + isPrimary() ? "primary, " : "", isVirtual() ? "virtual, " : "", + mDisplayName.c_str()); +} - // collect all known SDR render intents - std::unordered_set<RenderIntent> sdrRenderIntents(sSdrRenderIntents.begin(), - sSdrRenderIntents.end()); - auto iter = hwcColorModes.find(ColorMode::SRGB); - if (iter != hwcColorModes.end()) { - for (auto intent : iter->second) { - sdrRenderIntents.insert(intent); - } - } +void DisplayDevice::dump(std::string& result) const { + StringAppendF(&result, "+ %s\n", getDebugName().c_str()); - // add all known SDR combinations - for (auto intent : sdrRenderIntents) { - for (auto mode : sSdrColorModes) { - addColorMode(hwcColorModes, mode, intent); - } - } + result.append(" "); + StringAppendF(&result, "powerMode=%d, ", mPowerMode); + StringAppendF(&result, "activeConfig=%d, ", mActiveConfig); + StringAppendF(&result, "numLayers=%zu\n", mVisibleLayersSortedByZ.size()); + getCompositionDisplay()->dump(result); +} - // collect all known HDR render intents - std::unordered_set<RenderIntent> hdrRenderIntents(sHdrRenderIntents.begin(), - sHdrRenderIntents.end()); - iter = hwcColorModes.find(ColorMode::BT2100_PQ); - if (iter != hwcColorModes.end()) { - for (auto intent : iter->second) { - hdrRenderIntents.insert(intent); - } - } +bool DisplayDevice::hasRenderIntent(ui::RenderIntent intent) const { + return mCompositionDisplay->getDisplayColorProfile()->hasRenderIntent(intent); +} - // add all known HDR combinations - for (auto intent : sHdrRenderIntents) { - for (auto mode : sHdrColorModes) { - addColorMode(hwcColorModes, mode, intent); - } - } +// ---------------------------------------------------------------------------- + +const std::optional<DisplayId>& DisplayDevice::getId() const { + return mCompositionDisplay->getId(); } -bool DisplayDevice::hasRenderIntent(RenderIntent intent) const { - // assume a render intent is supported when SRGB supports it; we should - // get rid of that assumption. - auto iter = mColorModes.find(getColorModeKey(Dataspace::SRGB, intent)); - return iter != mColorModes.end() && iter->second.renderIntent == intent; +bool DisplayDevice::isSecure() const { + return mCompositionDisplay->isSecure(); } -bool DisplayDevice::hasLegacyHdrSupport(Dataspace dataspace) const { - if ((dataspace == Dataspace::BT2020_PQ && hasHDR10Support()) || - (dataspace == Dataspace::BT2020_HLG && hasHLGSupport())) { - auto iter = - mColorModes.find(getColorModeKey(dataspace, RenderIntent::TONE_MAP_COLORIMETRIC)); - return iter == mColorModes.end() || iter->second.dataspace != dataspace; - } +const Rect& DisplayDevice::getBounds() const { + return mCompositionDisplay->getState().bounds; +} - return false; -} - -void DisplayDevice::getBestColorMode(Dataspace dataspace, RenderIntent intent, - Dataspace* outDataspace, ColorMode* outMode, - RenderIntent* outIntent) const { - auto iter = mColorModes.find(getColorModeKey(dataspace, intent)); - if (iter != mColorModes.end()) { - *outDataspace = iter->second.dataspace; - *outMode = iter->second.colorMode; - *outIntent = iter->second.renderIntent; - } else { - // this is unexpected on a WCG display - if (hasWideColorGamut()) { - ALOGE("map unknown (%s)/(%s) to default color mode", - dataspaceDetails(static_cast<android_dataspace_t>(dataspace)).c_str(), - decodeRenderIntent(intent).c_str()); - } +const Region& DisplayDevice::getUndefinedRegion() const { + return mCompositionDisplay->getState().undefinedRegion; +} - *outDataspace = Dataspace::UNKNOWN; - *outMode = ColorMode::NATIVE; - *outIntent = RenderIntent::COLORIMETRIC; - } +bool DisplayDevice::needsFiltering() const { + return mCompositionDisplay->getState().needsFiltering; +} + +uint32_t DisplayDevice::getLayerStack() const { + return mCompositionDisplay->getState().layerStackId; +} + +const ui::Transform& DisplayDevice::getTransform() const { + return mCompositionDisplay->getState().transform; +} + +const Rect& DisplayDevice::getViewport() const { + return mCompositionDisplay->getState().viewport; +} + +const Rect& DisplayDevice::getFrame() const { + return mCompositionDisplay->getState().frame; } -std::atomic<int32_t> DisplayDeviceState::nextDisplayId(1); +const Rect& DisplayDevice::getScissor() const { + return mCompositionDisplay->getState().scissor; +} + +bool DisplayDevice::hasWideColorGamut() const { + return mCompositionDisplay->getDisplayColorProfile()->hasWideColorGamut(); +} + +bool DisplayDevice::hasHDR10PlusSupport() const { + return mCompositionDisplay->getDisplayColorProfile()->hasHDR10PlusSupport(); +} -DisplayDeviceState::DisplayDeviceState(DisplayDevice::DisplayType type, bool isSecure) - : type(type), - layerStack(DisplayDevice::NO_LAYER_STACK), - orientation(0), - width(0), - height(0), - isSecure(isSecure) -{ - viewport.makeInvalid(); - frame.makeInvalid(); +bool DisplayDevice::hasHDR10Support() const { + return mCompositionDisplay->getDisplayColorProfile()->hasHDR10Support(); } +bool DisplayDevice::hasHLGSupport() const { + return mCompositionDisplay->getDisplayColorProfile()->hasHLGSupport(); +} + +bool DisplayDevice::hasDolbyVisionSupport() const { + return mCompositionDisplay->getDisplayColorProfile()->hasDolbyVisionSupport(); +} + +int DisplayDevice::getSupportedPerFrameMetadata() const { + return mCompositionDisplay->getDisplayColorProfile()->getSupportedPerFrameMetadata(); +} + +const HdrCapabilities& DisplayDevice::getHdrCapabilities() const { + return mCompositionDisplay->getDisplayColorProfile()->getHdrCapabilities(); +} + +std::atomic<int32_t> DisplayDeviceState::sNextSequenceId(1); + } // namespace android |