encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

CopyTextureForBrowser: Support display p3 to Srgb color space conversion 

This CL add color space conversion bases for CopyTextureForBrowser.
Theoretically, it could support any color space conversion. But
test cases only cover (Srgb, DisplayP3) to (Srgb).
It could be expanded to more color spaces conversions.

Bug: dawn:1140
Change-Id: I332e6d1f7cf2424fd5f5af83c71fa45c98d2d8ac
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/70780
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Kai Ninomiya <kainino@chromium.org>
Commit-Queue: Shaobo Yan <shaobo.yan@intel.com>
This commit is contained in:
Yan 2021-12-14 04:51:45 +00:00 committed by Dawn LUCI CQ
parent fa2d418ee6
commit 483bead0e2
5 changed files with 827 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
dawn.json
View File

@ -857,20 +857,40 @@
}, },
"alpha op": { "alpha op": {
"category": "enum", "category": "enum",
"tags": ["dawn"], "tags": ["deprecated"],
"values": [ "values": [
{"value": 0, "name": "dont change"}, {"value": 0, "name": "dont change"},
{"value": 1, "name": "premultiply"}, {"value": 1, "name": "premultiply"},
{"value": 2, "name": "unpremultiply"} {"value": 2, "name": "unpremultiply"}
] ]
}, },
"alpha mode": {
"category": "enum",
"tags": ["dawn"],
"values": [
{"value": 0, "name": "premultiplied"},
{"value": 1, "name": "unpremultiplied"}
]
},
"copy texture for browser options": { "copy texture for browser options": {
"category": "structure", "category": "structure",
"extensible": "in", "extensible": "in",
"tags": ["dawn"], "tags": ["dawn"],
"_TODO": "support number as length input",
"members": [ "members": [
{"name": "flipY", "type": "bool", "default": "false"}, {"name": "flip y", "type": "bool", "default": "false"},
{"name": "alphaOp", "type": "alpha op", "default": "dont change"} {"name": "alpha op", "type": "alpha op", "default": "dont change", "tags": ["deprecated"]},
{"name": "needs color space conversion", "type": "bool", "default": "false"},
{"name": "src alpha mode", "type": "alpha mode", "default": "unpremultiplied"},
{"name": "transfer function parameters count", "type": "uint32_t", "default": "0"},
{"name": "src transfer function parameters", "type": "float", "annotation": "const*",
"length": "transfer function parameters count", "default": "nullptr"},
{"name": "conversion matrix elements count", "type": "uint32_t", "default": "0"},
{"name": "conversion matrix", "type": "float", "annotation": "const*",
"length": "conversion matrix elements count", "default": "nullptr"},
{"name": "dst transfer function parameters", "type": "float", "annotation": "const*",
"length": "transfer function parameters count", "default": "nullptr"},
{"name": "dst alpha mode", "type": "alpha mode", "default": "unpremultiplied"}
] ]
}, },
"create compute pipeline async callback": { "create compute pipeline async callback": {

251
src/dawn_native/CopyTextureForBrowserHelper.cpp
View File

@ -14,6 +14,7 @@
#include "dawn_native/CopyTextureForBrowserHelper.h" #include "dawn_native/CopyTextureForBrowserHelper.h"
#include "common/Log.h"
#include "dawn_native/BindGroup.h" #include "dawn_native/BindGroup.h"
#include "dawn_native/BindGroupLayout.h" #include "dawn_native/BindGroupLayout.h"
#include "dawn_native/Buffer.h" #include "dawn_native/Buffer.h"
@ -36,10 +37,25 @@ namespace dawn_native {
namespace { namespace {
static const char sCopyTextureForBrowserShader[] = R"( static const char sCopyTextureForBrowserShader[] = R"(
[[block]] struct Uniforms { struct GammaTransferParams {
u_scale: vec2<f32>; G: f32;
u_offset: vec2<f32>; A: f32;
u_alphaOp: u32; B: f32;
C: f32;
D: f32;
E: f32;
F: f32;
padding: u32;
};
[[block]] struct Uniforms { // offset align size
scale: vec2<f32>; // 0 8 8
offset: vec2<f32>; // 8 8 8
steps_mask: u32; // 16 4 4
// implicit padding; // 20 12
conversion_matrix: mat3x3<f32>; // 32 16 48
gamma_decoding_params: GammaTransferParams; // 80 4 32
gamma_encoding_params: GammaTransferParams; // 112 4 32
}; };
[[binding(0), group(0)]] var<uniform> uniforms : Uniforms; [[binding(0), group(0)]] var<uniform> uniforms : Uniforms;
@ -49,7 +65,26 @@ namespace dawn_native {
[[builtin(position)]] position : vec4<f32>; [[builtin(position)]] position : vec4<f32>;
}; };
[[stage(vertex)]] fn vs_main( // Chromium uses unified equation to construct gamma decoding function
// and gamma encoding function.
// The logic is:
// if x < D
// linear = C * x + F
// nonlinear = pow(A * x + B, G) + E
// (https://source.chromium.org/chromium/chromium/src/+/main:ui/gfx/color_transform.cc;l=541)
// Expand the equation with sign() to make it handle all gamma conversions.
fn gamma_conversion(v: f32, params: GammaTransferParams) -> f32 {
// Linear part: C * x + F
if (abs(v) < params.D) {
return sign(v) * (params.C * abs(v) + params.F);
}
// Gamma part: pow(A * x + B, G) + E
return sign(v) * (pow(params.A * abs(v) + params.B, params.G) + params.E);
}
[[stage(vertex)]]
fn vs_main(
[[builtin(vertex_index)]] VertexIndex : u32 [[builtin(vertex_index)]] VertexIndex : u32
) -> VertexOutputs { ) -> VertexOutputs {
var texcoord = array<vec2<f32>, 3>( var texcoord = array<vec2<f32>, 3>(
@ -62,7 +97,7 @@ namespace dawn_native {
// Y component of scale is calculated by the copySizeHeight / textureHeight. Only // Y component of scale is calculated by the copySizeHeight / textureHeight. Only
// flipY case can get negative number. // flipY case can get negative number.
var flipY = uniforms.u_scale.y < 0.0; var flipY = uniforms.scale.y < 0.0;
// Texture coordinate takes top-left as origin point. We need to map the // Texture coordinate takes top-left as origin point. We need to map the
// texture to triangle carefully. // texture to triangle carefully.
@ -70,14 +105,14 @@ namespace dawn_native {
// We need to get the mirror positions(mirrored based on y = 0.5) on flip cases. // We need to get the mirror positions(mirrored based on y = 0.5) on flip cases.
// Adopt transform to src texture and then mapping it to triangle coord which // Adopt transform to src texture and then mapping it to triangle coord which
// do a +1 shift on Y dimension will help us got that mirror position perfectly. // do a +1 shift on Y dimension will help us got that mirror position perfectly.
output.texcoords = (texcoord[VertexIndex] * uniforms.u_scale + uniforms.u_offset) * output.texcoords = (texcoord[VertexIndex] * uniforms.scale + uniforms.offset) *
vec2<f32>(1.0, -1.0) + vec2<f32>(0.0, 1.0); vec2<f32>(1.0, -1.0) + vec2<f32>(0.0, 1.0);
} else { } else {
// For the normal case, we need to get the exact position. // For the normal case, we need to get the exact position.
// So mapping texture to triangle firstly then adopt the transform. // So mapping texture to triangle firstly then adopt the transform.
output.texcoords = (texcoord[VertexIndex] * output.texcoords = (texcoord[VertexIndex] *
vec2<f32>(1.0, -1.0) + vec2<f32>(0.0, 1.0)) * vec2<f32>(1.0, -1.0) + vec2<f32>(0.0, 1.0)) *
uniforms.u_scale + uniforms.u_offset; uniforms.scale + uniforms.offset;
} }
return output; return output;
@ -86,7 +121,8 @@ namespace dawn_native {
[[binding(1), group(0)]] var mySampler: sampler; [[binding(1), group(0)]] var mySampler: sampler;
[[binding(2), group(0)]] var myTexture: texture_2d<f32>; [[binding(2), group(0)]] var myTexture: texture_2d<f32>;
[[stage(fragment)]] fn fs_main( [[stage(fragment)]]
fn fs_main(
[[location(0)]] texcoord : vec2<f32> [[location(0)]] texcoord : vec2<f32>
) -> [[location(0)]] vec4<f32> { ) -> [[location(0)]] vec4<f32> {
// Clamp the texcoord and discard the out-of-bound pixels. // Clamp the texcoord and discard the out-of-bound pixels.
@ -98,45 +134,81 @@ namespace dawn_native {
// Swizzling of texture formats when sampling / rendering is handled by the // Swizzling of texture formats when sampling / rendering is handled by the
// hardware so we don't need special logic in this shader. This is covered by tests. // hardware so we don't need special logic in this shader. This is covered by tests.
var srcColor = textureSample(myTexture, mySampler, texcoord); var color = textureSample(myTexture, mySampler, texcoord);
// Handle alpha. Alpha here helps on the source content and dst content have let kUnpremultiplyStep = 0x01u;
// different alpha config. There are three possible ops: DontChange, Premultiply let kDecodeToLinearStep = 0x02u;
// and Unpremultiply. let kConvertToDstGamutStep = 0x04u;
// TODO(crbug.com/1217153): if wgsl support `constexpr` and allow it let kEncodeToGammaStep = 0x08u;
// to be case selector, Replace 0u/1u/2u with a constexpr variable with let kPremultiplyStep = 0x10u;
// meaningful name.
switch(uniforms.u_alphaOp) { // Unpremultiply step. Appling color space conversion op on premultiplied source texture
case 0u: { // AlphaOp: DontChange // also needs to unpremultiply first.
break; if (bool(uniforms.steps_mask & kUnpremultiplyStep)) {
} if (color.a != 0.0) {
case 1u: { // AlphaOp: Premultiply color = vec4<f32>(color.rgb / color.a, color.a);
srcColor = vec4<f32>(srcColor.rgb * srcColor.a, srcColor.a);
break;
}
case 2u: { // AlphaOp: Unpremultiply
if (srcColor.a != 0.0) {
srcColor = vec4<f32>(srcColor.rgb / srcColor.a, srcColor.a);
}
break;
}
default: {
break;
} }
} }
return srcColor; // Linearize the source color using the source color space’s
// transfer function if it is non-linear.
if (bool(uniforms.steps_mask & kDecodeToLinearStep)) {
color = vec4<f32>(gamma_conversion(color.r, uniforms.gamma_decoding_params),
gamma_conversion(color.g, uniforms.gamma_decoding_params),
gamma_conversion(color.b, uniforms.gamma_decoding_params),
color.a);
}
// Convert unpremultiplied, linear source colors to the destination gamut by
// multiplying by a 3x3 matrix. Calculate transformFromXYZD50 * transformToXYZD50
// in CPU side and upload the final result in uniforms.
if (bool(uniforms.steps_mask & kConvertToDstGamutStep)) {
color = vec4<f32>(uniforms.conversion_matrix * color.rgb, color.a);
}
// Encode that color using the inverse of the destination color
// space’s transfer function if it is non-linear.
if (bool(uniforms.steps_mask & kEncodeToGammaStep)) {
color = vec4<f32>(gamma_conversion(color.r, uniforms.gamma_encoding_params),
gamma_conversion(color.g, uniforms.gamma_encoding_params),
gamma_conversion(color.b, uniforms.gamma_encoding_params),
color.a);
}
// Premultiply step.
if (bool(uniforms.steps_mask & kPremultiplyStep)) {
color = vec4<f32>(color.rgb * color.a, color.a);
}
return color;
} }
)"; )";
// Follow the same order of skcms_TransferFunction
// https://source.chromium.org/chromium/chromium/src/+/main:third_party/skia/include/third_party/skcms/skcms.h;l=46;
struct GammaTransferParams {
float G = 0.0;
float A = 0.0;
float B = 0.0;
float C = 0.0;
float D = 0.0;
float E = 0.0;
float F = 0.0;
uint32_t padding = 0;
};
struct Uniform { struct Uniform {
float scaleX; float scaleX;
float scaleY; float scaleY;
float offsetX; float offsetX;
float offsetY; float offsetY;
wgpu::AlphaOp alphaOp; uint32_t stepsMask = 0;
const std::array<uint32_t, 3> padding = {}; // 12 bytes padding
std::array<float, 12> conversionMatrix = {};
GammaTransferParams gammaDecodingParams = {};
GammaTransferParams gammaEncodingParams = {};
}; };
static_assert(sizeof(Uniform) == 20, ""); static_assert(sizeof(Uniform) == 144, "");
// TODO(crbug.com/dawn/856): Expand copyTextureForBrowser to support any // TODO(crbug.com/dawn/856): Expand copyTextureForBrowser to support any
// non-depth, non-stencil, non-compressed texture format pair copy. Now this API // non-depth, non-stencil, non-compressed texture format pair copy. Now this API
@ -232,7 +304,6 @@ namespace dawn_native {
return GetCachedPipeline(store, dstFormat); return GetCachedPipeline(store, dstFormat);
} }
} // anonymous namespace } // anonymous namespace
MaybeError ValidateCopyTextureForBrowser(DeviceBase* device, MaybeError ValidateCopyTextureForBrowser(DeviceBase* device,
@ -276,7 +347,27 @@ namespace dawn_native {
destination->texture->GetFormat().format)); destination->texture->GetFormat().format));
DAWN_INVALID_IF(options->nextInChain != nullptr, "nextInChain must be nullptr"); DAWN_INVALID_IF(options->nextInChain != nullptr, "nextInChain must be nullptr");
// TODO(crbug.com/dawn/1140): Remove alphaOp and wgpu::AlphaState::DontChange.
DAWN_TRY(ValidateAlphaOp(options->alphaOp)); DAWN_TRY(ValidateAlphaOp(options->alphaOp));
DAWN_TRY(ValidateAlphaMode(options->srcAlphaMode));
DAWN_TRY(ValidateAlphaMode(options->dstAlphaMode));
if (options->needsColorSpaceConversion) {
DAWN_INVALID_IF(options->transferFunctionParametersCount != 7u,
"Invalid transfer"
" function parameter count (%u).",
options->transferFunctionParametersCount);
DAWN_INVALID_IF(options->conversionMatrixElementsCount != 9u,
"Invalid conversion matrix elements count (%u).",
options->conversionMatrixElementsCount);
DAWN_INVALID_IF(options->srcTransferFunctionParameters == nullptr,
"srcTransferFunctionParameters is nullptr when doing color conversion");
DAWN_INVALID_IF(options->conversionMatrix == nullptr,
"conversionMatrix is nullptr when doing color conversion");
DAWN_INVALID_IF(options->dstTransferFunctionParameters == nullptr,
"dstTransferFunctionParameters is nullptr when doing color conversion");
}
return {}; return {};
} }
@ -309,8 +400,7 @@ namespace dawn_native {
copySize->width / static_cast<float>(srcTextureSize.width), copySize->width / static_cast<float>(srcTextureSize.width),
copySize->height / static_cast<float>(srcTextureSize.height), // scale copySize->height / static_cast<float>(srcTextureSize.height), // scale
source->origin.x / static_cast<float>(srcTextureSize.width), source->origin.x / static_cast<float>(srcTextureSize.width),
source->origin.y / static_cast<float>(srcTextureSize.height), // offset source->origin.y / static_cast<float>(srcTextureSize.height) // offset
wgpu::AlphaOp::DontChange // alphaOp default value: DontChange
}; };
// Handle flipY. FlipY here means we flip the source texture firstly and then // Handle flipY. FlipY here means we flip the source texture firstly and then
@ -321,8 +411,89 @@ namespace dawn_native {
uniformData.offsetY += copySize->height / static_cast<float>(srcTextureSize.height); uniformData.offsetY += copySize->height / static_cast<float>(srcTextureSize.height);
} }
// Set alpha op. uint32_t stepsMask = 0u;
uniformData.alphaOp = options->alphaOp;
// Steps to do color space conversion
// From https://skia.org/docs/user/color/
// - unpremultiply if the source color is premultiplied; Alpha is not involved in color
// management, and we need to divide it out if it’s multiplied in.
// - linearize the source color using the source color space’s transfer function
// - convert those unpremultiplied, linear source colors to XYZ D50 gamut by multiplying by
// a 3x3 matrix.
// - convert those XYZ D50 colors to the destination gamut by multiplying by a 3x3 matrix.
// - encode that color using the inverse of the destination color space’s transfer function.
// - premultiply by alpha if the destination is premultiplied.
// The reason to choose XYZ D50 as intermediate color space:
// From http://www.brucelindbloom.com/index.html?WorkingSpaceInfo.html
// "Since the Lab TIFF specification, the ICC profile specification and
// Adobe Photoshop all use a D50"
constexpr uint32_t kUnpremultiplyStep = 0x01;
constexpr uint32_t kDecodeToLinearStep = 0x02;
constexpr uint32_t kConvertToDstGamutStep = 0x04;
constexpr uint32_t kEncodeToGammaStep = 0x08;
constexpr uint32_t kPremultiplyStep = 0x10;
if (options->srcAlphaMode == wgpu::AlphaMode::Premultiplied) {
if (options->needsColorSpaceConversion ||
options->srcAlphaMode != options->dstAlphaMode) {
stepsMask |= kUnpremultiplyStep;
}
}
if (options->needsColorSpaceConversion) {
stepsMask |= kDecodeToLinearStep;
const float* decodingParams = options->srcTransferFunctionParameters;
uniformData.gammaDecodingParams = {
decodingParams[0], decodingParams[1], decodingParams[2], decodingParams[3],
decodingParams[4], decodingParams[5], decodingParams[6]};
stepsMask |= kConvertToDstGamutStep;
const float* matrix = options->conversionMatrix;
uniformData.conversionMatrix = {{
matrix[0],
matrix[1],
matrix[2],
0.0,
matrix[3],
matrix[4],
matrix[5],
0.0,
matrix[6],
matrix[7],
matrix[8],
0.0,
}};
stepsMask |= kEncodeToGammaStep;
const float* encodingParams = options->dstTransferFunctionParameters;
uniformData.gammaEncodingParams = {
encodingParams[0], encodingParams[1], encodingParams[2], encodingParams[3],
encodingParams[4], encodingParams[5], encodingParams[6]};
}
if (options->dstAlphaMode == wgpu::AlphaMode::Premultiplied) {
if (options->needsColorSpaceConversion ||
options->srcAlphaMode != options->dstAlphaMode) {
stepsMask |= kPremultiplyStep;
}
}
if (options->alphaOp != wgpu::AlphaOp::DontChange) {
dawn::WarningLog() << "CopyTextureForBrowserOption.alphaOp has been deprecated.";
}
// TODO(crbugs.com/dawn/1140): AlphaOp will be deprecated
if (options->alphaOp == wgpu::AlphaOp::Premultiply) {
stepsMask |= kPremultiplyStep;
}
if (options->alphaOp == wgpu::AlphaOp::Unpremultiply) {
stepsMask |= kUnpremultiplyStep;
}
uniformData.stepsMask = stepsMask;
Ref<BufferBase> uniformBuffer; Ref<BufferBase> uniformBuffer;
DAWN_TRY_ASSIGN( DAWN_TRY_ASSIGN(

28
src/tests/DawnTest.h
View File

@ -25,6 +25,7 @@
#include "tests/ParamGenerator.h" #include "tests/ParamGenerator.h"
#include "tests/ToggleParser.h" #include "tests/ToggleParser.h"
#include "utils/ScopedAutoreleasePool.h" #include "utils/ScopedAutoreleasePool.h"
#include "utils/TextureUtils.h"
#include <dawn_platform/DawnPlatform.h> #include <dawn_platform/DawnPlatform.h>
#include <gmock/gmock.h> #include <gmock/gmock.h>
@ -95,6 +96,9 @@
#define EXPECT_TEXTURE_EQ(...) AddTextureExpectation(__FILE__, __LINE__, __VA_ARGS__) #define EXPECT_TEXTURE_EQ(...) AddTextureExpectation(__FILE__, __LINE__, __VA_ARGS__)
#define EXPECT_TEXTURE_FLOAT16_EQ(...) \
AddTextureExpectation<float, uint16_t>(__FILE__, __LINE__, __VA_ARGS__)
#define ASSERT_DEVICE_ERROR_MSG(statement, matcher) \ #define ASSERT_DEVICE_ERROR_MSG(statement, matcher) \
StartExpectDeviceError(matcher); \ StartExpectDeviceError(matcher); \
statement; \ statement; \
@ -353,6 +357,30 @@ class DawnTestBase {
// T - expected value Type // T - expected value Type
// U - actual value Type (defaults = T) // U - actual value Type (defaults = T)
template <typename T, typename U = T>
std::ostringstream& AddTextureExpectation(const char* file,
int line,
const T* expectedData,
const wgpu::Texture& texture,
wgpu::Origin3D origin,
wgpu::Extent3D extent,
wgpu::TextureFormat format,
T tolerance = 0,
uint32_t level = 0,
wgpu::TextureAspect aspect = wgpu::TextureAspect::All,
uint32_t bytesPerRow = 0) {
uint32_t texelBlockSize = utils::GetTexelBlockSizeInBytes(format);
uint32_t texelComponentCount = utils::GetWGSLRenderableColorTextureComponentCount(format);
return AddTextureExpectationImpl(
file, line,
new detail::ExpectEq<T, U>(
expectedData,
texelComponentCount * extent.width * extent.height * extent.depthOrArrayLayers,
tolerance),
texture, origin, extent, level, aspect, texelBlockSize, bytesPerRow);
}
template <typename T, typename U = T> template <typename T, typename U = T>
std::ostringstream& AddTextureExpectation(const char* file, std::ostringstream& AddTextureExpectation(const char* file,
int line, int line,

439
src/tests/end2end/CopyTextureForBrowserTests.cpp
View File

@ -28,6 +28,11 @@ namespace {
static constexpr uint64_t kDefaultTextureWidth = 10; static constexpr uint64_t kDefaultTextureWidth = 10;
static constexpr uint64_t kDefaultTextureHeight = 1; static constexpr uint64_t kDefaultTextureHeight = 1;
enum class ColorSpace : uint32_t {
SRGB = 0x00,
DisplayP3 = 0x01,
};
using Alpha = wgpu::AlphaOp; using Alpha = wgpu::AlphaOp;
DAWN_TEST_PARAM_STRUCT(AlphaTestParams, Alpha); DAWN_TEST_PARAM_STRUCT(AlphaTestParams, Alpha);
@ -37,6 +42,10 @@ namespace {
using DstOrigin = wgpu::Origin3D; using DstOrigin = wgpu::Origin3D;
using CopySize = wgpu::Extent3D; using CopySize = wgpu::Extent3D;
using FlipY = bool; using FlipY = bool;
using SrcColorSpace = ColorSpace;
using DstColorSpace = ColorSpace;
using SrcAlphaMode = wgpu::AlphaMode;
using DstAlphaMode = wgpu::AlphaMode;
std::ostream& operator<<(std::ostream& o, wgpu::Origin3D origin) { std::ostream& operator<<(std::ostream& o, wgpu::Origin3D origin) {
o << origin.x << ", " << origin.y << ", " << origin.z; o << origin.x << ", " << origin.y << ", " << origin.z;
@ -48,9 +57,98 @@ namespace {
return o; return o;
} }
std::ostream& operator<<(std::ostream& o, ColorSpace space) {
o << static_cast<uint32_t>(space);
return o;
}
DAWN_TEST_PARAM_STRUCT(FormatTestParams, SrcFormat, DstFormat); DAWN_TEST_PARAM_STRUCT(FormatTestParams, SrcFormat, DstFormat);
DAWN_TEST_PARAM_STRUCT(SubRectTestParams, SrcOrigin, DstOrigin, CopySize, FlipY); DAWN_TEST_PARAM_STRUCT(SubRectTestParams, SrcOrigin, DstOrigin, CopySize, FlipY);
DAWN_TEST_PARAM_STRUCT(ColorSpaceTestParams,
DstFormat,
SrcColorSpace,
DstColorSpace,
SrcAlphaMode,
DstAlphaMode);
// Color Space table
struct ColorSpaceInfo {
ColorSpace index;
std::array<float, 9> toXYZD50; // 3x3 row major transform matrix
std::array<float, 9> fromXYZD50; // inverse transform matrix of toXYZD50, precomputed
std::array<float, 7> gammaDecodingParams; // Follow { A, B, G, E, epsilon, C, F } order
std::array<float, 7> gammaEncodingParams; // inverse op of decoding, precomputed
bool isNonLinear;
bool isExtended; // For extended color space.
};
static constexpr size_t kSupportedColorSpaceCount = 2;
static constexpr std::array<ColorSpaceInfo, kSupportedColorSpaceCount> ColorSpaceTable = {{
// sRGB,
// Got primary attributes from https://drafts.csswg.org/css-color/#predefined-sRGB
// Use matrices from
// http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html#WSMatrices
// Get gamma-linear conversion params from https://en.wikipedia.org/wiki/SRGB with some
// mathematics.
{
//
ColorSpace::SRGB,
{{
//
0.4360747, 0.3850649, 0.1430804, //
0.2225045, 0.7168786, 0.0606169, //
0.0139322, 0.0971045, 0.7141733 //
}},
{{
//
3.1338561, -1.6168667, -0.4906146, //
-0.9787684, 1.9161415, 0.0334540, //
0.0719453, -0.2289914, 1.4052427 //
}},
// {G, A, B, C, D, E, F, }
{{2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 4.045e-02, 0.0, 0.0}},
{{1.0 / 2.4, 1.13711 /*pow(1.055, 2.4)*/, 0.0, 12.92f, 3.1308e-03, -0.055, 0.0}},
true,
true //
},
// Display P3, got primary attributes from
// https://www.w3.org/TR/css-color-4/#valdef-color-display-p3
// Use equations found in
// http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html,
// Use Bradford method to do D65 to D50 transform.
// Get matrices with help of http://www.russellcottrell.com/photo/matrixCalculator.htm
// Gamma-linear conversion params is the same as Srgb.
{
//
ColorSpace::DisplayP3,
{{
//
0.5151114, 0.2919612, 0.1571274, //
0.2411865, 0.6922440, 0.0665695, //
-0.0010491, 0.0418832, 0.7842659 //
}},
{{
//
2.4039872, -0.9898498, -0.3976181, //
-0.8422138, 1.7988188, 0.0160511, //
0.0481937, -0.0973889, 1.2736887 //
}},
// {G, A, B, C, D, E, F, }
{{2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 4.045e-02, 0.0, 0.0}},
{{1.0 / 2.4, 1.13711 /*pow(1.055, 2.4)*/, 0.0, 12.92f, 3.1308e-03, -0.055, 0.0}},
true,
false //
}
//
}};
} // anonymous namespace } // anonymous namespace
template <typename Parent> template <typename Parent>
@ -578,21 +676,323 @@ class CopyTextureForBrowser_AlphaOps
} }
}; };
class CopyTextureForBrowser_ColorSpace
: public CopyTextureForBrowserTests<DawnTestWithParams<ColorSpaceTestParams>> {
protected:
const ColorSpaceInfo& GetColorSpaceInfo(ColorSpace colorSpace) {
uint32_t index = static_cast<uint32_t>(colorSpace);
ASSERT(index < ColorSpaceTable.size());
ASSERT(ColorSpaceTable[index].index == colorSpace);
return ColorSpaceTable[index];
}
std::array<float, 9> GetConversionMatrix(ColorSpace src, ColorSpace dst) {
const ColorSpaceInfo& srcColorSpace = GetColorSpaceInfo(src);
const ColorSpaceInfo& dstColorSpace = GetColorSpaceInfo(dst);
const std::array<float, 9> toXYZD50 = srcColorSpace.toXYZD50;
const std::array<float, 9> fromXYZD50 = dstColorSpace.fromXYZD50;
// Fuse the transform matrix. The color space transformation equation is:
// Pixels = fromXYZD50 * toXYZD50 * Pixels.
// Calculate fromXYZD50 * toXYZD50 to simplify
// Add a padding in each row for Mat3x3 in wgsl uniform(mat3x3, Align(16), Size(48)).
std::array<float, 9> fuseMatrix = {};
// Mat3x3 * Mat3x3
for (uint32_t row = 0; row < 3; ++row) {
for (uint32_t col = 0; col < 3; ++col) {
// Transpose the matrix from row major to column major for wgsl.
fuseMatrix[col * 3 + row] = fromXYZD50[row * 3 + 0] * toXYZD50[col] +
fromXYZD50[row * 3 + 1] * toXYZD50[3 + col] +
fromXYZD50[row * 3 + 2] * toXYZD50[3 * 2 + col];
}
}
return fuseMatrix;
}
// TODO(crbug.com/dawn/1140): Generate source data automatically.
std::vector<RGBA8> GetSourceData(wgpu::AlphaMode srcTextureAlphaMode) {
if (srcTextureAlphaMode == wgpu::AlphaMode::Premultiplied) {
return std::vector<RGBA8>{
RGBA8(0, 102, 102, 102), // a = 0.4
RGBA8(102, 0, 0, 102), // a = 0.4
RGBA8(153, 0, 0, 153), // a = 0.6
RGBA8(255, 0, 0, 255), // a = 1.0
RGBA8(153, 0, 153, 153), // a = 0.6
RGBA8(0, 102, 0, 102), // a = 0.4
RGBA8(0, 153, 0, 153), // a = 0.6
RGBA8(0, 255, 0, 255), // a = 1.0
RGBA8(255, 255, 0, 255), // a = 1.0
RGBA8(0, 0, 102, 102), // a = 0.4
RGBA8(0, 0, 153, 153), // a = 0.6
RGBA8(0, 0, 255, 255), // a = 1.0
};
}
return std::vector<RGBA8>{
// Take RGBA8Unorm as example:
// R channel has different values
RGBA8(0, 255, 255, 255), // r = 0.0
RGBA8(102, 0, 0, 255), // r = 0.4
RGBA8(153, 0, 0, 255), // r = 0.6
RGBA8(255, 0, 0, 255), // r = 1.0
// G channel has different values
RGBA8(255, 0, 255, 255), // g = 0.0
RGBA8(0, 102, 0, 255), // g = 0.4
RGBA8(0, 153, 0, 255), // g = 0.6
RGBA8(0, 255, 0, 255), // g = 1.0
// B channel has different values
RGBA8(255, 255, 0, 255), // b = 0.0
RGBA8(0, 0, 102, 255), // b = 0.4
RGBA8(0, 0, 153, 255), // b = 0.6
RGBA8(0, 0, 255, 255), // b = 1.0
};
}
// TODO(crbug.com/dawn/1140): Current expected values are from ColorSync utils
// tool on Mac. Should implement CPU or compute shader algorithm to do color
// conversion and use the result as expected data.
std::vector<float> GetExpectedData(ColorSpace srcColorSpace,
ColorSpace dstColorSpace,
wgpu::AlphaMode srcTextureAlphaMode,
wgpu::AlphaMode dstTextureAlphaMode) {
if (srcTextureAlphaMode == wgpu::AlphaMode::Premultiplied) {
return GetExpectedDataForPremultipliedSource(srcColorSpace, dstColorSpace,
dstTextureAlphaMode);
}
return GetExpectedDataForSeperateSource(srcColorSpace, dstColorSpace);
}
std::vector<float> GeneratePremultipliedResult(std::vector<float> result) {
// Four channels per pixel
for (uint32_t i = 0; i < result.size(); i += 4) {
result[i] *= result[i + 3];
result[i + 1] *= result[i + 3];
result[i + 2] *= result[i + 3];
}
return result;
}
std::vector<float> GetExpectedDataForPremultipliedSource(ColorSpace srcColorSpace,
ColorSpace dstColorSpace,
wgpu::AlphaMode dstTextureAlphaMode) {
if (srcColorSpace == dstColorSpace) {
std::vector<float> expected = {
0.0, 1.0, 1.0, 0.4, //
1.0, 0.0, 0.0, 0.4, //
1.0, 0.0, 0.0, 0.6, //
1.0, 0.0, 0.0, 1.0, //
1.0, 0.0, 1.0, 0.6, //
0.0, 1.0, 0.0, 0.4, //
0.0, 1.0, 0.0, 0.6, //
0.0, 1.0, 0.0, 1.0, //
1.0, 1.0, 0.0, 1.0, //
0.0, 0.0, 1.0, 0.4, //
0.0, 0.0, 1.0, 0.6, //
0.0, 0.0, 1.0, 1.0, //
};
return dstTextureAlphaMode == wgpu::AlphaMode::Premultiplied
? GeneratePremultipliedResult(expected)
: expected;
}
switch (srcColorSpace) {
case ColorSpace::DisplayP3: {
switch (dstColorSpace) {
case ColorSpace::SRGB: {
std::vector<float> expected = {
-0.5118, 1.0183, 1.0085, 0.4, //
1.093, -0.2267, -0.1501, 0.4, //
1.093, -0.2267, -0.1501, 0.6, //
1.093, -0.2267, -0.1501, 1.0, //
1.093, -0.2266, 1.0337, 0.6, //
-0.5118, 1.0183, -0.3107, 0.4, //
-0.5118, 1.0183, -0.3107, 0.6, //
-0.5118, 1.0183, -0.3107, 1.0, //
0.9999, 1.0001, -0.3462, 1.0, //
0.0002, 0.0004, 1.0419, 0.4, //
0.0002, 0.0004, 1.0419, 0.6, //
0.0002, 0.0004, 1.0419, 1.0, //
};
return dstTextureAlphaMode == wgpu::AlphaMode::Premultiplied
? GeneratePremultipliedResult(expected)
: expected;
}
default:
UNREACHABLE();
}
}
default:
break;
}
UNREACHABLE();
}
std::vector<float> GetExpectedDataForSeperateSource(ColorSpace srcColorSpace,
ColorSpace dstColorSpace) {
if (srcColorSpace == dstColorSpace) {
return std::vector<float>{
0.0, 1.0, 1.0, 1.0, //
0.4, 0.0, 0.0, 1.0, //
0.6, 0.0, 0.0, 1.0, //
1.0, 0.0, 0.0, 1.0, //
1.0, 0.0, 1.0, 1.0, //
0.0, 0.4, 0.0, 1.0, //
0.0, 0.6, 0.0, 1.0, //
0.0, 1.0, 0.0, 1.0, //
1.0, 1.0, 0.0, 1.0, //
0.0, 0.0, 0.4, 1.0, //
0.0, 0.0, 0.6, 1.0, //
0.0, 0.0, 1.0, 1.0, //
};
}
switch (srcColorSpace) {
case ColorSpace::DisplayP3: {
switch (dstColorSpace) {
case ColorSpace::SRGB: {
return std::vector<float>{
-0.5118, 1.0183, 1.0085, 1.0, //
0.4401, -0.0665, -0.0337, 1.0, //
0.6578, -0.1199, -0.0723, 1.0, //
1.093, -0.2267, -0.1501, 1.0, //
1.093, -0.2266, 1.0337, 1.0, //
-0.1894, 0.4079, -0.1027, 1.0, //
-0.2969, 0.6114, -0.1720, 1.0, //
-0.5118, 1.0183, -0.3107, 1.0, //
0.9999, 1.0001, -0.3462, 1.0, //
0.0000, 0.0001, 0.4181, 1.0, //
0.0001, 0.0001, 0.6260, 1.0, //
0.0002, 0.0004, 1.0419, 1.0, //
};
}
default:
UNREACHABLE();
}
}
default:
break;
}
UNREACHABLE();
}
void DoColorSpaceConversionTest() {
constexpr uint32_t kWidth = 12;
constexpr uint32_t kHeight = 1;
TextureSpec srcTextureSpec;
srcTextureSpec.textureSize = {kWidth, kHeight};
TextureSpec dstTextureSpec;
dstTextureSpec.textureSize = {kWidth, kHeight};
dstTextureSpec.format = GetParam().mDstFormat;
ColorSpace srcColorSpace = GetParam().mSrcColorSpace;
ColorSpace dstColorSpace = GetParam().mDstColorSpace;
ColorSpaceInfo srcColorSpaceInfo = GetColorSpaceInfo(srcColorSpace);
ColorSpaceInfo dstColorSpaceInfo = GetColorSpaceInfo(dstColorSpace);
std::array<float, 9> matrix = GetConversionMatrix(srcColorSpace, dstColorSpace);
wgpu::CopyTextureForBrowserOptions options = {};
options.needsColorSpaceConversion = srcColorSpace != dstColorSpace;
options.srcAlphaMode = GetParam().mSrcAlphaMode;
options.transferFunctionParametersCount = 7;
options.srcTransferFunctionParameters = srcColorSpaceInfo.gammaDecodingParams.data();
options.conversionMatrixElementsCount = 9;
options.conversionMatrix = matrix.data();
options.dstTransferFunctionParameters = dstColorSpaceInfo.gammaEncodingParams.data();
options.dstAlphaMode = GetParam().mDstAlphaMode;
std::vector<RGBA8> sourceTextureData = GetSourceData(options.srcAlphaMode);
const wgpu::Extent3D& copySize = {kWidth, kHeight};
const utils::TextureDataCopyLayout srcCopyLayout =
utils::GetTextureDataCopyLayoutForTextureAtLevel(
kTextureFormat,
{srcTextureSpec.textureSize.width, srcTextureSpec.textureSize.height},
srcTextureSpec.level);
wgpu::TextureUsage srcUsage = wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst |
wgpu::TextureUsage::TextureBinding;
wgpu::Texture srcTexture = this->CreateAndInitTexture(
srcTextureSpec, srcUsage, srcCopyLayout, sourceTextureData.data(),
sourceTextureData.size() * sizeof(RGBA8));
// Create dst texture.
wgpu::Texture dstTexture = this->CreateTexture(
dstTextureSpec, wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::TextureBinding |
wgpu::TextureUsage::RenderAttachment | wgpu::TextureUsage::CopySrc);
// Perform the texture to texture copy
this->RunCopyExternalImageToTexture(srcTextureSpec, srcTexture, dstTextureSpec, dstTexture,
copySize, options);
std::vector<float> expectedData = GetExpectedData(
srcColorSpace, dstColorSpace, options.srcAlphaMode, options.dstAlphaMode);
// The value provided by Apple's ColorSync Utility.
float tolerance = 0.001;
if (dstTextureSpec.format == wgpu::TextureFormat::RGBA16Float) {
EXPECT_TEXTURE_FLOAT16_EQ(expectedData.data(), dstTexture, {0, 0}, {kWidth, kHeight},
dstTextureSpec.format, tolerance);
} else {
EXPECT_TEXTURE_EQ(expectedData.data(), dstTexture, {0, 0}, {kWidth, kHeight},
dstTextureSpec.format, tolerance);
}
}
};
// Verify CopyTextureForBrowserTests works with internal pipeline. // Verify CopyTextureForBrowserTests works with internal pipeline.
// The case do copy without any transform. // The case do copy without any transform.
TEST_P(CopyTextureForBrowser_Basic, PassthroughCopy) { TEST_P(CopyTextureForBrowser_Basic, PassthroughCopy) {
// TODO(crbug.com/dawn/1232): Program link error on OpenGLES backend
DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
DoBasicCopyTest({10, 1}); DoBasicCopyTest({10, 1});
} }
TEST_P(CopyTextureForBrowser_Basic, VerifyCopyOnXDirection) { TEST_P(CopyTextureForBrowser_Basic, VerifyCopyOnXDirection) {
// TODO(crbug.com/dawn/1232): Program link error on OpenGLES backend
DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
DoBasicCopyTest({1000, 1}); DoBasicCopyTest({1000, 1});
} }
TEST_P(CopyTextureForBrowser_Basic, VerifyCopyOnYDirection) { TEST_P(CopyTextureForBrowser_Basic, VerifyCopyOnYDirection) {
// TODO(crbug.com/dawn/1232): Program link error on OpenGLES backend
DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
DoBasicCopyTest({1, 1000}); DoBasicCopyTest({1, 1000});
} }
TEST_P(CopyTextureForBrowser_Basic, VerifyCopyFromLargeTexture) { TEST_P(CopyTextureForBrowser_Basic, VerifyCopyFromLargeTexture) {
// TODO(crbug.com/dawn/1232): Program link error on OpenGLES backend
DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
// TODO(crbug.com/dawn/1070): Flaky VK_DEVICE_LOST // TODO(crbug.com/dawn/1070): Flaky VK_DEVICE_LOST
DAWN_SUPPRESS_TEST_IF(IsWindows() && IsVulkan() && IsIntel()); DAWN_SUPPRESS_TEST_IF(IsWindows() && IsVulkan() && IsIntel());
@ -600,6 +1000,10 @@ TEST_P(CopyTextureForBrowser_Basic, VerifyCopyFromLargeTexture) {
} }
TEST_P(CopyTextureForBrowser_Basic, VerifyFlipY) { TEST_P(CopyTextureForBrowser_Basic, VerifyFlipY) {
// TODO(crbug.com/dawn/1232): Program link error on OpenGLES backend
DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
wgpu::CopyTextureForBrowserOptions options = {}; wgpu::CopyTextureForBrowserOptions options = {};
options.flipY = true; options.flipY = true;
@ -607,6 +1011,10 @@ TEST_P(CopyTextureForBrowser_Basic, VerifyFlipY) {
} }
TEST_P(CopyTextureForBrowser_Basic, VerifyFlipYInSlimTexture) { TEST_P(CopyTextureForBrowser_Basic, VerifyFlipYInSlimTexture) {
// TODO(crbug.com/dawn/1232): Program link error on OpenGLES backend
DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
wgpu::CopyTextureForBrowserOptions options = {}; wgpu::CopyTextureForBrowserOptions options = {};
options.flipY = true; options.flipY = true;
@ -626,6 +1034,7 @@ TEST_P(CopyTextureForBrowser_Formats, ColorConversion) {
// Skip OpenGLES backend because it fails on using RGBA8Unorm as // Skip OpenGLES backend because it fails on using RGBA8Unorm as
// source texture format. // source texture format.
DAWN_SUPPRESS_TEST_IF(IsOpenGLES()); DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
// Skip OpenGL backend on linux because it fails on using *-srgb format as // Skip OpenGL backend on linux because it fails on using *-srgb format as
// dst texture format // dst texture format
@ -651,6 +1060,10 @@ DAWN_INSTANTIATE_TEST_P(
// green texture originally. After the subrect copy, affected part // green texture originally. After the subrect copy, affected part
// in dst texture should be red and other part should remain green. // in dst texture should be red and other part should remain green.
TEST_P(CopyTextureForBrowser_SubRects, CopySubRect) { TEST_P(CopyTextureForBrowser_SubRects, CopySubRect) {
// TODO(crbug.com/dawn/1232): Program link error on OpenGLES backend
DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
// Tests skip due to crbug.com/dawn/592. // Tests skip due to crbug.com/dawn/592.
DAWN_SUPPRESS_TEST_IF(IsD3D12() && IsBackendValidationEnabled()); DAWN_SUPPRESS_TEST_IF(IsD3D12() && IsBackendValidationEnabled());
@ -673,7 +1086,9 @@ DAWN_INSTANTIATE_TEST_P(CopyTextureForBrowser_SubRects,
TEST_P(CopyTextureForBrowser_AlphaOps, alphaOp) { TEST_P(CopyTextureForBrowser_AlphaOps, alphaOp) {
// Skip OpenGLES backend because it fails on using RGBA8Unorm as // Skip OpenGLES backend because it fails on using RGBA8Unorm as
// source texture format. // source texture format.
// TODO(crbug.com/dawn/1232): Program link error on OpenGLES backend
DAWN_SUPPRESS_TEST_IF(IsOpenGLES()); DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
// Tests skip due to crbug.com/dawn/1104. // Tests skip due to crbug.com/dawn/1104.
DAWN_SUPPRESS_TEST_IF(IsWARP()); DAWN_SUPPRESS_TEST_IF(IsWARP());
@ -686,3 +1101,27 @@ DAWN_INSTANTIATE_TEST_P(
{D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(), VulkanBackend()}, {D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(), VulkanBackend()},
std::vector<wgpu::AlphaOp>({wgpu::AlphaOp::DontChange, wgpu::AlphaOp::Premultiply, std::vector<wgpu::AlphaOp>({wgpu::AlphaOp::DontChange, wgpu::AlphaOp::Premultiply,
wgpu::AlphaOp::Unpremultiply})); wgpu::AlphaOp::Unpremultiply}));
// Verify |CopyTextureForBrowser| doing color space conversion.
TEST_P(CopyTextureForBrowser_ColorSpace, colorSpaceConversion) {
// TODO(crbug.com/dawn/1232): Program link error on OpenGLES backend
DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
// Tests skip due to crbug.com/dawn/1104.
DAWN_SUPPRESS_TEST_IF(IsWARP());
DoColorSpaceConversionTest();
}
DAWN_INSTANTIATE_TEST_P(CopyTextureForBrowser_ColorSpace,
{D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(),
VulkanBackend()},
std::vector<wgpu::TextureFormat>({wgpu::TextureFormat::RGBA16Float,
wgpu::TextureFormat::RGBA32Float}),
std::vector<ColorSpace>({ColorSpace::SRGB, ColorSpace::DisplayP3}),
std::vector<ColorSpace>({ColorSpace::SRGB}),
std::vector<wgpu::AlphaMode>({wgpu::AlphaMode::Premultiplied,
wgpu::AlphaMode::Unpremultiplied}),
std::vector<wgpu::AlphaMode>({wgpu::AlphaMode::Premultiplied,
wgpu::AlphaMode::Unpremultiplied}));

128
src/tests/unittests/validation/CopyTextureForBrowserTests.cpp
View File

@ -50,12 +50,12 @@ class CopyTextureForBrowserTest : public ValidationTest {
uint32_t dstLevel, uint32_t dstLevel,
wgpu::Origin3D dstOrigin, wgpu::Origin3D dstOrigin,
wgpu::Extent3D extent3D, wgpu::Extent3D extent3D,
wgpu::TextureAspect aspect = wgpu::TextureAspect::All) { wgpu::TextureAspect aspect = wgpu::TextureAspect::All,
wgpu::CopyTextureForBrowserOptions options = {}) {
wgpu::ImageCopyTexture srcImageCopyTexture = wgpu::ImageCopyTexture srcImageCopyTexture =
utils::CreateImageCopyTexture(srcTexture, srcLevel, srcOrigin, aspect); utils::CreateImageCopyTexture(srcTexture, srcLevel, srcOrigin, aspect);
wgpu::ImageCopyTexture dstImageCopyTexture = wgpu::ImageCopyTexture dstImageCopyTexture =
utils::CreateImageCopyTexture(dstTexture, dstLevel, dstOrigin, aspect); utils::CreateImageCopyTexture(dstTexture, dstLevel, dstOrigin, aspect);
wgpu::CopyTextureForBrowserOptions options = {};
if (expectation == utils::Expectation::Success) { if (expectation == utils::Expectation::Success) {
device.GetQueue().CopyTextureForBrowser(&srcImageCopyTexture, &dstImageCopyTexture, device.GetQueue().CopyTextureForBrowser(&srcImageCopyTexture, &dstImageCopyTexture,
@ -254,3 +254,127 @@ TEST_F(CopyTextureForBrowserTest, InvalidSampleCount) {
TestCopyTextureForBrowser(utils::Expectation::Failure, sourceMultiSampled4x, 0, {0, 0, 0}, TestCopyTextureForBrowser(utils::Expectation::Failure, sourceMultiSampled4x, 0, {0, 0, 0},
destinationMultiSampled1x, 0, {0, 0, 0}, {0, 0, 1}); destinationMultiSampled1x, 0, {0, 0, 0}, {0, 0, 1});
} }
// Test color space conversion related attributes in CopyTextureForBrowserOptions.
TEST_F(CopyTextureForBrowserTest, ColorSpaceConversion_ColorSpace) {
wgpu::Texture source =
Create2DTexture(16, 16, 5, 4, wgpu::TextureFormat::RGBA8Unorm,
wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::TextureBinding);
wgpu::Texture destination =
Create2DTexture(16, 16, 5, 4, wgpu::TextureFormat::RGBA8Unorm,
wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::RenderAttachment);
wgpu::CopyTextureForBrowserOptions options = {};
std::array<float, 7> srcTransferFunctionParameters = {};
std::array<float, 7> dstTransferFunctionParameters = {};
std::array<float, 9> conversionMatrix = {};
options.needsColorSpaceConversion = true;
options.srcTransferFunctionParameters = srcTransferFunctionParameters.data();
options.dstTransferFunctionParameters = dstTransferFunctionParameters.data();
options.conversionMatrix = conversionMatrix.data();
options.conversionMatrixElementsCount = 9;
options.transferFunctionParametersCount = 7;
// Valid cases
{
wgpu::CopyTextureForBrowserOptions validOptions = options;
TestCopyTextureForBrowser(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, validOptions);
// if no color space conversion, no need to validate related attributes
wgpu::CopyTextureForBrowserOptions noColorSpaceConversion = options;
noColorSpaceConversion.needsColorSpaceConversion = false;
TestCopyTextureForBrowser(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All,
noColorSpaceConversion);
}
// Invalid cases: wrong transferFunctionParametersCount
{
// wrong: transferFunctionParametersCount must be 7
wgpu::CopyTextureForBrowserOptions invalidOptions = options;
invalidOptions.transferFunctionParametersCount = 6;
TestCopyTextureForBrowser(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, invalidOptions);
}
// Invalid cases: wrong conversionMatrixElementsCount
{
// wrong: conversionMatrixElementsCount
wgpu::CopyTextureForBrowserOptions invalidOptions = options;
invalidOptions.transferFunctionParametersCount = 10;
TestCopyTextureForBrowser(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, invalidOptions);
}
// Invalid cases: srcTransferFunctionParameters, dstTransferFunctionParameters or
// conversionMatrix is nullptr
{
wgpu::CopyTextureForBrowserOptions invalidOptions = options;
if (UsesWire()) {
invalidOptions.transferFunctionParametersCount = 0;
}
invalidOptions.srcTransferFunctionParameters = nullptr;
TestCopyTextureForBrowser(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, invalidOptions);
}
{
wgpu::CopyTextureForBrowserOptions invalidOptions = options;
if (UsesWire()) {
invalidOptions.transferFunctionParametersCount = 0;
}
invalidOptions.dstTransferFunctionParameters = nullptr;
TestCopyTextureForBrowser(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, invalidOptions);
}
{
wgpu::CopyTextureForBrowserOptions invalidOptions = options;
if (UsesWire()) {
invalidOptions.conversionMatrixElementsCount = 0;
}
invalidOptions.conversionMatrix = nullptr;
TestCopyTextureForBrowser(utils::Expectation::Failure, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, invalidOptions);
}
}
// Test option.srcAlphaMode/dstAlphaMode
TEST_F(CopyTextureForBrowserTest, ColorSpaceConversion_TextureAlphaState) {
wgpu::Texture source =
Create2DTexture(16, 16, 5, 4, wgpu::TextureFormat::RGBA8Unorm,
wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::TextureBinding);
wgpu::Texture destination =
Create2DTexture(16, 16, 5, 4, wgpu::TextureFormat::RGBA8Unorm,
wgpu::TextureUsage::CopyDst | wgpu::TextureUsage::RenderAttachment);
wgpu::CopyTextureForBrowserOptions options = {};
// Valid src texture alpha state and valid dst texture alpha state
{
options.srcAlphaMode = wgpu::AlphaMode::Premultiplied;
options.dstAlphaMode = wgpu::AlphaMode::Premultiplied;
TestCopyTextureForBrowser(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, options);
options.srcAlphaMode = wgpu::AlphaMode::Premultiplied;
options.dstAlphaMode = wgpu::AlphaMode::Unpremultiplied;
TestCopyTextureForBrowser(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, options);
options.srcAlphaMode = wgpu::AlphaMode::Unpremultiplied;
options.dstAlphaMode = wgpu::AlphaMode::Premultiplied;
TestCopyTextureForBrowser(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, options);
options.srcAlphaMode = wgpu::AlphaMode::Unpremultiplied;
options.dstAlphaMode = wgpu::AlphaMode::Unpremultiplied;
TestCopyTextureForBrowser(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0,
{0, 0, 0}, {4, 4, 1}, wgpu::TextureAspect::All, options);
}
}