libs/shaders/shaders.cpp - LeafOS-Project/android_frameworks_native - Gitiles

 /*
  * 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 generateXYZTransforms(std::string& shader) {
     shader.append(R"(
         uniform float3x3 in_rgbToXyz;
         uniform float3x3 in_xyzToSrcRgb;
         uniform float4x4 in_colorTransform;
         float3 ToXYZ(float3 rgb) {
             return in_rgbToXyz * rgb;
         }

         float3 ToSrcRGB(float3 xyz) {
             return in_xyzToSrcRgb * xyz;
         }

         float3 ApplyColorTransform(float3 rgb) {
             return (in_colorTransform * float4(rgb, 1.0)).rgb;
         }
     )");
 }

 // Conversion from relative light to absolute light
 // Note that 1.0 == 203 nits.
 void generateLuminanceScalesForOOTF(ui::Dataspace inputDataspace, std::string& shader) {
     switch (inputDataspace & HAL_DATASPACE_TRANSFER_MASK) {
         case HAL_DATASPACE_TRANSFER_HLG:
             // BT. 2408 says that a signal level of 0.75 == 203 nits for HLG, but that's after
             // applying OOTF. But we haven't applied OOTF yet, so we need to scale by a different
             // constant instead.
             shader.append(R"(
                 float3 ScaleLuminance(float3 xyz) {
                     return xyz * 264.96;
                 }
             )");
             break;
         default:
             shader.append(R"(
                 float3 ScaleLuminance(float3 xyz) {
                     return xyz * 203.0;
                 }
             )");
             break;
     }
 }

 // Normalizes from absolute light back to relative light (maps from [0, maxNits] back to [0, 1])
 static void generateLuminanceNormalizationForOOTF(ui::Dataspace inputDataspace,
                                                   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 / 203.0;
                 }
             )");
             break;
         case HAL_DATASPACE_TRANSFER_HLG:
             switch (inputDataspace & HAL_DATASPACE_TRANSFER_MASK) {
                 case HAL_DATASPACE_TRANSFER_HLG:
                     shader.append(R"(
                             float3 NormalizeLuminance(float3 xyz) {
                                 return xyz / 264.96;
                             }
                         )");
                     break;
                 default:
                     // Transcoding to HLG requires applying the inverse OOTF
                     // with the expectation that the OOTF is then applied during
                     // tonemapping downstream.
                     // BT. 2100-2 operates on normalized luminances, so renormalize to the input to
                     // correctly adjust gamma.
                     // Note that following BT. 2408 for HLG OETF actually maps 0.75 == ~264.96 nits,
                     // rather than 203 nits, because 203 nits == OOTF(invOETF(0.75)), so even though
                     // we originally scaled by 203 nits we need to re-normalize to 264.96 nits when
                     // converting to the correct brightness range.
                     shader.append(R"(
                             float3 NormalizeLuminance(float3 xyz) {
                                 float ootfGain = pow(xyz.y / 1000.0, -0.2 / 1.2);
                                 return xyz * ootfGain / 264.96;
                             }
                         )");
                     break;
             }
             break;
         default:
             switch (inputDataspace & HAL_DATASPACE_TRANSFER_MASK) {
                 case HAL_DATASPACE_TRANSFER_HLG:
                 case HAL_DATASPACE_TRANSFER_ST2084:
                     // libtonemap outputs a range [0, in_libtonemap_displayMaxLuminance], so
                     // normalize back to [0, 1] when the output is SDR.
                     shader.append(R"(
                         float3 NormalizeLuminance(float3 xyz) {
                             return xyz / in_libtonemap_displayMaxLuminance;
                         }
                     )");
                     break;
                 default:
                     // Otherwise normalize back down to the range [0, 1]
                     // TODO: get this working for extended range outputs
                     shader.append(R"(
                         float3 NormalizeLuminance(float3 xyz) {
                             return xyz / 203.0;
                         }
                     )");
                     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, shader);
     generateLuminanceNormalizationForOOTF(inputDataspace, outputDataspace, shader);

     // Some tonemappers operate on CIE luminance, other tonemappers operate on linear rgb
     // luminance in the source gamut.
     shader.append(R"(
             float3 OOTF(float3 linearRGB) {
                 float3 scaledLinearRGB = ScaleLuminance(linearRGB);
                 float3 scaledXYZ = ToXYZ(scaledLinearRGB);

                 float gain = libtonemap_LookupTonemapGain(ToSrcRGB(scaledXYZ), scaledXYZ);

                 return NormalizeLuminance(scaledXYZ * gain);
             }
         )");
 }

 void generateOETF(std::string& shader) {
     // Only support gamma 2.2 for now
     shader.append(R"(
         float3 OETF(float3 linear) {
             return sign(linear) * pow(abs(linear), float3(1.0 / 2.2));
         }
     )");
 }

 void generateEffectiveOOTF(bool undoPremultipliedAlpha, LinearEffect::SkSLType type,
                            bool needsCustomOETF, std::string& shader) {
     switch (type) {
         case LinearEffect::SkSLType::ColorFilter:
             shader.append(R"(
                 half4 main(half4 inputColor) {
                     float4 c = float4(inputColor);
             )");
             break;
         case LinearEffect::SkSLType::Shader:
             shader.append(R"(
                 uniform shader child;
                 half4 main(float2 xy) {
                     float4 c = float4(child.eval(xy));
             )");
             break;
     }
     if (undoPremultipliedAlpha) {
         shader.append(R"(
             c.rgb = c.rgb / (c.a + 0.0019);
         )");
     }
     // We are using linear sRGB as a working space, with 1.0 == 203 nits
     shader.append(R"(
         c.rgb = ApplyColorTransform(OOTF(toLinearSrgb(c.rgb)));
     )");
     if (needsCustomOETF) {
         shader.append(R"(
             c.rgb = OETF(c.rgb);
         )");
     } else {
         shader.append(R"(
             c.rgb = fromLinearSrgb(c.rgb);
         )");
     }
     if (undoPremultipliedAlpha) {
         shader.append(R"(
             c.rgb = c.rgb * (c.a + 0.0019);
         )");
     }
     shader.append(R"(
             return c;
         }
     )");
 }

 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;
     generateXYZTransforms(shaderString);
     generateOOTF(linearEffect.inputDataspace, linearEffect.outputDataspace, shaderString);

     const bool needsCustomOETF = (linearEffect.fakeOutputDataspace & HAL_DATASPACE_TRANSFER_MASK) ==
             HAL_DATASPACE_TRANSFER_GAMMA2_2;
     if (needsCustomOETF) {
         generateOETF(shaderString);
     }
     generateEffectiveOOTF(linearEffect.undoPremultipliedAlpha, linearEffect.type, needsCustomOETF,
                           shaderString);
     return shaderString;
 }

 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();
     }
 }

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

     auto inputColorSpace = toColorSpace(linearEffect.inputDataspace);
     auto outputColorSpace = toColorSpace(linearEffect.outputDataspace);

     uniforms.push_back(
             {.name = "in_rgbToXyz",
              .value = buildUniformValue<mat3>(ColorSpace::linearExtendedSRGB().getRGBtoXYZ())});
     uniforms.push_back({.name = "in_xyzToSrcRgb",
                         .value = buildUniformValue<mat3>(inputColorSpace.getXYZtoRGB())});
     // Transforms xyz colors to linear source colors, then applies the color transform, then
     // transforms to linear extended RGB for skia to color manage.
     uniforms.push_back({.name = "in_colorTransform",
                         .value = buildUniformValue<mat4>(
                                 mat4(ColorSpace::linearExtendedSRGB().getXYZtoRGB()) *
                                 // TODO: the color transform ideally should be applied
                                 // in the source colorspace, but doing that breaks
                                 // renderengine tests
                                 mat4(outputColorSpace.getRGBtoXYZ()) * 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 is expected to only be meaningful for PQ content
                                .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
	/*
	* 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 generateXYZTransforms(std::string& shader) {
	shader.append(R"(
	uniform float3x3 in_rgbToXyz;
	uniform float3x3 in_xyzToSrcRgb;
	uniform float4x4 in_colorTransform;
	float3 ToXYZ(float3 rgb) {
	return in_rgbToXyz * rgb;
	}

	float3 ToSrcRGB(float3 xyz) {
	return in_xyzToSrcRgb * xyz;
	}

	float3 ApplyColorTransform(float3 rgb) {
	return (in_colorTransform * float4(rgb, 1.0)).rgb;
	}
	)");
	}

	// Conversion from relative light to absolute light
	// Note that 1.0 == 203 nits.
	void generateLuminanceScalesForOOTF(ui::Dataspace inputDataspace, std::string& shader) {
	switch (inputDataspace & HAL_DATASPACE_TRANSFER_MASK) {
	case HAL_DATASPACE_TRANSFER_HLG:
	// BT. 2408 says that a signal level of 0.75 == 203 nits for HLG, but that's after
	// applying OOTF. But we haven't applied OOTF yet, so we need to scale by a different
	// constant instead.
	shader.append(R"(
	float3 ScaleLuminance(float3 xyz) {
	return xyz * 264.96;
	}
	)");
	break;
	default:
	shader.append(R"(
	float3 ScaleLuminance(float3 xyz) {
	return xyz * 203.0;
	}
	)");
	break;
	}
	}

	// Normalizes from absolute light back to relative light (maps from [0, maxNits] back to [0, 1])
	static void generateLuminanceNormalizationForOOTF(ui::Dataspace inputDataspace,
	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 / 203.0;
	}
	)");
	break;
	case HAL_DATASPACE_TRANSFER_HLG:
	switch (inputDataspace & HAL_DATASPACE_TRANSFER_MASK) {
	case HAL_DATASPACE_TRANSFER_HLG:
	shader.append(R"(
	float3 NormalizeLuminance(float3 xyz) {
	return xyz / 264.96;
	}
	)");
	break;
	default:
	// Transcoding to HLG requires applying the inverse OOTF
	// with the expectation that the OOTF is then applied during
	// tonemapping downstream.
	// BT. 2100-2 operates on normalized luminances, so renormalize to the input to
	// correctly adjust gamma.
	// Note that following BT. 2408 for HLG OETF actually maps 0.75 == ~264.96 nits,
	// rather than 203 nits, because 203 nits == OOTF(invOETF(0.75)), so even though
	// we originally scaled by 203 nits we need to re-normalize to 264.96 nits when
	// converting to the correct brightness range.
	shader.append(R"(
	float3 NormalizeLuminance(float3 xyz) {
	float ootfGain = pow(xyz.y / 1000.0, -0.2 / 1.2);
	return xyz * ootfGain / 264.96;
	}
	)");
	break;
	}
	break;
	default:
	switch (inputDataspace & HAL_DATASPACE_TRANSFER_MASK) {
	case HAL_DATASPACE_TRANSFER_HLG:
	case HAL_DATASPACE_TRANSFER_ST2084:
	// libtonemap outputs a range [0, in_libtonemap_displayMaxLuminance], so
	// normalize back to [0, 1] when the output is SDR.
	shader.append(R"(
	float3 NormalizeLuminance(float3 xyz) {
	return xyz / in_libtonemap_displayMaxLuminance;
	}
	)");
	break;
	default:
	// Otherwise normalize back down to the range [0, 1]
	// TODO: get this working for extended range outputs
	shader.append(R"(
	float3 NormalizeLuminance(float3 xyz) {
	return xyz / 203.0;
	}
	)");
	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, shader);
	generateLuminanceNormalizationForOOTF(inputDataspace, outputDataspace, shader);

	// Some tonemappers operate on CIE luminance, other tonemappers operate on linear rgb
	// luminance in the source gamut.
	shader.append(R"(
	float3 OOTF(float3 linearRGB) {
	float3 scaledLinearRGB = ScaleLuminance(linearRGB);
	float3 scaledXYZ = ToXYZ(scaledLinearRGB);

	float gain = libtonemap_LookupTonemapGain(ToSrcRGB(scaledXYZ), scaledXYZ);

	return NormalizeLuminance(scaledXYZ * gain);
	}
	)");
	}

	void generateOETF(std::string& shader) {
	// Only support gamma 2.2 for now
	shader.append(R"(
	float3 OETF(float3 linear) {
	return sign(linear) * pow(abs(linear), float3(1.0 / 2.2));
	}
	)");
	}

	void generateEffectiveOOTF(bool undoPremultipliedAlpha, LinearEffect::SkSLType type,
	bool needsCustomOETF, std::string& shader) {
	switch (type) {
	case LinearEffect::SkSLType::ColorFilter:
	shader.append(R"(
	half4 main(half4 inputColor) {
	float4 c = float4(inputColor);
	)");
	break;
	case LinearEffect::SkSLType::Shader:
	shader.append(R"(
	uniform shader child;
	half4 main(float2 xy) {
	float4 c = float4(child.eval(xy));
	)");
	break;
	}
	if (undoPremultipliedAlpha) {
	shader.append(R"(
	c.rgb = c.rgb / (c.a + 0.0019);
	)");
	}
	// We are using linear sRGB as a working space, with 1.0 == 203 nits
	shader.append(R"(
	c.rgb = ApplyColorTransform(OOTF(toLinearSrgb(c.rgb)));
	)");
	if (needsCustomOETF) {
	shader.append(R"(
	c.rgb = OETF(c.rgb);
	)");
	} else {
	shader.append(R"(
	c.rgb = fromLinearSrgb(c.rgb);
	)");
	}
	if (undoPremultipliedAlpha) {
	shader.append(R"(
	c.rgb = c.rgb * (c.a + 0.0019);
	)");
	}
	shader.append(R"(
	return c;
	}
	)");
	}

	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;
	generateXYZTransforms(shaderString);
	generateOOTF(linearEffect.inputDataspace, linearEffect.outputDataspace, shaderString);

	const bool needsCustomOETF = (linearEffect.fakeOutputDataspace & HAL_DATASPACE_TRANSFER_MASK) ==
	HAL_DATASPACE_TRANSFER_GAMMA2_2;
	if (needsCustomOETF) {
	generateOETF(shaderString);
	}
	generateEffectiveOOTF(linearEffect.undoPremultipliedAlpha, linearEffect.type, needsCustomOETF,
	shaderString);
	return shaderString;
	}

	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();
	}
	}

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

	auto inputColorSpace = toColorSpace(linearEffect.inputDataspace);
	auto outputColorSpace = toColorSpace(linearEffect.outputDataspace);

	uniforms.push_back(
	{.name = "in_rgbToXyz",
	.value = buildUniformValue<mat3>(ColorSpace::linearExtendedSRGB().getRGBtoXYZ())});
	uniforms.push_back({.name = "in_xyzToSrcRgb",
	.value = buildUniformValue<mat3>(inputColorSpace.getXYZtoRGB())});
	// Transforms xyz colors to linear source colors, then applies the color transform, then
	// transforms to linear extended RGB for skia to color manage.
	uniforms.push_back({.name = "in_colorTransform",
	.value = buildUniformValue<mat4>(
	mat4(ColorSpace::linearExtendedSRGB().getXYZtoRGB()) *
	// TODO: the color transform ideally should be applied
	// in the source colorspace, but doing that breaks
	// renderengine tests
	mat4(outputColorSpace.getRGBtoXYZ()) * 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 is expected to only be meaningful for PQ content
	.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