| // Copyright 2026 The Dawn & Tint Authors | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are met: | |
| // | |
| // 1. Redistributions of source code must retain the above copyright notice, this | |
| // list of conditions and the following disclaimer. | |
| // | |
| // 2. Redistributions in binary form must reproduce the above copyright notice, | |
| // this list of conditions and the following disclaimer in the documentation | |
| // and/or other materials provided with the distribution. | |
| // | |
| // 3. Neither the name of the copyright holder nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| #include "src/dawn/common/ExternalTextureParams.h" | |
| #include "src/dawn/common/ColorSpace.h" | |
| namespace dawn { | |
| // HLG is mode 1 which is tagged with G = -1 | |
| // TODO(https://crbug.com/496604550): G = -1 as a mode selecator is a hack and instead a proper mode | |
| // enum should be added to the API. | |
| // | |
| // if (v <= D) { | |
| // return v * v / E; | |
| // } | |
| // return (B + exp((v - C) / A)) / F | |
| constexpr TransferFunction kEOTF_HLG = { | |
| .g = -1, // Mode HLG see src/dawn/native/ExternalTexture.cpp | |
| .a = 0.17883277, | |
| .b = 0.28466892, | |
| .c = 0.55991073, | |
| .d = 0.5, | |
| .e = 3.0, | |
| .f = 12.0, | |
| }; | |
| // PQ is mode 2 which is tagged with G = -2 | |
| // TODO(https://crbug.com/496604550): G = -2 as a mode selecator is a hack and instead a proper mode | |
| // enum should be added to the API. | |
| // | |
| // v = pow(clamp(v, 0, 1), 1.0 / B) | |
| // v = max(v - C, 0) / (D - E * v) | |
| // return pow(v, 1.0 / A) | |
| constexpr TransferFunction kEOTF_PQ = { | |
| .g = -2, // Mode PQ see src/dawn/native/ExternalTexture.cpp | |
| .a = (2610.0 / 16384.0), | |
| .b = (2523.0 / 4096.0) * 128.0, | |
| .c = (3424.0 / 4096.0), | |
| .d = (2413.0 / 4096.0) * 32.0, | |
| .e = (2392.0 / 4096.0) * 32.0, | |
| .f = 0.0, | |
| }; | |
| wgpu::Status ComputeExternalTextureParams(const wgpu::ColorSpaceDawn& srcColorSpace, | |
| wgpu::PredefinedColorSpace dstColorSpace, | |
| ExternalTextureColorSpaceParams* out) { | |
| if (srcColorSpace.nextInChain != nullptr) { | |
| return wgpu::Status::Error; | |
| } | |
| // Specifying the hdrReferenceWhiteLuminance is only allowed for HDR color spaces. | |
| if (srcColorSpace.hdrReferenceWhiteLuminance != 0 && | |
| srcColorSpace.transfer != wgpu::ColorSpaceTransferDawn::PQ && | |
| srcColorSpace.transfer != wgpu::ColorSpaceTransferDawn::HLG) { | |
| return wgpu::Status::Error; | |
| } | |
| // Convert each enum argument to the corresponding matrix / transfer function params. | |
| math::Mat4x3f rangeMatrix; | |
| switch (srcColorSpace.yCbCrRange) { | |
| case wgpu::ColorSpaceYCbCrRangeDawn::Identity: | |
| rangeMatrix = math::Mat4x3f::CropOrExpandFrom(math::Mat3x3f::Identity()); | |
| break; | |
| case wgpu::ColorSpaceYCbCrRangeDawn::Narrow: | |
| rangeMatrix = kYCbCrRange_Narrow; | |
| break; | |
| case wgpu::ColorSpaceYCbCrRangeDawn::Full: | |
| rangeMatrix = kYCbCrRange_Full; | |
| break; | |
| default: | |
| return wgpu::Status::Error; | |
| } | |
| math::Mat3x3f ycbcrToRgb; | |
| switch (srcColorSpace.yCbCrMatrix) { | |
| case wgpu::ColorSpaceYCbCrMatrixDawn::Identity: | |
| ycbcrToRgb = math::Mat3x3f::Identity(); | |
| break; | |
| case wgpu::ColorSpaceYCbCrMatrixDawn::Rec601: | |
| ycbcrToRgb = kYCbCrToRGB_Rec601; | |
| break; | |
| case wgpu::ColorSpaceYCbCrMatrixDawn::Rec709: | |
| ycbcrToRgb = kYCbCrToRGB_Rec709; | |
| break; | |
| case wgpu::ColorSpaceYCbCrMatrixDawn::Rec2020: | |
| ycbcrToRgb = kYCbCrToRGB_Rec2020; | |
| break; | |
| default: | |
| return wgpu::Status::Error; | |
| } | |
| math::Mat3x3f srcRGBToXYZ; | |
| switch (srcColorSpace.primaries) { | |
| case wgpu::ColorSpacePrimariesDawn::Rec601: | |
| srcRGBToXYZ = kRGBToXYZ_Rec601; | |
| break; | |
| case wgpu::ColorSpacePrimariesDawn::SRGB: | |
| srcRGBToXYZ = kRGBToXYZ_Rec709; | |
| break; | |
| case wgpu::ColorSpacePrimariesDawn::Rec2020: | |
| srcRGBToXYZ = kRGBToXYZ_Rec2020; | |
| break; | |
| case wgpu::ColorSpacePrimariesDawn::DisplayP3: | |
| srcRGBToXYZ = kRGBToXYZ_DisplayP3; | |
| break; | |
| default: | |
| return wgpu::Status::Error; | |
| } | |
| TransferFunction srcEOTF; | |
| float srcLuminanceOf1 = kDefaultHDRReferenceWhiteLuminance; | |
| switch (srcColorSpace.transfer) { | |
| case wgpu::ColorSpaceTransferDawn::Identity: | |
| srcEOTF = kEOTF_Identity; | |
| break; | |
| case wgpu::ColorSpaceTransferDawn::SRGB: | |
| srcEOTF = kEOTF_sRGB; | |
| break; | |
| case wgpu::ColorSpaceTransferDawn::DisplayP3: | |
| srcEOTF = kEOTF_DisplayP3; | |
| break; | |
| case wgpu::ColorSpaceTransferDawn::SMPTE_170M: | |
| srcEOTF = kEOTF_SMPTE_170M; | |
| break; | |
| case wgpu::ColorSpaceTransferDawn::HLG: | |
| srcLuminanceOf1 = kHLGLuminanceOf1; | |
| srcEOTF = kEOTF_HLG; | |
| break; | |
| case wgpu::ColorSpaceTransferDawn::PQ: | |
| srcLuminanceOf1 = kPQLuminanceOf1; | |
| srcEOTF = kEOTF_PQ; | |
| break; | |
| default: | |
| return wgpu::Status::Error; | |
| } | |
| math::Mat3x3f dstXYZToRGB; | |
| TransferFunction dstOETF; | |
| switch (dstColorSpace) { | |
| case wgpu::PredefinedColorSpace::SRGB: | |
| dstXYZToRGB = kXYZToRGB_sRGB; | |
| dstOETF = kEOTFInverse_sRGB; | |
| break; | |
| case wgpu::PredefinedColorSpace::DisplayP3: | |
| dstXYZToRGB = kXYZToRGB_DisplayP3; | |
| dstOETF = kEOTFInverse_DisplayP3; | |
| break; | |
| case wgpu::PredefinedColorSpace::SRGBLinear: | |
| dstXYZToRGB = kXYZToRGB_sRGB; | |
| dstOETF = kEOTF_Identity; | |
| break; | |
| case wgpu::PredefinedColorSpace::DisplayP3Linear: | |
| dstXYZToRGB = kXYZToRGB_DisplayP3; | |
| dstOETF = kEOTF_Identity; | |
| break; | |
| case wgpu::PredefinedColorSpace::Rec2020Linear: | |
| dstXYZToRGB = kXYZToRGB_Rec2020; | |
| dstOETF = kEOTF_Identity; | |
| break; | |
| default: | |
| return wgpu::Status::Error; | |
| } | |
| // The YCbCr to RGB matrix is passed row-major. | |
| math::Mat4x3f yuvToRgbConversionMatrix = math::Mul(ycbcrToRgb, rangeMatrix); | |
| for (size_t x = 0; x < 4; x++) { | |
| for (size_t y = 0; y < 3; y++) { | |
| out->yuvToRgbConversionMatrix[x + 4 * y] = yuvToRgbConversionMatrix[x][y]; | |
| } | |
| } | |
| // The gamut matrix is passed column-major. | |
| float hdrReferenceWhiteLuminance = kDefaultHDRReferenceWhiteLuminance; | |
| if (srcColorSpace.hdrReferenceWhiteLuminance != 0) { | |
| hdrReferenceWhiteLuminance = srcColorSpace.hdrReferenceWhiteLuminance; | |
| } | |
| float luminanceAdjustment = srcLuminanceOf1 / hdrReferenceWhiteLuminance; | |
| math::Mat3x3f gamutConversionMatrix = math::Mul(dstXYZToRGB, srcRGBToXYZ) * luminanceAdjustment; | |
| for (size_t x = 0; x < 3; x++) { | |
| for (size_t y = 0; y < 3; y++) { | |
| out->gamutConversionMatrix[y + 3 * x] = gamutConversionMatrix[x][y]; | |
| } | |
| } | |
| auto TransferFunctionToArray = [](const TransferFunction& tf) -> std::array<float, 7> { | |
| return {tf.g, tf.a, tf.b, tf.c, tf.d, tf.e, tf.f}; | |
| }; | |
| out->srcTransferFunction = TransferFunctionToArray(srcEOTF); | |
| out->dstTransferFunction = TransferFunctionToArray(dstOETF); | |
| return wgpu::Status::Success; | |
| } | |
| ExternalTextureColorSpaceParams GetNoopColorSpaceParams() { | |
| ExternalTextureColorSpaceParams params; | |
| wgpu::Status status = ComputeExternalTextureParams( | |
| { | |
| .primaries = wgpu::ColorSpacePrimariesDawn::SRGB, | |
| .transfer = wgpu::ColorSpaceTransferDawn::Identity, | |
| .yCbCrRange = wgpu::ColorSpaceYCbCrRangeDawn::Identity, | |
| .yCbCrMatrix = wgpu::ColorSpaceYCbCrMatrixDawn::Identity, | |
| }, | |
| wgpu::PredefinedColorSpace::SRGBLinear, ¶ms); | |
| DAWN_ASSERT(status == wgpu::Status::Success); | |
| return params; | |
| } | |
| } // namespace dawn |