Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d94b8ed4 authored by Chia-I Wu's avatar Chia-I Wu Committed by Android (Google) Code Review
Browse files

Merge changes from topic "color-vendor-intents" into pi-dev 

* changes:
  surfaceflinger: allow unknown render intents
  surfaceflinger: display color setting is a hint
  surfaceflinger: compute color mode mappings on hotplug
parents 56f68366 0d711268

services/surfaceflinger/DisplayDevice.cpp

+239 −30
Original line number Diff line number Diff line
@@ -18,6 +18,9 @@ 
#undef LOG_TAG

#define LOG_TAG "DisplayDevice"



#include <array>

#include <unordered_set>



#include <stdlib.h>

#include <stdio.h>

#include <string.h>
@@ -55,6 +58,7 @@ namespace android { 
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;
@@ -65,6 +69,147 @@ 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;

        }

    }



    // add other HDR candidates when intent is HDR

    if (isHdr) {

        for (auto hdrIntent : sHdrRenderIntents) {

            if (hdrIntent != intent) {

                candidates.push_back(hdrIntent);

            }

        }

    }



    // add COLORIMETRIC

    if (intent != RenderIntent::COLORIMETRIC) {

        candidates.push_back(RenderIntent::COLORIMETRIC);

    }



    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,
@@ -80,7 +225,7 @@ DisplayDevice::DisplayDevice( 
        bool hasWideColorGamut,

        const HdrCapabilities& hdrCapabilities,

        const int32_t supportedPerFrameMetadata,

        const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hdrAndRenderIntents,

        const std::unordered_map<ColorMode, std::vector<RenderIntent>>& hwcColorModes,

        int initialPowerMode)

    : lastCompositionHadVisibleLayers(false),

      mFlinger(flinger),
@@ -105,13 +250,11 @@ DisplayDevice::DisplayDevice( 
      mHasHdr10(false),

      mHasHLG(false),

      mHasDolbyVision(false),

      mSupportedPerFrameMetadata(supportedPerFrameMetadata),

      mHasBT2100PQColorimetric(false),

      mHasBT2100PQEnhance(false),

      mHasBT2100HLGColorimetric(false),

      mHasBT2100HLGEnhance(false)

      mSupportedPerFrameMetadata(supportedPerFrameMetadata)

{

    // clang-format on

    populateColorModes(hwcColorModes);



    std::vector<Hdr> types = hdrCapabilities.getSupportedHdrTypes();

    for (Hdr hdrType : types) {

        switch (hdrType) {
@@ -149,18 +292,6 @@ DisplayDevice::DisplayDevice( 
    }

    mHdrCapabilities = HdrCapabilities(types, maxLuminance, maxAverageLuminance, minLuminance);



    auto iter = hdrAndRenderIntents.find(ColorMode::BT2100_PQ);

    if (iter != hdrAndRenderIntents.end()) {

        hasToneMapping(iter->second,

                       &mHasBT2100PQColorimetric, &mHasBT2100PQEnhance);

    }



    iter = hdrAndRenderIntents.find(ColorMode::BT2100_HLG);

    if (iter != hdrAndRenderIntents.end()) {

        hasToneMapping(iter->second,

                       &mHasBT2100HLGColorimetric, &mHasBT2100HLGEnhance);

    }



    // initialize the display orientation transform.

    setProjection(DisplayState::eOrientationDefault, mViewport, mFrame);

}
@@ -545,20 +676,98 @@ void DisplayDevice::dump(String8& result) const { 
    result.append(surfaceDump);

}



void DisplayDevice::hasToneMapping(const std::vector<RenderIntent>& renderIntents,

                                   bool* outColorimetric, bool *outEnhance) {

    for (auto intent : renderIntents) {

        switch (intent) {

            case RenderIntent::TONE_MAP_COLORIMETRIC:

                *outColorimetric = true;

                break;

            case RenderIntent::TONE_MAP_ENHANCE:

                *outEnhance = true;

                break;

            default:

                break;

// 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;

    }



    // 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);

        }

    }



    // add known SDR combinations

    for (auto intent : sdrRenderIntents) {

        for (auto mode : sSdrColorModes) {

            addColorMode(hwcColorModes, mode, intent);

        }

    }



    // add known HDR combinations

    for (auto intent : sHdrRenderIntents) {

        for (auto mode : sHdrColorModes) {

            addColorMode(hwcColorModes, mode, intent);

        }

    }

}



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::hasModernHdrSupport(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;

    }



    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 {

        ALOGE("map unknown (%s)/(%s) to default color mode",

              dataspaceDetails(static_cast<android_dataspace_t>(dataspace)).c_str(),

              decodeRenderIntent(intent).c_str());



        *outDataspace = Dataspace::UNKNOWN;

        *outMode = ColorMode::NATIVE;

        *outIntent = RenderIntent::COLORIMETRIC;

    }

}



std::atomic<int32_t> DisplayDeviceState::nextDisplayId(1);

services/surfaceflinger/DisplayDevice.h

+32 −16
Original line number Diff line number Diff line
@@ -91,7 +91,7 @@ public: 
            bool hasWideColorGamut,

            const HdrCapabilities& hdrCapabilities,

            const int32_t supportedPerFrameMetadata,

            const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hdrAndRenderIntents,

            const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hwcColorModes,

            int initialPowerMode);

    // clang-format on
