512 lines
19 KiB
C++
512 lines
19 KiB
C++
|
/*
|
||
|
|
* Copyright 2021 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 <shaders/shaders.h>
|
||
|
|
|
||
|
|
#include <tonemap/tonemap.h>
|
||
|
|
|
||
|
|
#include <cmath>
|
||
|
|
#include <optional>
|
||
|
|
|
||
|
|
#include <math/mat4.h>
|
||
|
|
#include <system/graphics-base-v1.0.h>
|
||
|
|
#include <ui/ColorSpace.h>
|
||
|
|
|
||
|
|
namespace android::shaders {
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
aidl::android::hardware::graphics::common::Dataspace toAidlDataspace(ui::Dataspace dataspace) {
|
||
|
|
return static_cast<aidl::android::hardware::graphics::common::Dataspace>(dataspace);
|
||
|
|
}
|
||
|
|
|
||
|
|
void generateEOTF(ui::Dataspace dataspace, std::string& shader) {
|
||
|
|
switch (dataspace & HAL_DATASPACE_TRANSFER_MASK) {
|
||
|
|
case HAL_DATASPACE_TRANSFER_ST2084:
|
||
|
|
shader.append(R"(
|
||
|
|
|
||
|
|
float3 EOTF(float3 color) {
|
||
|
|
float m1 = (2610.0 / 4096.0) / 4.0;
|
||
|
|
float m2 = (2523.0 / 4096.0) * 128.0;
|
||
|
|
float c1 = (3424.0 / 4096.0);
|
||
|
|
float c2 = (2413.0 / 4096.0) * 32.0;
|
||
|
|
float c3 = (2392.0 / 4096.0) * 32.0;
|
||
|
|
|
||
|
|
float3 tmp = pow(clamp(color, 0.0, 1.0), 1.0 / float3(m2));
|
||
|
|
tmp = max(tmp - c1, 0.0) / (c2 - c3 * tmp);
|
||
|
|
return pow(tmp, 1.0 / float3(m1));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_HLG:
|
||
|
|
shader.append(R"(
|
||
|
|
float EOTF_channel(float channel) {
|
||
|
|
const float a = 0.17883277;
|
||
|
|
const float b = 0.28466892;
|
||
|
|
const float c = 0.55991073;
|
||
|
|
return channel <= 0.5 ? channel * channel / 3.0 :
|
||
|
|
(exp((channel - c) / a) + b) / 12.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF(float3 color) {
|
||
|
|
return float3(EOTF_channel(color.r), EOTF_channel(color.g),
|
||
|
|
EOTF_channel(color.b));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_LINEAR:
|
||
|
|
shader.append(R"(
|
||
|
|
float3 EOTF(float3 color) {
|
||
|
|
return color;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_SMPTE_170M:
|
||
|
|
shader.append(R"(
|
||
|
|
|
||
|
|
float EOTF_sRGB(float srgb) {
|
||
|
|
return srgb <= 0.08125 ? srgb / 4.50 : pow((srgb + 0.099) / 1.099, 1 / 0.45);
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF_sRGB(float3 srgb) {
|
||
|
|
return float3(EOTF_sRGB(srgb.r), EOTF_sRGB(srgb.g), EOTF_sRGB(srgb.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF(float3 srgb) {
|
||
|
|
return sign(srgb.rgb) * EOTF_sRGB(abs(srgb.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_GAMMA2_2:
|
||
|
|
shader.append(R"(
|
||
|
|
|
||
|
|
float EOTF_sRGB(float srgb) {
|
||
|
|
return pow(srgb, 2.2);
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF_sRGB(float3 srgb) {
|
||
|
|
return float3(EOTF_sRGB(srgb.r), EOTF_sRGB(srgb.g), EOTF_sRGB(srgb.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF(float3 srgb) {
|
||
|
|
return sign(srgb.rgb) * EOTF_sRGB(abs(srgb.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_GAMMA2_6:
|
||
|
|
shader.append(R"(
|
||
|
|
|
||
|
|
float EOTF_sRGB(float srgb) {
|
||
|
|
return pow(srgb, 2.6);
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF_sRGB(float3 srgb) {
|
||
|
|
return float3(EOTF_sRGB(srgb.r), EOTF_sRGB(srgb.g), EOTF_sRGB(srgb.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF(float3 srgb) {
|
||
|
|
return sign(srgb.rgb) * EOTF_sRGB(abs(srgb.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_GAMMA2_8:
|
||
|
|
shader.append(R"(
|
||
|
|
|
||
|
|
float EOTF_sRGB(float srgb) {
|
||
|
|
return pow(srgb, 2.8);
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF_sRGB(float3 srgb) {
|
||
|
|
return float3(EOTF_sRGB(srgb.r), EOTF_sRGB(srgb.g), EOTF_sRGB(srgb.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF(float3 srgb) {
|
||
|
|
return sign(srgb.rgb) * EOTF_sRGB(abs(srgb.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_SRGB:
|
||
|
|
default:
|
||
|
|
shader.append(R"(
|
||
|
|
|
||
|
|
float EOTF_sRGB(float srgb) {
|
||
|
|
return srgb <= 0.04045 ? srgb / 12.92 : pow((srgb + 0.055) / 1.055, 2.4);
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF_sRGB(float3 srgb) {
|
||
|
|
return float3(EOTF_sRGB(srgb.r), EOTF_sRGB(srgb.g), EOTF_sRGB(srgb.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 EOTF(float3 srgb) {
|
||
|
|
return sign(srgb.rgb) * EOTF_sRGB(abs(srgb.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void generateXYZTransforms(std::string& shader) {
|
||
|
|
shader.append(R"(
|
||
|
|
uniform float4x4 in_rgbToXyz;
|
||
|
|
uniform float4x4 in_xyzToRgb;
|
||
|
|
float3 ToXYZ(float3 rgb) {
|
||
|
|
return (in_rgbToXyz * float4(rgb, 1.0)).rgb;
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 ToRGB(float3 xyz) {
|
||
|
|
return clamp((in_xyzToRgb * float4(xyz, 1.0)).rgb, 0.0, 1.0);
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
}
|
||
|
|
|
||
|
|
// Conversion from relative light to absolute light (maps from [0, 1] to [0, maxNits])
|
||
|
|
void generateLuminanceScalesForOOTF(ui::Dataspace inputDataspace, ui::Dataspace outputDataspace,
|
||
|
|
std::string& shader) {
|
||
|
|
switch (inputDataspace & HAL_DATASPACE_TRANSFER_MASK) {
|
||
|
|
case HAL_DATASPACE_TRANSFER_ST2084:
|
||
|
|
shader.append(R"(
|
||
|
|
float3 ScaleLuminance(float3 xyz) {
|
||
|
|
return xyz * 10000.0;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_HLG:
|
||
|
|
shader.append(R"(
|
||
|
|
float3 ScaleLuminance(float3 xyz) {
|
||
|
|
return xyz * 1000.0;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
switch (outputDataspace & HAL_DATASPACE_TRANSFER_MASK) {
|
||
|
|
case HAL_DATASPACE_TRANSFER_ST2084:
|
||
|
|
case HAL_DATASPACE_TRANSFER_HLG:
|
||
|
|
// SDR -> HDR tonemap
|
||
|
|
shader.append(R"(
|
||
|
|
float3 ScaleLuminance(float3 xyz) {
|
||
|
|
return xyz * in_libtonemap_inputMaxLuminance;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
// Input and output are both SDR, so no tone-mapping is expected so
|
||
|
|
// no-op the luminance normalization.
|
||
|
|
shader.append(R"(
|
||
|
|
float3 ScaleLuminance(float3 xyz) {
|
||
|
|
return xyz * in_libtonemap_displayMaxLuminance;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Normalizes from absolute light back to relative light (maps from [0, maxNits] back to [0, 1])
|
||
|
|
static void generateLuminanceNormalizationForOOTF(ui::Dataspace outputDataspace,
|
||
|
|
std::string& shader) {
|
||
|
|
switch (outputDataspace & HAL_DATASPACE_TRANSFER_MASK) {
|
||
|
|
case HAL_DATASPACE_TRANSFER_ST2084:
|
||
|
|
shader.append(R"(
|
||
|
|
float3 NormalizeLuminance(float3 xyz) {
|
||
|
|
return xyz / 10000.0;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_HLG:
|
||
|
|
shader.append(R"(
|
||
|
|
float3 NormalizeLuminance(float3 xyz) {
|
||
|
|
return xyz / 1000.0;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
shader.append(R"(
|
||
|
|
float3 NormalizeLuminance(float3 xyz) {
|
||
|
|
return xyz / in_libtonemap_displayMaxLuminance;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void generateOOTF(ui::Dataspace inputDataspace, ui::Dataspace outputDataspace,
|
||
|
|
std::string& shader) {
|
||
|
|
shader.append(tonemap::getToneMapper()
|
||
|
|
->generateTonemapGainShaderSkSL(toAidlDataspace(inputDataspace),
|
||
|
|
toAidlDataspace(outputDataspace))
|
||
|
|
.c_str());
|
||
|
|
|
||
|
|
generateLuminanceScalesForOOTF(inputDataspace, outputDataspace, shader);
|
||
|
|
generateLuminanceNormalizationForOOTF(outputDataspace, shader);
|
||
|
|
|
||
|
|
shader.append(R"(
|
||
|
|
float3 OOTF(float3 linearRGB, float3 xyz) {
|
||
|
|
float3 scaledLinearRGB = ScaleLuminance(linearRGB);
|
||
|
|
float3 scaledXYZ = ScaleLuminance(xyz);
|
||
|
|
|
||
|
|
float gain = libtonemap_LookupTonemapGain(scaledLinearRGB, scaledXYZ);
|
||
|
|
|
||
|
|
return NormalizeLuminance(scaledXYZ * gain);
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
}
|
||
|
|
|
||
|
|
void generateOETF(ui::Dataspace dataspace, std::string& shader) {
|
||
|
|
switch (dataspace & HAL_DATASPACE_TRANSFER_MASK) {
|
||
|
|
case HAL_DATASPACE_TRANSFER_ST2084:
|
||
|
|
shader.append(R"(
|
||
|
|
|
||
|
|
float3 OETF(float3 xyz) {
|
||
|
|
float m1 = (2610.0 / 4096.0) / 4.0;
|
||
|
|
float m2 = (2523.0 / 4096.0) * 128.0;
|
||
|
|
float c1 = (3424.0 / 4096.0);
|
||
|
|
float c2 = (2413.0 / 4096.0) * 32.0;
|
||
|
|
float c3 = (2392.0 / 4096.0) * 32.0;
|
||
|
|
|
||
|
|
float3 tmp = pow(xyz, float3(m1));
|
||
|
|
tmp = (c1 + c2 * tmp) / (1.0 + c3 * tmp);
|
||
|
|
return pow(tmp, float3(m2));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_HLG:
|
||
|
|
shader.append(R"(
|
||
|
|
float OETF_channel(float channel) {
|
||
|
|
const float a = 0.17883277;
|
||
|
|
const float b = 0.28466892;
|
||
|
|
const float c = 0.55991073;
|
||
|
|
return channel <= 1.0 / 12.0 ? sqrt(3.0 * channel) :
|
||
|
|
a * log(12.0 * channel - b) + c;
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF(float3 linear) {
|
||
|
|
return float3(OETF_channel(linear.r), OETF_channel(linear.g),
|
||
|
|
OETF_channel(linear.b));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_LINEAR:
|
||
|
|
shader.append(R"(
|
||
|
|
float3 OETF(float3 linear) {
|
||
|
|
return linear;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_SMPTE_170M:
|
||
|
|
shader.append(R"(
|
||
|
|
float OETF_sRGB(float linear) {
|
||
|
|
return linear <= 0.018 ?
|
||
|
|
linear * 4.50 : (pow(linear, 0.45) * 1.099) - 0.099;
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF_sRGB(float3 linear) {
|
||
|
|
return float3(OETF_sRGB(linear.r), OETF_sRGB(linear.g), OETF_sRGB(linear.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF(float3 linear) {
|
||
|
|
return sign(linear.rgb) * OETF_sRGB(abs(linear.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_GAMMA2_2:
|
||
|
|
shader.append(R"(
|
||
|
|
float OETF_sRGB(float linear) {
|
||
|
|
return pow(linear, (1.0 / 2.2));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF_sRGB(float3 linear) {
|
||
|
|
return float3(OETF_sRGB(linear.r), OETF_sRGB(linear.g), OETF_sRGB(linear.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF(float3 linear) {
|
||
|
|
return sign(linear.rgb) * OETF_sRGB(abs(linear.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_GAMMA2_6:
|
||
|
|
shader.append(R"(
|
||
|
|
float OETF_sRGB(float linear) {
|
||
|
|
return pow(linear, (1.0 / 2.6));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF_sRGB(float3 linear) {
|
||
|
|
return float3(OETF_sRGB(linear.r), OETF_sRGB(linear.g), OETF_sRGB(linear.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF(float3 linear) {
|
||
|
|
return sign(linear.rgb) * OETF_sRGB(abs(linear.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_GAMMA2_8:
|
||
|
|
shader.append(R"(
|
||
|
|
float OETF_sRGB(float linear) {
|
||
|
|
return pow(linear, (1.0 / 2.8));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF_sRGB(float3 linear) {
|
||
|
|
return float3(OETF_sRGB(linear.r), OETF_sRGB(linear.g), OETF_sRGB(linear.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF(float3 linear) {
|
||
|
|
return sign(linear.rgb) * OETF_sRGB(abs(linear.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
case HAL_DATASPACE_TRANSFER_SRGB:
|
||
|
|
default:
|
||
|
|
shader.append(R"(
|
||
|
|
float OETF_sRGB(float linear) {
|
||
|
|
return linear <= 0.0031308 ?
|
||
|
|
linear * 12.92 : (pow(linear, 1.0 / 2.4) * 1.055) - 0.055;
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF_sRGB(float3 linear) {
|
||
|
|
return float3(OETF_sRGB(linear.r), OETF_sRGB(linear.g), OETF_sRGB(linear.b));
|
||
|
|
}
|
||
|
|
|
||
|
|
float3 OETF(float3 linear) {
|
||
|
|
return sign(linear.rgb) * OETF_sRGB(abs(linear.rgb));
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void generateEffectiveOOTF(bool undoPremultipliedAlpha, std::string& shader) {
|
||
|
|
shader.append(R"(
|
||
|
|
uniform shader child;
|
||
|
|
half4 main(float2 xy) {
|
||
|
|
float4 c = float4(child.eval(xy));
|
||
|
|
)");
|
||
|
|
if (undoPremultipliedAlpha) {
|
||
|
|
shader.append(R"(
|
||
|
|
c.rgb = c.rgb / (c.a + 0.0019);
|
||
|
|
)");
|
||
|
|
}
|
||
|
|
shader.append(R"(
|
||
|
|
float3 linearRGB = EOTF(c.rgb);
|
||
|
|
float3 xyz = ToXYZ(linearRGB);
|
||
|
|
c.rgb = OETF(ToRGB(OOTF(linearRGB, xyz)));
|
||
|
|
)");
|
||
|
|
if (undoPremultipliedAlpha) {
|
||
|
|
shader.append(R"(
|
||
|
|
c.rgb = c.rgb * (c.a + 0.0019);
|
||
|
|
)");
|
||
|
|
}
|
||
|
|
shader.append(R"(
|
||
|
|
return c;
|
||
|
|
}
|
||
|
|
)");
|
||
|
|
}
|
||
|
|
|
||
|
|
// please keep in sync with toSkColorSpace function in renderengine/skia/ColorSpaces.cpp
|
||
|
|
ColorSpace toColorSpace(ui::Dataspace dataspace) {
|
||
|
|
switch (dataspace & HAL_DATASPACE_STANDARD_MASK) {
|
||
|
|
case HAL_DATASPACE_STANDARD_BT709:
|
||
|
|
return ColorSpace::sRGB();
|
||
|
|
case HAL_DATASPACE_STANDARD_DCI_P3:
|
||
|
|
return ColorSpace::DisplayP3();
|
||
|
|
case HAL_DATASPACE_STANDARD_BT2020:
|
||
|
|
case HAL_DATASPACE_STANDARD_BT2020_CONSTANT_LUMINANCE:
|
||
|
|
return ColorSpace::BT2020();
|
||
|
|
case HAL_DATASPACE_STANDARD_ADOBE_RGB:
|
||
|
|
return ColorSpace::AdobeRGB();
|
||
|
|
// TODO(b/208290320): BT601 format and variants return different primaries
|
||
|
|
case HAL_DATASPACE_STANDARD_BT601_625:
|
||
|
|
case HAL_DATASPACE_STANDARD_BT601_625_UNADJUSTED:
|
||
|
|
case HAL_DATASPACE_STANDARD_BT601_525:
|
||
|
|
case HAL_DATASPACE_STANDARD_BT601_525_UNADJUSTED:
|
||
|
|
// TODO(b/208290329): BT407M format returns different primaries
|
||
|
|
case HAL_DATASPACE_STANDARD_BT470M:
|
||
|
|
// TODO(b/208290904): FILM format returns different primaries
|
||
|
|
case HAL_DATASPACE_STANDARD_FILM:
|
||
|
|
case HAL_DATASPACE_STANDARD_UNSPECIFIED:
|
||
|
|
default:
|
||
|
|
return ColorSpace::sRGB();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
template <typename T, std::enable_if_t<std::is_trivially_copyable<T>::value, bool> = true>
|
||
|
|
std::vector<uint8_t> buildUniformValue(T value) {
|
||
|
|
std::vector<uint8_t> result;
|
||
|
|
result.resize(sizeof(value));
|
||
|
|
std::memcpy(result.data(), &value, sizeof(value));
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
std::string buildLinearEffectSkSL(const LinearEffect& linearEffect) {
|
||
|
|
std::string shaderString;
|
||
|
|
generateEOTF(linearEffect.fakeInputDataspace == ui::Dataspace::UNKNOWN
|
||
|
|
? linearEffect.inputDataspace
|
||
|
|
: linearEffect.fakeInputDataspace,
|
||
|
|
shaderString);
|
||
|
|
generateXYZTransforms(shaderString);
|
||
|
|
generateOOTF(linearEffect.inputDataspace, linearEffect.outputDataspace, shaderString);
|
||
|
|
generateOETF(linearEffect.outputDataspace, shaderString);
|
||
|
|
generateEffectiveOOTF(linearEffect.undoPremultipliedAlpha, shaderString);
|
||
|
|
return shaderString;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Generates a list of uniforms to set on the LinearEffect shader above.
|
||
|
|
std::vector<tonemap::ShaderUniform> buildLinearEffectUniforms(
|
||
|
|
const LinearEffect& linearEffect, const mat4& colorTransform, float maxDisplayLuminance,
|
||
|
|
float currentDisplayLuminanceNits, float maxLuminance, AHardwareBuffer* buffer,
|
||
|
|
aidl::android::hardware::graphics::composer3::RenderIntent renderIntent) {
|
||
|
|
std::vector<tonemap::ShaderUniform> uniforms;
|
||
|
|
|
||
|
|
const ui::Dataspace inputDataspace = linearEffect.fakeInputDataspace == ui::Dataspace::UNKNOWN
|
||
|
|
? linearEffect.inputDataspace
|
||
|
|
: linearEffect.fakeInputDataspace;
|
||
|
|
|
||
|
|
if (inputDataspace == linearEffect.outputDataspace) {
|
||
|
|
uniforms.push_back({.name = "in_rgbToXyz", .value = buildUniformValue<mat4>(mat4())});
|
||
|
|
uniforms.push_back(
|
||
|
|
{.name = "in_xyzToRgb", .value = buildUniformValue<mat4>(colorTransform)});
|
||
|
|
} else {
|
||
|
|
ColorSpace inputColorSpace = toColorSpace(inputDataspace);
|
||
|
|
ColorSpace outputColorSpace = toColorSpace(linearEffect.outputDataspace);
|
||
|
|
uniforms.push_back({.name = "in_rgbToXyz",
|
||
|
|
.value = buildUniformValue<mat4>(mat4(inputColorSpace.getRGBtoXYZ()))});
|
||
|
|
uniforms.push_back({.name = "in_xyzToRgb",
|
||
|
|
.value = buildUniformValue<mat4>(
|
||
|
|
colorTransform * mat4(outputColorSpace.getXYZtoRGB()))});
|
||
|
|
}
|
||
|
|
|
||
|
|
tonemap::Metadata metadata{.displayMaxLuminance = maxDisplayLuminance,
|
||
|
|
// If the input luminance is unknown, use display luminance (aka,
|
||
|
|
// no-op any luminance changes)
|
||
|
|
// This will be the case for eg screenshots in addition to
|
||
|
|
// uncalibrated displays
|
||
|
|
.contentMaxLuminance =
|
||
|
|
maxLuminance > 0 ? maxLuminance : maxDisplayLuminance,
|
||
|
|
.currentDisplayLuminance = currentDisplayLuminanceNits > 0
|
||
|
|
? currentDisplayLuminanceNits
|
||
|
|
: maxDisplayLuminance,
|
||
|
|
.buffer = buffer,
|
||
|
|
.renderIntent = renderIntent};
|
||
|
|
|
||
|
|
for (const auto uniform : tonemap::getToneMapper()->generateShaderSkSLUniforms(metadata)) {
|
||
|
|
uniforms.push_back(uniform);
|
||
|
|
}
|
||
|
|
|
||
|
|
return uniforms;
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace android::shaders
|