| /* |
| * Copyright 2026 Google LLC |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "tests/Test.h" |
| |
| #include "include/core/SkColorType.h" |
| #include "include/gpu/graphite/Context.h" |
| #include "include/gpu/graphite/TextureInfo.h" |
| #include "include/private/SkTArray.h" |
| #include "src/core/SkColorSpaceXformSteps.h" |
| #include "src/core/SkFloatBits.h" |
| #include "src/core/SkHalf.h" |
| #include "src/core/SkImageInfoPriv.h" |
| #include "src/core/SkRasterPipeline.h" |
| #include "src/gpu/Swizzle.h" |
| #include "src/gpu/graphite/Caps.h" |
| #include "src/gpu/graphite/ContextPriv.h" |
| #include "src/gpu/graphite/TextureFormat.h" |
| #include "src/gpu/graphite/TextureFormatXferFn.h" |
| #include "src/gpu/graphite/TextureInfoPriv.h" |
| #include "tools/ToolUtils.h" |
| |
| // Uncomment the SK_ABORT() to exit on first pixel mismatch to help debugging |
| #define STOP_ON_TRANSFER_FAILURE // SK_ABORT(); |
| |
| namespace skgpu::graphite { |
| |
| // Types for defining color type and format behavior expectations |
| enum ChannelDataType { |
| UNorm, Signed, Float, FNorm, sRGB, XR, Pad |
| }; |
| |
| struct Channel { |
| char fName; // rgbayuv01 and G (for gray) |
| int fBits; |
| ChannelDataType fType; |
| }; |
| |
| struct ColorTypeExpectation { |
| SkColorType fColorType; |
| Swizzle fReadSwizzle; |
| std::optional<Swizzle> fWriteSwizzle; // not set implies not renderable |
| }; |
| |
| struct FormatExpectation { |
| TextureFormat fFormat; |
| skia_private::TArray<Channel> fChannels; |
| SkTextureCompressionType fCompressionType = SkTextureCompressionType::kNone; |
| |
| // Not set implies transfers are disabled; it is composed with a ColorTypeExpectation's |
| // read or write swizzle to produce the expected readback/upload swizzle. |
| std::optional<Swizzle> fXferSwizzle; |
| // The first color type expectation is assumed to be the best fit. |
| skia_private::TArray<ColorTypeExpectation> fCompatibleColorTypes; |
| |
| // All of the expectations for the fixed properties of a TextureFormat are derived from its |
| // fChannels definition. |
| bool isFloatingPoint() const { return this->hasType(Float) || this->hasType(FNorm); } |
| bool hasDepth() const { return this->hasChannel('d'); } |
| bool hasStencil() const { return this->hasChannel('s'); } |
| bool hasDepthOrStencil() const { return this->hasDepth() || this->hasStencil(); } |
| bool isMultiplanar() const { |
| return this->hasChannel('y') && this->hasChannel('u') && this->hasChannel('v'); |
| } |
| |
| bool autoClamps() const { |
| // Auto clamping is derived from the type of the channel with the most bits |
| bool autoClamp = true; |
| int maxBitSize = 0; |
| for (const Channel& c : fChannels) { |
| if (c.fBits > maxBitSize) { |
| autoClamp = c.fType == UNorm || c.fType == sRGB; |
| maxBitSize = c.fBits; |
| } |
| } |
| return autoClamp; |
| } |
| |
| int bytesPerBlock() const { |
| if (fCompressionType != SkTextureCompressionType::kNone) { |
| // At the moment, all supported compression types have the same bytes per block |
| return 8; |
| } |
| |
| int bitCount = 0; |
| for (const Channel& c : fChannels) { |
| bitCount += c.fBits; |
| } |
| return bitCount / 8; |
| } |
| |
| uint32_t channelMask() const { |
| uint32_t mask = 0; |
| if (this->hasChannel('r') || this->hasChannel('y')) { |
| mask |= kRed_SkColorChannelFlag; |
| } |
| if (this->hasChannel('g') || this->hasChannel('u')) { |
| mask |= kGreen_SkColorChannelFlag; |
| } |
| if (this->hasChannel('b') || this->hasChannel('v')) { |
| mask |= kBlue_SkColorChannelFlag; |
| } |
| if (this->hasChannel('a')) { |
| mask |= kAlpha_SkColorChannelFlag; |
| } |
| // Other channels do not contribute to SkColorChannel mask |
| return mask; |
| } |
| |
| private: |
| bool hasChannel(char channel) const { |
| for (const Channel& c : fChannels) { |
| if (c.fName == channel) { |
| return true; |
| } |
| } |
| return false; |
| } |
| bool hasType(ChannelDataType type) const { |
| for (const Channel& c : fChannels) { |
| if (c.fType == type) { |
| return true; |
| } |
| } |
| return false; |
| } |
| }; |
| |
| using PixelData = std::array<uint8_t, 16>; // The largest texel/pixel size is RGBA32F = 16 bytes |
| |
| uint32_t channel_to_bits(const Channel& channel, float value) { |
| switch (channel.fType) { |
| case Pad: |
| // Pad should only be used with 'x', which produces NaN in channel_to_float, so |
| // replace `value` with the default 'x' bit pattern in gen_channel_values, and then |
| // fall through to UNorm handling to adjust it to the right bit depth |
| SkASSERT(channel.fName == 'x'); |
| value = 0b0101 / 15.f; |
| [[fallthrough]]; |
| |
| case sRGB: |
| // sRGB data is stored in a non-linear gamma and automatically decodes to linear when |
| // being sampled or rendered into. This means an SRGB_8888 image with a linear |
| // SkColorSpace behaves like a regular 8888 image with an sRGB SkColorSpace. But |
| // transfers between CPU and GPU assume the SkColorSpace is the same, so we need to |
| // interpret the `v` as if it were an 8888 image with a linear SkColorSpace and map to |
| // the sRGB encoding. |
| if (channel.fType == sRGB) { |
| value = skcms_TransferFunction_eval(skcms_sRGB_Inverse_TransferFunction(), value); |
| } |
| [[fallthrough]]; |
| |
| case UNorm: { |
| uint32_t denominator = channel.fBits == 32 ? ~0 : ((1 << channel.fBits) - 1); |
| return (uint32_t) std::round(value * denominator); |
| } |
| |
| case XR: |
| // See SkRP_opts::store_1010102_xr |
| SkASSERT(channel.fBits == 10); |
| return std::min((uint32_t) std::round(value * 510 + 384), 1023u); |
| |
| case FNorm: |
| // For simplicity fall through to Float, the Norm is just a hint about range |
| [[fallthrough]]; |
| case Float: |
| SkASSERT(channel.fBits == 16 || channel.fBits == 32); |
| return channel.fBits == 16 ? (uint32_t) SkFloatToHalf(value) : SkFloat2Bits(value); |
| |
| case Signed: |
| // This should only be used for 's' channels, which are already not reaching this code |
| SK_ABORT("Should not be generating Signed values for pixel data"); |
| } |
| SkUNREACHABLE; |
| } |
| |
| float channel_to_float(const Channel& channel, uint32_t bits) { |
| switch (channel.fType) { |
| case sRGB: [[fallthrough]]; // first treat as unorm then apply gamma TF |
| case UNorm: { |
| uint32_t denominator = channel.fBits == 32 ? ~0 : ((1 << channel.fBits) - 1); |
| float vf = bits * (1 / (float) denominator); |
| if (channel.fType == sRGB) { |
| vf = skcms_TransferFunction_eval(skcms_sRGB_TransferFunction(), vf); |
| } |
| return vf; |
| } |
| |
| case XR: return (bits - 384.f) * (1/510.f); |
| |
| case FNorm: [[fallthrough]]; // Values are interpreted the same, values are in [0,1] |
| case Float: return channel.fBits == 16 ? SkHalfToFloat((SkHalf) bits) : SkBits2Float(bits); |
| |
| case Signed: [[fallthrough]]; |
| case Pad: return SK_FloatNaN; // No floating point printing |
| } |
| SkUNREACHABLE; |
| } |
| |
| char apply_swizzle_to_name(char dstName, const Swizzle& srcToDst) { |
| switch (dstName) { |
| case 'r': return srcToDst[0]; |
| case 'g': return srcToDst[1]; |
| case 'b': return srcToDst[2]; |
| case 'a': return srcToDst[3]; |
| default: return dstName; |
| } |
| } |
| |
| // Generate a unique value for `channelName` by applying `srcToDst` to the source channels. |
| float gen_channel_value(char name, |
| const Swizzle& loadSrcSwizzle, |
| SkSpan<const Channel> srcChannels) { |
| name = apply_swizzle_to_name(name, loadSrcSwizzle); |
| |
| // Try to look for an exact channel match, in which case we use the unique value corresponding |
| // to that channel name. |
| for (size_t c = 0; c < srcChannels.size(); ++c) { |
| if (srcChannels[c].fName == name || |
| (srcChannels[c].fName == 'G' && (name == 'r' || name == 'g' || name == 'b'))) { |
| uint32_t v; |
| switch (srcChannels[c].fName) { |
| case 'r': v = 0b0001; break; |
| case 'g': v = 0b0010; break; |
| case 'b': v = 0b0100; break; |
| case 'a': v = 0b1010; break; // `A` must additionally fit into 2 bit channel formats |
| case 'x': v = 0b0101; break; |
| case '0': v = 0b0000; break; |
| case '1': v = 0b1111; break; |
| case 'G': v = 0b1100; break; // arbitrary starting Gray value |
| default: |
| // NOTE: 'd', 's', 'y', 'u', 'v' are valid channel names, but the formats that |
| // have those should not be participating in the read/write transfer testing. |
| SK_ABORT("Bad source channel name for pixel data generation: %c", name); |
| } |
| // Route through the source channel's bit representation to account for rounding |
| return channel_to_float(srcChannels[c], channel_to_bits(srcChannels[c], v / 15.f)); |
| } |
| } |
| |
| // We didn't find an exact channel match, so we either use default values or apply gray handling |
| switch (name) { |
| // Trivial default values |
| case 'x': return SK_FloatNaN; |
| case 'r': case 'g': case 'b': case '0': return 0.f; |
| case 'a': case '1': return 1.f; |
| |
| // Construct a gray value from r, g, and b values of the source |
| case 'G': { |
| float r = gen_channel_value('r', loadSrcSwizzle, srcChannels); |
| float g = gen_channel_value('g', loadSrcSwizzle, srcChannels); |
| float b = gen_channel_value('b', loadSrcSwizzle, srcChannels); |
| |
| // Since this is a linear sum, if we divided or multiplied by A after converting |
| // through source's precision, we would arrive at the same value as if we applied |
| // the premul/unpremul multiplication in gen_pixel_data applied to G |
| return 0.2126f * r + 0.7142f * g + 0.0722f * b; |
| } |
| |
| default: |
| SK_ABORT("Bad dst channel name for pixel data generation: %c", name); |
| } |
| } |
| |
| // Src and Dst must be (uint32_t, PixelData) or (PixelData, uint32_t), and `dst` should be |
| // zero-initialized before calling. Returns the bitOffset for the next channel. |
| template <typename Src, typename Dst> |
| int copy_unaligned_bits(int numBits, int bitOffset, const Src& src, Dst& dst) { |
| static_assert(std::is_same_v<Src, uint32_t> || std::is_same_v<Src, PixelData>); |
| static_assert(std::is_same_v<Dst, uint32_t> || std::is_same_v<Dst, PixelData>); |
| static_assert(!std::is_same_v<Src, Dst>); |
| static constexpr bool kBytesToChannel = std::is_same_v<Src, PixelData>; |
| |
| int srcBitsLeft = numBits; |
| while (srcBitsLeft > 0) { |
| int arrayIndex = bitOffset / 8; |
| int arrayBitsLeft = (arrayIndex + 1) * 8 - bitOffset; |
| int copyBits = std::min(arrayBitsLeft, srcBitsLeft); |
| |
| int channelBitShift = numBits - srcBitsLeft; |
| int arrayBitShift = 8 - arrayBitsLeft; |
| |
| if constexpr (kBytesToChannel) { |
| dst |= ((src[arrayIndex] >> arrayBitShift) & ((1<<copyBits) - 1)) << channelBitShift; |
| } else { |
| dst[arrayIndex] |= ((src >> channelBitShift) & ((1<<copyBits) - 1)) << arrayBitShift; |
| } |
| srcBitsLeft -= copyBits; |
| bitOffset += copyBits; |
| } |
| return bitOffset; |
| } |
| |
| bool needs_premul(SkAlphaType srcAlphaType, SkAlphaType dstAlphaType) { |
| return dstAlphaType == kPremul_SkAlphaType && (srcAlphaType == kUnpremul_SkAlphaType || |
| srcAlphaType == kUnknown_SkAlphaType); |
| } |
| bool needs_unpremul(SkAlphaType srcAlphaType, SkAlphaType dstAlphaType) { |
| return srcAlphaType == kPremul_SkAlphaType && (dstAlphaType == kUnpremul_SkAlphaType || |
| dstAlphaType == kUnknown_SkAlphaType); |
| } |
| |
| // Returns the number of set *bits* within PixelData. |
| std::pair<PixelData, size_t> gen_pixel_data(SkSpan<const Channel> dstChannels, |
| Swizzle storeDstSwizzle, |
| SkAlphaType dstAlphaType, |
| SkSpan<const Channel> srcChannels, |
| Swizzle loadSrcSwizzle, |
| SkAlphaType srcAlphaType, |
| bool forInput=false) { |
| PixelData pixel{}; // zero-initialize all bytes |
| int bitOffset = 0; |
| for (size_t c = 0; c < dstChannels.size(); ++c) { |
| Channel channel = dstChannels[c]; |
| channel.fName = apply_swizzle_to_name(dstChannels[c].fName, storeDstSwizzle); |
| float srcValue = gen_channel_value(channel.fName, loadSrcSwizzle, srcChannels); |
| |
| // Handle alpha type conversion |
| if (forInput && ((channel.fName == 'a' && srcAlphaType == kUnknown_SkAlphaType) || |
| (channel.fName == '1' && dstChannels[c].fName == 'a'))) { |
| // Fill junk alpha that is masked by a later read swizzle as if it were padding |
| channel.fType = Pad; |
| channel.fName = 'x'; |
| } else if (channel.fName == 'a' && srcAlphaType == kOpaque_SkAlphaType) { |
| srcValue = 1.f; |
| // NOTE: We don't force alpha = 1 when dstAlphaType = opaque, since that is interpreted |
| // as a trust-the-user scenario and we assume input values are already opaque and don't |
| // modify the alpha. |
| } else if (channel.fName == 'r' || channel.fName == 'g' || channel.fName == 'b' || |
| channel.fName == 'G') { |
| if (needs_premul(srcAlphaType, dstAlphaType)) { |
| // Must multiply other channels by the alpha value |
| const float srcAlpha = gen_channel_value('a', loadSrcSwizzle, srcChannels); |
| srcValue *= srcAlpha; |
| } else if (needs_unpremul(srcAlphaType, dstAlphaType)) { |
| // Must divide the other channels by the alpha value |
| const float srcAlpha = gen_channel_value('a', loadSrcSwizzle, srcChannels); |
| srcValue *= 1.f / srcAlpha; |
| } |
| // else we're the same alpha type on both sides, or a mix of opaque and unknown, in |
| // which case premul vs. unpremul is a no-op. |
| } |
| |
| uint32_t channelValue = channel_to_bits(channel, srcValue); |
| bitOffset = copy_unaligned_bits(channel.fBits, bitOffset, channelValue, pixel); |
| } |
| |
| return {pixel, bitOffset}; |
| } |
| |
| // No swizzling or data conversion variant for input data generation |
| std::pair<PixelData, size_t> gen_pixel_data(SkSpan<const Channel> channels, |
| Swizzle readSwizzle, |
| SkAlphaType alphaType) { |
| return gen_pixel_data(channels, readSwizzle.invert(), alphaType, |
| channels, readSwizzle, alphaType, /*forInput=*/true); |
| } |
| |
| const char* channel_type_name(ChannelDataType type) { |
| switch (type) { |
| case UNorm: return "u"; |
| case Signed: return "s"; |
| case Float: return "f"; |
| case FNorm: return "fn"; |
| case sRGB: return "srgb"; |
| case XR: return "xr"; |
| case Pad: return "_"; |
| } |
| SkUNREACHABLE; |
| } |
| |
| skia_private::TArray<SkString> print_channel_names(SkSpan<const Channel> channels) { |
| skia_private::TArray<SkString> names; |
| names.push_back(SkString()); // empty to align with channel values row label |
| names.push_back(SkString("raw")); |
| for (const Channel& c : channels) { |
| const char* typeName = channel_type_name(c.fType); |
| names.push_back(SkStringPrintf("%c(%s%d)", c.fName, typeName, c.fBits)); |
| } |
| return names; |
| } |
| |
| skia_private::TArray<SkString> print_channel_values( |
| const char* prefix, SkSpan<const Channel> channels, const PixelData& pixel) { |
| skia_private::TArray<SkString> values; |
| |
| values.push_back(SkString(prefix)); |
| |
| values.push_back(SkString()); // Raw hex value |
| for (int i = 0; i < 16; ++i) { |
| values[1].appendf(" %0.2x", pixel[i]); |
| } |
| |
| int bitOffset = 0; |
| for (const Channel& c : channels) { |
| uint32_t channelValue = 0; |
| bitOffset = copy_unaligned_bits(c.fBits, bitOffset, pixel, channelValue); |
| |
| SkString binary; |
| for (int i = 0; i < c.fBits; ++i) { |
| binary.prependUnichar((channelValue >> i) & 1 ? '1' : '0'); |
| } |
| float vf = channel_to_float(c, channelValue); |
| |
| SkString numeric; |
| switch (c.fType) { |
| case Pad: numeric = "-"; break; |
| case Signed: numeric = SkStringPrintf("%u", channelValue); break; |
| |
| case sRGB: [[fallthrough]]; |
| case XR: |
| case UNorm: numeric = SkStringPrintf("0x%x / %.2f", channelValue, vf); break; |
| |
| case FNorm: [[fallthrough]]; |
| case Float: numeric = SkStringPrintf("%0.4f", vf); break; |
| } |
| values.push_back(SkStringPrintf("%s (%s)", binary.c_str(), numeric.c_str())); |
| } |
| |
| return values; |
| } |
| |
| void dump_string(const SkString& str, int length) { |
| int strLen = SkTo<int>(str.size()); |
| SkASSERT(strLen <= length); |
| SkDebugf("%*s", std::min(length, strLen), str.data()); |
| length -= strLen; |
| while(length > 0) { |
| SkDebugf(" "); |
| length--; |
| } |
| } |
| |
| void dump_pixel_comparison(const SkString& inputName, |
| SkSpan<const Channel> inputChannels, |
| const PixelData& inputPixel, |
| const SkString& outputName, |
| SkSpan<const Channel> outputChannels, |
| const PixelData& expectedOutputPixel, |
| const PixelData& actualOutputPixel) { |
| SkDebugf("Transfer from %s to %s:\n", inputName.c_str(), outputName.c_str()); |
| |
| auto inputChannelNames = print_channel_names(inputChannels); |
| auto inputChannelValues = print_channel_values("Input", inputChannels, inputPixel); |
| |
| auto outputChannelNames = print_channel_names(outputChannels); |
| auto expectedChannelValues = |
| print_channel_values("Expected", outputChannels, expectedOutputPixel); |
| auto actualChannelValues = |
| print_channel_values("Actual", outputChannels, actualOutputPixel); |
| |
| const int colCount = std::max(inputChannelNames.size(), outputChannelNames.size()); |
| auto rows = {inputChannelNames, |
| inputChannelValues, |
| outputChannelNames, |
| expectedChannelValues, |
| actualChannelValues}; |
| for (auto&& row : rows) { |
| for (int c = 0; c < std::min(colCount, row.size()); ++c) { |
| if (c == 0) { |
| SkDebugf(" "); |
| } else { |
| SkDebugf(" | "); |
| } |
| int colWidth = 0; |
| for (auto&& otherRow : rows) { |
| if (c < otherRow.size()) { |
| colWidth = std::max(colWidth, SkTo<int>(otherRow[c].size())); |
| } |
| } |
| dump_string(row[c], colWidth); |
| } |
| SkDebugf("\n"); |
| } |
| } |
| |
| int channel_tolerance(SkSpan<const Channel> srcChannels, SkAlphaType srcAT, |
| SkSpan<const Channel> dstChannels, SkAlphaType dstAT) { |
| bool srcHasSRGBOrGray = false; |
| for (const Channel c : srcChannels) { |
| srcHasSRGBOrGray |= c.fType == sRGB || c.fName == 'G'; |
| } |
| bool dstHasSRGBOrGray = false; |
| for (const Channel c : dstChannels) { |
| dstHasSRGBOrGray |= c.fType == sRGB || c.fName == 'G'; |
| } |
| // If the input or output data involves sRGB encoding/decoding or conversion to gray, or are |
| // doing premul/unpremul math, we allow 1 bit of difference because of mismatches between how |
| // SkRasterPipeline calculates channel values vs. the value generation in these tests. |
| return srcHasSRGBOrGray || |
| dstHasSRGBOrGray || |
| needs_premul(srcAT, dstAT) || |
| needs_unpremul(srcAT, dstAT) ? 1 : 0; |
| } |
| |
| bool compare_pixels(SkSpan<const Channel> channels, |
| const PixelData& expected, |
| const PixelData& actual, |
| int channelTolerance, |
| std::optional<char> ignoreChannel=std::nullopt) { |
| int bitOffset = 0; |
| for (const Channel& c : channels) { |
| uint32_t actualChannelBits = 0; |
| uint32_t expectedChannelBits = 0; |
| copy_unaligned_bits(c.fBits, bitOffset, expected, expectedChannelBits); |
| copy_unaligned_bits(c.fBits, bitOffset, actual, actualChannelBits); |
| bitOffset += c.fBits; |
| |
| int64_t channelDiff = static_cast<int64_t>(actualChannelBits) - |
| static_cast<int64_t>(expectedChannelBits); |
| if (c.fType != Pad && // ignore padding channels |
| !(ignoreChannel.has_value() && c.fName == *ignoreChannel) && // ignore alpha channels |
| std::abs(channelDiff) > channelTolerance) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| PixelData transfer_data(const TextureFormatXferFn& xferFn, |
| const PixelData& inputData, |
| size_t srcPixelBits, |
| size_t dstPixelBits) { |
| // First do a conversion on a 1x1 image, which will represent the expected output when |
| // testing various width/height/rowbyte combinations for a solid input. |
| PixelData outputData{}; // zero-initialize for comparison stability on unwritten values. |
| xferFn.run(1, 1, &inputData, sizeof(PixelData), &outputData, sizeof(PixelData)); |
| |
| SkASSERT(srcPixelBits % sizeof(std::uint8_t) == 0); |
| SkASSERT(dstPixelBits % sizeof(std::uint8_t) == 0); |
| const size_t srcPixelBytes = srcPixelBits / 8; |
| const size_t dstPixelBytes = dstPixelBits / 8; |
| |
| static constexpr int kMaxDim = 32; // > 128-bit SIMD processing for 8-bit formats |
| using ImageBytes = std::array<uint8_t, kMaxDim*kMaxDim*sizeof(PixelData)>; |
| std::unique_ptr<ImageBytes> src = std::make_unique<ImageBytes>(); |
| std::unique_ptr<ImageBytes> dst = std::make_unique<ImageBytes>(); |
| |
| auto fill_image = [&](int w, int h, size_t rowBytes) { |
| uint8_t* dataStart = src->data(); |
| for (int x = 0; x < w; ++x) { |
| memcpy(src->data() + x*srcPixelBytes, &inputData, srcPixelBytes); |
| } |
| for (int y = 1; y < h; ++y) { |
| memcpy(dataStart + rowBytes, dataStart, rowBytes); |
| dataStart += rowBytes; |
| } |
| }; |
| auto check_image = [&](int w, int h, size_t rowBytes) { |
| const uint8_t* dataStart = dst->data(); |
| PixelData pxData{}; // zero-initialize all bytes |
| for (int y = 0; y < h; ++y) { |
| for (int x = 0; x < w; ++x) { |
| memcpy(&pxData, dataStart + x*dstPixelBytes, dstPixelBytes); |
| if (pxData != outputData) { |
| SkDebugf("Pixel mismatch at (%d, %d) in bulk transfer.\n", x, y); |
| outputData = pxData; // propagate this error out for pixel dumping |
| return false; |
| } |
| } |
| dataStart += rowBytes; |
| } |
| return true; |
| }; |
| |
| // RasterPipeline isn't the fastest in debug builds and transfer_data is called ~70k times |
| // in this unit test, so only test a specific width and height. |
| static constexpr int kWidth = 17; // > 16 to test padding logic for 128-bit SIMD processing |
| static constexpr int kHeight = 7; // > 1 for multirow testing, but low to help performance |
| |
| for (bool inputDense : {true, false}) { |
| size_t srcRowBytes = (inputDense ? kWidth : kMaxDim) * srcPixelBytes; |
| fill_image(kWidth, kHeight, srcRowBytes); |
| for (bool outputDense : {true, false}) { |
| size_t dstRowBytes = (outputDense ? kWidth : kMaxDim) * dstPixelBytes; |
| xferFn.run(kWidth, kHeight, src->data(), srcRowBytes, dst->data(), dstRowBytes); |
| if (!check_image(kWidth, kHeight, dstRowBytes)) { |
| return outputData; |
| } |
| } |
| } |
| return outputData; |
| } |
| |
| // Define the channel layout for every SkColorType for use in generating and validating the |
| // result of transferring data to or from a texture format. |
| [[maybe_unused]] static const struct ColorTypeChannels { |
| SkColorType fColorType; |
| Swizzle fEffectiveSwizzle; // Derivable from channel mask |
| skia_private::TArray<Channel> fChannels; |
| } kColorTypeChannels[] { |
| {kAlpha_8_SkColorType, Swizzle("000a"), {{'a', 8, UNorm}}}, |
| // NOTE: 565 and 4444 are misnamed and are BGR and ABGR respectively. |
| {kRGB_565_SkColorType, Swizzle("rgb1"), {{'b', 5, UNorm}, |
| {'g', 6, UNorm}, |
| {'r', 5, UNorm}}}, |
| {kARGB_4444_SkColorType, Swizzle("rgba"), {{'a', 4, UNorm}, |
| {'b', 4, UNorm}, |
| {'g', 4, UNorm}, |
| {'r', 4, UNorm}}}, |
| {kRGBA_8888_SkColorType, Swizzle("rgba"), {{'r', 8, UNorm}, |
| {'g', 8, UNorm}, |
| {'b', 8, UNorm}, |
| {'a', 8, UNorm}}}, |
| {kRGB_888x_SkColorType, Swizzle("rgb1"), {{'r', 8, UNorm}, |
| {'g', 8, UNorm}, |
| {'b', 8, UNorm}, |
| {'x', 8, Pad}}}, |
| {kBGRA_8888_SkColorType, Swizzle("rgba"), {{'b', 8, UNorm}, |
| {'g', 8, UNorm}, |
| {'r', 8, UNorm}, |
| {'a', 8, UNorm}}}, |
| {kRGBA_1010102_SkColorType, Swizzle("rgba"), {{'r', 10, UNorm}, |
| {'g', 10, UNorm}, |
| {'b', 10, UNorm}, |
| {'a', 2, UNorm}}}, |
| {kBGRA_1010102_SkColorType, Swizzle("rgba"), {{'b', 10, UNorm}, |
| {'g', 10, UNorm}, |
| {'r', 10, UNorm}, |
| {'a', 2, UNorm}}}, |
| {kRGB_101010x_SkColorType, Swizzle("rgb1"), {{'r', 10, UNorm}, |
| {'g', 10, UNorm}, |
| {'b', 10, UNorm}, |
| {'x', 2, Pad}}}, |
| {kBGR_101010x_SkColorType, Swizzle("rgb1"), {{'b', 10, UNorm}, |
| {'g', 10, UNorm}, |
| {'r', 10, UNorm}, |
| {'x', 2, Pad}}}, |
| {kBGR_101010x_XR_SkColorType, Swizzle("rgb1"), {{'b', 10, XR}, |
| {'g', 10, XR}, |
| {'r', 10, XR}, |
| {'x', 2, Pad}}}, |
| {kBGRA_10101010_XR_SkColorType, Swizzle("rgba"), {{'x', 6, Pad}, {'b', 10, XR}, |
| {'x', 6, Pad}, {'g', 10, XR}, |
| {'x', 6, Pad}, {'r', 10, XR}, |
| {'x', 6, Pad}, {'a', 10, XR}}}, |
| {kRGBA_10x6_SkColorType, Swizzle("rgba"), {{'x', 6, Pad}, {'r', 10, UNorm}, |
| {'x', 6, Pad}, {'g', 10, UNorm}, |
| {'x', 6, Pad}, {'b', 10, UNorm}, |
| {'x', 6, Pad}, {'a', 10, UNorm}}}, |
| // NOTE: The swizzle is rrr1 since we store gray in the red channel of the texture, but we use |
| // 'G' as the channel to force generating gray/luminance values in the tests instead of just 'r' |
| {kGray_8_SkColorType, Swizzle("rrr1"), {{'G', 8, UNorm}}}, |
| {kRGBA_F16Norm_SkColorType, Swizzle("rgba"), {{'r', 16, FNorm}, |
| {'g', 16, FNorm}, |
| {'b', 16, FNorm}, |
| {'a', 16, FNorm}}}, |
| {kRGBA_F16_SkColorType, Swizzle("rgba"), {{'r', 16, Float}, |
| {'g', 16, Float}, |
| {'b', 16, Float}, |
| {'a', 16, Float}}}, |
| {kRGB_F16F16F16x_SkColorType, Swizzle("rgb1"), {{'r', 16, Float}, |
| {'g', 16, Float}, |
| {'b', 16, Float}, |
| {'x', 16, Pad}}}, |
| {kRGBA_F32_SkColorType, Swizzle("rgba"), {{'r', 32, Float}, |
| {'g', 32, Float}, |
| {'b', 32, Float}, |
| {'a', 32, Float}}}, |
| {kR8G8_unorm_SkColorType, Swizzle("rg01"), {{'r', 8, UNorm}, {'g', 8, UNorm}}}, |
| {kA16_float_SkColorType, Swizzle("000a"), {{'a', 16, Float}}}, |
| {kR16_float_SkColorType, Swizzle("r001"), {{'r', 16, Float}}}, |
| {kR16G16_float_SkColorType, Swizzle("rg01"), {{'r', 16, Float}, {'g', 16, Float}}}, |
| {kA16_unorm_SkColorType, Swizzle("000a"), {{'a', 16, UNorm}}}, |
| {kR16_unorm_SkColorType, Swizzle("r001"), {{'r', 16, UNorm}}}, |
| {kR16G16_unorm_SkColorType, Swizzle("rg01"), {{'r', 16, UNorm}, {'g', 16, UNorm}}}, |
| {kR16G16B16A16_unorm_SkColorType, Swizzle("rgba"), {{'r', 16, UNorm}, |
| {'g', 16, UNorm}, |
| {'b', 16, UNorm}, |
| {'a', 16, UNorm}}}, |
| {kSRGBA_8888_SkColorType, Swizzle("rgba"), {{'r', 8, sRGB}, |
| {'g', 8, sRGB}, |
| {'b', 8, sRGB}, |
| {'a', 8, UNorm}}}, |
| {kR8_unorm_SkColorType, Swizzle("r001"), {{'r', 8, UNorm}}}, |
| }; |
| // Must include one per SkColorType except for kUnknown |
| static_assert(std::size(kColorTypeChannels) == kSkColorTypeCnt - 1, |
| "Missing channel definition for SkColorType"); |
| |
| // Full definition of compatibility and behavior between SkColorType and TextureFormat: |
| static const FormatExpectation kExpectations[] { |
| {.fFormat=TextureFormat::kUnsupported, |
| .fChannels={}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={}}, |
| |
| {.fFormat=TextureFormat::kR8, |
| .fChannels={{'r', 8, UNorm}}, |
| .fXferSwizzle=Swizzle("r001"), |
| .fCompatibleColorTypes={{kR8_unorm_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kAlpha_8_SkColorType, Swizzle("000r"), Swizzle("a000")}, |
| {kGray_8_SkColorType, Swizzle("rrra"), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kR16, |
| .fChannels={{'r', 16, UNorm}}, |
| .fXferSwizzle=Swizzle("r001"), |
| .fCompatibleColorTypes={{kR16_unorm_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kA16_unorm_SkColorType, Swizzle("000r"), Swizzle("a000")}}}, |
| |
| {.fFormat=TextureFormat::kR16F, |
| .fChannels={{'r', 16, Float}}, |
| .fXferSwizzle=Swizzle("r001"), |
| .fCompatibleColorTypes={{kR16_float_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kA16_float_SkColorType, Swizzle("000r"), Swizzle("a000")}}}, |
| |
| {.fFormat=TextureFormat::kR32F, |
| .fChannels={{'r', 32, Float}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kR16_float_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kA8, |
| .fChannels={{'a', 8, UNorm}}, |
| .fXferSwizzle=Swizzle("000a"), |
| .fCompatibleColorTypes={{kAlpha_8_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRG8, |
| .fChannels={{'r', 8, UNorm}, {'g', 8, UNorm}}, |
| .fXferSwizzle=Swizzle("rg01"), |
| .fCompatibleColorTypes={{kR8G8_unorm_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRG16, |
| .fChannels={{'r', 16, UNorm}, {'g', 16, UNorm}}, |
| .fXferSwizzle=Swizzle("rg01"), |
| .fCompatibleColorTypes={{kR16G16_unorm_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRG16F, |
| .fChannels={{'r', 16, Float}, {'g', 16, Float}}, |
| .fXferSwizzle=Swizzle("rg01"), |
| .fCompatibleColorTypes={{kR16G16_float_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRG32F, |
| .fChannels={{'r', 32, Float}, {'g', 32, Float}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kR16G16_float_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRGB8, |
| .fChannels={{'r', 8, UNorm}, {'g', 8, UNorm}, {'b', 8, UNorm}}, |
| .fXferSwizzle=Swizzle("rgb1"), |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kBGR8, |
| .fChannels={{'b', 8, UNorm}, {'g', 8, UNorm}, {'r', 8, UNorm}}, |
| .fXferSwizzle=Swizzle("rgb1"), |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kB5_G6_R5, |
| .fChannels={{'b', 5, UNorm}, {'g', 6, UNorm}, {'r', 5, UNorm}}, |
| .fXferSwizzle=Swizzle("rgb1"), |
| .fCompatibleColorTypes={{kRGB_565_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kR5_G6_B5, |
| .fChannels={{'r', 5, UNorm}, {'g', 6, UNorm}, {'b', 5, UNorm}}, |
| .fXferSwizzle=Swizzle("rgb1"), |
| .fCompatibleColorTypes={{kRGB_565_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRGB16, |
| .fChannels={{'r', 16, UNorm}, {'g', 16, UNorm}, {'b', 16, UNorm}}, |
| .fXferSwizzle=Swizzle("rgb1"), |
| .fCompatibleColorTypes={{kR16G16B16A16_unorm_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRGB16F, |
| .fChannels={{'r', 16, Float}, {'g', 16, Float}, {'b', 16, Float}}, |
| .fXferSwizzle=Swizzle("rgb1"), |
| .fCompatibleColorTypes={{kRGB_F16F16F16x_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRGB32F, |
| .fChannels={{'r', 32, Float}, {'g', 32, Float}, {'b', 32, Float}}, |
| .fXferSwizzle=Swizzle("rgb1"), |
| .fCompatibleColorTypes={{kRGBA_F32_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRGB8_sRGB, |
| .fChannels={{'r', 8, sRGB}, {'g', 8, sRGB}, {'b', 8, sRGB}}, |
| .fXferSwizzle=Swizzle("rgb1"), |
| .fCompatibleColorTypes={{kSRGBA_8888_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kBGR10_XR, |
| .fChannels={{'b', 10, XR}, {'g', 10, XR}, {'r', 10, XR}, {'x', 2, Pad}}, |
| .fXferSwizzle=Swizzle("rgb1"), |
| .fCompatibleColorTypes={{kBGR_101010x_XR_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRGBA8, |
| .fChannels={{'r', 8, UNorm}, {'g', 8, UNorm}, {'b', 8, UNorm}, {'a', 8, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kRGBA_8888_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kBGRA_8888_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kRGB_888x_SkColorType, Swizzle::RGB1(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kRGBA16, |
| .fChannels={{'r', 16, UNorm}, {'g', 16, UNorm}, {'b', 16, UNorm}, {'a', 16, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kR16G16B16A16_unorm_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRGBA16F, |
| .fChannels={{'r', 16, Float}, {'g', 16, Float}, {'b', 16, Float}, {'a', 16, Float}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kRGBA_F16_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kRGBA_F16Norm_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kRGB_F16F16F16x_SkColorType, Swizzle::RGB1(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kRGBA32F, |
| .fChannels={{'r', 32, Float}, {'g', 32, Float}, {'b', 32, Float}, {'a', 32, Float}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kRGBA_F32_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRGB10_A2, |
| .fChannels={{'r', 10, UNorm}, {'g', 10, UNorm}, {'b', 10, UNorm}, {'a', 2, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kRGBA_1010102_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kRGB_101010x_SkColorType, Swizzle::RGB1(), std::nullopt}, |
| {kBGRA_1010102_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kBGR_101010x_SkColorType, Swizzle::RGB1(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kRGBA10x6, |
| .fChannels={{'x', 6, Pad}, {'r', 10, UNorm}, {'x', 6, Pad}, {'g', 10, UNorm}, |
| {'x', 6, Pad}, {'b', 10, UNorm}, {'x', 6, Pad}, {'a', 10, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kRGBA_10x6_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kRGBA8_sRGB, |
| .fChannels={{'r', 8, sRGB}, {'g', 8, sRGB}, {'b', 8, sRGB}, {'a', 8, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kSRGBA_8888_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kBGRA8, |
| .fChannels={{'b', 8, UNorm}, {'g', 8, UNorm}, {'r', 8, UNorm}, {'a', 8, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kBGRA_8888_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kRGBA_8888_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kRGB_888x_SkColorType, Swizzle::RGB1(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kBGR10_A2, |
| .fChannels={{'b', 10, UNorm}, {'g', 10, UNorm}, {'r', 10, UNorm}, {'a', 2, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kBGRA_1010102_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kBGR_101010x_SkColorType, Swizzle::RGB1(), std::nullopt}, |
| {kRGBA_1010102_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}, |
| {kRGB_101010x_SkColorType, Swizzle::RGB1(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kBGRA8_sRGB, |
| .fChannels={{'b', 8, sRGB}, {'g', 8, sRGB}, {'r', 8, sRGB}, {'a', 8, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kSRGBA_8888_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kABGR4, |
| .fChannels={{'a', 4, UNorm}, {'b', 4, UNorm}, {'g', 4, UNorm}, {'r', 4, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kARGB_4444_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kARGB4, |
| .fChannels={{'a', 4, UNorm}, {'r', 4, UNorm}, {'g', 4, UNorm}, {'b', 4, UNorm}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kARGB_4444_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| {.fFormat=TextureFormat::kBGRA10x6_XR, |
| .fChannels={{'x', 6, Pad}, {'b', 10, XR}, {'x', 6, Pad}, {'g', 10, XR}, |
| {'x', 6, Pad}, {'r', 10, XR}, {'x', 6, Pad}, {'a', 10, XR}}, |
| .fXferSwizzle=Swizzle("rgba"), |
| .fCompatibleColorTypes={{kBGRA_10101010_XR_SkColorType, Swizzle::RGBA(), Swizzle::RGBA()}}}, |
| |
| // For compressed formats, the bytes per block represents actual compressed block size, not |
| // just the size of a pixel. |
| {.fFormat=TextureFormat::kRGB8_ETC2, |
| .fChannels={{'r', 10, UNorm}, {'g', 8, UNorm}, {'b', 8, UNorm}}, |
| .fCompressionType=SkTextureCompressionType::kETC2_RGB8_UNORM, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kRGB8_ETC2_sRGB, |
| .fChannels={{'r', 10, sRGB}, {'g', 8, sRGB}, {'b', 8, sRGB}}, |
| .fCompressionType=SkTextureCompressionType::kETC2_RGB8_UNORM, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kSRGBA_8888_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kRGB8_BC1, |
| .fChannels={{'r', 10, UNorm}, {'g', 8, UNorm}, {'b', 8, UNorm}}, |
| .fCompressionType=SkTextureCompressionType::kBC1_RGB8_UNORM, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kRGBA8_BC1, |
| .fChannels={{'r', 10, UNorm}, {'g', 8, UNorm}, {'b', 8, UNorm}, {'a', 8, UNorm}}, |
| .fCompressionType=SkTextureCompressionType::kBC1_RGBA8_UNORM, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGBA_8888_SkColorType, Swizzle::RGBA(), std::nullopt}, |
| {kRGB_888x_SkColorType, Swizzle::RGB1(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kRGBA8_BC1_sRGB, |
| .fChannels={{'r', 10, sRGB}, {'g', 8, sRGB}, {'b', 8, sRGB}, {'a', 8, UNorm}}, |
| .fCompressionType=SkTextureCompressionType::kBC1_RGBA8_UNORM, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kSRGBA_8888_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| // For these multiplanar formats, we set the bytes per block assuming the UV planes are the |
| // same size as the Y plane, which is an overestimate of the total texture memory. |
| {.fFormat=TextureFormat::kYUV8_P2_420, |
| .fChannels={{'y', 8, UNorm}, {'u', 8, UNorm}, {'v', 8, UNorm}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kYUV8_P3_420, |
| .fChannels={{'y', 8, UNorm}, {'u', 8, UNorm}, {'v', 8, UNorm}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kYUV10x6_P2_420, |
| .fChannels={{'y', 10, UNorm}, {'x', 6, Pad}, {'u', 10, UNorm}, {'x', 6, Pad}, |
| {'v', 10, UNorm}, {'x', 6, Pad}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGBA_10x6_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kYUV8_P2_422, |
| .fChannels={{'y', 8, UNorm}, {'u', 8, UNorm}, {'v', 8, UNorm}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kYUV8_P3_422, |
| .fChannels={{'y', 8, UNorm}, {'u', 8, UNorm}, {'v', 8, UNorm}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kYUV10x6_P2_422, |
| .fChannels={{'y', 10, UNorm}, {'x', 6, Pad}, {'u', 10, UNorm}, {'x', 6, Pad}, |
| {'v', 10, UNorm}, {'x', 6, Pad}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGBA_10x6_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kYUV8_P2_444, |
| .fChannels={{'y', 8, UNorm}, {'u', 8, UNorm}, {'v', 8, UNorm}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kYUV8_P3_444, |
| .fChannels={{'y', 8, UNorm}, {'u', 8, UNorm}, {'v', 8, UNorm}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGB_888x_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kYUV10x6_P2_444, |
| .fChannels={{'y', 10, UNorm}, {'x', 6, Pad}, {'u', 10, UNorm}, {'x', 6, Pad}, |
| {'v', 10, UNorm}, {'x', 6, Pad}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGBA_10x6_SkColorType, Swizzle::RGBA(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kExternal, |
| // We don't really know this, but most Skia behavior defaults to assuming 8-bit color |
| .fChannels={{'r', 8, UNorm}, {'g', 8, UNorm}, {'b', 8, UNorm}, {'a', 8, UNorm}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={{kRGBA_8888_SkColorType, Swizzle::RGBA(), std::nullopt}, |
| {kRGB_888x_SkColorType, Swizzle::RGB1(), std::nullopt}}}, |
| |
| {.fFormat=TextureFormat::kS8, |
| .fChannels={{'s', 8, Signed}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={}}, |
| |
| {.fFormat=TextureFormat::kD16, |
| .fChannels={{'d', 16, UNorm}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={}}, |
| |
| {.fFormat=TextureFormat::kD32F, |
| .fChannels={{'d', 32, Float}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={}}, |
| |
| {.fFormat=TextureFormat::kD24_S8, |
| .fChannels={{'d', 24, UNorm}, {'s', 8, Signed}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={}}, |
| |
| {.fFormat=TextureFormat::kD32F_S8, |
| .fChannels={{'d', 32, Float}, {'s', 8, Signed}}, |
| .fXferSwizzle=std::nullopt, |
| .fCompatibleColorTypes={}}, |
| }; |
| |
| // Match convention used with WrapTexture, where unknown alpha is forced to opaque via swizzle |
| Swizzle adjust_swizzle_for_alphatype(Swizzle readSwizzle, SkAlphaType at) { |
| if (at == kUnknown_SkAlphaType) { |
| return Swizzle::Concat(readSwizzle, Swizzle::RGB1()); |
| } else { |
| return readSwizzle; |
| } |
| } |
| |
| bool raster_pipeline_allowed_in_transfer(SkSpan<const Channel> src, |
| SkSpan<const Channel> dst, |
| const SkColorSpaceXformSteps& cs) { |
| // Colorspace conversions have to happen in raster pipeline |
| if (SkToBool(cs)) { |
| return true; |
| } |
| |
| if (src.size() != dst.size()) { |
| // Converting between RGB and RGBA shouldn't require raster pipeline, |
| // but larger channel swizzlings such as RGBA to A do. |
| if ((src.size() != 3 && src.size() != 4) || |
| (dst.size() != 3 && dst.size() != 4)) { |
| return true; |
| } |
| } |
| |
| auto summarize = [](SkSpan<const Channel> channels) { |
| int maxChannelBitDepth = 0; |
| ChannelDataType primaryType = UNorm; |
| bool holdsLuminance = false; |
| for (const Channel& c : channels) { |
| holdsLuminance = c.fName == 'G'; |
| if (c.fType != Pad) { |
| maxChannelBitDepth = std::max(maxChannelBitDepth, c.fBits); |
| primaryType = std::max(primaryType, c.fType); |
| } |
| } |
| return std::make_tuple(maxChannelBitDepth, primaryType, holdsLuminance); |
| }; |
| |
| auto [srcBits, srcType, srcLum] = summarize(src); |
| auto [dstBits, dstType, dstLum] = summarize(dst); |
| |
| // Data bit representation has to go through raster pipeline |
| if (srcBits != dstBits || srcType != dstType) { |
| return true; |
| } |
| |
| // Computing a luminance value has to go through raster pipeline |
| if (dstLum && !srcLum && (src.size() != 1 || src[0].fName != 'a')) { |
| return true; |
| } |
| return false; |
| } |
| |
| void validate_optimal_xfer_fn(skiatest::Reporter* r, |
| const TextureFormatXferFn& xferFn, |
| const SkColorSpaceXformSteps& cs, |
| std::optional<char> ignoreChannel, |
| const SkString& srcName, |
| SkSpan<const Channel> srcChannels, |
| const PixelData& srcData, |
| const SkString& dstName, |
| SkSpan<const Channel> dstChannels, |
| const PixelData& dstData) { |
| // If the transferred data remains unmodified, confirm that the transfer function detected that |
| // it could have been an identity transfer. We skip that due to red herrings when there's a |
| // colorspace (which would force raster pipeline always, but because of our RGB->BGR synthetic |
| // space it can sometimes leave computed values unmodified). We skip when there's a channel |
| // change (which can sometimes appear as an identity if certain channels remain 0). We skip the |
| // case when it's an ignore-src + force-opaque, because TextureFormatXferfn will choose that |
| // for alpha-only color types with unknown alpha but when the source data is alpha-only + opaque |
| // it looks equivalent. |
| const bool identityRedHerring = SkToBool(cs) || |
| srcChannels.size() != dstChannels.size() || |
| xferFn.isIgnoreSrcForceOpaque(); |
| if (!identityRedHerring && memcmp(&srcData, &dstData, sizeof(PixelData)) == 0) { |
| REPORTER_ASSERT(r, xferFn.isIdentity(), "Expected identity xfer fn between %s -> %s", |
| srcName.c_str(), dstName.c_str()); |
| } |
| |
| // The flip-side, if `xferFn` claims its the identity, then the data should match as well. |
| if (xferFn.isIdentity()) { |
| if (!compare_pixels(dstChannels, srcData, dstData, /*channelTolerance=*/0, ignoreChannel)) { |
| dump_pixel_comparison(srcName, srcChannels, srcData, |
| dstName, dstChannels, srcData, dstData); |
| REPORTER_ASSERT(r, false, "Xfer fn between %s -> %s claimed identity but was not", |
| srcName.c_str(), dstName.c_str()); |
| STOP_ON_TRANSFER_FAILURE |
| } |
| } |
| |
| // Otherwise, check that the transfer function is only relying on the raster pipeline when |
| // necessary. And if it is using raster pipeline, then it's not mixing the SIMD xfer ops. |
| if (xferFn.usesRasterPipeline()) { |
| REPORTER_ASSERT(r, raster_pipeline_allowed_in_transfer(srcChannels, dstChannels, cs), |
| "Transfer between %s -> %s unexpected uses raster pipeline", |
| srcName.c_str(), dstName.c_str()); |
| if (xferFn.usesXferOps()) { |
| // The only time it's okay to mix xfer ops and RP is for handling kDrop/kPadAlpha since |
| // the format is not representable with raster pipeline. |
| REPORTER_ASSERT(r, xferFn.isDropOrPadAlpha(), |
| "Transfer between %s -> %s mixes transfer methods", |
| srcName.c_str(), dstName.c_str()); |
| } |
| } |
| } |
| |
| void test_format_transfers(skiatest::Reporter* r, |
| const FormatExpectation& textureFormat, |
| const ColorTypeExpectation& textureCT, |
| SkAlphaType srcAT, |
| SkAlphaType dstAT, |
| bool applyCS) { |
| // When transferring to CPU->GPU, we want to apply the textureCT's write swizzle, but if that |
| // is undefined because rendering is disabled, just use RGBA. |
| Swizzle writeSwizzle = textureCT.fWriteSwizzle.value_or(Swizzle::RGBA()); |
| |
| // Adjust the R8 channel to be 'G' for gray-storing textures so that gen_pixel_data includes |
| // any conversion to or from luminance. |
| const bool isRedOnly = textureFormat.fChannels.size() == 1 && |
| textureFormat.fChannels[0].fName == 'r'; |
| skia_private::TArray<Channel> expectedTextureChannels = textureFormat.fChannels; |
| if (textureCT.fColorType == kGray_8_SkColorType) { |
| SkASSERT(isRedOnly); |
| expectedTextureChannels[0].fName = 'G'; |
| } |
| |
| // This colorspace is constructed to have a linear gamma curve and an identity gamut transform |
| // so that any operations that it applies are just multiplies by 0 or 1. Anything else adds |
| // minor bit variations to processed data, making checking expectations harder. |
| sk_sp<SkColorSpace> srcCS = SkColorSpace::MakeRGB(SkNamedTransferFn::kLinear, |
| SkNamedGamut::kXYZ); |
| sk_sp<SkColorSpace> dstCS = applyCS ? srcCS->makeColorSpin() : srcCS; |
| SkColorSpaceXformSteps csSteps{srcCS.get(), srcAT, dstCS.get(), dstAT}; |
| |
| SkString gpuLabel = SkStringPrintf("GPU format %s as %s", |
| TextureFormatName(textureFormat.fFormat), |
| ToolUtils::colortype_name(textureCT.fColorType)); |
| // Transfering from srcCT into a GPU textureFormat interpreted as textureCT |
| for (const ColorTypeChannels& src : kColorTypeChannels) { |
| // Adjust srcAT as if they had created a valid SkBitmap, which may mean skipping. Since we |
| // test every srcAT possibility, if the srcAT changes, we skip to avoid running extra work. |
| SkAlphaType validSrcAT; |
| if (!SkColorTypeValidateAlphaType(src.fColorType, srcAT, &validSrcAT) || |
| validSrcAT != srcAT) { |
| continue; |
| } |
| // Adjust the read swizzle to account for unknown alpha type semantics |
| Swizzle readSwizzle = adjust_swizzle_for_alphatype(textureCT.fReadSwizzle, dstAT); |
| std::optional<TextureFormatXferFn> xferFn = |
| TextureFormatXferFn::MakeCpuToGpu(src.fColorType, |
| csSteps, |
| textureFormat.fFormat, |
| readSwizzle); |
| REPORTER_ASSERT(r, textureFormat.fXferSwizzle.has_value() == xferFn.has_value()); |
| |
| if (textureFormat.fXferSwizzle.has_value() && xferFn.has_value()) { |
| SkString ctLabel = |
| SkStringPrintf("CPU colortype %s", ToolUtils::colortype_name(src.fColorType)); |
| auto [cpuPixel, cpuPixelBits] = gen_pixel_data(src.fChannels, Swizzle::RGBA(), srcAT); |
| |
| // The expected GPU value is formed by applying the source colortype's effective |
| // swizzle (i.e. fill in missing channels), and the format's compatible colortype's |
| // write swizzle to the channel definition of format. |
| Swizzle loadSrc = src.fEffectiveSwizzle; |
| if (applyCS) { |
| // The colorspace conversion is constructed to be a spin via gamut transform matrix, |
| // so the end effect should match a rotation swizzle on R,G,B (ignoring alpha). |
| loadSrc = Swizzle::Concat(loadSrc, Swizzle("gbra")); |
| } |
| |
| auto [expectedGpuPixel, gpuPixelBits] = gen_pixel_data(expectedTextureChannels, |
| writeSwizzle, |
| dstAT, |
| src.fChannels, |
| loadSrc, |
| validSrcAT); |
| PixelData actualGpuPixel = transfer_data(*xferFn, cpuPixel, cpuPixelBits, gpuPixelBits); |
| |
| // The data transfer can skip alpha handling if we know that all samples/reads are going |
| // to override it with 1.0 anyways. Testing the final readSwizzle includes both color |
| // type semantics that induce the swizzle and requesting unknown alpha type. |
| std::optional<char> ignoreChannel; |
| if (readSwizzle[3] == '1') { |
| // If the format stores alpha in r, we need to ignore the r value. |
| ignoreChannel = isRedOnly ? 'r' : 'a'; |
| } |
| |
| // Confirm the transfer is as optimized as possible |
| validate_optimal_xfer_fn(r, *xferFn, csSteps, ignoreChannel, |
| ctLabel, src.fChannels, cpuPixel, |
| gpuLabel, expectedTextureChannels, expectedGpuPixel); |
| |
| const int tol = channel_tolerance(src.fChannels, validSrcAT, |
| expectedTextureChannels, dstAT); |
| if (!compare_pixels(expectedTextureChannels, expectedGpuPixel, actualGpuPixel, tol, |
| ignoreChannel)) { |
| dump_pixel_comparison(ctLabel, |
| src.fChannels, |
| cpuPixel, |
| gpuLabel, |
| textureFormat.fChannels, |
| expectedGpuPixel, |
| actualGpuPixel); |
| REPORTER_ASSERT(r, false, "Pixel mismatch uploading from %s, alpha %s -> %s%s", |
| ctLabel.c_str(), |
| ToolUtils::alphatype_name(validSrcAT), |
| ToolUtils::alphatype_name(dstAT), |
| applyCS ? " with colorspace conversion" : ""); |
| STOP_ON_TRANSFER_FAILURE |
| } |
| } |
| } |
| |
| // Transfering from a GPU textureFormat interpreted as textureCT into dstCT |
| for (const ColorTypeChannels& dst : kColorTypeChannels) { |
| // Adjust dstAT as if they had created a valid SkBitmap, which may mean skipping. Since we |
| // test every dstAT possibility, if the dstAT changes, we skip to avoid running extra work. |
| SkAlphaType validDstAT; |
| if (!SkColorTypeValidateAlphaType(dst.fColorType, dstAT, &validDstAT) || |
| validDstAT != dstAT) { |
| continue; |
| } |
| // Adjust the read swizzle to account for unknown alpha type semantics |
| Swizzle readSwizzle = adjust_swizzle_for_alphatype(textureCT.fReadSwizzle, srcAT); |
| std::optional<TextureFormatXferFn> xferFn = |
| TextureFormatXferFn::MakeGpuToCpu(textureFormat.fFormat, |
| readSwizzle, |
| csSteps, |
| dst.fColorType); |
| REPORTER_ASSERT(r, textureFormat.fXferSwizzle.has_value() == xferFn.has_value()); |
| |
| if (textureFormat.fXferSwizzle.has_value() && xferFn.has_value()) { |
| SkString ctLabel = |
| SkStringPrintf("CPU colortype %s", ToolUtils::colortype_name(dst.fColorType)); |
| auto [gpuPixel, gpuPixelBits] = gen_pixel_data(expectedTextureChannels, |
| textureCT.fReadSwizzle, |
| srcAT); |
| |
| // The expected CPU value is formed by applying the TextureFormat's implicit transfer |
| // swizzle (i.e. fill in missing channels), its compatible colortype's read swizzle |
| // to the channel definition of the dst color type. |
| Swizzle loadSrc = Swizzle::Concat(*textureFormat.fXferSwizzle, readSwizzle); |
| if (applyCS) { |
| loadSrc = Swizzle::Concat(loadSrc, Swizzle("gbra")); // See above |
| } |
| auto [expectedCpuPixel, cpuPixelBits] = gen_pixel_data(dst.fChannels, |
| Swizzle::RGBA(), |
| dstAT, |
| expectedTextureChannels, |
| loadSrc, |
| srcAT); |
| // Confirm the transfer is as optimized as possible |
| validate_optimal_xfer_fn(r, *xferFn, csSteps, /*ignoreChannel=*/std::nullopt, |
| gpuLabel, expectedTextureChannels, gpuPixel, |
| ctLabel, dst.fChannels, expectedCpuPixel); |
| |
| PixelData actualCpuPixel = transfer_data(*xferFn, gpuPixel, gpuPixelBits, cpuPixelBits); |
| |
| const int tol = channel_tolerance(expectedTextureChannels, srcAT, |
| dst.fChannels, dstAT); |
| if (!compare_pixels(dst.fChannels, expectedCpuPixel, actualCpuPixel, tol)) { |
| dump_pixel_comparison(gpuLabel, |
| textureFormat.fChannels, |
| gpuPixel, |
| ctLabel, |
| dst.fChannels, |
| expectedCpuPixel, |
| actualCpuPixel); |
| REPORTER_ASSERT(r, false, "Pixel mismatch reading back to %s, alpha %s -> %s%s", |
| ctLabel.c_str(), |
| ToolUtils::alphatype_name(srcAT), |
| ToolUtils::alphatype_name(dstAT), |
| applyCS ? " with colorspace conversion" : ""); |
| STOP_ON_TRANSFER_FAILURE |
| } |
| } |
| } |
| } |
| |
| void run_texture_format_test(skiatest::Reporter* r, const Caps* caps, TextureFormat format) { |
| bool foundExpectation = false; |
| for (auto&& e : kExpectations) { |
| if (e.fFormat != format) { |
| continue; |
| } |
| |
| // Should only find it once |
| REPORTER_ASSERT(r, !foundExpectation, "Format expectation listed multiple times"); |
| foundExpectation = true; |
| |
| skiatest::ReporterContext scope(r, SkStringPrintf("Format %s", TextureFormatName(format))); |
| |
| // Found the expectation for the requested format. Check fixed properties first. |
| REPORTER_ASSERT(r, e.fCompressionType == TextureFormatCompressionType(format)); |
| REPORTER_ASSERT(r, e.bytesPerBlock() == TextureFormatBytesPerBlock(format)); |
| REPORTER_ASSERT(r, e.channelMask() == TextureFormatChannelMask(format)); |
| REPORTER_ASSERT(r, e.hasDepthOrStencil() == TextureFormatIsDepthOrStencil(format)); |
| REPORTER_ASSERT(r, e.hasDepth() == TextureFormatHasDepth(format)); |
| REPORTER_ASSERT(r, e.hasStencil() == TextureFormatHasStencil(format)); |
| REPORTER_ASSERT(r, e.isMultiplanar() == TextureFormatIsMultiplanar(format)); |
| REPORTER_ASSERT(r, e.autoClamps() == TextureFormatAutoClamps(format)); |
| REPORTER_ASSERT(r, e.isFloatingPoint() == TextureFormatIsFloatingPoint(format)); |
| |
| // Verify compatible color types |
| auto [baseColorType, _] = TextureFormatColorTypeInfo(format); |
| if (baseColorType == kUnknown_SkColorType) { |
| REPORTER_ASSERT(r, e.fCompatibleColorTypes.empty()); |
| } else { |
| // Should be the first listed compatible color type |
| REPORTER_ASSERT(r, !e.fCompatibleColorTypes.empty()); |
| REPORTER_ASSERT(r, e.fCompatibleColorTypes[0].fColorType == baseColorType); |
| } |
| |
| for (int c = 0; c <= kLastEnum_SkColorType; ++c) { |
| SkColorType ct = static_cast<SkColorType>(c); |
| |
| skiatest::ReporterContext ctScope{ |
| r, SkStringPrintf("color type %s\n", ToolUtils::colortype_name(ct))}; |
| |
| bool foundColorExpectation = false; |
| for (auto&& ec : e.fCompatibleColorTypes) { |
| if (ec.fColorType == ct) { |
| // Expected to be compatible (and should only find it once) |
| REPORTER_ASSERT(r, !foundColorExpectation, |
| "Color type listed multiple times: %s", |
| ToolUtils::colortype_name(ec.fColorType)); |
| foundColorExpectation = true; |
| |
| // Check swizzles and transfers here, the rest of the color type checks happen |
| // outside the loop based on `foundColorExpectation`. |
| Swizzle actualReadSwizzle = ReadSwizzleForColorType(ct, format); |
| REPORTER_ASSERT(r, ec.fReadSwizzle == actualReadSwizzle, |
| "actual %s vs. expected %s", |
| actualReadSwizzle.asString().c_str(), |
| ec.fReadSwizzle.asString().c_str()); |
| |
| auto actualWriteSwizzle = WriteSwizzleForColorType(ct, format); |
| if (ec.fWriteSwizzle.has_value()) { |
| REPORTER_ASSERT(r, actualWriteSwizzle.has_value()); |
| REPORTER_ASSERT(r, ec.fWriteSwizzle == actualWriteSwizzle, |
| "actual %s vs. expected %s", |
| actualWriteSwizzle ? actualWriteSwizzle->asString().c_str() |
| : "null", |
| ec.fWriteSwizzle->asString().c_str()); |
| } else { |
| REPORTER_ASSERT(r, !actualWriteSwizzle.has_value()); |
| // This is a proxy for "the format can represent CT, and there are some |
| // formats that can render CT, but this format does not render w/ CT". |
| TextureInfo renderableInfo = caps->getDefaultSampledTextureInfo( |
| ct, Mipmapped::kNo, Protected::kNo, Renderable::kYes); |
| REPORTER_ASSERT(r, format != TextureInfoPriv::ViewFormat(renderableInfo)); |
| } |
| |
| // Test sampled and readable copy info |
| TextureInfo sampledInfo = caps->getDefaultSampledTextureInfo( |
| ct, Mipmapped::kNo, Protected::kNo, Renderable::kNo); |
| if (sampledInfo.isValid() && |
| TextureInfoPriv::ViewFormat(sampledInfo) == format) { |
| REPORTER_ASSERT(r, caps->isTexturable(sampledInfo)); |
| REPORTER_ASSERT(r, caps->isReadable(sampledInfo)); |
| TextureInfo copyInfo = caps->getTextureInfoForSampledCopy( |
| sampledInfo, Mipmapped::kNo); |
| REPORTER_ASSERT(r, copyInfo.isValid()); |
| } |
| |
| TextureInfo readableInfo = caps->getDefaultReadableTextureInfo( |
| format, Protected::kNo); |
| if (readableInfo.isValid() && |
| TextureInfoPriv::ViewFormat(readableInfo) == format) { |
| REPORTER_ASSERT(r, caps->isReadable(readableInfo)); |
| TextureInfo copyInfo = caps->getTextureInfoForReadableCopy(readableInfo); |
| REPORTER_ASSERT(r, copyInfo.isValid()); |
| } |
| |
| TextureInfo storageInfo = caps->getDefaultReadableStorageTextureInfo( |
| format, Protected::kNo); |
| if (storageInfo.isValid() && |
| TextureInfoPriv::ViewFormat(storageInfo) == format) { |
| REPORTER_ASSERT(r, caps->isStorage(storageInfo)); |
| REPORTER_ASSERT(r, caps->isReadable(storageInfo)); |
| } |
| |
| // Test all combinations of alpha type x 2 (texture vs cpu) and whether or not |
| // colorspace conversions are handled in the transfer. |
| static constexpr int kAlphaTypeCount = (int) kLastEnum_SkAlphaType + 1; |
| for (bool applyCS : {false, true}) { |
| for (int srcAT = 0; srcAT < kAlphaTypeCount; ++srcAT) { |
| for (int dstAT = 0; dstAT < kAlphaTypeCount; ++dstAT) { |
| test_format_transfers(r, e, ec, |
| static_cast<SkAlphaType>(srcAT), |
| static_cast<SkAlphaType>(dstAT), |
| applyCS); |
| } |
| } |
| } |
| } |
| } |
| |
| // If we found an expectation, it should be detected as compatible (and false otherwise) |
| const bool actualCompatible = AreColorTypeAndFormatCompatible(ct, format); |
| REPORTER_ASSERT(r, foundColorExpectation == actualCompatible, |
| "actual (%d) vs expected (%d)", |
| actualCompatible, foundColorExpectation); |
| } |
| } |
| |
| // All formats should have expectations |
| REPORTER_ASSERT(r, foundExpectation, "Missing expectation for %s", TextureFormatName(format)); |
| } |
| |
| DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS(TextureFormatTest, r, ctx, CtsEnforcement::kApiLevel_202604) { |
| for (int i = 0; i < kTextureFormatCount; ++i) { |
| run_texture_format_test(r, ctx->priv().caps(), static_cast<TextureFormat>(i)); |
| } |
| } |
| |
| } // namespace skgpu::graphite |
