case CodecSrc::kIndex8_Always_DstColorType:
folder.append("_kIndex8");
break;
+ case CodecSrc::kNonNative8888_Always_DstColorType:
+ folder.append("_kNonNative");
+ break;
default:
break;
}
case CodecSrc::kIndex8_Always_DstColorType:
folder.append("_kIndex8");
break;
+ case CodecSrc::kNonNative8888_Always_DstColorType:
+ folder.append("_kNonNative");
+ break;
default:
break;
}
SkTArray<CodecSrc::DstColorType> colorTypes;
colorTypes.push_back(CodecSrc::kGetFromCanvas_DstColorType);
+ colorTypes.push_back(CodecSrc::kNonNative8888_Always_DstColorType);
switch (codec->getInfo().colorType()) {
case kGray_8_SkColorType:
colorTypes.push_back(CodecSrc::kGrayscale_Always_DstColorType);
case CodecSrc::kGrayscale_Always_DstColorType:
colorType = kGray_8_SkColorType;
break;
+ default:
+ SkASSERT(false);
+ break;
}
SkAutoTDelete<SkBitmapRegionDecoder> brd(create_brd(fPath, fStrategy));
return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
}
+// Allows us to test decodes to non-native 8888.
+void swap_rb_if_necessary(SkBitmap& bitmap, CodecSrc::DstColorType dstColorType) {
+ if (CodecSrc::kNonNative8888_Always_DstColorType != dstColorType) {
+ return;
+ }
+
+ for (int y = 0; y < bitmap.height(); y++) {
+ uint32_t* row = (uint32_t*) bitmap.getAddr(0, y);
+ SkOpts::RGBA_to_BGRA(row, row, bitmap.width());
+ }
+}
+
// FIXME: Currently we cannot draw unpremultiplied sources. skbug.com/3338 and skbug.com/3339.
// This allows us to still test unpremultiplied decodes.
void premultiply_if_necessary(SkBitmap& bitmap) {
}
*decodeInfo = decodeInfo->makeColorType(kGray_8_SkColorType);
break;
+ case CodecSrc::kNonNative8888_Always_DstColorType:
+ if (kRGB_565_SkColorType == canvasColorType) {
+ return false;
+ }
+#ifdef SK_PMCOLOR_IS_RGBA
+ *decodeInfo = decodeInfo->makeColorType(kBGRA_8888_SkColorType);
+#else
+ *decodeInfo = decodeInfo->makeColorType(kRGBA_8888_SkColorType);
+#endif
+ break;
default:
if (kRGB_565_SkColorType == canvasColorType &&
kOpaque_SkAlphaType != decodeInfo->alphaType()) {
factory = &zeroFactory;
options.fZeroInitialized = SkCodec::kYes_ZeroInitialized;
}
- if (!bitmap.tryAllocPixels(decodeInfo, factory, colorTable.get())) {
+
+ SkImageInfo bitmapInfo = decodeInfo;
+ if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
+ kBGRA_8888_SkColorType == decodeInfo.colorType()) {
+ bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
+ }
+ if (!bitmap.tryAllocPixels(bitmapInfo, factory, colorTable.get())) {
return SkStringPrintf("Image(%s) is too large (%d x %d)", fPath.c_str(),
decodeInfo.width(), decodeInfo.height());
}
return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
}
premultiply_if_necessary(bitmap);
+ swap_rb_if_necessary(bitmap, fDstColorType);
canvas->drawBitmap(bitmap, 0, 0);
break;
}
}
premultiply_if_necessary(bitmap);
+ swap_rb_if_necessary(bitmap, fDstColorType);
canvas->drawBitmap(bitmap, 0, 0);
break;
}
}
}
premultiply_if_necessary(bitmap);
+ swap_rb_if_necessary(bitmap, fDstColorType);
canvas->drawBitmap(bitmap, 0, 0);
break;
}
}
premultiply_if_necessary(bitmap);
+ swap_rb_if_necessary(bitmap, fDstColorType);
canvas->drawBitmap(bitmap, 0, 0);
break;
}
fPath.c_str(), W, H, result);
}
premultiply_if_necessary(subsetBm);
+ swap_rb_if_necessary(bitmap, fDstColorType);
canvas->drawBitmap(subsetBm, SkIntToScalar(left), SkIntToScalar(top));
// translate by the scaled height.
top += decodeInfo.height();
}
SkBitmap bitmap;
- if (!bitmap.tryAllocPixels(decodeInfo, nullptr, colorTable.get())) {
+ SkImageInfo bitmapInfo = decodeInfo;
+ if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
+ kBGRA_8888_SkColorType == decodeInfo.colorType()) {
+ bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
+ }
+ if (!bitmap.tryAllocPixels(bitmapInfo, nullptr, colorTable.get())) {
return SkStringPrintf("Image(%s) is too large (%d x %d)", fPath.c_str(),
decodeInfo.width(), decodeInfo.height());
}
return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
}
premultiply_if_necessary(bitmap);
+ swap_rb_if_necessary(bitmap, fDstColorType);
canvas->drawBitmap(bitmap, 0, 0);
return "";
}
SkRect rect = SkRect::MakeXYWH(0, 0, (SkScalar) finalScaledWidth,
(SkScalar) finalScaledHeight);
premultiply_if_necessary(bitmap);
+ swap_rb_if_necessary(bitmap, fDstColorType);
canvas->drawBitmapRect(bitmap, rect, rect, nullptr);
return "";
}
kGetFromCanvas_DstColorType,
kIndex8_Always_DstColorType,
kGrayscale_Always_DstColorType,
+ kNonNative8888_Always_DstColorType,
};
CodecSrc(Path, Mode, DstColorType, SkAlphaType, float);
/*
* Process the color table for the bmp input
*/
- bool SkBmpRLECodec::createColorTable(int* numColors) {
+ bool SkBmpRLECodec::createColorTable(SkColorType dstColorType, int* numColors) {
// Allocate memory for color table
uint32_t colorBytes = 0;
SkPMColor colorTable[256];
}
// Fill in the color table
+ PackColorProc packARGB = choose_pack_color_proc(false, dstColorType);
uint32_t i = 0;
for (; i < numColorsToRead; i++) {
uint8_t blue = get_byte(cBuffer.get(), i*fBytesPerColor);
uint8_t green = get_byte(cBuffer.get(), i*fBytesPerColor + 1);
uint8_t red = get_byte(cBuffer.get(), i*fBytesPerColor + 2);
- colorTable[i] = SkPackARGB32NoCheck(0xFF, red, green, blue);
+ colorTable[i] = packARGB(0xFF, red, green, blue);
}
// To avoid segmentation faults on bad pixel data, fill the end of the
// Set the pixel based on destination color type
const int dstX = get_dst_coord(x, fSampleX);
switch (dstInfo.colorType()) {
- case kN32_SkColorType: {
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType: {
SkPMColor* dstRow = SkTAddOffset<SkPMColor>(dst, row * (int) dstRowBytes);
dstRow[dstX] = fColorTable->operator[](index);
break;
// Set the pixel based on destination color type
const int dstX = get_dst_coord(x, fSampleX);
switch (dstInfo.colorType()) {
- case kN32_SkColorType: {
+ case kRGBA_8888_SkColorType: {
SkPMColor* dstRow = SkTAddOffset<SkPMColor>(dst, row * (int) dstRowBytes);
- dstRow[dstX] = SkPackARGB32NoCheck(0xFF, red, green, blue);
+ dstRow[dstX] = SkPackARGB_as_RGBA(0xFF, red, green, blue);
+ break;
+ }
+ case kBGRA_8888_SkColorType: {
+ SkPMColor* dstRow = SkTAddOffset<SkPMColor>(dst, row * (int) dstRowBytes);
+ dstRow[dstX] = SkPackARGB_as_BGRA(0xFF, red, green, blue);
break;
}
case kRGB_565_SkColorType: {
// Create the color table if necessary and prepare the stream for decode
// Note that if it is non-NULL, inputColorCount will be modified
- if (!this->createColorTable(inputColorCount)) {
+ if (!this->createColorTable(dstInfo.colorType(), inputColorCount)) {
SkCodecPrintf("Error: could not create color table.\n");
return SkCodec::kInvalidInput;
}
// the skipped pixels will be transparent.
// Because of the need for transparent pixels, kN32 is the only color
// type that makes sense for the destination format.
- SkASSERT(kN32_SkColorType == dstInfo.colorType());
+ SkASSERT(kRGBA_8888_SkColorType == dstInfo.colorType() ||
+ kBGRA_8888_SkColorType == dstInfo.colorType());
if (dst) {
SkSampler::Fill(dstInfo, dst, dstRowBytes, SK_ColorTRANSPARENT, opts.fZeroInitialized);
}
* Creates the color table
* Sets colorCount to the new color count if it is non-nullptr
*/
- bool createColorTable(int* colorCount);
+ bool createColorTable(SkColorType dstColorType, int* colorCount);
bool initializeStreamBuffer();
/*
* Process the color table for the bmp input
*/
- bool SkBmpStandardCodec::createColorTable(SkAlphaType dstAlphaType, int* numColors) {
+ bool SkBmpStandardCodec::createColorTable(SkColorType dstColorType, SkAlphaType dstAlphaType,
+ int* numColors) {
// Allocate memory for color table
uint32_t colorBytes = 0;
SkPMColor colorTable[256];
}
// Choose the proper packing function
- SkPMColor (*packARGB) (uint32_t, uint32_t, uint32_t, uint32_t);
- if (fIsOpaque || kUnpremul_SkAlphaType == dstAlphaType) {
- packARGB = &SkPackARGB32NoCheck;
- } else {
- packARGB = &SkPremultiplyARGBInline;
- }
+ bool isPremul = (kPremul_SkAlphaType == dstAlphaType) && !fIsOpaque;
+ PackColorProc packARGB = choose_pack_color_proc(isPremul, dstColorType);
// Fill in the color table
uint32_t i = 0;
const SkCodec::Options& options, SkPMColor inputColorPtr[], int* inputColorCount) {
// Create the color table if necessary and prepare the stream for decode
// Note that if it is non-NULL, inputColorCount will be modified
- if (!this->createColorTable(dstInfo.alphaType(), inputColorCount)) {
+ if (!this->createColorTable(dstInfo.colorType(), dstInfo.alphaType(), inputColorCount)) {
SkCodecPrintf("Error: could not create color table.\n");
return SkCodec::kInvalidInput;
}
// BMP in ICO have transparency, so this cannot be 565, and this mask
// prevents us from using kIndex8. The below code depends on the output
// being an SkPMColor.
- SkASSERT(dstInfo.colorType() == kN32_SkColorType);
+ SkASSERT(kRGBA_8888_SkColorType == dstInfo.colorType() ||
+ kBGRA_8888_SkColorType == dstInfo.colorType());
// If we are sampling, make sure that we only mask the sampled pixels.
// We do not need to worry about sampling in the y-dimension because that
* Creates the color table
* Sets colorCount to the new color count if it is non-nullptr
*/
- bool createColorTable(SkAlphaType alphaType, int* colorCount);
+ bool createColorTable(SkColorType colorType, SkAlphaType alphaType, int* colorCount);
void initializeSwizzler(const SkImageInfo& dstInfo, const Options& opts);
// Check for supported color types
switch (dst.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType:
return true;
case kRGB_565_SkColorType:
return kOpaque_SkAlphaType == dst.alphaType();
uint8_t fillIndex) {
SkASSERT(nullptr != colorPtr);
switch (colorType) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType:
return colorPtr[fillIndex];
case kRGB_565_SkColorType:
return SkPixel32ToPixel16(colorPtr[fillIndex]);
return (data[0] << 8) | (data[1]);
}
+inline SkPMColor premultiply_argb_as_rgba(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
+ if (a != 255) {
+ r = SkMulDiv255Round(r, a);
+ g = SkMulDiv255Round(g, a);
+ b = SkMulDiv255Round(b, a);
+ }
+
+ return SkPackARGB_as_RGBA(a, r, g, b);
+}
+
+inline SkPMColor premultiply_argb_as_bgra(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
+ if (a != 255) {
+ r = SkMulDiv255Round(r, a);
+ g = SkMulDiv255Round(g, a);
+ b = SkMulDiv255Round(b, a);
+ }
+
+ return SkPackARGB_as_BGRA(a, r, g, b);
+}
+
+inline bool is_rgba(SkColorType colorType) {
+#ifdef SK_PMCOLOR_IS_RGBA
+ return (kBGRA_8888_SkColorType != colorType);
+#else
+ return (kRGBA_8888_SkColorType == colorType);
+#endif
+}
+
+// Method for coverting to a 32 bit pixel.
+typedef uint32_t (*PackColorProc)(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
+
+inline PackColorProc choose_pack_color_proc(bool isPremul, SkColorType colorType) {
+ bool isRGBA = is_rgba(colorType);
+ if (isPremul) {
+ if (isRGBA) {
+ return &premultiply_argb_as_rgba;
+ } else {
+ return &premultiply_argb_as_bgra;
+ }
+ } else {
+ if (isRGBA) {
+ return &SkPackARGB_as_RGBA;
+ } else {
+ return &SkPackARGB_as_BGRA;
+ }
+ }
+}
+
#endif // SkCodecPriv_DEFINED
// giflib guarantees these properties
SkASSERT(colorCount == (unsigned) (1 << (colorMap->BitsPerPixel)));
SkASSERT(colorCount <= 256);
+ PackColorProc proc = choose_pack_color_proc(false, dstInfo.colorType());
for (uint32_t i = 0; i < colorCount; i++) {
- colorPtr[i] = SkPackARGB32(0xFF, colorMap->Colors[i].Red,
+ colorPtr[i] = proc(0xFF, colorMap->Colors[i].Red,
colorMap->Colors[i].Green, colorMap->Colors[i].Blue);
}
}
// Check for valid color types and set the output color space
switch (dst.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
if (isCMYK) {
fDecoderMgr->dinfo()->out_color_space = JCS_CMYK;
} else {
#ifdef LIBJPEG_TURBO_VERSION
- // Check the byte ordering of the RGBA color space for the
- // current platform
- #ifdef SK_PMCOLOR_IS_RGBA
fDecoderMgr->dinfo()->out_color_space = JCS_EXT_RGBA;
- #else
+#else
+ fDecoderMgr->dinfo()->out_color_space = JCS_RGB;
+#endif
+ }
+ return true;
+ case kBGRA_8888_SkColorType:
+ if (isCMYK) {
+ fDecoderMgr->dinfo()->out_color_space = JCS_CMYK;
+ } else {
+#ifdef LIBJPEG_TURBO_VERSION
fDecoderMgr->dinfo()->out_color_space = JCS_EXT_BGRA;
- #endif
#else
fDecoderMgr->dinfo()->out_color_space = JCS_RGB;
#endif
#include "SkColorPriv.h"
#include "SkMaskSwizzler.h"
-static void swizzle_mask16_to_n32_opaque(
+static void swizzle_mask16_to_rgba_opaque(
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
uint32_t startX, uint32_t sampleX) {
uint8_t red = masks->getRed(p);
uint8_t green = masks->getGreen(p);
uint8_t blue = masks->getBlue(p);
- dstPtr[i] = SkPackARGB32NoCheck(0xFF, red, green, blue);
+ dstPtr[i] = SkPackARGB_as_RGBA(0xFF, red, green, blue);
srcPtr += sampleX;
}
}
-static void swizzle_mask16_to_n32_unpremul(
+static void swizzle_mask16_to_bgra_opaque(
+ void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
+ uint32_t startX, uint32_t sampleX) {
+
+ // Use the masks to decode to the destination
+ uint16_t* srcPtr = ((uint16_t*) srcRow) + startX;
+ SkPMColor* dstPtr = (SkPMColor*) dstRow;
+ for (int i = 0; i < width; i++) {
+ uint16_t p = srcPtr[0];
+ uint8_t red = masks->getRed(p);
+ uint8_t green = masks->getGreen(p);
+ uint8_t blue = masks->getBlue(p);
+ dstPtr[i] = SkPackARGB_as_BGRA(0xFF, red, green, blue);
+ srcPtr += sampleX;
+ }
+}
+
+static void swizzle_mask16_to_rgba_unpremul(
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
uint32_t startX, uint32_t sampleX) {
uint8_t green = masks->getGreen(p);
uint8_t blue = masks->getBlue(p);
uint8_t alpha = masks->getAlpha(p);
- dstPtr[i] = SkPackARGB32NoCheck(alpha, red, green, blue);
+ dstPtr[i] = SkPackARGB_as_RGBA(alpha, red, green, blue);
srcPtr += sampleX;
}
}
-static void swizzle_mask16_to_n32_premul(
+static void swizzle_mask16_to_bgra_unpremul(
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
uint32_t startX, uint32_t sampleX) {
uint8_t green = masks->getGreen(p);
uint8_t blue = masks->getBlue(p);
uint8_t alpha = masks->getAlpha(p);
- dstPtr[i] = SkPreMultiplyARGB(alpha, red, green, blue);
+ dstPtr[i] = SkPackARGB_as_BGRA(alpha, red, green, blue);
+ srcPtr += sampleX;
+ }
+}
+
+static void swizzle_mask16_to_rgba_premul(
+ void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
+ uint32_t startX, uint32_t sampleX) {
+
+ // Use the masks to decode to the destination
+ uint16_t* srcPtr = ((uint16_t*) srcRow) + startX;
+ SkPMColor* dstPtr = (SkPMColor*) dstRow;
+ for (int i = 0; i < width; i++) {
+ uint16_t p = srcPtr[0];
+ uint8_t red = masks->getRed(p);
+ uint8_t green = masks->getGreen(p);
+ uint8_t blue = masks->getBlue(p);
+ uint8_t alpha = masks->getAlpha(p);
+ dstPtr[i] = premultiply_argb_as_rgba(alpha, red, green, blue);
+ srcPtr += sampleX;
+ }
+}
+
+static void swizzle_mask16_to_bgra_premul(
+ void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
+ uint32_t startX, uint32_t sampleX) {
+
+ // Use the masks to decode to the destination
+ uint16_t* srcPtr = ((uint16_t*) srcRow) + startX;
+ SkPMColor* dstPtr = (SkPMColor*) dstRow;
+ for (int i = 0; i < width; i++) {
+ uint16_t p = srcPtr[0];
+ uint8_t red = masks->getRed(p);
+ uint8_t green = masks->getGreen(p);
+ uint8_t blue = masks->getBlue(p);
+ uint8_t alpha = masks->getAlpha(p);
+ dstPtr[i] = premultiply_argb_as_bgra(alpha, red, green, blue);
srcPtr += sampleX;
}
}
}
}
-static void swizzle_mask24_to_n32_opaque(
+static void swizzle_mask24_to_rgba_opaque(
+ void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
+ uint32_t startX, uint32_t sampleX) {
+
+ // Use the masks to decode to the destination
+ srcRow += 3 * startX;
+ SkPMColor* dstPtr = (SkPMColor*) dstRow;
+ for (int i = 0; i < width; i++) {
+ uint32_t p = srcRow[0] | (srcRow[1] << 8) | srcRow[2] << 16;
+ uint8_t red = masks->getRed(p);
+ uint8_t green = masks->getGreen(p);
+ uint8_t blue = masks->getBlue(p);
+ dstPtr[i] = SkPackARGB_as_RGBA(0xFF, red, green, blue);
+ srcRow += 3 * sampleX;
+ }
+}
+
+static void swizzle_mask24_to_bgra_opaque(
+ void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
+ uint32_t startX, uint32_t sampleX) {
+
+ // Use the masks to decode to the destination
+ srcRow += 3 * startX;
+ SkPMColor* dstPtr = (SkPMColor*) dstRow;
+ for (int i = 0; i < width; i++) {
+ uint32_t p = srcRow[0] | (srcRow[1] << 8) | srcRow[2] << 16;
+ uint8_t red = masks->getRed(p);
+ uint8_t green = masks->getGreen(p);
+ uint8_t blue = masks->getBlue(p);
+ dstPtr[i] = SkPackARGB_as_BGRA(0xFF, red, green, blue);
+ srcRow += 3 * sampleX;
+ }
+}
+
+static void swizzle_mask24_to_rgba_unpremul(
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
uint32_t startX, uint32_t sampleX) {
uint8_t red = masks->getRed(p);
uint8_t green = masks->getGreen(p);
uint8_t blue = masks->getBlue(p);
- dstPtr[i] = SkPackARGB32NoCheck(0xFF, red, green, blue);
+ uint8_t alpha = masks->getAlpha(p);
+ dstPtr[i] = SkPackARGB_as_RGBA(alpha, red, green, blue);
srcRow += 3 * sampleX;
}
}
-static void swizzle_mask24_to_n32_unpremul(
+static void swizzle_mask24_to_bgra_unpremul(
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
uint32_t startX, uint32_t sampleX) {
uint8_t green = masks->getGreen(p);
uint8_t blue = masks->getBlue(p);
uint8_t alpha = masks->getAlpha(p);
- dstPtr[i] = SkPackARGB32NoCheck(alpha, red, green, blue);
+ dstPtr[i] = SkPackARGB_as_BGRA(alpha, red, green, blue);
srcRow += 3 * sampleX;
}
}
-static void swizzle_mask24_to_n32_premul(
+static void swizzle_mask24_to_rgba_premul(
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
uint32_t startX, uint32_t sampleX) {
uint8_t green = masks->getGreen(p);
uint8_t blue = masks->getBlue(p);
uint8_t alpha = masks->getAlpha(p);
- dstPtr[i] = SkPreMultiplyARGB(alpha, red, green, blue);
+ dstPtr[i] = premultiply_argb_as_rgba(alpha, red, green, blue);
+ srcRow += 3 * sampleX;
+ }
+}
+
+static void swizzle_mask24_to_bgra_premul(
+ void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
+ uint32_t startX, uint32_t sampleX) {
+
+ // Use the masks to decode to the destination
+ srcRow += 3 * startX;
+ SkPMColor* dstPtr = (SkPMColor*) dstRow;
+ for (int i = 0; i < width; i++) {
+ uint32_t p = srcRow[0] | (srcRow[1] << 8) | srcRow[2] << 16;
+ uint8_t red = masks->getRed(p);
+ uint8_t green = masks->getGreen(p);
+ uint8_t blue = masks->getBlue(p);
+ uint8_t alpha = masks->getAlpha(p);
+ dstPtr[i] = premultiply_argb_as_bgra(alpha, red, green, blue);
srcRow += 3 * sampleX;
}
}
}
}
-static void swizzle_mask32_to_n32_opaque(
+static void swizzle_mask32_to_rgba_opaque(
+ void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
+ uint32_t startX, uint32_t sampleX) {
+
+ // Use the masks to decode to the destination
+ uint32_t* srcPtr = ((uint32_t*) srcRow) + startX;
+ SkPMColor* dstPtr = (SkPMColor*) dstRow;
+ for (int i = 0; i < width; i++) {
+ uint32_t p = srcPtr[0];
+ uint8_t red = masks->getRed(p);
+ uint8_t green = masks->getGreen(p);
+ uint8_t blue = masks->getBlue(p);
+ dstPtr[i] = SkPackARGB_as_RGBA(0xFF, red, green, blue);
+ srcPtr += sampleX;
+ }
+}
+
+static void swizzle_mask32_to_bgra_opaque(
+ void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
+ uint32_t startX, uint32_t sampleX) {
+
+ // Use the masks to decode to the destination
+ uint32_t* srcPtr = ((uint32_t*) srcRow) + startX;
+ SkPMColor* dstPtr = (SkPMColor*) dstRow;
+ for (int i = 0; i < width; i++) {
+ uint32_t p = srcPtr[0];
+ uint8_t red = masks->getRed(p);
+ uint8_t green = masks->getGreen(p);
+ uint8_t blue = masks->getBlue(p);
+ dstPtr[i] = SkPackARGB_as_BGRA(0xFF, red, green, blue);
+ srcPtr += sampleX;
+ }
+}
+
+static void swizzle_mask32_to_rgba_unpremul(
+ void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
+ uint32_t startX, uint32_t sampleX) {
+
+ // Use the masks to decode to the destination
+ uint32_t* srcPtr = ((uint32_t*) srcRow) + startX;
+ SkPMColor* dstPtr = (SkPMColor*) dstRow;
+ for (int i = 0; i < width; i++) {
+ uint32_t p = srcPtr[0];
+ uint8_t red = masks->getRed(p);
+ uint8_t green = masks->getGreen(p);
+ uint8_t blue = masks->getBlue(p);
+ uint8_t alpha = masks->getAlpha(p);
+ dstPtr[i] = SkPackARGB_as_RGBA(alpha, red, green, blue);
+ srcPtr += sampleX;
+ }
+}
+
+static void swizzle_mask32_to_bgra_unpremul(
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
uint32_t startX, uint32_t sampleX) {
uint8_t red = masks->getRed(p);
uint8_t green = masks->getGreen(p);
uint8_t blue = masks->getBlue(p);
- dstPtr[i] = SkPackARGB32NoCheck(0xFF, red, green, blue);
+ uint8_t alpha = masks->getAlpha(p);
+ dstPtr[i] = SkPackARGB_as_BGRA(alpha, red, green, blue);
srcPtr += sampleX;
}
}
-static void swizzle_mask32_to_n32_unpremul(
+static void swizzle_mask32_to_rgba_premul(
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
uint32_t startX, uint32_t sampleX) {
uint8_t green = masks->getGreen(p);
uint8_t blue = masks->getBlue(p);
uint8_t alpha = masks->getAlpha(p);
- dstPtr[i] = SkPackARGB32NoCheck(alpha, red, green, blue);
+ dstPtr[i] = premultiply_argb_as_rgba(alpha, red, green, blue);
srcPtr += sampleX;
}
}
-static void swizzle_mask32_to_n32_premul(
+static void swizzle_mask32_to_bgra_premul(
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks,
uint32_t startX, uint32_t sampleX) {
uint8_t green = masks->getGreen(p);
uint8_t blue = masks->getBlue(p);
uint8_t alpha = masks->getAlpha(p);
- dstPtr[i] = SkPreMultiplyARGB(alpha, red, green, blue);
+ dstPtr[i] = premultiply_argb_as_bgra(alpha, red, green, blue);
srcPtr += sampleX;
}
}
switch (bitsPerPixel) {
case 16:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ if (kOpaque_SkAlphaType == srcInfo.alphaType()) {
+ proc = &swizzle_mask16_to_rgba_opaque;
+ } else {
+ switch (dstInfo.alphaType()) {
+ case kUnpremul_SkAlphaType:
+ proc = &swizzle_mask16_to_rgba_unpremul;
+ break;
+ case kPremul_SkAlphaType:
+ proc = &swizzle_mask16_to_rgba_premul;
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case kBGRA_8888_SkColorType:
if (kOpaque_SkAlphaType == srcInfo.alphaType()) {
- proc = &swizzle_mask16_to_n32_opaque;
+ proc = &swizzle_mask16_to_bgra_opaque;
} else {
switch (dstInfo.alphaType()) {
case kUnpremul_SkAlphaType:
- proc = &swizzle_mask16_to_n32_unpremul;
+ proc = &swizzle_mask16_to_bgra_unpremul;
break;
case kPremul_SkAlphaType:
- proc = &swizzle_mask16_to_n32_premul;
+ proc = &swizzle_mask16_to_bgra_premul;
break;
default:
break;
break;
case 24:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ if (kOpaque_SkAlphaType == srcInfo.alphaType()) {
+ proc = &swizzle_mask24_to_rgba_opaque;
+ } else {
+ switch (dstInfo.alphaType()) {
+ case kUnpremul_SkAlphaType:
+ proc = &swizzle_mask24_to_rgba_unpremul;
+ break;
+ case kPremul_SkAlphaType:
+ proc = &swizzle_mask24_to_rgba_premul;
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case kBGRA_8888_SkColorType:
if (kOpaque_SkAlphaType == srcInfo.alphaType()) {
- proc = &swizzle_mask24_to_n32_opaque;
+ proc = &swizzle_mask24_to_bgra_opaque;
} else {
switch (dstInfo.alphaType()) {
case kUnpremul_SkAlphaType:
- proc = &swizzle_mask24_to_n32_unpremul;
+ proc = &swizzle_mask24_to_bgra_unpremul;
break;
case kPremul_SkAlphaType:
- proc = &swizzle_mask24_to_n32_premul;
+ proc = &swizzle_mask24_to_bgra_premul;
break;
default:
break;
break;
case 32:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ if (kOpaque_SkAlphaType == srcInfo.alphaType()) {
+ proc = &swizzle_mask32_to_rgba_opaque;
+ } else {
+ switch (dstInfo.alphaType()) {
+ case kUnpremul_SkAlphaType:
+ proc = &swizzle_mask32_to_rgba_unpremul;
+ break;
+ case kPremul_SkAlphaType:
+ proc = &swizzle_mask32_to_rgba_premul;
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case kBGRA_8888_SkColorType:
if (kOpaque_SkAlphaType == srcInfo.alphaType()) {
- proc = &swizzle_mask32_to_n32_opaque;
+ proc = &swizzle_mask32_to_bgra_opaque;
} else {
switch (dstInfo.alphaType()) {
case kUnpremul_SkAlphaType:
- proc = &swizzle_mask32_to_n32_unpremul;
+ proc = &swizzle_mask32_to_bgra_unpremul;
break;
case kPremul_SkAlphaType:
- proc = &swizzle_mask32_to_n32_premul;
+ proc = &swizzle_mask32_to_bgra_premul;
break;
default:
break;
};
#define AutoCleanPng(...) SK_REQUIRE_LOCAL_VAR(AutoCleanPng)
-// Method for coverting to either an SkPMColor or a similarly packed
-// unpremultiplied color.
-typedef uint32_t (*PackColorProc)(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
-
// Note: SkColorTable claims to store SkPMColors, which is not necessarily
// the case here.
// TODO: If we add support for non-native swizzles, we'll need to handle that here.
-bool SkPngCodec::decodePalette(bool premultiply, int* ctableCount) {
+bool SkPngCodec::createColorTable(SkColorType dstColorType, bool premultiply, int* ctableCount) {
int numColors;
png_color* palette;
if (png_get_tRNS(fPng_ptr, fInfo_ptr, &alphas, &numColorsWithAlpha, nullptr)) {
// Choose which function to use to create the color table. If the final destination's
// colortype is unpremultiplied, the color table will store unpremultiplied colors.
- PackColorProc proc;
- if (premultiply) {
- proc = &SkPremultiplyARGBInline;
- } else {
- proc = &SkPackARGB32NoCheck;
- }
+ PackColorProc proc = choose_pack_color_proc(premultiply, dstColorType);
for (int i = 0; i < numColorsWithAlpha; i++) {
// We don't have a function in SkOpts that combines a set of alphas with a set
SkASSERT(&palette->green < &palette->blue);
#endif
-#ifdef SK_PMCOLOR_IS_RGBA
- SkOpts::RGB_to_RGB1(colorPtr + numColorsWithAlpha, palette, numColors - numColorsWithAlpha);
-#else
- SkOpts::RGB_to_BGR1(colorPtr + numColorsWithAlpha, palette, numColors - numColorsWithAlpha);
-#endif
+ if (is_rgba(dstColorType)) {
+ SkOpts::RGB_to_RGB1(colorPtr + numColorsWithAlpha, palette,
+ numColors - numColorsWithAlpha);
+ } else {
+ SkOpts::RGB_to_BGR1(colorPtr + numColorsWithAlpha, palette,
+ numColors - numColorsWithAlpha);
+ }
}
// Pad the color table with the last color in the table (or black) in the case that
png_read_update_info(fPng_ptr, fInfo_ptr);
if (SkEncodedInfo::kPalette_Color == this->getEncodedInfo().color()) {
- if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(), ctableCount)) {
+ if (!this->createColorTable(requestedInfo.colorType(),
+ kPremul_SkAlphaType == requestedInfo.alphaType(), ctableCount)) {
return kInvalidInput;
}
}
const int fNumberPasses;
int fBitDepth;
- bool decodePalette(bool premultiply, int* ctableCount);
+ bool createColorTable(SkColorType dstColorType, bool premultiply, int* ctableCount);
void destroyReadStruct();
typedef SkCodec INHERITED;
// Use the proper memset routine to fill the remaining bytes
switch (info.colorType()) {
- case kN32_SkColorType: {
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType: {
// If memory is zero initialized, we may not need to fill
uint32_t color = colorOrIndex;
if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == color) {
SkOpts::grayA_to_rgbA((uint32_t*) dst, src + offset, width);
}
-// kBGRX
+// kBGR
-static void swizzle_bgrx_to_n32(
- void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
- int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
-
- src += offset;
- SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
- for (int x = 0; x < dstWidth; x++) {
- dst[x] = SkPackARGB32NoCheck(0xFF, src[2], src[1], src[0]);
- src += deltaSrc;
- }
-}
-
-static void swizzle_bgrx_to_565(
+static void swizzle_bgr_to_565(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
}
}
-// kBGRA
+// kRGB
-static void swizzle_bgra_to_n32_unpremul(
+static void swizzle_rgb_to_rgba(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
for (int x = 0; x < dstWidth; x++) {
- uint8_t alpha = src[3];
- dst[x] = SkPackARGB32NoCheck(alpha, src[2], src[1], src[0]);
+ dst[x] = SkPackARGB_as_RGBA(0xFF, src[0], src[1], src[2]);
src += deltaSrc;
}
}
-static void fast_swizzle_bgra_to_n32_unpremul(
- void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
- const SkPMColor ctable[]) {
-
- // This function must not be called if we are sampling. If we are not
- // sampling, deltaSrc should equal bpp.
- SkASSERT(deltaSrc == bpp);
-
-#ifdef SK_PMCOLOR_IS_RGBA
- SkOpts::RGBA_to_BGRA((uint32_t*) dst, src + offset, width);
-#else
- memcpy(dst, src + offset, width * bpp);
-#endif
-}
-
-static void swizzle_bgra_to_n32_premul(
+static void swizzle_rgb_to_bgra(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
for (int x = 0; x < dstWidth; x++) {
- uint8_t alpha = src[3];
- dst[x] = SkPremultiplyARGBInline(alpha, src[2], src[1], src[0]);
+ dst[x] = SkPackARGB_as_BGRA(0xFF, src[0], src[1], src[2]);
src += deltaSrc;
}
}
-static void fast_swizzle_bgra_to_n32_premul(
- void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
- const SkPMColor ctable[]) {
+static void fast_swizzle_rgb_to_rgba(
+ void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
+ int offset, const SkPMColor ctable[]) {
// This function must not be called if we are sampling. If we are not
// sampling, deltaSrc should equal bpp.
SkASSERT(deltaSrc == bpp);
-#ifdef SK_PMCOLOR_IS_RGBA
- SkOpts::RGBA_to_bgrA((uint32_t*) dst, src + offset, width);
-#else
- SkOpts::RGBA_to_rgbA((uint32_t*) dst, src + offset, width);
-#endif
-}
-
-// kRGB
-
-static void swizzle_rgb_to_n32(
- void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
- int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
-
- src += offset;
- SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
- for (int x = 0; x < dstWidth; x++) {
- dst[x] = SkPackARGB32NoCheck(0xFF, src[0], src[1], src[2]);
- src += deltaSrc;
- }
+ SkOpts::RGB_to_RGB1((uint32_t*) dst, src + offset, width);
}
-static void fast_swizzle_rgb_to_n32(
+static void fast_swizzle_rgb_to_bgra(
void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
int offset, const SkPMColor ctable[]) {
// sampling, deltaSrc should equal bpp.
SkASSERT(deltaSrc == bpp);
-#ifdef SK_PMCOLOR_IS_RGBA
- SkOpts::RGB_to_RGB1((uint32_t*) dst, src + offset, width);
-#else
SkOpts::RGB_to_BGR1((uint32_t*) dst, src + offset, width);
-#endif
}
static void swizzle_rgb_to_565(
// kRGBA
-static void swizzle_rgba_to_n32_premul(
+static void swizzle_rgba_to_rgba_premul(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
for (int x = 0; x < dstWidth; x++) {
- unsigned alpha = src[3];
- dst[x] = SkPremultiplyARGBInline(alpha, src[0], src[1], src[2]);
+ dst[x] = premultiply_argb_as_rgba(src[3], src[0], src[1], src[2]);
+ src += deltaSrc;
+ }
+}
+
+static void swizzle_rgba_to_bgra_premul(
+ void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
+ int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
+
+ src += offset;
+ SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+ for (int x = 0; x < dstWidth; x++) {
+ dst[x] = premultiply_argb_as_bgra(src[3], src[0], src[1], src[2]);
src += deltaSrc;
}
}
-static void fast_swizzle_rgba_to_n32_premul(
+static void fast_swizzle_rgba_to_rgba_premul(
void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
int offset, const SkPMColor ctable[]) {
// sampling, deltaSrc should equal bpp.
SkASSERT(deltaSrc == bpp);
-#ifdef SK_PMCOLOR_IS_RGBA
SkOpts::RGBA_to_rgbA((uint32_t*) dst, src + offset, width);
-#else
+}
+
+static void fast_swizzle_rgba_to_bgra_premul(
+ void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
+ int offset, const SkPMColor ctable[]) {
+
+ // This function must not be called if we are sampling. If we are not
+ // sampling, deltaSrc should equal bpp.
+ SkASSERT(deltaSrc == bpp);
+
SkOpts::RGBA_to_bgrA((uint32_t*) dst, src + offset, width);
-#endif
}
-static void swizzle_rgba_to_n32_unpremul(
+static void swizzle_rgba_to_bgra_unpremul(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
for (int x = 0; x < dstWidth; x++) {
unsigned alpha = src[3];
- dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
+ dst[x] = SkPackARGB_as_BGRA(alpha, src[0], src[1], src[2]);
src += deltaSrc;
}
}
-static void fast_swizzle_rgba_to_n32_unpremul(
+static void fast_swizzle_rgba_to_bgra_unpremul(
void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
const SkPMColor ctable[]) {
// sampling, deltaSrc should equal bpp.
SkASSERT(deltaSrc == bpp);
-#ifdef SK_PMCOLOR_IS_RGBA
- memcpy(dst, src + offset, width * bpp);
-#else
SkOpts::RGBA_to_BGRA((uint32_t*) dst, src + offset, width);
-#endif
}
// kCMYK
// R = C * K / 255
// G = M * K / 255
// B = Y * K / 255
-static void swizzle_cmyk_to_n32(
+static void swizzle_cmyk_to_rgba(
+ void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
+ int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
+
+ src += offset;
+ SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
+ for (int x = 0; x < dstWidth; x++) {
+ const uint8_t r = SkMulDiv255Round(src[0], src[3]);
+ const uint8_t g = SkMulDiv255Round(src[1], src[3]);
+ const uint8_t b = SkMulDiv255Round(src[2], src[3]);
+
+ dst[x] = SkPackARGB_as_RGBA(0xFF, r, g, b);
+ src += deltaSrc;
+ }
+}
+
+static void swizzle_cmyk_to_bgra(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
const uint8_t g = SkMulDiv255Round(src[1], src[3]);
const uint8_t b = SkMulDiv255Round(src[2], src[3]);
- dst[x] = SkPackARGB32NoCheck(0xFF, r, g, b);
+ dst[x] = SkPackARGB_as_BGRA(0xFF, r, g, b);
src += deltaSrc;
}
}
-static void fast_swizzle_cmyk_to_n32(
+static void fast_swizzle_cmyk_to_rgba(
void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
const SkPMColor ctable[]) {
// sampling, deltaSrc should equal bpp.
SkASSERT(deltaSrc == bpp);
-#ifdef SK_PMCOLOR_IS_RGBA
SkOpts::inverted_CMYK_to_RGB1((uint32_t*) dst, src + offset, width);
-#else
+}
+
+static void fast_swizzle_cmyk_to_bgra(
+ void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
+ const SkPMColor ctable[]) {
+
+ // This function must not be called if we are sampling. If we are not
+ // sampling, deltaSrc should equal bpp.
+ SkASSERT(deltaSrc == bpp);
+
SkOpts::inverted_CMYK_to_BGR1((uint32_t*) dst, src + offset, width);
-#endif
}
static void swizzle_cmyk_to_565(
switch (encodedInfo.bitsPerComponent()) {
case 1:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType:
proc = &swizzle_bit_to_n32;
break;
case kIndex_8_SkColorType:
break;
case 8:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType:
proc = &swizzle_gray_to_n32;
fastProc = &fast_swizzle_gray_to_n32;
break;
break;
case SkEncodedInfo::kGrayAlpha_Color:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType:
if (premultiply) {
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
proc = &SkipLeadingGrayAlphaZerosThen<swizzle_grayalpha_to_n32_premul>;
case 2:
case 4:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType:
proc = &swizzle_small_index_to_n32;
break;
case kRGB_565_SkColorType:
break;
case 8:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType:
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
proc = &swizzle_index_to_n32_skipZ;
} else {
break;
case SkEncodedInfo::kRGB_Color:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
- proc = &swizzle_rgb_to_n32;
- fastProc = &fast_swizzle_rgb_to_n32;
+ case kRGBA_8888_SkColorType:
+ proc = &swizzle_rgb_to_rgba;
+ fastProc = &fast_swizzle_rgb_to_rgba;
+ break;
+ case kBGRA_8888_SkColorType:
+ proc = &swizzle_rgb_to_bgra;
+ fastProc = &fast_swizzle_rgb_to_bgra;
break;
case kRGB_565_SkColorType:
proc = &swizzle_rgb_to_565;
break;
case SkEncodedInfo::kRGBA_Color:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ if (premultiply) {
+ if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+ proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_rgba_premul>;
+ fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_rgba_premul>;
+ } else {
+ proc = &swizzle_rgba_to_rgba_premul;
+ fastProc = &fast_swizzle_rgba_to_rgba_premul;
+ }
+ } else {
+ if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+ proc = &SkipLeading8888ZerosThen<sample4>;
+ fastProc = &SkipLeading8888ZerosThen<copy>;
+ } else {
+ proc = &sample4;
+ fastProc = ©
+ }
+ }
+ break;
+ case kBGRA_8888_SkColorType:
if (premultiply) {
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_premul>;
- fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_n32_premul>;
+ proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_premul>;
+ fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_bgra_premul>;
} else {
- proc = &swizzle_rgba_to_n32_premul;
- fastProc = &fast_swizzle_rgba_to_n32_premul;
+ proc = &swizzle_rgba_to_bgra_premul;
+ fastProc = &fast_swizzle_rgba_to_bgra_premul;
}
} else {
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_unpremul>;
+ proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_unpremul>;
fastProc = &SkipLeading8888ZerosThen
- <fast_swizzle_rgba_to_n32_unpremul>;
+ <fast_swizzle_rgba_to_bgra_unpremul>;
} else {
- proc = &swizzle_rgba_to_n32_unpremul;
- fastProc = &fast_swizzle_rgba_to_n32_unpremul;
+ proc = &swizzle_rgba_to_bgra_unpremul;
+ fastProc = &fast_swizzle_rgba_to_bgra_unpremul;
}
}
break;
break;
case SkEncodedInfo::kBGR_Color:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
- proc = &swizzle_bgrx_to_n32;
+ case kBGRA_8888_SkColorType:
+ proc = &swizzle_rgb_to_rgba;
+ fastProc = &fast_swizzle_rgb_to_rgba;
+ break;
+ case kRGBA_8888_SkColorType:
+ proc = &swizzle_rgb_to_bgra;
+ fastProc = &fast_swizzle_rgb_to_bgra;
break;
case kRGB_565_SkColorType:
- proc = &swizzle_bgrx_to_565;
+ proc = &swizzle_bgr_to_565;
break;
default:
return nullptr;
break;
case SkEncodedInfo::kBGRX_Color:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
- proc = &swizzle_bgrx_to_n32;
+ case kBGRA_8888_SkColorType:
+ proc = &swizzle_rgb_to_rgba;
+ break;
+ case kRGBA_8888_SkColorType:
+ proc = &swizzle_rgb_to_bgra;
break;
case kRGB_565_SkColorType:
- proc = &swizzle_bgrx_to_565;
+ proc = &swizzle_bgr_to_565;
break;
default:
return nullptr;
break;
case SkEncodedInfo::kBGRA_Color:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
+ case kBGRA_8888_SkColorType:
+ if (premultiply) {
+ if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+ proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_rgba_premul>;
+ fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_rgba_premul>;
+ } else {
+ proc = &swizzle_rgba_to_rgba_premul;
+ fastProc = &fast_swizzle_rgba_to_rgba_premul;
+ }
+ } else {
+ if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+ proc = &SkipLeading8888ZerosThen<sample4>;
+ fastProc = &SkipLeading8888ZerosThen<copy>;
+ } else {
+ proc = &sample4;
+ fastProc = ©
+ }
+ }
+ break;
+ case kRGBA_8888_SkColorType:
if (premultiply) {
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &SkipLeading8888ZerosThen<swizzle_bgra_to_n32_premul>;
- fastProc = &SkipLeading8888ZerosThen<fast_swizzle_bgra_to_n32_premul>;
+ proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_premul>;
+ fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_bgra_premul>;
} else {
- proc = &swizzle_bgra_to_n32_premul;
- fastProc = &fast_swizzle_bgra_to_n32_premul;
+ proc = &swizzle_rgba_to_bgra_premul;
+ fastProc = &fast_swizzle_rgba_to_bgra_premul;
}
} else {
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_unpremul>;
+ proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_bgra_unpremul>;
fastProc = &SkipLeading8888ZerosThen
- <fast_swizzle_bgra_to_n32_unpremul>;
+ <fast_swizzle_rgba_to_bgra_unpremul>;
} else {
- proc = &swizzle_bgra_to_n32_unpremul;
- fastProc = &fast_swizzle_bgra_to_n32_unpremul;
+ proc = &swizzle_rgba_to_bgra_unpremul;
+ fastProc = &fast_swizzle_rgba_to_bgra_unpremul;
}
}
break;
break;
case SkEncodedInfo::kInvertedCMYK_Color:
switch (dstInfo.colorType()) {
- case kN32_SkColorType:
- proc = &swizzle_cmyk_to_n32;
- fastProc = &fast_swizzle_cmyk_to_n32;
+ case kRGBA_8888_SkColorType:
+ proc = &swizzle_cmyk_to_rgba;
+ fastProc = &fast_swizzle_cmyk_to_rgba;
+ break;
+ case kBGRA_8888_SkColorType:
+ proc = &swizzle_cmyk_to_bgra;
+ fastProc = &fast_swizzle_cmyk_to_bgra;
break;
case kRGB_565_SkColorType:
proc = &swizzle_cmyk_to_565;
proc = &sample2;
fastProc = ©
break;
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType:
proc = &sample4;
fastProc = ©
break;
static inline bool valid_color_type(SkColorType colorType, SkAlphaType alphaType) {
switch (colorType) {
- case kN32_SkColorType:
+ case kRGBA_8888_SkColorType:
+ case kBGRA_8888_SkColorType:
case kIndex_8_SkColorType:
return true;
case kGray_8_SkColorType:
projects / platform / upstream / libSkiaSharp.git / commitdiff