Rename SkColorTypeComponentFlags to SkColorChannelFlags.
Precusor step for making this public and adding a method to
GrBackendFormat to query its channels.
Bug: skia:10078
Change-Id: I2d8fa6586721c35961bc328a15eef8e2ebd4406e
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/279422
Reviewed-by: Brian Osman <brianosman@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h
index e302f31..6c8c928 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -875,38 +875,35 @@
SkColorType skCT,
const GrBackendFormat& format);
-static constexpr uint32_t GrColorTypeComponentFlags(GrColorType ct) {
+static constexpr uint32_t GrColorTypeChannelFlags(GrColorType ct) {
switch (ct) {
case GrColorType::kUnknown: return 0;
- case GrColorType::kAlpha_8: return kAlpha_SkColorTypeComponentFlag;
- case GrColorType::kBGR_565: return kRGB_SkColorTypeComponentFlags;
- case GrColorType::kABGR_4444: return kRGBA_SkColorTypeComponentFlags;
- case GrColorType::kRGBA_8888: return kRGBA_SkColorTypeComponentFlags;
- case GrColorType::kRGBA_8888_SRGB: return kRGBA_SkColorTypeComponentFlags;
- case GrColorType::kRGB_888x: return kRGB_SkColorTypeComponentFlags;
- case GrColorType::kRG_88: return kRed_SkColorTypeComponentFlag |
- kGreen_SkColorTypeComponentFlag;
- case GrColorType::kBGRA_8888: return kRGBA_SkColorTypeComponentFlags;
- case GrColorType::kRGBA_1010102: return kRGBA_SkColorTypeComponentFlags;
- case GrColorType::kGray_8: return kGray_SkColorTypeComponentFlag;
- case GrColorType::kAlpha_F16: return kAlpha_SkColorTypeComponentFlag;
- case GrColorType::kRGBA_F16: return kRGBA_SkColorTypeComponentFlags;
- case GrColorType::kRGBA_F16_Clamped: return kRGBA_SkColorTypeComponentFlags;
- case GrColorType::kRGBA_F32: return kRGBA_SkColorTypeComponentFlags;
- case GrColorType::kAlpha_8xxx: return kAlpha_SkColorTypeComponentFlag;
- case GrColorType::kAlpha_F32xxx: return kAlpha_SkColorTypeComponentFlag;
- case GrColorType::kGray_8xxx: return kGray_SkColorTypeComponentFlag;
- case GrColorType::kAlpha_16: return kAlpha_SkColorTypeComponentFlag;
- case GrColorType::kRG_1616: return kRed_SkColorTypeComponentFlag |
- kGreen_SkColorTypeComponentFlag;
- case GrColorType::kRGBA_16161616: return kRGBA_SkColorTypeComponentFlags;
- case GrColorType::kRG_F16: return kRed_SkColorTypeComponentFlag |
- kGreen_SkColorTypeComponentFlag;
- case GrColorType::kRGB_888: return kRGB_SkColorTypeComponentFlags;
- case GrColorType::kR_8: return kRed_SkColorTypeComponentFlag;
- case GrColorType::kR_16: return kRed_SkColorTypeComponentFlag;
- case GrColorType::kR_F16: return kRed_SkColorTypeComponentFlag;
- case GrColorType::kGray_F16: return kGray_SkColorTypeComponentFlag;
+ case GrColorType::kAlpha_8: return kAlpha_SkColorChannelFlag;
+ case GrColorType::kBGR_565: return kRGB_SkColorChannelFlags;
+ case GrColorType::kABGR_4444: return kRGBA_SkColorChannelFlags;
+ case GrColorType::kRGBA_8888: return kRGBA_SkColorChannelFlags;
+ case GrColorType::kRGBA_8888_SRGB: return kRGBA_SkColorChannelFlags;
+ case GrColorType::kRGB_888x: return kRGB_SkColorChannelFlags;
+ case GrColorType::kRG_88: return kRG_SkColorChannelFlags;
+ case GrColorType::kBGRA_8888: return kRGBA_SkColorChannelFlags;
+ case GrColorType::kRGBA_1010102: return kRGBA_SkColorChannelFlags;
+ case GrColorType::kGray_8: return kGray_SkColorChannelFlag;
+ case GrColorType::kAlpha_F16: return kAlpha_SkColorChannelFlag;
+ case GrColorType::kRGBA_F16: return kRGBA_SkColorChannelFlags;
+ case GrColorType::kRGBA_F16_Clamped: return kRGBA_SkColorChannelFlags;
+ case GrColorType::kRGBA_F32: return kRGBA_SkColorChannelFlags;
+ case GrColorType::kAlpha_8xxx: return kAlpha_SkColorChannelFlag;
+ case GrColorType::kAlpha_F32xxx: return kAlpha_SkColorChannelFlag;
+ case GrColorType::kGray_8xxx: return kGray_SkColorChannelFlag;
+ case GrColorType::kAlpha_16: return kAlpha_SkColorChannelFlag;
+ case GrColorType::kRG_1616: return kRG_SkColorChannelFlags;
+ case GrColorType::kRGBA_16161616: return kRGBA_SkColorChannelFlags;
+ case GrColorType::kRG_F16: return kRG_SkColorChannelFlags;
+ case GrColorType::kRGB_888: return kRGB_SkColorChannelFlags;
+ case GrColorType::kR_8: return kRed_SkColorChannelFlag;
+ case GrColorType::kR_16: return kRed_SkColorChannelFlag;
+ case GrColorType::kR_F16: return kRed_SkColorChannelFlag;
+ case GrColorType::kGray_F16: return kGray_SkColorChannelFlag;
}
SkUNREACHABLE;
}
@@ -1081,11 +1078,11 @@
}
static constexpr bool GrColorTypeIsAlphaOnly(GrColorType ct) {
- return kAlpha_SkColorTypeComponentFlag == GrColorTypeComponentFlags(ct);
+ return GrColorTypeChannelFlags(ct) == kAlpha_SkColorChannelFlag;
}
static constexpr bool GrColorTypeHasAlpha(GrColorType ct) {
- return kAlpha_SkColorTypeComponentFlag & GrColorTypeComponentFlags(ct);
+ return GrColorTypeChannelFlags(ct) & kAlpha_SkColorChannelFlag;
}
static constexpr size_t GrColorTypeBytesPerPixel(GrColorType ct) {
diff --git a/include/private/SkImageInfoPriv.h b/include/private/SkImageInfoPriv.h
index fdca276..e43e3d7 100644
--- a/include/private/SkImageInfoPriv.h
+++ b/include/private/SkImageInfoPriv.h
@@ -8,52 +8,51 @@
#ifndef SkImageInfoPriv_DEFINED
#define SkImageInfoPriv_DEFINED
+#include "include/core/SkColor.h"
#include "include/core/SkImageInfo.h"
-enum SkColorTypeComponentFlag {
- kRed_SkColorTypeComponentFlag = 0x1,
- kGreen_SkColorTypeComponentFlag = 0x2,
- kBlue_SkColorTypeComponentFlag = 0x4,
- kAlpha_SkColorTypeComponentFlag = 0x8,
- kGray_SkColorTypeComponentFlag = 0x10,
- kRG_SkColorTypeComponentFlags = kRed_SkColorTypeComponentFlag |
- kGreen_SkColorTypeComponentFlag,
- kRGB_SkColorTypeComponentFlags = kRed_SkColorTypeComponentFlag |
- kGreen_SkColorTypeComponentFlag |
- kBlue_SkColorTypeComponentFlag,
- kRGBA_SkColorTypeComponentFlags = kRGB_SkColorTypeComponentFlags |
- kAlpha_SkColorTypeComponentFlag,
+enum SkColorChannelFlag : uint32_t {
+ kRed_SkColorChannelFlag = 1 << static_cast<uint32_t>(SkColorChannel::kR),
+ kGreen_SkColorChannelFlag = 1 << static_cast<uint32_t>(SkColorChannel::kG),
+ kBlue_SkColorChannelFlag = 1 << static_cast<uint32_t>(SkColorChannel::kB),
+ kAlpha_SkColorChannelFlag = 1 << static_cast<uint32_t>(SkColorChannel::kA),
+ kGray_SkColorChannelFlag = 0x10,
+ // Convenience values
+ kRG_SkColorChannelFlags = kRed_SkColorChannelFlag | kGreen_SkColorChannelFlag,
+ kRGB_SkColorChannelFlags = kRG_SkColorChannelFlags | kBlue_SkColorChannelFlag,
+ kRGBA_SkColorChannelFlags = kRGB_SkColorChannelFlags | kAlpha_SkColorChannelFlag,
};
+static_assert(0 == (kGray_SkColorChannelFlag & kRGBA_SkColorChannelFlags), "bitfield conflict");
-static inline uint32_t SkColorTypeComponentFlags(SkColorType ct) {
+static inline uint32_t SkColorTypeChannelFlags(SkColorType ct) {
switch (ct) {
case kUnknown_SkColorType: return 0;
- case kAlpha_8_SkColorType: return kAlpha_SkColorTypeComponentFlag;
- case kRGB_565_SkColorType: return kRGB_SkColorTypeComponentFlags;
- case kARGB_4444_SkColorType: return kRGBA_SkColorTypeComponentFlags;
- case kRGBA_8888_SkColorType: return kRGBA_SkColorTypeComponentFlags;
- case kRGB_888x_SkColorType: return kRGB_SkColorTypeComponentFlags;
- case kBGRA_8888_SkColorType: return kRGBA_SkColorTypeComponentFlags;
- case kRGBA_1010102_SkColorType: return kRGBA_SkColorTypeComponentFlags;
- case kRGB_101010x_SkColorType: return kRGB_SkColorTypeComponentFlags;
- case kBGRA_1010102_SkColorType: return kRGBA_SkColorTypeComponentFlags;
- case kBGR_101010x_SkColorType: return kRGB_SkColorTypeComponentFlags;
- case kGray_8_SkColorType: return kGray_SkColorTypeComponentFlag;
- case kRGBA_F16Norm_SkColorType: return kRGBA_SkColorTypeComponentFlags;
- case kRGBA_F16_SkColorType: return kRGBA_SkColorTypeComponentFlags;
- case kRGBA_F32_SkColorType: return kRGBA_SkColorTypeComponentFlags;
- case kR8G8_unorm_SkColorType: return kRG_SkColorTypeComponentFlags;
- case kA16_unorm_SkColorType: return kAlpha_SkColorTypeComponentFlag;
- case kR16G16_unorm_SkColorType: return kRG_SkColorTypeComponentFlags;
- case kA16_float_SkColorType: return kAlpha_SkColorTypeComponentFlag;
- case kR16G16_float_SkColorType: return kRG_SkColorTypeComponentFlags;
- case kR16G16B16A16_unorm_SkColorType: return kRGBA_SkColorTypeComponentFlags;
+ case kAlpha_8_SkColorType: return kAlpha_SkColorChannelFlag;
+ case kRGB_565_SkColorType: return kRGB_SkColorChannelFlags;
+ case kARGB_4444_SkColorType: return kRGBA_SkColorChannelFlags;
+ case kRGBA_8888_SkColorType: return kRGBA_SkColorChannelFlags;
+ case kRGB_888x_SkColorType: return kRGB_SkColorChannelFlags;
+ case kBGRA_8888_SkColorType: return kRGBA_SkColorChannelFlags;
+ case kRGBA_1010102_SkColorType: return kRGBA_SkColorChannelFlags;
+ case kRGB_101010x_SkColorType: return kRGB_SkColorChannelFlags;
+ case kBGRA_1010102_SkColorType: return kRGBA_SkColorChannelFlags;
+ case kBGR_101010x_SkColorType: return kRGB_SkColorChannelFlags;
+ case kGray_8_SkColorType: return kGray_SkColorChannelFlag;
+ case kRGBA_F16Norm_SkColorType: return kRGBA_SkColorChannelFlags;
+ case kRGBA_F16_SkColorType: return kRGBA_SkColorChannelFlags;
+ case kRGBA_F32_SkColorType: return kRGBA_SkColorChannelFlags;
+ case kR8G8_unorm_SkColorType: return kRG_SkColorChannelFlags;
+ case kA16_unorm_SkColorType: return kAlpha_SkColorChannelFlag;
+ case kR16G16_unorm_SkColorType: return kRG_SkColorChannelFlags;
+ case kA16_float_SkColorType: return kAlpha_SkColorChannelFlag;
+ case kR16G16_float_SkColorType: return kRG_SkColorChannelFlags;
+ case kR16G16B16A16_unorm_SkColorType: return kRGBA_SkColorChannelFlags;
}
SkUNREACHABLE;
}
static inline bool SkColorTypeIsAlphaOnly(SkColorType ct) {
- return kAlpha_SkColorTypeComponentFlag == SkColorTypeComponentFlags(ct);
+ return SkColorTypeChannelFlags(ct) == kAlpha_SkColorChannelFlag;
}
static inline bool SkAlphaTypeIsValid(unsigned value) {
diff --git a/src/core/SkImageInfo.cpp b/src/core/SkImageInfo.cpp
index b5179f8..11789d1 100644
--- a/src/core/SkImageInfo.cpp
+++ b/src/core/SkImageInfo.cpp
@@ -38,7 +38,7 @@
}
bool SkColorTypeIsAlwaysOpaque(SkColorType ct) {
- return !(kAlpha_SkColorTypeComponentFlag & SkColorTypeComponentFlags(ct));
+ return !(SkColorTypeChannelFlags(ct) & kAlpha_SkColorChannelFlag);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/GrCaps.cpp b/src/gpu/GrCaps.cpp
index a00397d..7e210e0 100644
--- a/src/gpu/GrCaps.cpp
+++ b/src/gpu/GrCaps.cpp
@@ -333,11 +333,9 @@
}
// It's very convenient to access 1 byte-per-channel 32 bit color types as uint32_t on the CPU.
// Make those aligned reads out of the buffer even if the underlying API doesn't require it.
- auto componentFlags = GrColorTypeComponentFlags(read.fColorType);
- if ((componentFlags == kRGBA_SkColorTypeComponentFlags ||
- componentFlags == kRGB_SkColorTypeComponentFlags ||
- componentFlags == kAlpha_SkColorTypeComponentFlag ||
- componentFlags == kGray_SkColorTypeComponentFlag) &&
+ auto channelFlags = GrColorTypeChannelFlags(read.fColorType);
+ if ((channelFlags == kRGBA_SkColorChannelFlags || channelFlags == kRGB_SkColorChannelFlags ||
+ channelFlags == kAlpha_SkColorChannelFlag || channelFlags == kGray_SkColorChannelFlag) &&
GrColorTypeBytesPerPixel(read.fColorType) == 4) {
switch (read.fOffsetAlignmentForTransferBuffer & 0b11) {
// offset alignment already a multiple of 4
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 9476695..ada5a04 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -1696,10 +1696,10 @@
}
// Fail if read color type does not have all of dstCT's color channels and those missing color
// channels are in the src.
- uint32_t dstComponents = GrColorTypeComponentFlags(dstCT);
- uint32_t legalReadComponents = GrColorTypeComponentFlags(readInfo.fColorType);
- uint32_t srcComponents = GrColorTypeComponentFlags(this->colorInfo().colorType());
- if ((~legalReadComponents & dstComponents) & srcComponents) {
+ uint32_t dstChannels = GrColorTypeChannelFlags(dstCT);
+ uint32_t legalReadChannels = GrColorTypeChannelFlags(readInfo.fColorType);
+ uint32_t srcChannels = GrColorTypeChannelFlags(this->colorInfo().colorType());
+ if ((~legalReadChannels & dstChannels) & srcChannels) {
callback(context, nullptr);
return;
}
diff --git a/src/gpu/GrSurfaceContext.cpp b/src/gpu/GrSurfaceContext.cpp
index 0b799b9..094c8b9 100644
--- a/src/gpu/GrSurfaceContext.cpp
+++ b/src/gpu/GrSurfaceContext.cpp
@@ -686,10 +686,10 @@
proxy->backendFormat(), dstCT);
// Fail if read color type does not have all of dstCT's color channels and those missing color
// channels are in the src.
- uint32_t dstComponents = GrColorTypeComponentFlags(dstCT);
- uint32_t legalReadComponents = GrColorTypeComponentFlags(supportedRead.fColorType);
- uint32_t srcComponents = GrColorTypeComponentFlags(this->colorInfo().colorType());
- if ((~legalReadComponents & dstComponents) & srcComponents) {
+ uint32_t dstChannels = GrColorTypeChannelFlags(dstCT);
+ uint32_t legalReadChannels = GrColorTypeChannelFlags(supportedRead.fColorType);
+ uint32_t srcChannels = GrColorTypeChannelFlags(this->colorInfo().colorType());
+ if ((~legalReadChannels & dstChannels) & srcChannels) {
return {};
}
diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
index 3a5b10b..5447c3d 100644
--- a/src/image/SkImage_GpuBase.cpp
+++ b/src/image/SkImage_GpuBase.cpp
@@ -295,29 +295,29 @@
tempViews[textureIndex] = GrSurfaceProxyView(std::move(proxy), imageOrigin, swizzle);
// Check that each texture contains the channel data for the corresponding YUVA index
- auto componentFlags = GrColorTypeComponentFlags(grColorType);
+ auto channelFlags = GrColorTypeChannelFlags(grColorType);
for (int yuvaIndex = 0; yuvaIndex < SkYUVAIndex::kIndexCount; ++yuvaIndex) {
if (yuvaIndices[yuvaIndex].fIndex == textureIndex) {
switch (yuvaIndices[yuvaIndex].fChannel) {
case SkColorChannel::kR:
// TODO: Chrome needs to be patched before this can be
// enforced.
- // if (!(kRed_SkColorTypeComponentFlag & componentFlags)) {
+ // if (!(kRed_SkColorChannelFlag & channelFlags)) {
// return false;
// }
break;
case SkColorChannel::kG:
- if (!(kGreen_SkColorTypeComponentFlag & componentFlags)) {
+ if (!(kGreen_SkColorChannelFlag & channelFlags)) {
return false;
}
break;
case SkColorChannel::kB:
- if (!(kBlue_SkColorTypeComponentFlag & componentFlags)) {
+ if (!(kBlue_SkColorChannelFlag & channelFlags)) {
return false;
}
break;
case SkColorChannel::kA:
- if (!(kAlpha_SkColorTypeComponentFlag & componentFlags)) {
+ if (!(kAlpha_SkColorChannelFlag & channelFlags)) {
return false;
}
break;
diff --git a/tests/ExtendedSkColorTypeTests.cpp b/tests/ExtendedSkColorTypeTests.cpp
index 9c1063e..bac9f97 100644
--- a/tests/ExtendedSkColorTypeTests.cpp
+++ b/tests/ExtendedSkColorTypeTests.cpp
@@ -15,29 +15,28 @@
static constexpr int kSize = 32;
-static SkColor4f get_trans_black_expected_color(SkColorTypeComponentFlag components) {
+static SkColor4f get_trans_black_expected_color(SkColorChannelFlag channels) {
float a = 0;
- if (!(components & kAlpha_SkColorTypeComponentFlag)) {
+ if (!(channels & kAlpha_SkColorChannelFlag)) {
a = 1;
}
return { 0, 0, 0, a };
}
-static SkColor4f get_opaque_white_expected_color(SkColorTypeComponentFlag components) {
-
- if (components & kGray_SkColorTypeComponentFlag) {
+static SkColor4f get_opaque_white_expected_color(SkColorChannelFlag channels) {
+ if (channels & kGray_SkColorChannelFlag) {
return { 1, 1, 1, 1 };
}
float r = 1, g = 1, b = 1;
- if (!(components & kRed_SkColorTypeComponentFlag)) {
+ if (!(channels & kRed_SkColorChannelFlag)) {
r = 0;
}
- if (!(components & kGreen_SkColorTypeComponentFlag)) {
+ if (!(channels & kGreen_SkColorChannelFlag)) {
g = 0;
}
- if (!(components & kBlue_SkColorTypeComponentFlag)) {
+ if (!(channels & kBlue_SkColorChannelFlag)) {
b = 0;
}
@@ -45,33 +44,33 @@
}
struct TestCase {
- SkColorType fColorType;
- SkAlphaType fAlphaType;
- SkColorTypeComponentFlag fComponents;
- bool fGpuCanMakeSurfaces;
- bool fCpuCanMakeSurfaces;
+ SkColorType fColorType;
+ SkAlphaType fAlphaType;
+ SkColorChannelFlag fChannels;
+ bool fGpuCanMakeSurfaces;
+ bool fCpuCanMakeSurfaces;
};
static const TestCase gTests[] = {
- { kAlpha_8_SkColorType, kPremul_SkAlphaType, kAlpha_SkColorTypeComponentFlag, true, true },
- { kA16_unorm_SkColorType, kPremul_SkAlphaType, kAlpha_SkColorTypeComponentFlag, false, false},
- { kA16_float_SkColorType, kPremul_SkAlphaType, kAlpha_SkColorTypeComponentFlag, false, false},
- { kRGB_565_SkColorType, kOpaque_SkAlphaType, kRGB_SkColorTypeComponentFlags, true, true },
- { kARGB_4444_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorTypeComponentFlags, true, true },
- { kRGBA_8888_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorTypeComponentFlags, true, true },
- { kRGB_888x_SkColorType, kOpaque_SkAlphaType, kRGB_SkColorTypeComponentFlags, true, true },
- { kBGRA_8888_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorTypeComponentFlags, true, true },
- { kRGBA_1010102_SkColorType,kPremul_SkAlphaType, kRGBA_SkColorTypeComponentFlags, true, true },
- { kRGB_101010x_SkColorType, kOpaque_SkAlphaType, kRGB_SkColorTypeComponentFlags, true, true },
- { kGray_8_SkColorType, kOpaque_SkAlphaType, kGray_SkColorTypeComponentFlag, true, true },
- { kRGBA_F16Norm_SkColorType,kPremul_SkAlphaType, kRGBA_SkColorTypeComponentFlags, true, true },
- { kRGBA_F16_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorTypeComponentFlags, true, true },
- { kRGBA_F32_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorTypeComponentFlags, true, true },
- { kR8G8_unorm_SkColorType, kOpaque_SkAlphaType, kRG_SkColorTypeComponentFlags, true, false},
- { kR16G16_unorm_SkColorType,kOpaque_SkAlphaType, kRG_SkColorTypeComponentFlags, false, false},
- { kR16G16_float_SkColorType,kOpaque_SkAlphaType, kRG_SkColorTypeComponentFlags, false, false},
+ { kAlpha_8_SkColorType, kPremul_SkAlphaType, kAlpha_SkColorChannelFlag, true, true },
+ { kA16_unorm_SkColorType, kPremul_SkAlphaType, kAlpha_SkColorChannelFlag, false, false},
+ { kA16_float_SkColorType, kPremul_SkAlphaType, kAlpha_SkColorChannelFlag, false, false},
+ { kRGB_565_SkColorType, kOpaque_SkAlphaType, kRGB_SkColorChannelFlags, true, true },
+ { kARGB_4444_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorChannelFlags, true, true },
+ { kRGBA_8888_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorChannelFlags, true, true },
+ { kRGB_888x_SkColorType, kOpaque_SkAlphaType, kRGB_SkColorChannelFlags, true, true },
+ { kBGRA_8888_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorChannelFlags, true, true },
+ { kRGBA_1010102_SkColorType,kPremul_SkAlphaType, kRGBA_SkColorChannelFlags, true, true },
+ { kRGB_101010x_SkColorType, kOpaque_SkAlphaType, kRGB_SkColorChannelFlags, true, true },
+ { kGray_8_SkColorType, kOpaque_SkAlphaType, kGray_SkColorChannelFlag, true, true },
+ { kRGBA_F16Norm_SkColorType,kPremul_SkAlphaType, kRGBA_SkColorChannelFlags, true, true },
+ { kRGBA_F16_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorChannelFlags, true, true },
+ { kRGBA_F32_SkColorType, kPremul_SkAlphaType, kRGBA_SkColorChannelFlags, true, true },
+ { kR8G8_unorm_SkColorType, kOpaque_SkAlphaType, kRG_SkColorChannelFlags, true, false},
+ { kR16G16_unorm_SkColorType,kOpaque_SkAlphaType, kRG_SkColorChannelFlags, false, false},
+ { kR16G16_float_SkColorType,kOpaque_SkAlphaType, kRG_SkColorChannelFlags, false, false},
{ kR16G16B16A16_unorm_SkColorType,
- kPremul_SkAlphaType, kRGBA_SkColorTypeComponentFlags, false, false},
+ kPremul_SkAlphaType, kRGBA_SkColorChannelFlags, false, false},
};
static void raster_tests(skiatest::Reporter* reporter, const TestCase& test) {
@@ -80,8 +79,8 @@
const SkImageInfo f32Unpremul = SkImageInfo::Make(kSize, kSize, kRGBA_F32_SkColorType,
kUnpremul_SkAlphaType);
- uint32_t actualComponents = SkColorTypeComponentFlags(test.fColorType);
- REPORTER_ASSERT(reporter, test.fComponents == actualComponents);
+ uint32_t actualChannels = SkColorTypeChannelFlags(test.fColorType);
+ REPORTER_ASSERT(reporter, test.fChannels == actualChannels);
// Not all colorTypes can be drawn to
{
@@ -95,7 +94,7 @@
pm.alloc(nativeII);
pm.erase(SkColors::kTransparent);
SkColor actual = pm.getColor(0, 0);
- SkColor4f expected = get_trans_black_expected_color(test.fComponents);
+ SkColor4f expected = get_trans_black_expected_color(test.fChannels);
REPORTER_ASSERT(reporter, expected.toSkColor() == actual);
}
@@ -105,7 +104,7 @@
pm.alloc(nativeII);
pm.erase(SkColors::kWhite);
SkColor actual = pm.getColor(0, 0);
- SkColor4f expected = get_opaque_white_expected_color(test.fComponents);
+ SkColor4f expected = get_opaque_white_expected_color(test.fChannels);
REPORTER_ASSERT(reporter, expected.toSkColor() == actual);
}
@@ -241,7 +240,7 @@
{
SkAutoPixmapStorage f32Expected;
f32Expected.alloc(f32Unpremul);
- f32Expected.erase(get_opaque_white_expected_color(test.fComponents));
+ f32Expected.erase(get_opaque_white_expected_color(test.fChannels));
// read back to F32 if possible
{
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index cd9a2ff..fe8547d 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -232,8 +232,8 @@
// color type with alpha that we will get one for alpha rather than zero. We used to
// require this but the Intel Iris 6100 on Win 10 test bot doesn't put one in the
// alpha channel when reading back from GL_RG16 or GL_RG16F. So now we allow either.
- uint32_t components = GrColorTypeComponentFlags(combo.fColorType);
- bool allowAlphaOne = !(components & kAlpha_SkColorTypeComponentFlag);
+ uint32_t channels = GrColorTypeChannelFlags(combo.fColorType);
+ bool allowAlphaOne = !(channels & kAlpha_SkColorChannelFlag);
if (allowAlphaOne) {
if (readColor != 0x00000000 && readColor != 0xFF000000) {
ERRORF(reporter,
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index 64f8eed..1838baa 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -719,8 +719,8 @@
SkIRect dstWriteRect = srcReadRect.makeOffset(-rect.fLeft, -rect.fTop);
const bool lumConversion =
- !(SkColorTypeComponentFlags(srcCT) & kGray_SkColorTypeComponentFlag) &&
- (SkColorTypeComponentFlags(readCT) & kGray_SkColorTypeComponentFlag);
+ !(SkColorTypeChannelFlags(srcCT) & kGray_SkColorChannelFlag) &&
+ (SkColorTypeChannelFlags(readCT) & kGray_SkColorChannelFlag);
// A CS or luminance conversion allows a 3 value difference and otherwise a 2 value
// difference. Note that sometimes read back on GPU can be lossy even when there no
// conversion at allbecause GPU->CPU read may go to a lower bit depth format and then be
