aboutsummaryrefslogtreecommitdiffhomepage
path: root/src/codec
diff options
context:
space:
mode:
Diffstat (limited to 'src/codec')
-rw-r--r--src/codec/SkBmpStandardCodec.cpp36
-rw-r--r--src/codec/SkGifCodec.cpp2
-rw-r--r--src/codec/SkJpegCodec.cpp39
-rw-r--r--src/codec/SkPngCodec.cpp59
-rw-r--r--src/codec/SkPngCodec.h2
-rw-r--r--src/codec/SkRawCodec.cpp2
-rw-r--r--src/codec/SkSwizzler.cpp297
-rw-r--r--src/codec/SkSwizzler.h74
-rw-r--r--src/codec/SkWbmpCodec.cpp2
9 files changed, 209 insertions, 304 deletions
diff --git a/src/codec/SkBmpStandardCodec.cpp b/src/codec/SkBmpStandardCodec.cpp
index a509c75b6d..b2d8fc9735 100644
--- a/src/codec/SkBmpStandardCodec.cpp
+++ b/src/codec/SkBmpStandardCodec.cpp
@@ -153,40 +153,20 @@ SkCodec::Result SkBmpStandardCodec::onGetPixels(const SkImageInfo& dstInfo,
}
void SkBmpStandardCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options& opts) {
- // Get swizzler configuration
- SkSwizzler::SrcConfig config = SkSwizzler::kUnknown;
- switch (this->bitsPerPixel()) {
- case 1:
- config = SkSwizzler::kIndex1;
- break;
- case 2:
- config = SkSwizzler::kIndex2;
- break;
- case 4:
- config = SkSwizzler::kIndex4;
- break;
- case 8:
- config = SkSwizzler::kIndex;
- break;
- case 24:
- config = SkSwizzler::kBGR;
- break;
- case 32:
- if (fIsOpaque) {
- config = SkSwizzler::kBGRX;
- } else {
- config = SkSwizzler::kBGRA;
- }
- break;
- default:
- SkASSERT(false);
+ // In the case of paletted ico-in-bmps, we will report BGRA to the client,
+ // since we may be required to apply an alpha mask after the decode. But
+ // the swizzler needs to know the actual format of the bmp.
+ SkEncodedInfo swizzlerInfo = this->getEncodedInfo();
+ if (fInIco && this->bitsPerPixel() <= 8) {
+ swizzlerInfo = SkEncodedInfo::Make(SkEncodedInfo::kPalette_Color, swizzlerInfo.alpha(),
+ this->bitsPerPixel());
}
// Get a pointer to the color table if it exists
const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
// Create swizzler
- fSwizzler.reset(SkSwizzler::CreateSwizzler(config, colorPtr, dstInfo, opts));
+ fSwizzler.reset(SkSwizzler::CreateSwizzler(swizzlerInfo, colorPtr, dstInfo, opts));
SkASSERT(fSwizzler);
}
diff --git a/src/codec/SkGifCodec.cpp b/src/codec/SkGifCodec.cpp
index cdd9d088f1..774131f648 100644
--- a/src/codec/SkGifCodec.cpp
+++ b/src/codec/SkGifCodec.cpp
@@ -464,7 +464,7 @@ SkCodec::Result SkGifCodec::prepareToDecode(const SkImageInfo& dstInfo, SkPMColo
void SkGifCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options& opts) {
const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
const SkIRect* frameRect = fFrameIsSubset ? &fFrameRect : nullptr;
- fSwizzler.reset(SkSwizzler::CreateSwizzler(SkSwizzler::kIndex, colorPtr, dstInfo, opts,
+ fSwizzler.reset(SkSwizzler::CreateSwizzler(this->getEncodedInfo(), colorPtr, dstInfo, opts,
frameRect));
SkASSERT(fSwizzler);
}
diff --git a/src/codec/SkJpegCodec.cpp b/src/codec/SkJpegCodec.cpp
index 88b7fcbde1..8d32f2b44d 100644
--- a/src/codec/SkJpegCodec.cpp
+++ b/src/codec/SkJpegCodec.cpp
@@ -510,30 +510,19 @@ SkCodec::Result SkJpegCodec::onGetPixels(const SkImageInfo& dstInfo,
}
void SkJpegCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options& options) {
- SkSwizzler::SrcConfig srcConfig = SkSwizzler::kUnknown;
- if (JCS_CMYK == fDecoderMgr->dinfo()->out_color_space) {
- srcConfig = SkSwizzler::kCMYK;
- } else {
- // If the out_color_space is not CMYK, the only reason we would need a swizzler is
- // for sampling and/or subsetting.
- switch (dstInfo.colorType()) {
- case kGray_8_SkColorType:
- srcConfig = SkSwizzler::kNoOp8;
- break;
- case kN32_SkColorType:
- srcConfig = SkSwizzler::kNoOp32;
- break;
- case kRGB_565_SkColorType:
- srcConfig = SkSwizzler::kNoOp16;
- break;
- default:
- // This function should only be called if the colorType is supported by jpeg
- SkASSERT(false);
- }
- }
-
- if (JCS_RGB == fDecoderMgr->dinfo()->out_color_space) {
- srcConfig = SkSwizzler::kRGB;
+ // libjpeg-turbo may have already performed color conversion. We must indicate the
+ // appropriate format to the swizzler.
+ SkEncodedInfo swizzlerInfo = this->getEncodedInfo();
+ switch (fDecoderMgr->dinfo()->out_color_space) {
+ case JCS_RGB:
+ swizzlerInfo.setColor(SkEncodedInfo::kRGB_Color);
+ break;
+ case JCS_CMYK:
+ swizzlerInfo.setColor(SkEncodedInfo::kInvertedCMYK_Color);
+ break;
+ default:
+ swizzlerInfo.setColor(SkEncodedInfo::kPreSwizzled_Color);
+ break;
}
Options swizzlerOptions = options;
@@ -545,7 +534,7 @@ void SkJpegCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options&
fSwizzlerSubset.width() == options.fSubset->width());
swizzlerOptions.fSubset = &fSwizzlerSubset;
}
- fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, dstInfo, swizzlerOptions));
+ fSwizzler.reset(SkSwizzler::CreateSwizzler(swizzlerInfo, nullptr, dstInfo, swizzlerOptions));
SkASSERT(fSwizzler);
fStorage.reset(get_row_bytes(fDecoderMgr->dinfo()));
fSrcRow = fStorage.get();
diff --git a/src/codec/SkPngCodec.cpp b/src/codec/SkPngCodec.cpp
index 33c3b6095b..240902de30 100644
--- a/src/codec/SkPngCodec.cpp
+++ b/src/codec/SkPngCodec.cpp
@@ -439,7 +439,6 @@ SkPngCodec::SkPngCodec(int width, int height, const SkEncodedInfo& info, SkStrea
, fPngChunkReader(SkSafeRef(chunkReader))
, fPng_ptr(png_ptr)
, fInfo_ptr(info_ptr)
- , fSrcConfig(SkSwizzler::kUnknown)
, fNumberPasses(numberPasses)
, fBitDepth(bitDepth)
{}
@@ -474,45 +473,10 @@ SkCodec::Result SkPngCodec::initializeSwizzler(const SkImageInfo& requestedInfo,
}
png_read_update_info(fPng_ptr, fInfo_ptr);
- // suggestedColorType was determined in read_header() based on the encodedColorType
- const SkColorType suggestedColorType = this->getInfo().colorType();
-
- switch (suggestedColorType) {
- case kIndex_8_SkColorType:
- //decode palette to Skia format
- fSrcConfig = SkSwizzler::kIndex;
- if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(),
- ctableCount)) {
- return kInvalidInput;
- }
- break;
- case kGray_8_SkColorType:
- fSrcConfig = SkSwizzler::kGray;
- break;
- case kN32_SkColorType: {
- const uint8_t encodedColorType = png_get_color_type(fPng_ptr, fInfo_ptr);
- if (PNG_COLOR_TYPE_GRAY_ALPHA == encodedColorType ||
- PNG_COLOR_TYPE_GRAY == encodedColorType) {
- // If encodedColorType is GRAY, there must be a transparent chunk.
- // Otherwise, suggestedColorType would be kGray. We have already
- // instructed libpng to convert the transparent chunk to alpha,
- // so we can treat both GRAY and GRAY_ALPHA as kGrayAlpha.
- SkASSERT(encodedColorType == PNG_COLOR_TYPE_GRAY_ALPHA ||
- png_get_valid(fPng_ptr, fInfo_ptr, PNG_INFO_tRNS));
-
- fSrcConfig = SkSwizzler::kGrayAlpha;
- } else {
- if (this->getInfo().alphaType() == kOpaque_SkAlphaType) {
- fSrcConfig = SkSwizzler::kRGB;
- } else {
- fSrcConfig = SkSwizzler::kRGBA;
- }
- }
- break;
+ if (SkEncodedInfo::kPalette_Color == this->getEncodedInfo().color()) {
+ if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(), ctableCount)) {
+ return kInvalidInput;
}
- default:
- // We will always recommend one of the above colorTypes.
- SkASSERT(false);
}
// Copy the color table to the client if they request kIndex8 mode
@@ -520,7 +484,8 @@ SkCodec::Result SkPngCodec::initializeSwizzler(const SkImageInfo& requestedInfo,
// Create the swizzler. SkPngCodec retains ownership of the color table.
const SkPMColor* colors = get_color_ptr(fColorTable.get());
- fSwizzler.reset(SkSwizzler::CreateSwizzler(fSrcConfig, colors, requestedInfo, options));
+ fSwizzler.reset(SkSwizzler::CreateSwizzler(this->getEncodedInfo(), colors, requestedInfo,
+ options));
SkASSERT(fSwizzler);
return kSuccess;
@@ -547,6 +512,12 @@ bool SkPngCodec::onRewind() {
return true;
}
+static int bytes_per_pixel(int bitsPerPixel) {
+ // Note that we will have to change this implementation if we start
+ // supporting outputs from libpng that are less than 8-bits per component.
+ return bitsPerPixel / 8;
+}
+
SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
size_t dstRowBytes, const Options& options,
SkPMColor ctable[], int* ctableCount,
@@ -567,7 +538,7 @@ SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& requestedInfo, void*
const int width = requestedInfo.width();
const int height = requestedInfo.height();
- const int bpp = SkSwizzler::BytesPerPixel(fSrcConfig);
+ const int bpp = bytes_per_pixel(this->getEncodedInfo().bitsPerPixel());
const size_t srcRowBytes = width * bpp;
// FIXME: Could we use the return value of setjmp to specify the type of
@@ -664,7 +635,8 @@ public:
return result;
}
- fStorage.reset(this->getInfo().width() * SkSwizzler::BytesPerPixel(this->srcConfig()));
+ fStorage.reset(this->getInfo().width() *
+ (bytes_per_pixel(this->getEncodedInfo().bitsPerPixel())));
fSrcRow = fStorage.get();
return kSuccess;
@@ -736,7 +708,8 @@ public:
fHeight = dstInfo.height();
// FIXME: This need not be called on a second call to onStartScanlineDecode.
- fSrcRowBytes = this->getInfo().width() * SkSwizzler::BytesPerPixel(this->srcConfig());
+ fSrcRowBytes = this->getInfo().width() *
+ (bytes_per_pixel(this->getEncodedInfo().bitsPerPixel()));
fGarbageRow.reset(fSrcRowBytes);
fGarbageRowPtr = static_cast<uint8_t*>(fGarbageRow.get());
fCanSkipRewind = true;
diff --git a/src/codec/SkPngCodec.h b/src/codec/SkPngCodec.h
index 8587bf8a14..934513a676 100644
--- a/src/codec/SkPngCodec.h
+++ b/src/codec/SkPngCodec.h
@@ -46,7 +46,6 @@ protected:
png_structp png_ptr() { return fPng_ptr; }
SkSwizzler* swizzler() { return fSwizzler; }
- SkSwizzler::SrcConfig srcConfig() const { return fSrcConfig; }
int numberPasses() const { return fNumberPasses; }
private:
@@ -58,7 +57,6 @@ private:
SkAutoTUnref<SkColorTable> fColorTable; // May be unpremul.
SkAutoTDelete<SkSwizzler> fSwizzler;
- SkSwizzler::SrcConfig fSrcConfig;
const int fNumberPasses;
int fBitDepth;
diff --git a/src/codec/SkRawCodec.cpp b/src/codec/SkRawCodec.cpp
index 51de2fcec0..dc638e60e0 100644
--- a/src/codec/SkRawCodec.cpp
+++ b/src/codec/SkRawCodec.cpp
@@ -688,7 +688,7 @@ SkCodec::Result SkRawCodec::onGetPixels(const SkImageInfo& requestedInfo, void*
}
SkAutoTDelete<SkSwizzler> swizzler(SkSwizzler::CreateSwizzler(
- SkSwizzler::kRGB, nullptr, requestedInfo, options));
+ this->getEncodedInfo(), nullptr, requestedInfo, options));
SkASSERT(swizzler);
const int width = requestedInfo.width();
diff --git a/src/codec/SkSwizzler.cpp b/src/codec/SkSwizzler.cpp
index 133736879f..a4b30287c2 100644
--- a/src/codec/SkSwizzler.cpp
+++ b/src/codec/SkSwizzler.cpp
@@ -661,127 +661,175 @@ void SkSwizzler::SkipLeading8888ZerosThen(
proc(dst32, (const uint8_t*)src32, dstWidth, bpp, deltaSrc, 0, ctable);
}
-SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
+SkSwizzler* SkSwizzler::CreateSwizzler(const SkEncodedInfo& encodedInfo,
const SkPMColor* ctable,
const SkImageInfo& dstInfo,
const SkCodec::Options& options,
const SkIRect* frame) {
- if (dstInfo.colorType() == kUnknown_SkColorType || kUnknown == sc) {
- return nullptr;
- }
- if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
- && nullptr == ctable) {
+ if (SkEncodedInfo::kPalette_Color == encodedInfo.color() && nullptr == ctable) {
return nullptr;
}
+
RowProc fastProc = nullptr;
RowProc proc = nullptr;
SkCodec::ZeroInitialized zeroInit = options.fZeroInitialized;
- switch (sc) {
- case kBit:
- switch (dstInfo.colorType()) {
- case kN32_SkColorType:
- proc = &swizzle_bit_to_n32;
- break;
- case kIndex_8_SkColorType:
- proc = &swizzle_bit_to_index;
- break;
- case kRGB_565_SkColorType:
- proc = &swizzle_bit_to_565;
+ const bool premultiply = (SkEncodedInfo::kOpaque_Alpha != encodedInfo.alpha()) &&
+ (kPremul_SkAlphaType == dstInfo.alphaType());
+ switch (encodedInfo.color()) {
+ case SkEncodedInfo::kGray_Color:
+ switch (encodedInfo.bitsPerComponent()) {
+ case 1:
+ switch (dstInfo.colorType()) {
+ case kN32_SkColorType:
+ proc = &swizzle_bit_to_n32;
+ break;
+ case kIndex_8_SkColorType:
+ proc = &swizzle_bit_to_index;
+ break;
+ case kRGB_565_SkColorType:
+ proc = &swizzle_bit_to_565;
+ break;
+ case kGray_8_SkColorType:
+ proc = &swizzle_bit_to_grayscale;
+ break;
+ default:
+ return nullptr;
+ }
break;
- case kGray_8_SkColorType:
- proc = &swizzle_bit_to_grayscale;
+ case 8:
+ switch (dstInfo.colorType()) {
+ case kN32_SkColorType:
+ proc = &swizzle_gray_to_n32;
+ fastProc = &fast_swizzle_gray_to_n32;
+ break;
+ case kGray_8_SkColorType:
+ proc = &sample1;
+ fastProc = &copy;
+ break;
+ case kRGB_565_SkColorType:
+ proc = &swizzle_gray_to_565;
+ break;
+ default:
+ return nullptr;
+ }
break;
default:
- break;
+ return nullptr;
}
break;
- case kIndex1:
- case kIndex2:
- case kIndex4:
+ case SkEncodedInfo::kGrayAlpha_Color:
switch (dstInfo.colorType()) {
case kN32_SkColorType:
- proc = &swizzle_small_index_to_n32;
- break;
- case kRGB_565_SkColorType:
- proc = &swizzle_small_index_to_565;
- break;
- case kIndex_8_SkColorType:
- proc = &swizzle_small_index_to_index;
+ if (premultiply) {
+ if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+ proc = &SkipLeadingGrayAlphaZerosThen<swizzle_grayalpha_to_n32_premul>;
+ fastProc = &SkipLeadingGrayAlphaZerosThen
+ <fast_swizzle_grayalpha_to_n32_premul>;
+ } else {
+ proc = &swizzle_grayalpha_to_n32_premul;
+ fastProc = &fast_swizzle_grayalpha_to_n32_premul;
+ }
+ } else {
+ if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+ proc = &SkipLeadingGrayAlphaZerosThen
+ <swizzle_grayalpha_to_n32_unpremul>;
+ fastProc = &SkipLeadingGrayAlphaZerosThen
+ <fast_swizzle_grayalpha_to_n32_unpremul>;
+ } else {
+ proc = &swizzle_grayalpha_to_n32_unpremul;
+ fastProc = &fast_swizzle_grayalpha_to_n32_unpremul;
+ }
+ }
break;
default:
- break;
+ return nullptr;
}
break;
- case kIndex:
- switch (dstInfo.colorType()) {
- case kN32_SkColorType:
- // We assume the color premultiplied ctable (or not) as desired.
- if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &swizzle_index_to_n32_skipZ;
- break;
- } else {
- proc = &swizzle_index_to_n32;
- break;
+ case SkEncodedInfo::kPalette_Color:
+ // We assume that the color table is premultiplied and swizzled
+ // as desired.
+ switch (encodedInfo.bitsPerComponent()) {
+ case 1:
+ case 2:
+ case 4:
+ switch (dstInfo.colorType()) {
+ case kN32_SkColorType:
+ proc = &swizzle_small_index_to_n32;
+ break;
+ case kRGB_565_SkColorType:
+ proc = &swizzle_small_index_to_565;
+ break;
+ case kIndex_8_SkColorType:
+ proc = &swizzle_small_index_to_index;
+ break;
+ default:
+ return nullptr;
}
break;
- case kRGB_565_SkColorType:
- proc = &swizzle_index_to_565;
- break;
- case kIndex_8_SkColorType:
- proc = &sample1;
- fastProc = &copy;
+ case 8:
+ switch (dstInfo.colorType()) {
+ case kN32_SkColorType:
+ if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+ proc = &swizzle_index_to_n32_skipZ;
+ } else {
+ proc = &swizzle_index_to_n32;
+ }
+ break;
+ case kRGB_565_SkColorType:
+ proc = &swizzle_index_to_565;
+ break;
+ case kIndex_8_SkColorType:
+ proc = &sample1;
+ fastProc = &copy;
+ break;
+ default:
+ return nullptr;
+ }
break;
default:
- break;
+ return nullptr;
}
break;
- case kGray:
+ case SkEncodedInfo::kRGB_Color:
switch (dstInfo.colorType()) {
case kN32_SkColorType:
- proc = &swizzle_gray_to_n32;
- fastProc = &fast_swizzle_gray_to_n32;
- break;
- case kGray_8_SkColorType:
- proc = &sample1;
- fastProc = &copy;
+ proc = &swizzle_rgb_to_n32;
+ fastProc = &fast_swizzle_rgb_to_n32;
break;
case kRGB_565_SkColorType:
- proc = &swizzle_gray_to_565;
+ proc = &swizzle_rgb_to_565;
break;
default:
- break;
+ return nullptr;
}
break;
- case kGrayAlpha:
+ case SkEncodedInfo::kRGBA_Color:
switch (dstInfo.colorType()) {
case kN32_SkColorType:
- if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
+ if (premultiply) {
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &SkipLeadingGrayAlphaZerosThen
- <swizzle_grayalpha_to_n32_unpremul>;
- fastProc = &SkipLeadingGrayAlphaZerosThen
- <fast_swizzle_grayalpha_to_n32_unpremul>;
+ proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_premul>;
+ fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_n32_premul>;
} else {
- proc = &swizzle_grayalpha_to_n32_unpremul;
- fastProc = &fast_swizzle_grayalpha_to_n32_unpremul;
+ proc = &swizzle_rgba_to_n32_premul;
+ fastProc = &fast_swizzle_rgba_to_n32_premul;
}
} else {
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &SkipLeadingGrayAlphaZerosThen<swizzle_grayalpha_to_n32_premul>;
- fastProc = &SkipLeadingGrayAlphaZerosThen
- <fast_swizzle_grayalpha_to_n32_premul>;
+ proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_unpremul>;
+ fastProc = &SkipLeading8888ZerosThen
+ <fast_swizzle_rgba_to_n32_unpremul>;
} else {
- proc = &swizzle_grayalpha_to_n32_premul;
- fastProc = &fast_swizzle_grayalpha_to_n32_premul;
+ proc = &swizzle_rgba_to_n32_unpremul;
+ fastProc = &fast_swizzle_rgba_to_n32_unpremul;
}
}
break;
default:
- break;
+ return nullptr;
}
break;
- case kBGR:
- case kBGRX:
+ case SkEncodedInfo::kBGR_Color:
switch (dstInfo.colorType()) {
case kN32_SkColorType:
proc = &swizzle_bgrx_to_n32;
@@ -790,73 +838,48 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
proc = &swizzle_bgrx_to_565;
break;
default:
- break;
+ return nullptr;
}
break;
- case kBGRA:
+ case SkEncodedInfo::kBGRX_Color:
switch (dstInfo.colorType()) {
case kN32_SkColorType:
- if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
- if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &SkipLeading8888ZerosThen<swizzle_bgra_to_n32_unpremul>;
- fastProc = &SkipLeading8888ZerosThen<fast_swizzle_bgra_to_n32_unpremul>;
- } else {
- proc = &swizzle_bgra_to_n32_unpremul;
- fastProc = &fast_swizzle_bgra_to_n32_unpremul;
- }
- } else {
- if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &SkipLeading8888ZerosThen<swizzle_bgra_to_n32_premul>;
- fastProc = &SkipLeading8888ZerosThen<fast_swizzle_bgra_to_n32_premul>;
- } else {
- proc = &swizzle_bgra_to_n32_premul;
- fastProc = &fast_swizzle_bgra_to_n32_premul;
- }
- }
- break;
- default:
- break;
- }
- break;
- case kRGB:
- switch (dstInfo.colorType()) {
- case kN32_SkColorType:
- proc = &swizzle_rgb_to_n32;
- fastProc = &fast_swizzle_rgb_to_n32;
+ proc = &swizzle_bgrx_to_n32;
break;
case kRGB_565_SkColorType:
- proc = &swizzle_rgb_to_565;
+ proc = &swizzle_bgrx_to_565;
break;
default:
- break;
+ return nullptr;
}
break;
- case kRGBA:
+ case SkEncodedInfo::kBGRA_Color:
switch (dstInfo.colorType()) {
case kN32_SkColorType:
- if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
+ if (premultiply) {
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
- proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_unpremul>;
- fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_n32_unpremul>;
+ proc = &SkipLeading8888ZerosThen<swizzle_bgra_to_n32_premul>;
+ fastProc = &SkipLeading8888ZerosThen<fast_swizzle_bgra_to_n32_premul>;
} else {
- proc = &swizzle_rgba_to_n32_unpremul;
- fastProc = &fast_swizzle_rgba_to_n32_unpremul;
+ proc = &swizzle_bgra_to_n32_premul;
+ fastProc = &fast_swizzle_bgra_to_n32_premul;
}
} else {
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_n32_unpremul>;
+ fastProc = &SkipLeading8888ZerosThen
+ <fast_swizzle_bgra_to_n32_unpremul>;
} else {
- proc = &swizzle_rgba_to_n32_premul;
- fastProc = &fast_swizzle_rgba_to_n32_premul;
+ proc = &swizzle_bgra_to_n32_unpremul;
+ fastProc = &fast_swizzle_bgra_to_n32_unpremul;
}
}
break;
default:
- break;
+ return nullptr;
}
break;
- case kCMYK:
+ case SkEncodedInfo::kInvertedCMYK_Color:
switch (dstInfo.colorType()) {
case kN32_SkColorType:
proc = &swizzle_cmyk_to_n32;
@@ -866,28 +889,40 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
proc = &swizzle_cmyk_to_565;
break;
default:
- break;
+ return nullptr;
}
break;
- case kNoOp8:
- proc = &sample1;
- fastProc = &copy;
- break;
- case kNoOp16:
- proc = sample2;
- fastProc = &copy;
- break;
- case kNoOp32:
- proc = &sample4;
- fastProc = &copy;
+ case SkEncodedInfo::kPreSwizzled_Color:
+ switch (dstInfo.colorType()) {
+ case kGray_8_SkColorType:
+ proc = &sample1;
+ fastProc = &copy;
+ break;
+ case kRGB_565_SkColorType:
+ proc = &sample2;
+ fastProc = &copy;
+ break;
+ case kN32_SkColorType:
+ proc = &sample4;
+ fastProc = &copy;
+ break;
+ default:
+ return nullptr;
+ }
break;
default:
- break;
+ return nullptr;
}
- // Store bpp in bytes if it is an even multiple, otherwise use bits
- int srcBPP = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) : BitsPerPixel(sc);
int dstBPP = SkColorTypeBytesPerPixel(dstInfo.colorType());
+ int srcBPP;
+ if (SkEncodedInfo::kPreSwizzled_Color == encodedInfo.color()) {
+ srcBPP = dstBPP;
+ } else {
+ // Store bpp in bytes if it is an even multiple, otherwise use bits
+ uint8_t bitsPerPixel = encodedInfo.bitsPerPixel();
+ srcBPP = SkIsAlign8(bitsPerPixel) ? bitsPerPixel / 8 : bitsPerPixel;
+ }
int srcOffset = 0;
int srcWidth = dstInfo.width();
diff --git a/src/codec/SkSwizzler.h b/src/codec/SkSwizzler.h
index 7eebe7f981..070652cc8a 100644
--- a/src/codec/SkSwizzler.h
+++ b/src/codec/SkSwizzler.h
@@ -16,78 +16,8 @@
class SkSwizzler : public SkSampler {
public:
/**
- * Enum describing the config of the source data.
- */
- enum SrcConfig {
- kUnknown, // Invalid type.
- kBit, // A single bit to distinguish between white and black.
- kGray,
- kGrayAlpha,
- kIndex1,
- kIndex2,
- kIndex4,
- kIndex,
- kRGB,
- kBGR,
- kBGRX, // The alpha channel can be anything, but the image is opaque.
- kRGBA,
- kBGRA,
- kCMYK,
- kNoOp8, // kNoOp modes are used exclusively for sampling, subsetting, and
- kNoOp16, // copying. The pixels themselves do not need to be modified.
- kNoOp32,
- };
-
- /*
- *
- * Returns bits per pixel for source config
- *
- */
- static int BitsPerPixel(SrcConfig sc) {
- switch (sc) {
- case kBit:
- case kIndex1:
- return 1;
- case kIndex2:
- return 2;
- case kIndex4:
- return 4;
- case kGray:
- case kIndex:
- case kNoOp8:
- return 8;
- case kGrayAlpha:
- case kNoOp16:
- return 16;
- case kRGB:
- case kBGR:
- return 24;
- case kRGBA:
- case kBGRX:
- case kBGRA:
- case kCMYK:
- case kNoOp32:
- return 32;
- default:
- SkASSERT(false);
- return 0;
- }
- }
-
- /*
- *
- * Returns bytes per pixel for source config
- * Raises an error if each pixel is not stored in an even number of bytes
- *
- */
- static int BytesPerPixel(SrcConfig sc) {
- SkASSERT(SkIsAlign8(BitsPerPixel(sc)));
- return BitsPerPixel(sc) >> 3;
- }
-
- /**
* Create a new SkSwizzler.
- * @param SrcConfig Description of the format of the source.
+ * @param encodedInfo Description of the format of the encoded data.
* @param ctable Unowned pointer to an array of up to 256 colors for an
* index source.
* @param dstInfo Describes the destination.
@@ -104,7 +34,7 @@ public:
*
* @return A new SkSwizzler or nullptr on failure.
*/
- static SkSwizzler* CreateSwizzler(SrcConfig, const SkPMColor* ctable,
+ static SkSwizzler* CreateSwizzler(const SkEncodedInfo& encodedInfo, const SkPMColor* ctable,
const SkImageInfo& dstInfo, const SkCodec::Options&,
const SkIRect* frame = nullptr);
diff --git a/src/codec/SkWbmpCodec.cpp b/src/codec/SkWbmpCodec.cpp
index 9a842ac91f..1e165b4e1d 100644
--- a/src/codec/SkWbmpCodec.cpp
+++ b/src/codec/SkWbmpCodec.cpp
@@ -97,7 +97,7 @@ bool SkWbmpCodec::onRewind() {
SkSwizzler* SkWbmpCodec::initializeSwizzler(const SkImageInfo& info, const SkPMColor* ctable,
const Options& opts) {
- return SkSwizzler::CreateSwizzler(SkSwizzler::kBit, ctable, info, opts);
+ return SkSwizzler::CreateSwizzler(this->getEncodedInfo(), ctable, info, opts);
}
bool SkWbmpCodec::readRow(uint8_t* row) {
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-01 04:33:54 +0000