@@ -143,11 +143,17 @@ public: 
    // machine happy without actually queueing a buffer if nothing has changed

    status_t beginFrame(bool mustRecompose) const;

    status_t prepareFrame(HWComposer& hwc);



    bool hasWideColorGamut() const { return mHasWideColorGamut; }

    // Whether h/w composer has native support for specific HDR type.

    bool hasHDR10Support() const { return mHasHdr10; }

    bool hasHLGSupport() const { return mHasHLG; }

    bool hasDolbyVisionSupport() const { return mHasDolbyVision; }



    // Return true if the corresponding color mode for the HDR dataspace is

    // supported.

    bool hasModernHdrSupport(ui::Dataspace dataspace) const;



    // The returned HdrCapabilities is the combination of HDR capabilities from

    // hardware composer and RenderEngine. When the DisplayDevice supports wide

    // color gamut, RenderEngine is able to simulate HDR support in Display P3
@@ -156,13 +162,12 @@ public: 
    // respectively if hardware composer doesn't return meaningful values.

    const HdrCapabilities& getHdrCapabilities() const { return mHdrCapabilities; }



    // Whether h/w composer has BT2100_PQ color mode.

    bool hasBT2100PQColorimetricSupport() const { return mHasBT2100PQColorimetric; }

    bool hasBT2100PQEnhanceSupport() const { return mHasBT2100PQEnhance; }

    // Return true if intent is supported by the display.

    bool hasRenderIntent(ui::RenderIntent intent) const;



    // Whether h/w composer has BT2100_HLG color mode.

    bool hasBT2100HLGColorimetricSupport() const { return mHasBT2100HLGColorimetric; }

    bool hasBT2100HLGEnhanceSupport() const { return mHasBT2100HLGEnhance; }

    void getBestColorMode(ui::Dataspace dataspace, ui::RenderIntent intent,

                          ui::Dataspace* outDataspace, ui::ColorMode* outMode,

                          ui::RenderIntent* outIntent) const;



    void swapBuffers(HWComposer& hwc) const;
@@ -214,9 +219,6 @@ public: 
    void dump(String8& result) const;



private:

    void hasToneMapping(const std::vector<ui::RenderIntent>& renderIntents,

                        bool* outColorimetric, bool *outEnhance);



    /*

     *  Constants, set during initialization

     */
@@ -288,12 +290,26 @@ private: 
    bool mHasDolbyVision;

    HdrCapabilities mHdrCapabilities;

    const int32_t mSupportedPerFrameMetadata;

    // Whether h/w composer has BT2100_PQ and BT2100_HLG color mode with

    // colorimetrical tone mapping or enhanced tone mapping.

    bool mHasBT2100PQColorimetric;

    bool mHasBT2100PQEnhance;

    bool mHasBT2100HLGColorimetric;

    bool mHasBT2100HLGEnhance;



    // Mappings from desired Dataspace/RenderIntent to the supported

    // Dataspace/ColorMode/RenderIntent.

    using ColorModeKey = uint64_t;

    struct ColorModeValue {

        ui::Dataspace dataspace;

        ui::ColorMode colorMode;

        ui::RenderIntent renderIntent;

    };



    static ColorModeKey getColorModeKey(ui::Dataspace dataspace, ui::RenderIntent intent) {

        return (static_cast<uint64_t>(dataspace) << 32) | static_cast<uint32_t>(intent);

    }

    void populateColorModes(

            const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hwcColorModes);

    void addColorMode(

            const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>& hwcColorModes,

            const ui::ColorMode mode, const ui::RenderIntent intent);



    std::unordered_map<ColorModeKey, ColorModeValue> mColorModes;

};



struct DisplayDeviceState {

services/surfaceflinger/SurfaceFlinger.cpp

+55 −159

File changed.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/SurfaceFlinger.h

+0 −3
Original line number Diff line number Diff line
@@ -664,8 +664,6 @@ private: 
                       ui::ColorMode* outMode,

                       ui::Dataspace* outDataSpace,

                       ui::RenderIntent* outRenderIntent) const;

    ui::RenderIntent pickRenderIntent(const sp<DisplayDevice>& displayDevice,

                                      ui::ColorMode colorMode) const;



    void setUpHWComposer();

    void doComposition();
@@ -880,7 +878,6 @@ private: 
    DisplayColorSetting mDisplayColorSetting = DisplayColorSetting::MANAGED;

    // Applied on sRGB layers when the render intent is non-colorimetric.

    mat4 mLegacySrgbSaturationMatrix;

    bool mBuiltinDisplaySupportsEnhance = false;



    using CreateBufferQueueFunction =

            std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,