Google GitGoogle Git
Sign in
skia/skia/655fcc60a0f24d5bc4afb3c781d187f27703e077/./src/gpu/graphite/TextureFormatXferFn.cpp
blob: 15cf532e8fd255917b917cbb1a316ab66df70d6e [file]
/*
* 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 "src/gpu/graphite/TextureFormatXferFn.h"
#include "include/core/SkColorType.h"
#include "include/private/SkLog.h"
#include "src/core/SkAutoMalloc.h"
#include "src/core/SkColorSpaceXformSteps.h"
#include "src/core/SkFloatBits.h"
#include "src/core/SkHalf.h"
#include "src/core/SkImageInfoPriv.h"
#include "src/core/SkMathPriv.h"
#include "src/core/SkRasterPipeline.h"
#include "src/core/SkRasterPipelineOpContexts.h"
#include "src/core/SkRasterPipelineOpList.h"
#include "src/core/SkSwizzlePriv.h"
#include "src/core/SkVx.h"
#include <functional>
namespace skgpu::graphite {
namespace {
using TF = TextureFormat;
// This is intentionally not a class enum and is distinct from FormatXferOps for two reasons:
// 1. We can't use SkEnumBitmask inside template parameters for the row bit manipulation functions.
// 2. It's convenient to split the FormatXferOps into specific ops based on their conversion
// direction that doesn't need to be exposed in the public API.
enum ExtendedFormatXferOp : uint8_t {
kDropAlpha = 0x1, // FormatXferOp::kDropAlpha for CPU->GPU conversion
kPadAlpha = 0x2, // FormatXferOp::kDropAlpha for GPU->CPU conversion
kSwapRB = 0x4, // FormatXferOp::kSwapRB behaves the same for either conversion direction
kForceOpaque = 0x8, // RGBx handling to avoid raster pipeline is the same in both directions
kIgnoreSrc = 0x10, // The output value does not depend on the src, will be either 0 or 1.
};
using XferRowFn = std::function<void(const char* src, char* dst, int width)>;
template <typename Px, int N, typename PixelFn /* [](Vec<N,Px>, Px opaqueAlpha) -> Vec<N,Px> */>
XferRowFn create_xfer_row_fn(int n, int srcBpp, int dstBpp,
Px opaqueAlpha, Px zeroValue, PixelFn applyPixel) {
using PxVec = skvx::Vec<N, Px>;
if (srcBpp != 0) {
// PxVec should be sufficient to hold N src and dst pixels, and should match at least one
SkASSERT(sizeof(PxVec) >= (size_t)srcBpp*n && sizeof(PxVec) >= (size_t)dstBpp*n);
SkASSERT(sizeof(PxVec) == (size_t)srcBpp*n || sizeof(PxVec) == (size_t)dstBpp*n);
// NOTE: These must all be named explicitly, since using the & to auto-capture does not copy
// them, so then their references become corrupted when executing the lambda later.
return [n, srcBpp, dstBpp, opaqueAlpha, applyPixel](const char* src, char* dst, int width) {
const int srcBppN = n * srcBpp;
const int dstBppN = n * dstBpp;
PxVec pixel{};
while (width >= n) {
memcpy(&pixel, src, srcBppN);
pixel = applyPixel(pixel, opaqueAlpha);
memcpy(dst, &pixel, dstBppN);
width -= n;
src += srcBppN;
dst += dstBppN;
}
if (width > 0) {
// Process tail that is less than a full vector
SkASSERT(width < n);
memcpy(&pixel, src, width * srcBpp);
pixel = applyPixel(pixel, opaqueAlpha);
memcpy(dst, &pixel, width * dstBpp);
}
};
} else {
// Ignore the source in favor of loading zeroValue into pixel each time
SkASSERT(sizeof(PxVec) >= (size_t)dstBpp*n);
return [n, opaqueAlpha, zeroValue, dstBpp, applyPixel](const char*, char* dst, int width) {
const int dstBppN = n * dstBpp;
PxVec pixel{};
while (width >= n) {
pixel = zeroValue;
pixel = applyPixel(pixel, opaqueAlpha);
memcpy(dst, &pixel, dstBppN);
width -= n;
dst += dstBppN;
}
if (width > 0) {
// Process tail that is less than a full vector
SkASSERT(width < n);
pixel = zeroValue;
pixel = applyPixel(pixel, opaqueAlpha);
memcpy(dst, &pixel, width * dstBpp);
}
};
}
}
// N represents the number of pixels being processed; each pixel is packed into a single element of
// the Vec. To implement kSwapRB, this requires that the R and B channels have the same number of
// bits. It arbitrarily requires that R is originally in the lower-significance bits relative to B.
template <typename Px, int N, uint8_t Ops, Px RShift, Px BShift, Px RBBits>
skvx::Vec<N, Px> apply_ops_packed(skvx::Vec<N, Px> pixel, Px opaqueAlpha) {
static_assert(!(Ops & (kPadAlpha | kDropAlpha)), "Packed formats do not drop/pad alpha");
static_assert(RShift < BShift, "Shifts are not in the correct significance order");
static_assert(RShift + RBBits <= BShift, "Low swap channel overflows");
static_assert(BShift + RBBits <= sizeof(Px)*8, "Hi swap channel overflows");
if constexpr (Ops & kSwapRB) {
static constexpr Px kChannelMask = (1 << RBBits) - 1;
static constexpr Px kRMask = kChannelMask << RShift;
static constexpr Px kBMask = kChannelMask << BShift;
pixel = (pixel & ~(kRMask | kBMask)) | // Preserve non-RB bits
((pixel & kRMask) << (BShift - RShift)) | // Move red (lo) to blue (hi) position
((pixel & kBMask) >> (BShift - RShift)); // Move blue (hi) to red (lo) position
}
if constexpr (Ops & kForceOpaque) {
// This assumes the opaqueAlpha value will have 0 bits set in the R,G,B channels.
pixel = pixel | opaqueAlpha;
}
return pixel;
}
// NOTE: This takes no parameters for alpha because none of the formats that use this support
// kDrop/PadAlpha. Since the channels are packed into Px, both source and dst must have the same bpp
// `opaqueAlpha` specifies the bit pattern for the entire pixel representing {0, 0, 0, 1.0}.
// `zeroValue` specifies the bit pattern for the entire pixel representing {0, 0, 0, 0}.
template <typename Px, Px RShift, Px BShift, Px RBBits>
XferRowFn xfer_rows_packed(uint8_t ops, Px opaqueAlpha, Px zeroValue = 0) {
static constexpr int kBpp = sizeof(Px);
static constexpr int N = 16 / sizeof(Px); // Fit to 128-bit/16-byte SIMD
static_assert(N == 1 || N == 2 || N == 4 || N == 8);
#define RETURN_XFER_ROW_FN(ops) \
case ops: \
return create_xfer_row_fn<Px, N>( \
N, (ops) & kIgnoreSrc ? 0 : kBpp, kBpp, opaqueAlpha, zeroValue, \
apply_ops_packed<Px, N, (ops) & ~kIgnoreSrc, RShift, BShift, RBBits>); \
switch (ops) {
// The expected combination of ExtendedFormatXferOps
RETURN_XFER_ROW_FN(kSwapRB)
RETURN_XFER_ROW_FN(kIgnoreSrc)
RETURN_XFER_ROW_FN(kForceOpaque)
RETURN_XFER_ROW_FN(kForceOpaque | kSwapRB)
RETURN_XFER_ROW_FN(kForceOpaque | kIgnoreSrc)
default:
SK_ABORT("Unsupported ExtendedFormatXferOps combination: %u", ops);
}
#undef RETURN_XFER_ROW_FN
}
// N represents the number of pixels being processed; some Ops are only supported for C == 1 or
// C == 4. For other channel counts, those Ops are ignored at compile time (to make the ops switch
// tables easier to write). Hopefully the linker will see that they are equivalent to the template
// w/o the incompatible Ops.
template <typename Cx, int N, int CPow2, uint8_t Ops>
skvx::Vec<CPow2*N, Cx> apply_ops_by_channel(skvx::Vec<CPow2*N, Cx> pixel, Cx opaqueAlpha) {
static_assert(CPow2 == 1 || CPow2 == 2 || CPow2 == 4);
if constexpr (Ops & kPadAlpha && CPow2 == 4) {
// If we are padding alpha, we are moving from a 3-channel source data (loaded in the first
// N*3 values of pixel) to a 4-channel value. 3*N+1 holds undefined data after loading the
// pixel, which we can set to the opaque alpha value. Then we shuffle the slots to spread
// out each pixel's R,G, and B values and insert copies of the opaque alpha value.
static constexpr int kA = 3*N;
pixel[kA] = opaqueAlpha;
if constexpr (N == 4) {
pixel = skvx::shuffle<0,1,2,kA, 3,4,5,kA, 6,7,8,kA, 9,10,11,kA>(pixel);
} else if constexpr (N == 2) {
pixel = skvx::shuffle<0,1,2,kA, 3,4,5,kA>(pixel);
} else {
// No shuffling needed for N=1, since pixel == shuffle<0,1,2,A>(pixel)
static_assert(N == 1);
}
}
// Ops that assume 4 channels can be applied between kPadAlpha and kDropAlpha w/o worrying about
// how to handle the 3-channel formats.
if constexpr (Ops & kSwapRB && CPow2 == 4) {
// For all 3 and 4 channel formats, it is assumed that R and B are in channels 0 and 2.
if constexpr (N == 4) {
pixel = skvx::shuffle<2,1,0,3, 6,5,4,7, 10,9,8,11, 14,13,12,15>(pixel);
} else if constexpr (N == 2) {
pixel = skvx::shuffle<2,1,0,3, 6,5,4,7>(pixel);
} else {
static_assert(N == 1);
pixel = skvx::shuffle<2,1,0,3>(pixel);
}
}
// 2-channel formats are incompatible with forcing opaque since there's never an alpha channel
if constexpr (Ops & kForceOpaque && (CPow2 != 2)) {
if constexpr (CPow2 == 1) {
// For single-channel formats, the opaque alpha gets splatted over the whole vector
pixel = opaqueAlpha;
} else {
// Between kPadAlpha and kDropAlpha, it is assumed that alpha is always channel 3
if constexpr (N == 4) {
pixel[3] = pixel[7] = pixel[11] = pixel[15] = opaqueAlpha;
} else if constexpr (N == 2) {
pixel[3] = pixel[7] = opaqueAlpha;
} else {
static_assert(N == 1);
pixel[3] = opaqueAlpha;
}
}
}
if constexpr (Ops & kDropAlpha && CPow2 == 4) {
// If we are dropping alpha, we need to shuffle the R,G, and B values of the 4-channel
// source data into the first N*3 slots of the returned pixel. The remaining N slots will
// be ignored by the final memcpy.
if constexpr (N == 4) {
pixel = skvx::shuffle<0,1,2, 4,5,6, 8,9,10, 12,13,14, 14,14,14,14>(pixel);
} else if constexpr (N == 2) {
pixel = skvx::shuffle<0,1,2, 4,5,6, 6,6>(pixel);
} else {
// No shuffling needed for N=1, since pixel == shuffle<0,1,2,_>(pixel)
static_assert(N == 1);
}
}
return pixel;
}
// NOTE: This takes no parameters for SwapRB or DropAlpha because for all formats that use this,
// SwapRB involves swapping channel 0 and channel 2, and dropping alpha removes channel 3. This
// can be parameterized via template parameters to be able to push into the skvx::shuffle calls
// if needed in the future.
// `opaqueAlpha` specifies the bit pattern for a channel representing 1.0.
// `zeroValue` specifies the bit pattern for a channel representing 0.0.
template <typename Cx, int C>
XferRowFn xfer_rows_by_channel(uint8_t ops, Cx opaqueAlpha, Cx zeroValue=0) {
static_assert(C == 1 || C == 2 || C == 3 || C == 4);
static constexpr int CPow2 = SkNextPow2(C);
static constexpr int N = 16 / (CPow2 * sizeof(Cx)); // Fit to 128-bit/16-byte SIMD
static_assert(N == 1 || N == 2 || N == 4 || N == 8 || N == 16);
int srcBpp = C * sizeof(Cx);
int dstBpp = C * sizeof(Cx);
if (ops & kDropAlpha) {
// Going from 4-channel src to the 3-channel format
SkASSERT(C == 3);
srcBpp = CPow2 * sizeof(Cx);
} else if (ops & kPadAlpha) {
// Going from the 3-channel format to 4-channel dst
SkASSERT(C == 3);
dstBpp = CPow2 * sizeof(Cx);
}
#define RETURN_XFER_ROW_FN(ops) \
case ops: \
return create_xfer_row_fn<Cx, N*CPow2>( \
N, (ops) & kIgnoreSrc ? 0 : srcBpp, dstBpp, opaqueAlpha, zeroValue, \
apply_ops_by_channel<Cx, N, CPow2, (ops) & ~kIgnoreSrc>);
switch (ops) {
// The expected combination of ExtendedFormatXferOps
RETURN_XFER_ROW_FN(kDropAlpha)
RETURN_XFER_ROW_FN(kDropAlpha | kSwapRB)
RETURN_XFER_ROW_FN(kDropAlpha | kIgnoreSrc)
RETURN_XFER_ROW_FN(kPadAlpha)
RETURN_XFER_ROW_FN(kPadAlpha | kSwapRB)
RETURN_XFER_ROW_FN(kPadAlpha | kIgnoreSrc)
RETURN_XFER_ROW_FN(kSwapRB)
RETURN_XFER_ROW_FN(kIgnoreSrc)
RETURN_XFER_ROW_FN(kForceOpaque)
RETURN_XFER_ROW_FN(kForceOpaque | kSwapRB)
RETURN_XFER_ROW_FN(kForceOpaque | kIgnoreSrc)
default:
SK_ABORT("Unsupported ExtendedFormatXferOps combination: %u", ops);
}
#undef RETURN_XFERFN_CASE
}
XferRowFn get_xfer_row_fn(TextureFormat format, uint8_t ops) {
static constexpr uint32_t kFloatBits1 = 0x3f800000; // SkFloat2Bits isn't constexpr
SkASSERT(kFloatBits1 == SkFloat2Bits(1.f));
// 10 bits for _XR formats that encodes 1.0 and 0.0 given their extended normalization range.
static constexpr uint32_t kXROne = 0x37e;
static constexpr uint32_t kXRZero = 0x180;
SkASSERT(ops); // For now, assume we only call into this if we have work to do.
switch (format) {
// Packed formats operate on a primitive that holds the entire pixel value
case TF::kB5_G6_R5:
case TF::kR5_G6_B5:
return xfer_rows_packed<uint16_t, /*RShift=*/0, /*BShift=*/11, /*RBBits=*/5>(
ops, /*opaqueAlpha=*/0);
case TF::kABGR4:
case TF::kARGB4:
return xfer_rows_packed<uint16_t, /*RShift=*/4, /*BShift=*/12, /*RBBits=*/4>(
ops, /*opaqueAlpha=*/0xF);
case TF::kRGB10_A2:
case TF::kBGR10_A2:
return xfer_rows_packed<uint32_t, /*RShift=*/0, /*BShift=*/20, /*RBBits=*/10>(
ops, /*opaqueAlpha=*/0b11 << 30);
case TF::kBGR10_XR:
// NOTE: opaqueAlpha doesn't matter here since it's just BGRx data, but to match
// SkRP's handling of BGR10A2_XR, treat the last 2 bits as regular unorm.
return xfer_rows_packed<uint32_t, /*RShift=*/0, /*BShift=*/20, /*RBBits=*/10>(
ops, /*opaqueAlpha=*/0b11 << 30,
/*zeroValue=*/(kXRZero << 20) | (kXRZero << 10) | kXRZero);
// The remaining formats can be operated on with each channel as a primitive
case TF::kR8:
case TF::kA8:
return xfer_rows_by_channel<uint8_t, /*C=*/1>(ops, /*opaqueAlpha=*/0xFF);
case TF::kR16:
return xfer_rows_by_channel<uint16_t, /*C=*/1>(ops, /*opaqueAlpha=*/0xFFFF);
case TF::kR16F:
return xfer_rows_by_channel<uint16_t, /*C=*/1>(ops, /*opaqueAlpha=*/SK_Half1);
case TF::kRG8:
return xfer_rows_by_channel<uint8_t, /*C=*/2>(ops, /*opaqueAlpha=*/0xFF);
case TF::kRG16:
return xfer_rows_by_channel<uint16_t, /*C=*/2>(ops, /*opaqueAlpha=*/0xFF);
case TF::kRG16F:
return xfer_rows_by_channel<uint16_t, /*C=*/2>(ops, /*opaqueAlpha=*/SK_Half1);
case TF::kRG32F:
return xfer_rows_by_channel<uint32_t, /*C=*/2>(ops, /*opaqueAlpha=*/kFloatBits1);
case TF::kRGB8_sRGB:
case TF::kRGB8:
case TF::kBGR8:
return xfer_rows_by_channel<uint8_t, /*C=*/3>(ops, /*opaqueAlpha=*/0xFF);
case TF::kRGB16:
return xfer_rows_by_channel<uint16_t, /*C=*/3>(ops, /*opaqueAlpha=*/0xFFFF);
case TF::kRGB16F:
return xfer_rows_by_channel<uint16_t, /*C=*/3>(ops, /*opaqueAlpha=*/SK_Half1);
case TF::kRGB32F:
return xfer_rows_by_channel<uint32_t, /*C=*/3>(ops, /*opaqueAlpha=*/kFloatBits1);
case TF::kRGBA8:
case TF::kRGBA8_sRGB:
case TF::kBGRA8:
case TF::kBGRA8_sRGB:
return xfer_rows_by_channel<uint8_t, /*C=*/4>(ops, /*opaqueAlpha=*/0xFF);
case TF::kRGBA10x6:
// Each channel is the 10 real bits, with the least significant 6 padding bits.
return xfer_rows_by_channel<uint16_t, /*C=*/4>(ops, /*opaqueAlpha=*/0xFFC0);
case TF::kBGRA10x6_XR:
// Like RGBA10x6 except the constants have to fit the extended range.
return xfer_rows_by_channel<uint16_t, /*C=*/4>(
ops, /*opaqueAlpha=*/kXROne << 6, /*zeroValue=*/kXRZero << 6);
case TF::kRGBA16:
return xfer_rows_by_channel<uint16_t, /*C=*/4>(ops, /*opaqueAlpha=*/0xFFFF);
case TF::kRGBA16F:
return xfer_rows_by_channel<uint16_t, /*C=*/4>(ops, /*opaqueAlpha=*/SK_Half1);
case TF::kRGBA32F:
return xfer_rows_by_channel<uint32_t, /*C=*/4>(ops, /*opaqueAlpha=*/kFloatBits1);
default:
// Remaining cases are compressed, multiplanar, or non-color so shouldn't be reached.
// If the first assert trips, we missed a valid transfer format in the cases above.
// If we hit the unreachable, we missed rejecting the transfer sooner.
SkASSERT(TextureFormatColorTypeInfo(format).second & FormatXferOp::kDisabled);
SkUNREACHABLE;
}
}
// --- Functions for collapsing equivalent colortypes and formats into fewer xfer ops
// An RPModifier for RPOps::Make() that handles calculating bt709 luminance. The API is that it
// must have an explicit bool operator, and an apply(SkRasterPipeline*) function.
struct BT709Luminance {
bool fEnabled;
explicit operator bool() const { return fEnabled; }
void apply(SkRasterPipeline* rp) const {
if (fEnabled) {
rp->append(SkRasterPipelineOp::bt709_luminance_or_luma_to_alpha);
} // else no op needed
}
};
bool account_for_luminance(SkColorType srcCT,
bool hasColorSpaceTransform,
SkColorType* dstCT) {
if (*dstCT == kGray_8_SkColorType) {
if (srcCT != kGray_8_SkColorType || hasColorSpaceTransform) {
// Luminance must be calculated by raster pipeline, but we'll have to apply it before
// any srcToDst swizzle, so pull it out to its own RPModifier. The op stores the value
// in the alpha channel, so that needs to be dstCT that SkRasterPipeline sees.
*dstCT = kAlpha_8_SkColorType;
return true;
} // else leave it as gray->gray
} else if (srcCT == kGray_8_SkColorType &&
*dstCT == kR8_unorm_SkColorType &&
!hasColorSpaceTransform) {
// The source gray value can just be copied to the red channel, so adjust this to be
// gray->"gray" for a no-op copy
*dstCT = kGray_8_SkColorType;
return false;
} // else trivially no extra luminance needs to be calculated, leave dstCT as-is
return false;
}
bool rgbx_to_rgba(SkColorType* ct) {
switch (*ct) {
case kRGB_888x_SkColorType: *ct = kRGBA_8888_SkColorType; return true;
case kRGB_101010x_SkColorType: *ct = kRGBA_1010102_SkColorType; return true;
case kRGB_F16F16F16x_SkColorType: *ct = kRGBA_F16_SkColorType; return true;
case kBGR_101010x_SkColorType: *ct = kBGRA_1010102_SkColorType; return true;
default:
// No colortype consolidation possible by switching to a kForceOpaque op instead.
return false;
}
}
bool bgra_to_rgba(SkColorType* ct) {
switch (*ct) {
case kBGRA_8888_SkColorType: *ct = kRGBA_8888_SkColorType; return true;
case kBGRA_1010102_SkColorType: *ct = kRGBA_1010102_SkColorType; return true;
case kBGR_101010x_SkColorType: *ct = kRGB_101010x_SkColorType; return true;
// NOTE: For now there's no RGBA version of the _XR color types, so they can't be swapped
case kBGRA_10101010_XR_SkColorType:
case kBGR_101010x_XR_SkColorType: [[fallthrough]];
default:
// No colortype consolidation possible by switching to a kSwapRB op instead.
return false;
}
}
uint32_t gray_adjusted_channels(SkColorType ct) {
return ct == kGray_8_SkColorType ? kRGB_SkColorChannelFlags : SkColorTypeChannelFlags(ct);
}
uint32_t swizzle_adjusted_channels(uint32_t channels, Swizzle swizzle) {
auto removeChannelIfConstant = [&](SkColorChannelFlag flag, int index) {
if (swizzle[index] == '0' || swizzle[index] == '1') {
channels &= ~flag;
}
};
removeChannelIfConstant(kRed_SkColorChannelFlag, 0);
removeChannelIfConstant(kGreen_SkColorChannelFlag, 1);
removeChannelIfConstant(kBlue_SkColorChannelFlag, 2);
removeChannelIfConstant(kAlpha_SkColorChannelFlag, 3);
return channels;
}
template <bool TextureIsDst>
std::pair</*ops=*/uint8_t, /*computeLuminance=*/bool> optimize_transfer(
SkColorType* cpuCT,
SkColorType* texBaseCT,
Swizzle* texReadSwizzle,
SkColorSpaceXformSteps* csSteps,
SkEnumBitMask<FormatXferOp> xferOps) {
// Aliases for color types that are based on the transfer direction
SkColorType* srcCT = TextureIsDst ? cpuCT : texBaseCT;
SkColorType* dstCT = TextureIsDst ? texBaseCT : cpuCT;
uint8_t finalOps = 0;
// Some combinations of swizzle and load/store ops in raster pipeline are redundant so try to
// make adjustments to reduce or eliminate the use of raster pipeline entirely.
// First, adjust texBaseCT to match colortype semantics that can be inferred from swizzle for
// alpha-only and red-only color types (hopefully creating a no-op transfer). These also test
// the forced-opaque swizzle equivalents.
{
SkColorType adjustedBase = *texBaseCT;
if (*texReadSwizzle == Swizzle("000r") || *texReadSwizzle == Swizzle("0001")) {
// Red -> Alpha so shift the texture's "base" colortype to be the its alpha type
switch(adjustedBase) {
case kR8_unorm_SkColorType: adjustedBase = kAlpha_8_SkColorType; break;
case kR16_unorm_SkColorType: adjustedBase = kA16_unorm_SkColorType; break;
case kR16_float_SkColorType: adjustedBase = kA16_float_SkColorType; break;
default: break; // Go through regular RP + swizzle flow
}
} else if ((*texReadSwizzle == Swizzle("rrra") || *texReadSwizzle == Swizzle("rrr1")) &&
adjustedBase == kR8_unorm_SkColorType) {
// Red -> Gray so shift to kGray, which either ensures RP will generate the gray values
// from a non-gray input, or will be detected as a no-op when transferring to/from
// existing gray.
adjustedBase = kGray_8_SkColorType;
}
if (adjustedBase != *texBaseCT) {
*texBaseCT = adjustedBase;
// Must preserve any forced opacity in the swizzle
if ((SkColorTypeChannelFlags(adjustedBase) & kAlpha_SkColorChannelFlag) &&
(*texReadSwizzle)[3] == '1') {
*texReadSwizzle = Swizzle::RGB1();
} else {
*texReadSwizzle = Swizzle::RGBA();
}
}
}
// Second, remove normalized floating point semantics, since historically we don't enforce them
// during transfers (for better or worse).
{
if (*srcCT == kRGBA_F16Norm_SkColorType) {
*srcCT = kRGBA_F16_SkColorType;
}
if (*dstCT == kRGBA_F16Norm_SkColorType) {
*dstCT = kRGBA_F16_SkColorType;
}
}
// Third, discard colorspace conversions if there's no RGB data that would be adjusted
{
if (SkToBool(*csSteps) &&
(SkColorTypeIsAlphaOnly(*srcCT) || SkColorTypeIsAlphaOnly(*dstCT))) {
*csSteps = {};
}
}
// Fourth, switch swizzle components back to their default if the format doesn't have them
{
uint32_t texChannels = SkColorTypeChannelFlags(*texBaseCT);
const char c[4] = {(*texReadSwizzle)[0], (*texReadSwizzle)[1],
(*texReadSwizzle)[2], (*texReadSwizzle)[3]};
*texReadSwizzle = Swizzle((texChannels & kRed_SkColorChannelFlag) ? c[0] : 'r',
(texChannels & kGreen_SkColorChannelFlag) ? c[1] : 'g',
(texChannels & kBlue_SkColorChannelFlag) ? c[2] : 'b',
(texChannels & kAlpha_SkColorChannelFlag) ? c[3] : 'a');
}
// Fifth, if the channels are disjoint between the src and the dst, then the dst values can
// ignore the source, at which point we reset everything else to the identity and flag what
// value is required by the dst (1 if the dst is alpha, 0 if it's RGB/gray).
{
uint32_t cpuChannels = gray_adjusted_channels(*cpuCT);
uint32_t gpuChannels = swizzle_adjusted_channels(gray_adjusted_channels(*texBaseCT),
*texReadSwizzle);
if (!(gpuChannels & cpuChannels)) {
finalOps |= kIgnoreSrc;
if (SkToBool(xferOps & FormatXferOp::kDropAlpha)) {
// We're skipping the final xfer op handling, but we still have to make sure to drop
// the alpha channel for 3-channel formats
if constexpr (TextureIsDst) {
finalOps |= kDropAlpha;
} else {
// Normally this would be kPadAlpha, but we're ignoring the src texture data,
// so instead it can just use kForceOpaque
finalOps |= kForceOpaque;
}
} else if (!SkColorTypeIsAlwaysOpaque(*dstCT)) {
finalOps |= kForceOpaque;
}
// Disable everything else for the transfer
*texReadSwizzle = Swizzle::RGBA();
*srcCT = *dstCT;
*csSteps = SkColorSpaceXformSteps{};
return {finalOps, /*computeLuminance=*/false};
}
}
// Sixth, handle masking any unknown alpha bits if the dst doesn't already mask them. This must
// happen *after* checking for channel overlap to optimize to the kIgnoreSrc case. If not, the
// RGBx color types getting lifted to RGBA adds a channel overlap when there wasn't one.
{
bool cpuMasksAlpha = rgbx_to_rgba(cpuCT);
bool gpuMasksAlpha = rgbx_to_rgba(texBaseCT) || (*texReadSwizzle)[3] == '1';
bool srcHasJunkAlpha = TextureIsDst ? cpuMasksAlpha : gpuMasksAlpha;
bool dstStoresAlpha =
(SkColorTypeChannelFlags(*dstCT) & kAlpha_SkColorChannelFlag) &&
!(TextureIsDst ? gpuMasksAlpha : cpuMasksAlpha);
if (srcHasJunkAlpha) {
csSteps->fFlags.premul = false;
csSteps->fFlags.unpremul = false;
}
if (dstStoresAlpha && srcHasJunkAlpha) {
finalOps |= kForceOpaque;
}
// Reset any opacity forcing in the swizzle since it's handled by kForceOpaque.
if ((*texReadSwizzle)[3] == '1') {
*texReadSwizzle = Swizzle((*texReadSwizzle)[0],
(*texReadSwizzle)[1],
(*texReadSwizzle)[2],
'a');
}
}
// Seventh, lift gray/luminance calculation out of colortype so that its placement in the
// raster pipeline ops list can be controlled (vs. attached to a store). If luminance has to be
// calculated, some additional optimizations may not be possible.
const bool computeLuminance = account_for_luminance(*srcCT, SkToBool(*csSteps), dstCT);
// Eighth, consolidate red/blue swaps present in colortype, swizzle, and xferOps into just ops
{
// Any swaps from the texture's base color type, swizzle, and xfer ops can always be
// combined since those operations are grouped together, regardless of `TextureIsDst`.
int numRBSwaps = 0;
if ((*texReadSwizzle)[0] == 'b' && (*texReadSwizzle)[2] == 'r') {
// Remove the swap in the swizzle (moving towards a no-op swizzle).
*texReadSwizzle = Swizzle::Concat(*texReadSwizzle, Swizzle::BGRA());
numRBSwaps++;
}
if (bgra_to_rgba(texBaseCT)) {
numRBSwaps++;
}
if (xferOps & FormatXferOp::kSwapRB) {
numRBSwaps++;
}
// If there is not any RGB-dependent calculation between CPU and GPU data, we can also
// consolidate the swap from cpu color type (CS transfer functions and unpremul/premul
// steps are per-channel so swapping is still okay).
if (!computeLuminance && !(csSteps->fFlags.gamut_transform ||
csSteps->fFlags.src_ootf ||
csSteps->fFlags.dst_ootf)) {
// TODO(michaelludwig): Once we push finalOps back into raster pipeline if we need SkRP,
// we can always apply this to cpuCT to remove an implicit swap_rb op.
SkColorType swappedCT = *cpuCT;
if (bgra_to_rgba(&swappedCT) && swappedCT == *texBaseCT) {
numRBSwaps++;
*cpuCT = swappedCT;
}
}
// An even number of swaps is a no-op; an odd number of swaps is the same as one swap. The
// swap can be skipped if the source data is known to have the same values in R and B, or
// if R and B will be discarded.
bool srcHasRBData = *srcCT != kGray_8_SkColorType && !SkColorTypeIsAlphaOnly(*srcCT);
bool dstKeepsRBData = !SkColorTypeIsAlphaOnly(*dstCT) || computeLuminance;
if ((numRBSwaps & 1) && srcHasRBData && dstKeepsRBData) {
finalOps |= kSwapRB;
}
}
if (xferOps & FormatXferOp::kDropAlpha) {
if constexpr (TextureIsDst) {
// On CPU->GPU conversion, FormatXferOp::kDropAlpha actually drops the alpha bits
finalOps |= kDropAlpha;
} else {
finalOps |= kPadAlpha;
}
// Remove kForceOpaque as it's redundant with kDropAlpha/kPadAlpha
finalOps &= ~kForceOpaque;
}
return {finalOps, computeLuminance};
}
} // anonymous namespace
std::optional<TextureFormatXferFn> TextureFormatXferFn::MakeCpuToGpu(
SkColorType srcCT,
const SkColorSpaceXformSteps& csSteps,
TextureFormat dstFormat,
Swizzle dstReadSwizzle) {
auto [baseCT, xferOps] = TextureFormatColorTypeInfo(dstFormat);
if (xferOps & FormatXferOp::kDisabled) {
return std::nullopt;
}
SkColorSpaceXformSteps csStepsOptimized = csSteps;
auto [postOps, luminance] = optimize_transfer</*TextureIsDst=*/true>(
&srcCT, &baseCT, &dstReadSwizzle, &csStepsOptimized, xferOps);
// The CPU -> GPU transform is:
// SkRP{load(srcCT) ->
// csSteps? ->
// luminance? -> NOTE: luminance must be computed *before* the texture's swizzle
// srcToDst(dstReadSwizzle^-1)? ->
// store(baseCT)}? ->
// postOps(baseCT->TF)?
auto rp = RPOps::Make(srcCT, baseCT, &postOps, // ==> rpModifiers
csStepsOptimized, BT709Luminance{luminance}, dstReadSwizzle.invert());
return TextureFormatXferFn(dstFormat, /*preOps=*/0, std::move(rp), postOps);
}
std::optional<TextureFormatXferFn> TextureFormatXferFn::MakeGpuToCpu(
TextureFormat srcFormat,
Swizzle srcReadSwizzle,
const SkColorSpaceXformSteps& csSteps,
SkColorType dstCT) {
auto [baseCT, xferOps] = TextureFormatColorTypeInfo(srcFormat);
if (xferOps & FormatXferOp::kDisabled) {
return std::nullopt;
}
SkColorSpaceXformSteps csStepsOptimized = csSteps;
auto [preOps, luminance] = optimize_transfer</*TextureIsDst=*/false>(
&dstCT, &baseCT, &srcReadSwizzle, &csStepsOptimized, xferOps);
if (preOps & kIgnoreSrc) {
// The source is the texture format, which is what defines how ops are implemented, is
// currently set to be ignored, so pick a new format that matches the `dstCT`. Actual GPU
// support doesn't matter, this will just ensure the CPU data is initialized correctly.
srcFormat = PreferredTextureFormats(dstCT)[0];
}
// The GPU -> CPU transform is:
// preOps(TF->baseCT)? ->
// SkRP{load(baseCT) ->
// srcToDst(srcReadSwizzle)? ->
// csSteps? ->
// luminance? ->
// store(dstCT)}?
auto rp = RPOps::Make(baseCT, dstCT, &preOps, // ==> rpModifiers
srcReadSwizzle, csStepsOptimized, BT709Luminance{luminance});
return TextureFormatXferFn(srcFormat, preOps, std::move(rp), /*postOps=*/0);
}
std::optional<TextureFormatXferFn> TextureFormatXferFn::MakeIdentity(TextureFormat format) {
auto [baseCT, xferOps] = TextureFormatColorTypeInfo(format);
if (xferOps & FormatXferOp::kDisabled) {
if (TextureFormatCompressionType(format) == SkTextureCompressionType::kNone) {
return std::nullopt;
} // else allow compressed formats through for identity conversion uploads
}
return TextureFormatXferFn(format, /*preOps=*/0, /*rp=*/nullptr, /*postOps=*/0);
}
template <typename... RPModifiers>
sk_sp<TextureFormatXferFn::RPOps> TextureFormatXferFn::RPOps::Make(
SkColorType srcColorType,
SkColorType dstColorType,
uint8_t* xferOps,
RPModifiers... rpModifiers) {
if (srcColorType == dstColorType &&
(!SkToBool(rpModifiers) && ...)) {
return nullptr; // Identity conversion
}
// Luminance has to be calculated before the texture's swizzle so it's pulled out manually
// and put in the right place in `rpModifiers`, so we don't want to encounter them where
// the appendStore() also computes luminance.
SkASSERT(dstColorType != kGray_8_SkColorType);
sk_sp<RPOps> ops{new RPOps(/*srcBpp=*/SkColorTypeBytesPerPixel(srcColorType),
/*dstBpp=*/SkColorTypeBytesPerPixel(dstColorType))};
// Match SkConvertPixels swizzle_or_premul and delegate to SkOpts for certain combinations. Not
// all of the Swizzler functions are relevant because the same cases are already covered by sole
// use of ExtendedXferOps (e.g. RGBA_to_BGRA is just kSwapRB) or never occur in format transfers
// (e.g. the CMYK conversions).
auto isOnlyPremul = [] <typename RPModifier> (RPModifier modifier) {
if constexpr (std::is_same_v<RPModifier, SkColorSpaceXformSteps>) {
auto flags = modifier.fFlags;
return flags.premul &&
!(flags.unpremul || flags.linearize || flags.gamut_transform || flags.encode);
} else {
return !SkToBool(modifier);
}
};
if ((srcColorType == kRGBA_8888_SkColorType || srcColorType == kBGRA_8888_SkColorType) &&
(dstColorType == kRGBA_8888_SkColorType || dstColorType == kBGRA_8888_SkColorType)) {
// 32-bit unorm8 colors that can be swizzled with a premul go to SkOpts.
if ((isOnlyPremul(rpModifiers) && ...)) {
SkASSERT(srcColorType == dstColorType && !(*xferOps & kForceOpaque));
if (*xferOps & kSwapRB) {
ops->fSwizzler = SkOpts::RGBA_to_bgrA; // swap RB and premultiply
*xferOps &= ~kSwapRB;
} else {
ops->fSwizzler = SkOpts::RGBA_to_rgbA; // just premultiply
}
return ops;
} // else fall through to use raster pipeline
}
// NOTE: The src and dst memory contexts are not modified here, they just provide stable
// pointers for the appended ops to reference, and will be patched during run().
ops->fRP.appendLoad(srcColorType, &ops->fSrcCtx);
auto apply = [target = ops.get()] <typename RPModifier> (RPModifier modifier,
uint8_t* xferOps) {
const RPModifier* stableModifier = &modifier;
if constexpr (std::is_same_v<RPModifier, Swizzle>) {
// Swizzle does not require any persisted context, but we can also fold kSwapRB into
// the swizzle. This is done here so that the kSwapRB op is grouped with the swizzle
// modifier (given the order of modifiers passed into Make).
if (*xferOps & kSwapRB) {
modifier = Swizzle::Concat(modifier, Swizzle::BGRA());
*xferOps &= ~kSwapRB;
}
if (*xferOps & kForceOpaque) {
modifier = Swizzle::Concat(modifier, Swizzle::RGB1());
*xferOps &= ~kForceOpaque;
}
} else if constexpr (!std::is_same_v<RPModifier, BT709Luminance>) {
// We must create a copy of rpModifiers[i] in the arena, because its apply() function
// may reference parts of itself as the context's passed to the appended ops.
stableModifier = target->fArena.make<RPModifier>(modifier);
} // else BT709Luminance does not require any persisted context
stableModifier->apply(&target->fRP);
};
(apply(rpModifiers, xferOps), ...);
ops->fRP.appendStore(dstColorType, &ops->fDstCtx);
return ops;
}
int TextureFormatXferFn::getRowInvokeCount(int* width,
int* height,
size_t srcRowBytes,
size_t dstRowBytes) const {
bool denseTransfer;
const size_t widthSz = (size_t) (*width);
if (fRP) {
// Mixed transfer methods are always row-by-row to minimize intermediate storage
if (((fPreOps | fPostOps) != 0) ||
// Swizzler has to go row by row if the src and dst strides aren't dense
(fRP->fSwizzler && (widthSz * fRP->fSrcBpp != srcRowBytes ||
widthSz * fRP->fDstBpp != dstRowBytes)) ||
// RasterPipeline operates in pixel units so its built-in row handling can be used if
// the src and dst strides are multiples of the pixel sizes
(!fRP->fSwizzler && srcRowBytes % fRP->fSrcBpp == 0 &&
dstRowBytes % fRP->fDstBpp == 0)) {
// Set the strides to 0 when the control loop will be handling the src/dst pointers
fRP->fSrcCtx.stride = 0;
fRP->fDstCtx.stride = 0;
denseTransfer = false;
} else {
// RasterPipeline or the Swizzler function can be invoked just once
fRP->fSrcCtx.stride = SkTo<int>(srcRowBytes / fRP->fSrcBpp);
fRP->fDstCtx.stride = SkTo<int>(dstRowBytes / fRP->fDstBpp);
denseTransfer = true;
}
} else {
// There's only extended xfer ops, so the src and dst bpp's can be derived from the format.
const int bpp = TextureFormatBytesPerBlock(fFormat);
if (fPreOps & kPadAlpha) {
const size_t srcStride = widthSz * bpp;
const size_t dstStride = widthSz * (bpp + bpp/3);
denseTransfer = srcStride == srcRowBytes && dstStride == dstRowBytes;
} else if (fPostOps & kDropAlpha) {
const size_t srcStride = widthSz * (bpp + bpp/3);
const size_t dstStride = widthSz * bpp;
denseTransfer = srcStride == srcRowBytes && dstStride == dstRowBytes;
} else {
const size_t stride = widthSz * bpp;
denseTransfer = stride == srcRowBytes && stride == dstRowBytes;
}
}
if (denseTransfer) {
if (fRP && !fRP->fRP.empty()) {
// RasterPipeline manages its own dense transfer and needs to see the original width and
// height values, since it will use the set strides on the MemoryCtxs to adjust pointers
return 1; // one RP invocation over width x height pixels
} else {
// When not using the raster pipeline, the dense transfer happens by treating the data
// as a single row that is width*height long. This can only be done if that still fits
// into an int.
SkASSERT(!fRP || fRP->fSwizzler);
if (std::numeric_limits<int>::max() / *height > *width) {
*width *= *height;
*height = 1;
return 1; // one "width*height" invocation of swizzler or xfer_row_fn
} // otherwise fall through to do a row-by-row transfer
}
}
// If we're here, it can't be dense, so the transfer will be row-by-row
const int rowInvokeCount = *height;
*height = 1;
return rowInvokeCount;
}
void TextureFormatXferFn::run(int width, int height,
const void* src, size_t srcRowBytes,
void* dst, size_t dstRowBytes) const {
SkASSERT(width >= 1 && height >= 1);
const int rowInvokeCount = this->getRowInvokeCount(&width, &height, srcRowBytes, dstRowBytes);
SkAutoMalloc tempRowStorage; // empty if not mixing transfer methods
skia_private::STArray<2, XferRowFn> rowFns; // At most 2 actions per row
if (fPreOps) {
// `src` is definitively the texture
if (fRP) {
// We need a temporary buffer equal to srcBpp*width to hold the output of the preOps
// that is used as the source of data for SkRasterPipeline (executed per row).
tempRowStorage.reset(fRP->fSrcBpp * width);
}
rowFns.push_back(get_xfer_row_fn(fFormat, fPreOps));
}
if (fRP) {
if (fRP->fSwizzler) {
SkASSERT(fRP->fRP.empty());
rowFns.push_back([&](const char* src, char* dst, int width) {
const uint32_t* srcU32 = reinterpret_cast<const uint32_t*>(src);
uint32_t* dstU32 = reinterpret_cast<uint32_t*>(dst);
fRP->fSwizzler(dstU32, srcU32, width);
});
} else {
SkASSERT(!fRP->fRP.empty());
rowFns.push_back([&](const char* src, char* dst, int width) {
// NOTE: When height != 1, this invocation actually processes the entire image.
// Otherwise we assume src and dst have been offset by y so we update the
// MemoryCtx's pixel addresses.
fRP->fSrcCtx.pixels = const_cast<char*>(src); // This won't be written to
fRP->fDstCtx.pixels = dst;
fRP->fRP.run(0, 0, width, height);
});
}
}
if (fPostOps) {
// `dst` is definitively the texture
if (fRP) {
// We need a temporary buffer equal to dstBpp*width to hold the output of the
// SkRasterPipeline conversion that is used as the input to postOps (executed per row).
tempRowStorage.reset(fRP->fDstBpp * width);
}
rowFns.push_back(get_xfer_row_fn(fFormat, fPostOps));
}
if (rowFns.empty()) {
// Identity conversion function still needs to move the data
const int bpp = TextureFormatBytesPerBlock(fFormat);
rowFns.push_back([bpp](const char* src, char* dst, int width) {
memcpy(dst, src, bpp * width);
});
}
for (int y = 0; y < rowInvokeCount; ++y) {
// Always start by processing `src`
const char* input = static_cast<const char*>(src) + y * srcRowBytes;
for (int i = 0; i < rowFns.size(); ++i) {
// And either output to the temporary row or the final `dst`
char* target = i == rowFns.size() - 1 ? (static_cast<char*>(dst) + y * dstRowBytes)
: static_cast<char*>(tempRowStorage.get());
rowFns[i](input, target, width);
// If there's more than one rowFn, switch to using the temporary row as input
input = target;
}
}
}
#if defined(GPU_TEST_UTILS)
bool TextureFormatXferFn::isIgnoreSrcForceOpaque() const {
uint8_t ops = fPreOps | fPostOps;
return ops == (kIgnoreSrc | kForceOpaque);
}
bool TextureFormatXferFn::isDropOrPadAlpha() const {
uint8_t ops = fPreOps | fPostOps;
return ops == kPadAlpha || ops == kDropAlpha;
}
#endif // defined(GPU_TEST_UTILS)
} // namespace skgpu::graphite
// TODO(b/390473370): TextureUploadWriter isn't very useful with TextureFormatXferFn's
// capabilities and the writer model doesn't work well with the more explicit placement of dst
// data that has to happen. UploadBufferManager should just provide a span and then we can call
// run() directly and delete TextureUploadWriter entirely.
#include "src/gpu/BufferWriter.h"
namespace skgpu {
void TextureUploadWriter::convert(size_t offset, int width, int height,
const void* src, size_t srcRowBytes,
const graphite::TextureFormatXferFn& dst, size_t dstRowBytes) {
this->validate(offset + dstRowBytes * height);
void* dstPtr = SkTAddOffset<void>(fPtr, offset);
dst.run(width, height, src, srcRowBytes, dstPtr, dstRowBytes);
}
} // namespace skgpu