Revert "Implementation of image decoding for bmp files, in accordance with the new API."
This reverts commit 3675874468
.
BUG=skia:
NOTREECHECKS=true
NOTRY=true
TBR=
Review URL: https://codereview.chromium.org/1012873002
This commit is contained in:
parent
d18475854c
commit
dfdec78a5d
@ -141,27 +141,15 @@ Error ImageSrc::draw(SkCanvas* canvas) const {
|
||||
|
||||
SkISize ImageSrc::size() const {
|
||||
SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
|
||||
if (FLAGS_codec) {
|
||||
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
|
||||
if (!codec) {
|
||||
return SkISize::Make(0,0);
|
||||
}
|
||||
SkImageInfo info;
|
||||
if (!codec->getInfo(&info)) {
|
||||
return SkISize::Make(0,0);
|
||||
}
|
||||
return info.dimensions();
|
||||
} else {
|
||||
SkBitmap bitmap;
|
||||
if (!encoded || !SkImageDecoder::DecodeMemory(encoded->data(),
|
||||
encoded->size(),
|
||||
&bitmap,
|
||||
kUnknown_SkColorType,
|
||||
SkImageDecoder::kDecodeBounds_Mode)) {
|
||||
return SkISize::Make(0,0);
|
||||
}
|
||||
return bitmap.dimensions();
|
||||
SkBitmap bitmap;
|
||||
if (!encoded || !SkImageDecoder::DecodeMemory(encoded->data(),
|
||||
encoded->size(),
|
||||
&bitmap,
|
||||
kUnknown_SkColorType,
|
||||
SkImageDecoder::kDecodeBounds_Mode)) {
|
||||
return SkISize::Make(0,0);
|
||||
}
|
||||
return bitmap.dimensions();
|
||||
}
|
||||
|
||||
Name ImageSrc::name() const {
|
||||
|
@ -17,9 +17,6 @@
|
||||
'sources': [
|
||||
'../src/codec/SkCodec.cpp',
|
||||
'../src/codec/SkCodec_libpng.cpp',
|
||||
'../src/codec/SkCodec_libbmp.cpp',
|
||||
'../src/codec/SkMaskSwizzler.cpp',
|
||||
'../src/codec/SkMasks.cpp',
|
||||
'../src/codec/SkSwizzler.cpp',
|
||||
],
|
||||
'direct_dependent_settings': {
|
||||
|
@ -84,15 +84,6 @@ protected:
|
||||
*/
|
||||
bool SK_WARN_UNUSED_RESULT rewindIfNeeded();
|
||||
|
||||
/*
|
||||
*
|
||||
* Get method for the input stream
|
||||
*
|
||||
*/
|
||||
SkStream* stream() {
|
||||
return fStream.get();
|
||||
}
|
||||
|
||||
private:
|
||||
const SkImageInfo fInfo;
|
||||
SkAutoTDelete<SkStream> fStream;
|
||||
|
@ -7,33 +7,24 @@
|
||||
|
||||
#include "SkCodec.h"
|
||||
#include "SkData.h"
|
||||
#include "SkCodec_libbmp.h"
|
||||
#include "SkCodec_libpng.h"
|
||||
#include "SkStream.h"
|
||||
|
||||
struct DecoderProc {
|
||||
bool (*IsFormat)(SkStream*);
|
||||
SkCodec* (*NewFromStream)(SkStream*);
|
||||
};
|
||||
|
||||
static const DecoderProc gDecoderProcs[] = {
|
||||
{ SkPngCodec::IsPng, SkPngCodec::NewFromStream },
|
||||
{ SkBmpCodec::IsBmp, SkBmpCodec::NewFromStream }
|
||||
};
|
||||
|
||||
SkCodec* SkCodec::NewFromStream(SkStream* stream) {
|
||||
if (!stream) {
|
||||
return NULL;
|
||||
}
|
||||
for (DecoderProc proc : gDecoderProcs) {
|
||||
const bool correctFormat = proc.IsFormat(stream);
|
||||
if (!stream->rewind()) {
|
||||
return NULL;
|
||||
}
|
||||
if (correctFormat) {
|
||||
return proc.NewFromStream(stream);
|
||||
}
|
||||
SkAutoTDelete<SkStream> streamDeleter(stream);
|
||||
const bool isPng = SkPngCodec::IsPng(stream);
|
||||
// TODO: Avoid rewinding.
|
||||
if (!stream->rewind()) {
|
||||
return NULL;
|
||||
}
|
||||
if (isPng) {
|
||||
streamDeleter.detach();
|
||||
return SkPngCodec::NewFromStream(stream);
|
||||
}
|
||||
// TODO: Check other image types.
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -1,117 +0,0 @@
|
||||
/*
|
||||
* Copyright 2015 The Android Open Source Project
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license that can be
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#ifndef SkCodecPriv_DEFINED
|
||||
#define SkCodecPriv_DEFINED
|
||||
|
||||
#include "SkImageInfo.h"
|
||||
#include "SkSwizzler.h"
|
||||
#include "SkTypes.h"
|
||||
|
||||
/*
|
||||
*
|
||||
* Helper routine for alpha result codes
|
||||
*
|
||||
*/
|
||||
#define INIT_RESULT_ALPHA \
|
||||
uint8_t zeroAlpha = 0; \
|
||||
uint8_t maxAlpha = 0xFF;
|
||||
|
||||
#define UPDATE_RESULT_ALPHA(alpha) \
|
||||
zeroAlpha |= (alpha); \
|
||||
maxAlpha &= (alpha);
|
||||
|
||||
#define COMPUTE_RESULT_ALPHA \
|
||||
SkSwizzler::GetResult(zeroAlpha, maxAlpha);
|
||||
|
||||
/*
|
||||
*
|
||||
* Compute row bytes for an image using pixels per byte
|
||||
*
|
||||
*/
|
||||
static inline size_t compute_row_bytes_ppb(int width, uint32_t pixelsPerByte) {
|
||||
return (width + pixelsPerByte - 1) / pixelsPerByte;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Compute row bytes for an image using bytes per pixel
|
||||
*
|
||||
*/
|
||||
static inline size_t compute_row_bytes_bpp(int width, uint32_t bytesPerPixel) {
|
||||
return width * bytesPerPixel;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Compute row bytes for an image
|
||||
*
|
||||
*/
|
||||
static inline size_t compute_row_bytes(int width, uint32_t bitsPerPixel) {
|
||||
if (bitsPerPixel < 16) {
|
||||
SkASSERT(0 == 8 % bitsPerPixel);
|
||||
const uint32_t pixelsPerByte = 8 / bitsPerPixel;
|
||||
return compute_row_bytes_ppb(width, pixelsPerByte);
|
||||
} else {
|
||||
SkASSERT(0 == bitsPerPixel % 8);
|
||||
const uint32_t bytesPerPixel = bitsPerPixel / 8;
|
||||
return compute_row_bytes_bpp(width, bytesPerPixel);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Checks if alpha types are premul and unpremul
|
||||
*
|
||||
*/
|
||||
static inline bool premul_and_unpremul(SkAlphaType dst, SkAlphaType src) {
|
||||
return kPremul_SkAlphaType == dst && kUnpremul_SkAlphaType == src;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Get a byte from a buffer
|
||||
* This method is unsafe, the caller is responsible for performing a check
|
||||
*
|
||||
*/
|
||||
static inline uint8_t get_byte(uint8_t* buffer, uint32_t i) {
|
||||
return buffer[i];
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Get a short from a buffer
|
||||
* This method is unsafe, the caller is responsible for performing a check
|
||||
*
|
||||
*/
|
||||
static inline uint16_t get_short(uint8_t* buffer, uint32_t i) {
|
||||
uint16_t result;
|
||||
memcpy(&result, &(buffer[i]), 2);
|
||||
#ifdef SK_CPU_BENDIAN
|
||||
return SkEndianSwap16(result);
|
||||
#else
|
||||
return result;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Get an int from a buffer
|
||||
* This method is unsafe, the caller is responsible for performing a check
|
||||
*
|
||||
*/
|
||||
static inline uint32_t get_int(uint8_t* buffer, uint32_t i) {
|
||||
uint32_t result;
|
||||
memcpy(&result, &(buffer[i]), 4);
|
||||
#ifdef SK_CPU_BENDIAN
|
||||
return SkEndianSwap32(result);
|
||||
#else
|
||||
return result;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // SkCodecPriv_DEFINED
|
@ -1,903 +0,0 @@
|
||||
/*
|
||||
* Copyright 2015 Google Inc.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license that can be
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "SkCodec_libbmp.h"
|
||||
#include "SkCodecPriv.h"
|
||||
#include "SkColorPriv.h"
|
||||
#include "SkStream.h"
|
||||
|
||||
/*
|
||||
*
|
||||
* Checks if the conversion between the input image and the requested output
|
||||
* image has been implemented
|
||||
*
|
||||
*/
|
||||
static bool conversion_possible(const SkImageInfo& dst,
|
||||
const SkImageInfo& src) {
|
||||
// All of the swizzles convert to kN32
|
||||
// TODO: Update this when more swizzles are supported
|
||||
if (kN32_SkColorType != dst.colorType()) {
|
||||
return false;
|
||||
}
|
||||
// Support the swizzle if the requested alpha type is the same as our guess
|
||||
// for the input alpha type
|
||||
if (src.alphaType() == dst.alphaType()) {
|
||||
return true;
|
||||
}
|
||||
// TODO: Support more swizzles, especially premul
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Defines the version and type of the second bitmap header
|
||||
*
|
||||
*/
|
||||
enum BitmapHeaderType {
|
||||
kInfoV1_BitmapHeaderType,
|
||||
kInfoV2_BitmapHeaderType,
|
||||
kInfoV3_BitmapHeaderType,
|
||||
kInfoV4_BitmapHeaderType,
|
||||
kInfoV5_BitmapHeaderType,
|
||||
kOS2V1_BitmapHeaderType,
|
||||
kOS2VX_BitmapHeaderType,
|
||||
kUnknown_BitmapHeaderType
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
* Possible bitmap compression types
|
||||
*
|
||||
*/
|
||||
enum BitmapCompressionMethod {
|
||||
kNone_BitmapCompressionMethod = 0,
|
||||
k8BitRLE_BitmapCompressionMethod = 1,
|
||||
k4BitRLE_BitmapCompressionMethod = 2,
|
||||
kBitMasks_BitmapCompressionMethod = 3,
|
||||
kJpeg_BitmapCompressionMethod = 4,
|
||||
kPng_BitmapCompressionMethod = 5,
|
||||
kAlphaBitMasks_BitmapCompressionMethod = 6,
|
||||
kCMYK_BitmapCompressionMethod = 11,
|
||||
kCMYK8BitRLE_BitmapCompressionMethod = 12,
|
||||
kCMYK4BitRLE_BitmapCompressionMethod = 13
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
* Checks the start of the stream to see if the image is a bitmap
|
||||
*
|
||||
*/
|
||||
bool SkBmpCodec::IsBmp(SkStream* stream) {
|
||||
// TODO: Support "IC", "PT", "CI", "CP", "BA"
|
||||
// TODO: ICO files may contain a BMP and need to use this decoder
|
||||
const char bmpSig[] = { 'B', 'M' };
|
||||
char buffer[sizeof(bmpSig)];
|
||||
return stream->read(buffer, sizeof(bmpSig)) == sizeof(bmpSig) &&
|
||||
!memcmp(buffer, bmpSig, sizeof(bmpSig));
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Assumes IsBmp was called and returned true
|
||||
* Creates a bitmap decoder
|
||||
* Reads enough of the stream to determine the image format
|
||||
*
|
||||
*/
|
||||
SkCodec* SkBmpCodec::NewFromStream(SkStream* stream) {
|
||||
// Header size constants
|
||||
static const uint32_t kBmpHeaderBytes = 14;
|
||||
static const uint32_t kBmpHeaderBytesPlusFour = kBmpHeaderBytes + 4;
|
||||
static const uint32_t kBmpOS2V1Bytes = 12;
|
||||
static const uint32_t kBmpOS2V2Bytes = 64;
|
||||
static const uint32_t kBmpInfoBaseBytes = 16;
|
||||
static const uint32_t kBmpInfoV1Bytes = 40;
|
||||
static const uint32_t kBmpInfoV2Bytes = 52;
|
||||
static const uint32_t kBmpInfoV3Bytes = 56;
|
||||
static const uint32_t kBmpInfoV4Bytes = 108;
|
||||
static const uint32_t kBmpInfoV5Bytes = 124;
|
||||
static const uint32_t kBmpMaskBytes = 12;
|
||||
|
||||
// Read the first header and the size of the second header
|
||||
SkAutoTDeleteArray<uint8_t> hBuffer(
|
||||
SkNEW_ARRAY(uint8_t, kBmpHeaderBytesPlusFour));
|
||||
if (stream->read(hBuffer.get(), kBmpHeaderBytesPlusFour) !=
|
||||
kBmpHeaderBytesPlusFour) {
|
||||
SkDebugf("Error: unable to read first bitmap header.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// The total bytes in the bmp file
|
||||
// We only need to use this value for RLE decoding, so we will only check
|
||||
// that it is valid in the RLE case.
|
||||
const uint32_t totalBytes = get_int(hBuffer.get(), 2);
|
||||
|
||||
// The offset from the start of the file where the pixel data begins
|
||||
const uint32_t offset = get_int(hBuffer.get(), 10);
|
||||
if (offset < kBmpHeaderBytes + kBmpOS2V1Bytes) {
|
||||
SkDebugf("Error: invalid starting location for pixel data\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// The size of the second (info) header in bytes
|
||||
// The size is the first field of the second header, so we have already
|
||||
// read the first four infoBytes.
|
||||
const uint32_t infoBytes = get_int(hBuffer.get(), 14);
|
||||
if (infoBytes < kBmpOS2V1Bytes) {
|
||||
SkDebugf("Error: invalid second header size.\n");
|
||||
return NULL;
|
||||
}
|
||||
const uint32_t infoBytesRemaining = infoBytes - 4;
|
||||
hBuffer.free();
|
||||
|
||||
// Read the second header
|
||||
SkAutoTDeleteArray<uint8_t> iBuffer(
|
||||
SkNEW_ARRAY(uint8_t, infoBytesRemaining));
|
||||
if (stream->read(iBuffer.get(), infoBytesRemaining) != infoBytesRemaining) {
|
||||
SkDebugf("Error: unable to read second bitmap header.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// The number of bits used per pixel in the pixel data
|
||||
uint16_t bitsPerPixel;
|
||||
|
||||
// The compression method for the pixel data
|
||||
uint32_t compression = kNone_BitmapCompressionMethod;
|
||||
|
||||
// Number of colors in the color table, defaults to 0 or max (see below)
|
||||
uint32_t numColors = 0;
|
||||
|
||||
// Bytes per color in the color table, early versions use 3, most use 4
|
||||
uint32_t bytesPerColor;
|
||||
|
||||
// The image width and height
|
||||
int width, height;
|
||||
|
||||
// Determine image information depending on second header format
|
||||
BitmapHeaderType headerType;
|
||||
if (infoBytes >= kBmpInfoBaseBytes) {
|
||||
// Check the version of the header
|
||||
switch (infoBytes) {
|
||||
case kBmpInfoV1Bytes:
|
||||
headerType = kInfoV1_BitmapHeaderType;
|
||||
break;
|
||||
case kBmpInfoV2Bytes:
|
||||
headerType = kInfoV2_BitmapHeaderType;
|
||||
break;
|
||||
case kBmpInfoV3Bytes:
|
||||
headerType = kInfoV3_BitmapHeaderType;
|
||||
break;
|
||||
case kBmpInfoV4Bytes:
|
||||
headerType = kInfoV4_BitmapHeaderType;
|
||||
break;
|
||||
case kBmpInfoV5Bytes:
|
||||
headerType = kInfoV5_BitmapHeaderType;
|
||||
break;
|
||||
case 16:
|
||||
case 20:
|
||||
case 24:
|
||||
case 28:
|
||||
case 32:
|
||||
case 36:
|
||||
case 42:
|
||||
case 46:
|
||||
case 48:
|
||||
case 60:
|
||||
case kBmpOS2V2Bytes:
|
||||
headerType = kOS2VX_BitmapHeaderType;
|
||||
break;
|
||||
default:
|
||||
// We do not signal an error here because there is the
|
||||
// possibility of new or undocumented bmp header types. Most
|
||||
// of the newer versions of bmp headers are similar to and
|
||||
// build off of the older versions, so we may still be able to
|
||||
// decode the bmp.
|
||||
SkDebugf("Warning: unknown bmp header format.\n");
|
||||
headerType = kUnknown_BitmapHeaderType;
|
||||
break;
|
||||
}
|
||||
// We check the size of the header before entering the if statement.
|
||||
// We should not reach this point unless the size is large enough for
|
||||
// these required fields.
|
||||
SkASSERT(infoBytesRemaining >= 12);
|
||||
width = get_int(iBuffer.get(), 0);
|
||||
height = get_int(iBuffer.get(), 4);
|
||||
bitsPerPixel = get_short(iBuffer.get(), 10);
|
||||
|
||||
// Some versions do not have these fields, so we check before
|
||||
// overwriting the default value.
|
||||
if (infoBytesRemaining >= 16) {
|
||||
compression = get_int(iBuffer.get(), 12);
|
||||
if (infoBytesRemaining >= 32) {
|
||||
numColors = get_int(iBuffer.get(), 28);
|
||||
}
|
||||
}
|
||||
|
||||
// All of the headers that reach this point, store color table entries
|
||||
// using 4 bytes per pixel.
|
||||
bytesPerColor = 4;
|
||||
} else if (infoBytes >= kBmpOS2V1Bytes) {
|
||||
// The OS2V1 is treated separately because it has a unique format
|
||||
headerType = kOS2V1_BitmapHeaderType;
|
||||
width = (int) get_short(iBuffer.get(), 0);
|
||||
height = (int) get_short(iBuffer.get(), 2);
|
||||
bitsPerPixel = get_short(iBuffer.get(), 6);
|
||||
bytesPerColor = 3;
|
||||
} else {
|
||||
// There are no valid bmp headers
|
||||
SkDebugf("Error: second bitmap header size is invalid.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Check for valid dimensions from header
|
||||
RowOrder rowOrder = kBottomUp_RowOrder;
|
||||
if (height < 0) {
|
||||
height = -height;
|
||||
rowOrder = kTopDown_RowOrder;
|
||||
}
|
||||
static const int kBmpMaxDim = 1 << 16;
|
||||
if (width < 0 || width >= kBmpMaxDim || height >= kBmpMaxDim) {
|
||||
// TODO: Decide if we want to support really large bmps.
|
||||
SkDebugf("Error: invalid bitmap dimensions.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Create mask struct
|
||||
SkMasks::InputMasks inputMasks;
|
||||
memset(&inputMasks, 0, 4*sizeof(uint32_t));
|
||||
|
||||
// Determine the input compression format and set bit masks if necessary
|
||||
uint32_t maskBytes = 0;
|
||||
BitmapInputFormat inputFormat = kUnknown_BitmapInputFormat;
|
||||
switch (compression) {
|
||||
case kNone_BitmapCompressionMethod:
|
||||
inputFormat = kStandard_BitmapInputFormat;
|
||||
break;
|
||||
case k8BitRLE_BitmapCompressionMethod:
|
||||
if (bitsPerPixel != 8) {
|
||||
SkDebugf("Warning: correcting invalid bitmap format.\n");
|
||||
bitsPerPixel = 8;
|
||||
}
|
||||
inputFormat = kRLE_BitmapInputFormat;
|
||||
break;
|
||||
case k4BitRLE_BitmapCompressionMethod:
|
||||
if (bitsPerPixel != 4) {
|
||||
SkDebugf("Warning: correcting invalid bitmap format.\n");
|
||||
bitsPerPixel = 4;
|
||||
}
|
||||
inputFormat = kRLE_BitmapInputFormat;
|
||||
break;
|
||||
case kAlphaBitMasks_BitmapCompressionMethod:
|
||||
case kBitMasks_BitmapCompressionMethod:
|
||||
// Load the masks
|
||||
inputFormat = kBitMask_BitmapInputFormat;
|
||||
switch (headerType) {
|
||||
case kInfoV1_BitmapHeaderType: {
|
||||
// The V1 header stores the bit masks after the header
|
||||
SkAutoTDeleteArray<uint8_t> mBuffer(
|
||||
SkNEW_ARRAY(uint8_t, kBmpMaskBytes));
|
||||
if (stream->read(mBuffer.get(), kBmpMaskBytes) !=
|
||||
kBmpMaskBytes) {
|
||||
SkDebugf("Error: unable to read bit inputMasks.\n");
|
||||
return NULL;
|
||||
}
|
||||
maskBytes = kBmpMaskBytes;
|
||||
inputMasks.red = get_int(mBuffer.get(), 0);
|
||||
inputMasks.green = get_int(mBuffer.get(), 4);
|
||||
inputMasks.blue = get_int(mBuffer.get(), 8);
|
||||
break;
|
||||
}
|
||||
case kInfoV2_BitmapHeaderType:
|
||||
case kInfoV3_BitmapHeaderType:
|
||||
case kInfoV4_BitmapHeaderType:
|
||||
case kInfoV5_BitmapHeaderType:
|
||||
// Header types are matched based on size. If the header
|
||||
// is V2+, we are guaranteed to be able to read at least
|
||||
// this size.
|
||||
SkASSERT(infoBytesRemaining >= 48);
|
||||
inputMasks.red = get_int(iBuffer.get(), 36);
|
||||
inputMasks.green = get_int(iBuffer.get(), 40);
|
||||
inputMasks.blue = get_int(iBuffer.get(), 44);
|
||||
break;
|
||||
case kOS2VX_BitmapHeaderType:
|
||||
// TODO: Decide if we intend to support this.
|
||||
// It is unsupported in the previous version and
|
||||
// in chromium. I have not come across a test case
|
||||
// that uses this format.
|
||||
SkDebugf("Error: huffman format unsupported.\n");
|
||||
return NULL;
|
||||
default:
|
||||
SkDebugf("Error: invalid bmp bit masks header.\n");
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
case kJpeg_BitmapCompressionMethod:
|
||||
if (24 == bitsPerPixel) {
|
||||
inputFormat = kRLE_BitmapInputFormat;
|
||||
break;
|
||||
}
|
||||
// Fall through
|
||||
case kPng_BitmapCompressionMethod:
|
||||
// TODO: Decide if we intend to support this.
|
||||
// It is unsupported in the previous version and
|
||||
// in chromium. I think it is used mostly for printers.
|
||||
SkDebugf("Error: compression format not supported.\n");
|
||||
return NULL;
|
||||
case kCMYK_BitmapCompressionMethod:
|
||||
case kCMYK8BitRLE_BitmapCompressionMethod:
|
||||
case kCMYK4BitRLE_BitmapCompressionMethod:
|
||||
// TODO: Same as above.
|
||||
SkDebugf("Error: CMYK not supported for bitmap decoding.\n");
|
||||
return NULL;
|
||||
default:
|
||||
SkDebugf("Error: invalid format for bitmap decoding.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Most versions of bmps should be rendered as opaque. Either they do
|
||||
// not have an alpha channel, or they expect the alpha channel to be
|
||||
// ignored. V4+ bmp files introduce an alpha mask and allow the creator
|
||||
// of the image to use the alpha channels. However, many of these images
|
||||
// leave the alpha channel blank and expect to be rendered as opaque. For
|
||||
// this reason, we set the alpha type to kUnknown for V4+ bmps and figure
|
||||
// out the alpha type during the decode.
|
||||
SkAlphaType alphaType = kOpaque_SkAlphaType;
|
||||
if (kInfoV4_BitmapHeaderType == headerType ||
|
||||
kInfoV5_BitmapHeaderType == headerType) {
|
||||
// Header types are matched based on size. If the header is
|
||||
// V4+, we are guaranteed to be able to read at least this size.
|
||||
SkASSERT(infoBytesRemaining > 52);
|
||||
inputMasks.alpha = get_int(iBuffer.get(), 48);
|
||||
if (inputMasks.alpha != 0) {
|
||||
alphaType = kUnpremul_SkAlphaType;
|
||||
}
|
||||
}
|
||||
iBuffer.free();
|
||||
|
||||
// Check for valid bits per pixel input
|
||||
switch (bitsPerPixel) {
|
||||
// In addition to more standard pixel compression formats, bmp supports
|
||||
// the use of bit masks to determine pixel components. The standard
|
||||
// format for representing 16-bit colors is 555 (XRRRRRGGGGGBBBBB),
|
||||
// which does not map well to any Skia color formats. For this reason,
|
||||
// we will always enable mask mode with 16 bits per pixel.
|
||||
case 16:
|
||||
if (kBitMask_BitmapInputFormat != inputFormat) {
|
||||
inputMasks.red = 0x7C00;
|
||||
inputMasks.green = 0x03E0;
|
||||
inputMasks.blue = 0x001F;
|
||||
inputFormat = kBitMask_BitmapInputFormat;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
case 2:
|
||||
case 4:
|
||||
case 8:
|
||||
case 24:
|
||||
case 32:
|
||||
break;
|
||||
default:
|
||||
SkDebugf("Error: invalid input value for bits per pixel.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Check that input bit masks are valid and create the masks object
|
||||
SkAutoTDelete<SkMasks>
|
||||
masks(SkMasks::CreateMasks(inputMasks, bitsPerPixel));
|
||||
if (NULL == masks) {
|
||||
SkDebugf("Error: invalid input masks.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Process the color table
|
||||
uint32_t colorBytes = 0;
|
||||
SkPMColor* colorTable = NULL;
|
||||
if (bitsPerPixel < 16) {
|
||||
// Verify the number of colors for the color table
|
||||
const uint32_t maxColors = 1 << bitsPerPixel;
|
||||
// Zero is a default for maxColors
|
||||
// Also set numColors to maxColors when input is too large
|
||||
if (numColors <= 0 || numColors > maxColors) {
|
||||
numColors = maxColors;
|
||||
}
|
||||
colorTable = SkNEW_ARRAY(SkPMColor, maxColors);
|
||||
|
||||
// Construct the color table
|
||||
colorBytes = numColors * bytesPerColor;
|
||||
SkAutoTDeleteArray<uint8_t> cBuffer(SkNEW_ARRAY(uint8_t, colorBytes));
|
||||
if (stream->read(cBuffer.get(), colorBytes) != colorBytes) {
|
||||
SkDebugf("Error: unable to read color table.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Fill in the color table (colors are stored unpremultiplied)
|
||||
uint32_t i = 0;
|
||||
for (; i < numColors; i++) {
|
||||
uint8_t blue = get_byte(cBuffer.get(), i*bytesPerColor);
|
||||
uint8_t green = get_byte(cBuffer.get(), i*bytesPerColor + 1);
|
||||
uint8_t red = get_byte(cBuffer.get(), i*bytesPerColor + 2);
|
||||
uint8_t alpha = 0xFF;
|
||||
if (kOpaque_SkAlphaType != alphaType) {
|
||||
alpha = (inputMasks.alpha >> 24) &
|
||||
get_byte(cBuffer.get(), i*bytesPerColor + 3);
|
||||
}
|
||||
// Store the unpremultiplied color
|
||||
colorTable[i] = SkPackARGB32NoCheck(alpha, red, green, blue);
|
||||
}
|
||||
|
||||
// To avoid segmentation faults on bad pixel data, fill the end of the
|
||||
// color table with black. This is the same the behavior as the
|
||||
// chromium decoder.
|
||||
for (; i < maxColors; i++) {
|
||||
colorTable[i] = SkPackARGB32NoCheck(0xFF, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure that the stream now points to the start of the pixel array
|
||||
uint32_t bytesRead = kBmpHeaderBytes + infoBytes + maskBytes + colorBytes;
|
||||
|
||||
// Check that we have not read past the pixel array offset
|
||||
if(bytesRead > offset) {
|
||||
// This may occur on OS 2.1 and other old versions where the color
|
||||
// table defaults to max size, and the bmp tries to use a smaller color
|
||||
// table. This is invalid, and our decision is to indicate an error,
|
||||
// rather than try to guess the intended size of the color table and
|
||||
// rewind the stream to display the image.
|
||||
SkDebugf("Error: pixel data offset less than header size.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Skip to the start of the pixel array
|
||||
if (stream->skip(offset - bytesRead) != offset - bytesRead) {
|
||||
SkDebugf("Error: unable to skip to image data.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Remaining bytes is only used for RLE
|
||||
const int remainingBytes = totalBytes - offset;
|
||||
if (remainingBytes <= 0 && kRLE_BitmapInputFormat == inputFormat) {
|
||||
SkDebugf("Error: RLE requires valid input size.\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Return the codec
|
||||
// We will use ImageInfo to store width, height, and alpha type. We will
|
||||
// choose kN32_SkColorType as the input color type because that is the
|
||||
// expected choice for a destination color type. In reality, the input
|
||||
// color type has many possible formats.
|
||||
const SkImageInfo& imageInfo = SkImageInfo::Make(width, height,
|
||||
kN32_SkColorType, alphaType);
|
||||
return SkNEW_ARGS(SkBmpCodec, (imageInfo, stream, bitsPerPixel,
|
||||
inputFormat, masks.detach(), colorTable,
|
||||
rowOrder, remainingBytes));
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Creates an instance of the decoder
|
||||
* Called only by NewFromStream
|
||||
*
|
||||
*/
|
||||
SkBmpCodec::SkBmpCodec(const SkImageInfo& info, SkStream* stream,
|
||||
uint16_t bitsPerPixel, BitmapInputFormat inputFormat,
|
||||
SkMasks* masks, SkPMColor* colorTable,
|
||||
RowOrder rowOrder,
|
||||
const uint32_t remainingBytes)
|
||||
: INHERITED(info, stream)
|
||||
, fBitsPerPixel(bitsPerPixel)
|
||||
, fInputFormat(inputFormat)
|
||||
, fMasks(masks)
|
||||
, fColorTable(colorTable)
|
||||
, fRowOrder(rowOrder)
|
||||
, fRemainingBytes(remainingBytes)
|
||||
{}
|
||||
|
||||
/*
|
||||
*
|
||||
* Initiates the bitmap decode
|
||||
*
|
||||
*/
|
||||
SkCodec::Result SkBmpCodec::onGetPixels(const SkImageInfo& dstInfo,
|
||||
void* dst, size_t dstRowBytes,
|
||||
SkPMColor*, int*) {
|
||||
if (!this->rewindIfNeeded()) {
|
||||
return kCouldNotRewind;
|
||||
}
|
||||
if (dstInfo.dimensions() != this->getOriginalInfo().dimensions()) {
|
||||
SkDebugf("Error: scaling not supported.\n");
|
||||
return kInvalidScale;
|
||||
}
|
||||
if (!conversion_possible(dstInfo, this->getOriginalInfo())) {
|
||||
SkDebugf("Error: cannot convert input type to output type.\n");
|
||||
return kInvalidConversion;
|
||||
}
|
||||
|
||||
switch (fInputFormat) {
|
||||
case kBitMask_BitmapInputFormat:
|
||||
return decodeMask(dstInfo, dst, dstRowBytes);
|
||||
case kRLE_BitmapInputFormat:
|
||||
return decodeRLE(dstInfo, dst, dstRowBytes);
|
||||
case kStandard_BitmapInputFormat:
|
||||
return decode(dstInfo, dst, dstRowBytes);
|
||||
default:
|
||||
SkASSERT(false);
|
||||
return kInvalidInput;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Performs the bitmap decoding for bit masks input format
|
||||
*
|
||||
*/
|
||||
SkCodec::Result SkBmpCodec::decodeMask(const SkImageInfo& dstInfo,
|
||||
void* dst, size_t dstRowBytes) {
|
||||
// Set constant values
|
||||
const int width = dstInfo.width();
|
||||
const int height = dstInfo.height();
|
||||
const size_t rowBytes = SkAlign4(compute_row_bytes(width, fBitsPerPixel));
|
||||
|
||||
// Allocate space for a row buffer and a source for the swizzler
|
||||
SkAutoTDeleteArray<uint8_t> srcBuffer(SkNEW_ARRAY(uint8_t, rowBytes));
|
||||
|
||||
// Get the destination start row and delta
|
||||
SkPMColor* dstRow;
|
||||
int delta;
|
||||
if (kTopDown_RowOrder == fRowOrder) {
|
||||
dstRow = (SkPMColor*) dst;
|
||||
delta = (int) dstRowBytes;
|
||||
} else {
|
||||
dstRow = (SkPMColor*) SkTAddOffset<void>(dst, (height-1) * dstRowBytes);
|
||||
delta = -((int) dstRowBytes);
|
||||
}
|
||||
|
||||
// Create the swizzler
|
||||
SkMaskSwizzler* swizzler = SkMaskSwizzler::CreateMaskSwizzler(
|
||||
dstInfo, fMasks, fBitsPerPixel);
|
||||
|
||||
// Iterate over rows of the image
|
||||
bool transparent = true;
|
||||
for (int y = 0; y < height; y++) {
|
||||
// Read a row of the input
|
||||
if (stream()->read(srcBuffer.get(), rowBytes) != rowBytes) {
|
||||
SkDebugf("Warning: incomplete input stream.\n");
|
||||
return kIncompleteInput;
|
||||
}
|
||||
|
||||
// Decode the row in destination format
|
||||
SkSwizzler::ResultAlpha r = swizzler->next(dstRow, srcBuffer.get());
|
||||
transparent &= SkSwizzler::IsTransparent(r);
|
||||
|
||||
// Move to the next row
|
||||
dstRow = SkTAddOffset<SkPMColor>(dstRow, delta);
|
||||
}
|
||||
|
||||
// Some fully transparent bmp images are intended to be opaque. Here, we
|
||||
// correct for this possibility.
|
||||
dstRow = (SkPMColor*) dst;
|
||||
if (transparent) {
|
||||
for (int y = 0; y < height; y++) {
|
||||
for (int x = 0; x < width; x++) {
|
||||
dstRow[x] |= 0xFF000000;
|
||||
}
|
||||
dstRow = SkTAddOffset<SkPMColor>(dstRow, dstRowBytes);
|
||||
}
|
||||
}
|
||||
|
||||
// Finished decoding the entire image
|
||||
return kSuccess;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Set an RLE pixel using the color table
|
||||
*
|
||||
*/
|
||||
void SkBmpCodec::setRLEPixel(SkPMColor* dst, size_t dstRowBytes, int height,
|
||||
uint32_t x, uint32_t y, uint8_t index) {
|
||||
if (kBottomUp_RowOrder == fRowOrder) {
|
||||
y = height - y - 1;
|
||||
}
|
||||
SkPMColor* dstRow = SkTAddOffset<SkPMColor>(dst, y * dstRowBytes);
|
||||
dstRow[x] = fColorTable.get()[index];
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Performs the bitmap decoding for RLE input format
|
||||
* RLE decoding is performed all at once, rather than a one row at a time
|
||||
*
|
||||
*/
|
||||
SkCodec::Result SkBmpCodec::decodeRLE(const SkImageInfo& dstInfo,
|
||||
void* dst, size_t dstRowBytes) {
|
||||
// Set RLE flags
|
||||
static const uint8_t RLE_ESCAPE = 0;
|
||||
static const uint8_t RLE_EOL = 0;
|
||||
static const uint8_t RLE_EOF = 1;
|
||||
static const uint8_t RLE_DELTA = 2;
|
||||
|
||||
// Set constant values
|
||||
const int width = dstInfo.width();
|
||||
const int height = dstInfo.height();
|
||||
|
||||
// Input buffer parameters
|
||||
uint32_t currByte = 0;
|
||||
SkAutoTDeleteArray<uint8_t> buffer(SkNEW_ARRAY(uint8_t, fRemainingBytes));
|
||||
size_t totalBytes = stream()->read(buffer.get(), fRemainingBytes);
|
||||
if ((uint32_t) totalBytes < fRemainingBytes) {
|
||||
SkDebugf("Warning: incomplete RLE file.\n");
|
||||
} else if (totalBytes <= 0) {
|
||||
SkDebugf("Error: could not read RLE image data.\n");
|
||||
return kInvalidInput;
|
||||
}
|
||||
|
||||
// Destination parameters
|
||||
int x = 0;
|
||||
int y = 0;
|
||||
// If the code skips pixels, remaining pixels are transparent or black
|
||||
// TODO: Skip this if memory was already zeroed.
|
||||
memset(dst, 0, dstRowBytes * height);
|
||||
SkPMColor* dstPtr = (SkPMColor*) dst;
|
||||
|
||||
while (true) {
|
||||
// Every entry takes at least two bytes
|
||||
if ((int) totalBytes - currByte < 2) {
|
||||
SkDebugf("Warning: incomplete RLE input.\n");
|
||||
return kIncompleteInput;
|
||||
}
|
||||
|
||||
// Read the next two bytes. These bytes have different meanings
|
||||
// depending on their values. In the first interpretation, the first
|
||||
// byte is an escape flag and the second byte indicates what special
|
||||
// task to perform.
|
||||
const uint8_t flag = buffer.get()[currByte++];
|
||||
const uint8_t task = buffer.get()[currByte++];
|
||||
|
||||
// If we have reached a row that is beyond the image size, and the RLE
|
||||
// code does not indicate end of file, abort and signal a warning.
|
||||
if (y >= height && (flag != RLE_ESCAPE || (task != RLE_EOF))) {
|
||||
SkDebugf("Warning: invalid RLE input.\n");
|
||||
return kIncompleteInput;
|
||||
}
|
||||
|
||||
// Perform decoding
|
||||
if (RLE_ESCAPE == flag) {
|
||||
switch (task) {
|
||||
case RLE_EOL:
|
||||
x = 0;
|
||||
y++;
|
||||
break;
|
||||
case RLE_EOF:
|
||||
return kSuccess;
|
||||
case RLE_DELTA: {
|
||||
// Two bytes are needed to specify delta
|
||||
if ((int) totalBytes - currByte < 2) {
|
||||
SkDebugf("Warning: incomplete RLE input\n");
|
||||
return kIncompleteInput;
|
||||
}
|
||||
// Modify x and y
|
||||
const uint8_t dx = buffer.get()[currByte++];
|
||||
const uint8_t dy = buffer.get()[currByte++];
|
||||
x += dx;
|
||||
y += dy;
|
||||
if (x > width || y > height) {
|
||||
SkDebugf("Warning: invalid RLE input.\n");
|
||||
return kIncompleteInput;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
// If task does not match any of the above signals, it
|
||||
// indicates that we have a sequence of non-RLE pixels.
|
||||
// Furthermore, the value of task is equal to the number
|
||||
// of pixels to interpret.
|
||||
uint8_t numPixels = task;
|
||||
const size_t rowBytes = compute_row_bytes(numPixels,
|
||||
fBitsPerPixel);
|
||||
// Abort if setting numPixels moves us off the edge of the
|
||||
// image. Also abort if there are not enough bytes
|
||||
// remaining in the stream to set numPixels.
|
||||
if (x + numPixels > width ||
|
||||
(int) totalBytes - currByte < SkAlign2(rowBytes)) {
|
||||
SkDebugf("Warning: invalid RLE input.\n");
|
||||
return kIncompleteInput;
|
||||
}
|
||||
// Set numPixels number of pixels
|
||||
SkPMColor* dstRow = SkTAddOffset<SkPMColor>(
|
||||
dstPtr, y * dstRowBytes);
|
||||
while (numPixels > 0) {
|
||||
switch(fBitsPerPixel) {
|
||||
case 4: {
|
||||
SkASSERT(currByte < totalBytes);
|
||||
uint8_t val = buffer.get()[currByte++];
|
||||
setRLEPixel(dstPtr, dstRowBytes, height, x++, y,
|
||||
val >> 4);
|
||||
numPixels--;
|
||||
if (numPixels != 0) {
|
||||
setRLEPixel(dstPtr, dstRowBytes, height,
|
||||
x++, y, val & 0xF);
|
||||
numPixels--;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 8:
|
||||
SkASSERT(currByte < totalBytes);
|
||||
setRLEPixel(dstPtr, dstRowBytes, height, x++, y,
|
||||
buffer.get()[currByte++]);
|
||||
numPixels--;
|
||||
break;
|
||||
case 24: {
|
||||
SkASSERT(currByte + 2 < totalBytes);
|
||||
uint8_t blue = buffer.get()[currByte++];
|
||||
uint8_t green = buffer.get()[currByte++];
|
||||
uint8_t red = buffer.get()[currByte++];
|
||||
SkPMColor color = SkPackARGB32NoCheck(
|
||||
0xFF, red, green, blue);
|
||||
dstRow[x++] = color;
|
||||
numPixels--;
|
||||
}
|
||||
default:
|
||||
SkASSERT(false);
|
||||
return kInvalidInput;
|
||||
}
|
||||
}
|
||||
// Skip a byte if necessary to maintain alignment
|
||||
if (!SkIsAlign2(rowBytes)) {
|
||||
currByte++;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// If the first byte read is not a flag, it indicates the number of
|
||||
// pixels to set in RLE mode.
|
||||
const uint8_t numPixels = flag;
|
||||
const int endX = SkTMin<int>(x + numPixels, width);
|
||||
|
||||
if (24 == fBitsPerPixel) {
|
||||
// In RLE24, the second byte read is part of the pixel color.
|
||||
// There are two more required bytes to finish encoding the
|
||||
// color.
|
||||
if ((int) totalBytes - currByte < 2) {
|
||||
SkDebugf("Warning: incomplete RLE input\n");
|
||||
return kIncompleteInput;
|
||||
}
|
||||
|
||||
// Fill the pixels up to endX with the specified color
|
||||
uint8_t blue = task;
|
||||
uint8_t green = buffer.get()[currByte++];
|
||||
uint8_t red = buffer.get()[currByte++];
|
||||
SkPMColor color = SkPackARGB32NoCheck(0xFF, red, green, blue);
|
||||
SkPMColor* dstRow =
|
||||
SkTAddOffset<SkPMColor>(dstPtr, y * dstRowBytes);
|
||||
while (x < endX) {
|
||||
dstRow[x++] = color;
|
||||
}
|
||||
} else {
|
||||
// In RLE8 or RLE4, the second byte read gives the index in the
|
||||
// color table to look up the pixel color.
|
||||
// RLE8 has one color index that gets repeated
|
||||
// RLE4 has two color indexes in the upper and lower 4 bits of
|
||||
// the bytes, which are alternated
|
||||
uint8_t indices[2] = { task, task };
|
||||
if (4 == fBitsPerPixel) {
|
||||
indices[0] >>= 4;
|
||||
indices[1] &= 0xf;
|
||||
}
|
||||
|
||||
// Set the indicated number of pixels
|
||||
for (int which = 0; x < endX; x++) {
|
||||
setRLEPixel(dstPtr, dstRowBytes, height, x, y,
|
||||
indices[which]);
|
||||
which = !which;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Performs the bitmap decoding for standard input format
|
||||
*
|
||||
*/
|
||||
SkCodec::Result SkBmpCodec::decode(const SkImageInfo& dstInfo,
|
||||
void* dst, size_t dstRowBytes) {
|
||||
// Set constant values
|
||||
const int width = dstInfo.width();
|
||||
const int height = dstInfo.height();
|
||||
const size_t rowBytes = SkAlign4(compute_row_bytes(width, fBitsPerPixel));
|
||||
const uint32_t alphaMask = fMasks->getAlphaMask();
|
||||
|
||||
// Get swizzler configuration
|
||||
SkSwizzler::SrcConfig config;
|
||||
switch (fBitsPerPixel) {
|
||||
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 (0 == alphaMask) {
|
||||
config = SkSwizzler::kBGRX;
|
||||
} else {
|
||||
config = SkSwizzler::kBGRA;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
SkASSERT(false);
|
||||
return kInvalidInput;
|
||||
}
|
||||
|
||||
// Create swizzler
|
||||
SkSwizzler* swizzler = SkSwizzler::CreateSwizzler(config, fColorTable.get(),
|
||||
dstInfo, dst, dstRowBytes, false);
|
||||
|
||||
// Allocate space for a row buffer and a source for the swizzler
|
||||
SkAutoTDeleteArray<uint8_t> srcBuffer(SkNEW_ARRAY(uint8_t, rowBytes));
|
||||
|
||||
// Iterate over rows of the image
|
||||
// FIXME: bool transparent = true;
|
||||
for (int y = 0; y < height; y++) {
|
||||
// Read a row of the input
|
||||
if (stream()->read(srcBuffer.get(), rowBytes) != rowBytes) {
|
||||
SkDebugf("Warning: incomplete input stream.\n");
|
||||
return kIncompleteInput;
|
||||
}
|
||||
|
||||
// Decode the row in destination format
|
||||
uint32_t row;
|
||||
if (kTopDown_RowOrder == fRowOrder) {
|
||||
row = y;
|
||||
} else {
|
||||
row = height - 1 - y;
|
||||
}
|
||||
|
||||
swizzler->next(srcBuffer.get(), row);
|
||||
// FIXME: SkSwizzler::ResultAlpha r =
|
||||
// swizzler->next(srcBuffer.get(), row);
|
||||
// FIXME: transparent &= SkSwizzler::IsTransparent(r);
|
||||
}
|
||||
|
||||
// FIXME: This code exists to match the behavior in the chromium decoder
|
||||
// and to follow the bmp specification as it relates to alpha masks. It is
|
||||
// commented out because we have yet to discover a test image that provides
|
||||
// an alpha mask and uses this decode mode.
|
||||
|
||||
// Now we adjust the output image with some additional behavior that
|
||||
// SkSwizzler does not support. Firstly, all bmp images that contain
|
||||
// alpha are masked by the alpha mask. Secondly, many fully transparent
|
||||
// bmp images are intended to be opaque. Here, we make those corrections.
|
||||
// Modifying alpha is safe because colors are stored unpremultiplied.
|
||||
/*
|
||||
SkPMColor* dstRow = (SkPMColor*) dst;
|
||||
if (SkSwizzler::kBGRA == config) {
|
||||
for (int y = 0; y < height; y++) {
|
||||
for (int x = 0; x < width; x++) {
|
||||
if (transparent) {
|
||||
dstRow[x] |= 0xFF000000;
|
||||
} else {
|
||||
dstRow[x] &= alphaMask;
|
||||
}
|
||||
dstRow = SkTAddOffset<SkPMColor>(dstRow, dstRowBytes);
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
// Finished decoding the entire image
|
||||
return kSuccess;
|
||||
}
|
@ -1,142 +0,0 @@
|
||||
/*
|
||||
* Copyright 2015 Google Inc.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license that can be
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "SkCodec.h"
|
||||
#include "SkImageInfo.h"
|
||||
#include "SkMaskSwizzler.h"
|
||||
#include "SkStream.h"
|
||||
#include "SkSwizzler.h"
|
||||
#include "SkTypes.h"
|
||||
|
||||
// TODO: rename SkCodec_libbmp files to SkBmpCodec
|
||||
// TODO: define a wrapper for SkDebugf that doesn't always print
|
||||
/*
|
||||
*
|
||||
* This class implements the decoding for bmp images
|
||||
*
|
||||
*/
|
||||
class SkBmpCodec : public SkCodec {
|
||||
public:
|
||||
|
||||
/*
|
||||
*
|
||||
* Describes if rows of the input start at the top or bottom of the image
|
||||
*
|
||||
*/
|
||||
enum RowOrder {
|
||||
kTopDown_RowOrder,
|
||||
kBottomUp_RowOrder
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
* Checks the start of the stream to see if the image is a bitmap
|
||||
*
|
||||
*/
|
||||
static bool IsBmp(SkStream*);
|
||||
|
||||
/*
|
||||
*
|
||||
* Assumes IsBmp was called and returned true
|
||||
* Creates a bitmap decoder
|
||||
* Reads enough of the stream to determine the image format
|
||||
*
|
||||
*/
|
||||
static SkCodec* NewFromStream(SkStream*);
|
||||
|
||||
protected:
|
||||
|
||||
/*
|
||||
*
|
||||
* Initiates the bitmap decode
|
||||
*
|
||||
*/
|
||||
virtual Result onGetPixels(const SkImageInfo& dstInfo, void* dst,
|
||||
size_t dstRowBytes, SkPMColor*,
|
||||
int*) SK_OVERRIDE;
|
||||
|
||||
private:
|
||||
|
||||
/*
|
||||
*
|
||||
* Used to define the input format of the bitmap
|
||||
*
|
||||
*/
|
||||
enum BitmapInputFormat {
|
||||
kStandard_BitmapInputFormat,
|
||||
kRLE_BitmapInputFormat,
|
||||
kBitMask_BitmapInputFormat,
|
||||
kUnknown_BitmapInputFormat
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
* Performs the bitmap decoding for bit masks input format
|
||||
*
|
||||
*/
|
||||
Result decodeMask(const SkImageInfo& dstInfo, void* dst,
|
||||
size_t dstRowBytes);
|
||||
|
||||
/*
|
||||
*
|
||||
* Set an RLE pixel using the color table
|
||||
*
|
||||
*/
|
||||
void setRLEPixel(SkPMColor* dst, size_t dstRowBytes, int height,
|
||||
uint32_t x, uint32_t y, uint8_t index);
|
||||
|
||||
/*
|
||||
*
|
||||
* Performs the bitmap decoding for RLE input format
|
||||
*
|
||||
*/
|
||||
Result decodeRLE(const SkImageInfo& dstInfo, void* dst,
|
||||
size_t dstRowBytes);
|
||||
|
||||
/*
|
||||
*
|
||||
* Performs the bitmap decoding for standard input format
|
||||
*
|
||||
*/
|
||||
Result decode(const SkImageInfo& dstInfo, void* dst, size_t dstRowBytes);
|
||||
|
||||
/*
|
||||
*
|
||||
* Creates an instance of the decoder
|
||||
* Called only by NewFromStream
|
||||
*
|
||||
* @param srcInfo contains the source width and height
|
||||
* @param stream the stream of image data
|
||||
* @param bitsPerPixel the number of bits used to store each pixel
|
||||
* @param format the format of the bmp file
|
||||
* @param masks optional color masks for certain bmp formats, passes
|
||||
ownership to SkBmpCodec
|
||||
* @param colorTable array representing the color table for index-based bmp
|
||||
* formats, colors are unpremultiplied, passes ownership
|
||||
* to SkBmpCodec
|
||||
* @param rowOrder indicates whether rows are ordered top-down or bottom-up
|
||||
* @param remainingBytes used only for RLE decodes, as we must decode all
|
||||
* of the data at once rather than row by row
|
||||
* it indicates the amount of data left in the stream
|
||||
* after decoding the headers
|
||||
*
|
||||
*/
|
||||
SkBmpCodec(const SkImageInfo& srcInfo, SkStream* stream,
|
||||
uint16_t bitsPerPixel, BitmapInputFormat format,
|
||||
SkMasks* masks, SkPMColor* colorTable,
|
||||
RowOrder rowOrder, uint32_t remainingBytes);
|
||||
|
||||
// Fields
|
||||
const uint16_t fBitsPerPixel;
|
||||
const BitmapInputFormat fInputFormat;
|
||||
SkAutoTDelete<SkMasks> fMasks; // owned
|
||||
const SkAutoTDeleteArray<SkPMColor> fColorTable; // owned, unpremul
|
||||
const RowOrder fRowOrder;
|
||||
const uint32_t fRemainingBytes;
|
||||
|
||||
typedef SkCodec INHERITED;
|
||||
};
|
@ -6,7 +6,6 @@
|
||||
*/
|
||||
|
||||
#include "SkCodec_libpng.h"
|
||||
#include "SkCodecPriv.h"
|
||||
#include "SkColorPriv.h"
|
||||
#include "SkColorTable.h"
|
||||
#include "SkBitmap.h"
|
||||
@ -347,6 +346,10 @@ SkPngCodec::~SkPngCodec() {
|
||||
// Getting the pixels
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static bool premul_and_unpremul(SkAlphaType A, SkAlphaType B) {
|
||||
return kPremul_SkAlphaType == A && kUnpremul_SkAlphaType == B;
|
||||
}
|
||||
|
||||
static bool conversion_possible(const SkImageInfo& A, const SkImageInfo& B) {
|
||||
// TODO: Support other conversions
|
||||
if (A.colorType() != B.colorType()) {
|
||||
@ -463,7 +466,7 @@ SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& requestedInfo, void*
|
||||
// Now swizzle it.
|
||||
uint8_t* row = base;
|
||||
for (int y = 0; y < height; y++) {
|
||||
reallyHasAlpha |= !SkSwizzler::IsOpaque(swizzler->next(row));
|
||||
reallyHasAlpha |= swizzler->next(row);
|
||||
row += rowBytes;
|
||||
}
|
||||
} else {
|
||||
@ -471,7 +474,7 @@ SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& requestedInfo, void*
|
||||
uint8_t* srcRow = static_cast<uint8_t*>(storage.get());
|
||||
for (int y = 0; y < requestedInfo.height(); y++) {
|
||||
png_read_rows(fPng_ptr, &srcRow, png_bytepp_NULL, 1);
|
||||
reallyHasAlpha |= !SkSwizzler::IsOpaque(swizzler->next(srcRow));
|
||||
reallyHasAlpha |= swizzler->next(srcRow);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1,205 +0,0 @@
|
||||
/*
|
||||
* Copyright 2015 Google Inc.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license that can be
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "SkCodecPriv.h"
|
||||
#include "SkColorPriv.h"
|
||||
#include "SkMaskSwizzler.h"
|
||||
|
||||
/*
|
||||
*
|
||||
* Row procedure for masked color components with 16 bits per pixel
|
||||
*
|
||||
*/
|
||||
static SkSwizzler::ResultAlpha swizzle_mask16_to_n32(
|
||||
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
|
||||
|
||||
// Use the masks to decode to the destination
|
||||
uint16_t* srcPtr = (uint16_t*) srcRow;
|
||||
SkPMColor* dstPtr = (SkPMColor*) dstRow;
|
||||
for (int i = 0; i < width; i++) {
|
||||
uint16_t p = srcPtr[i];
|
||||
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);
|
||||
}
|
||||
return SkSwizzler::kOpaque_ResultAlpha;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Row procedure for masked color components with 16 bits per pixel with alpha
|
||||
*
|
||||
*/
|
||||
static SkSwizzler::ResultAlpha swizzle_mask16_alpha_to_n32(
|
||||
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
|
||||
|
||||
// Use the masks to decode to the destination
|
||||
uint16_t* srcPtr = (uint16_t*) srcRow;
|
||||
SkPMColor* dstPtr = (SkPMColor*) dstRow;
|
||||
INIT_RESULT_ALPHA;
|
||||
for (int i = 0; i < width; i++) {
|
||||
uint16_t p = srcPtr[i];
|
||||
uint8_t red = masks->getRed(p);
|
||||
uint8_t green = masks->getGreen(p);
|
||||
uint8_t blue = masks->getBlue(p);
|
||||
uint8_t alpha = masks->getAlpha(p);
|
||||
UPDATE_RESULT_ALPHA(alpha);
|
||||
dstPtr[i] = SkPackARGB32NoCheck(alpha, red, green, blue);
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Row procedure for masked color components with 24 bits per pixel
|
||||
*
|
||||
*/
|
||||
static SkSwizzler::ResultAlpha swizzle_mask24_to_n32(
|
||||
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
|
||||
|
||||
// Use the masks to decode to the destination
|
||||
SkPMColor* dstPtr = (SkPMColor*) dstRow;
|
||||
for (int i = 0; i < 3*width; i += 3) {
|
||||
uint32_t p = srcRow[i] | (srcRow[i + 1] << 8) | srcRow[i + 2] << 16;
|
||||
uint8_t red = masks->getRed(p);
|
||||
uint8_t green = masks->getGreen(p);
|
||||
uint8_t blue = masks->getBlue(p);
|
||||
dstPtr[i/3] = SkPackARGB32NoCheck(0xFF, red, green, blue);
|
||||
}
|
||||
return SkSwizzler::kOpaque_ResultAlpha;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Row procedure for masked color components with 24 bits per pixel with alpha
|
||||
*
|
||||
*/
|
||||
static SkSwizzler::ResultAlpha swizzle_mask24_alpha_to_n32(
|
||||
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
|
||||
|
||||
// Use the masks to decode to the destination
|
||||
SkPMColor* dstPtr = (SkPMColor*) dstRow;
|
||||
INIT_RESULT_ALPHA;
|
||||
for (int i = 0; i < 3*width; i += 3) {
|
||||
uint32_t p = srcRow[i] | (srcRow[i + 1] << 8) | srcRow[i + 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);
|
||||
UPDATE_RESULT_ALPHA(alpha);
|
||||
dstPtr[i/3] = SkPackARGB32NoCheck(alpha, red, green, blue);
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Row procedure for masked color components with 32 bits per pixel
|
||||
*
|
||||
*/
|
||||
static SkSwizzler::ResultAlpha swizzle_mask32_to_n32(
|
||||
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
|
||||
|
||||
// Use the masks to decode to the destination
|
||||
uint32_t* srcPtr = (uint32_t*) srcRow;
|
||||
SkPMColor* dstPtr = (SkPMColor*) dstRow;
|
||||
for (int i = 0; i < width; i++) {
|
||||
uint32_t p = srcPtr[i];
|
||||
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);
|
||||
}
|
||||
return SkSwizzler::kOpaque_ResultAlpha;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Row procedure for masked color components with 32 bits per pixel
|
||||
*
|
||||
*/
|
||||
static SkSwizzler::ResultAlpha swizzle_mask32_alpha_to_n32(
|
||||
void* dstRow, const uint8_t* srcRow, int width, SkMasks* masks) {
|
||||
|
||||
// Use the masks to decode to the destination
|
||||
uint32_t* srcPtr = (uint32_t*) srcRow;
|
||||
SkPMColor* dstPtr = (SkPMColor*) dstRow;
|
||||
INIT_RESULT_ALPHA;
|
||||
for (int i = 0; i < width; i++) {
|
||||
uint32_t p = srcPtr[i];
|
||||
uint8_t red = masks->getRed(p);
|
||||
uint8_t green = masks->getGreen(p);
|
||||
uint8_t blue = masks->getBlue(p);
|
||||
uint8_t alpha = masks->getAlpha(p);
|
||||
UPDATE_RESULT_ALPHA(alpha);
|
||||
dstPtr[i] = SkPackARGB32NoCheck(alpha, red, green, blue);
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Create a new mask swizzler
|
||||
*
|
||||
*/
|
||||
SkMaskSwizzler* SkMaskSwizzler::CreateMaskSwizzler(
|
||||
const SkImageInfo& imageInfo, SkMasks* masks, uint32_t bitsPerPixel) {
|
||||
|
||||
// Choose the appropriate row procedure
|
||||
RowProc proc = NULL;
|
||||
uint32_t alphaMask = masks->getAlphaMask();
|
||||
switch (bitsPerPixel) {
|
||||
case 16:
|
||||
if (0 == alphaMask) {
|
||||
proc = &swizzle_mask16_to_n32;
|
||||
} else {
|
||||
proc = &swizzle_mask16_alpha_to_n32;
|
||||
}
|
||||
break;
|
||||
case 24:
|
||||
if (0 == alphaMask) {
|
||||
proc = &swizzle_mask24_to_n32;
|
||||
} else {
|
||||
proc = &swizzle_mask24_alpha_to_n32;
|
||||
}
|
||||
break;
|
||||
case 32:
|
||||
if (0 == alphaMask) {
|
||||
proc = &swizzle_mask32_to_n32;
|
||||
} else {
|
||||
proc = &swizzle_mask32_alpha_to_n32;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
SkASSERT(false);
|
||||
return NULL;
|
||||
}
|
||||
return SkNEW_ARGS(SkMaskSwizzler, (imageInfo, masks, proc));
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Constructor for mask swizzler
|
||||
*
|
||||
*/
|
||||
SkMaskSwizzler::SkMaskSwizzler(const SkImageInfo& imageInfo,
|
||||
SkMasks* masks, RowProc proc)
|
||||
: fImageInfo(imageInfo)
|
||||
, fMasks(masks)
|
||||
, fRowProc(proc)
|
||||
{}
|
||||
|
||||
/*
|
||||
*
|
||||
* Swizzle the next row
|
||||
*
|
||||
*/
|
||||
SkSwizzler::ResultAlpha SkMaskSwizzler::next(void* dst,
|
||||
const uint8_t* src) {
|
||||
return fRowProc(dst, src, fImageInfo.width(), fMasks);
|
||||
}
|
@ -1,60 +0,0 @@
|
||||
/*
|
||||
* Copyright 2015 Google Inc.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license that can be
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "SkMasks.h"
|
||||
#include "SkSwizzler.h"
|
||||
#include "SkTypes.h"
|
||||
|
||||
/*
|
||||
*
|
||||
* Used to swizzle images whose pixel components are extracted by bit masks
|
||||
* Currently only used by bmp
|
||||
*
|
||||
*/
|
||||
class SkMaskSwizzler {
|
||||
public:
|
||||
|
||||
/*
|
||||
*
|
||||
* Create a new swizzler
|
||||
* @param masks Unowned pointer to helper class
|
||||
*
|
||||
*/
|
||||
static SkMaskSwizzler* CreateMaskSwizzler(const SkImageInfo& imageInfo,
|
||||
SkMasks* masks,
|
||||
uint32_t bitsPerPixel);
|
||||
|
||||
/*
|
||||
*
|
||||
* Swizzle the next row
|
||||
*
|
||||
*/
|
||||
SkSwizzler::ResultAlpha next(void* dst, const uint8_t* src);
|
||||
|
||||
private:
|
||||
|
||||
/*
|
||||
*
|
||||
* Row procedure used for swizzle
|
||||
*
|
||||
*/
|
||||
typedef SkSwizzler::ResultAlpha (*RowProc)(
|
||||
void* dstRow, const uint8_t* srcRow, int width,
|
||||
SkMasks* masks);
|
||||
|
||||
/*
|
||||
*
|
||||
* Constructor for mask swizzler
|
||||
*
|
||||
*/
|
||||
SkMaskSwizzler(const SkImageInfo& info, SkMasks* masks, RowProc proc);
|
||||
|
||||
// Fields
|
||||
const SkImageInfo& fImageInfo;
|
||||
SkMasks* fMasks; // unowned
|
||||
const RowProc fRowProc;
|
||||
};
|
@ -1,160 +0,0 @@
|
||||
/*
|
||||
* Copyright 2015 Google Inc.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license that can be
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "SkMasks.h"
|
||||
#include "SkTypes.h"
|
||||
|
||||
/*
|
||||
*
|
||||
* Used to convert 1-7 bit color components into 8-bit color components
|
||||
*
|
||||
*/
|
||||
const static uint8_t n_bit_to_8_bit_lookup_table[] = {
|
||||
// 1 bit
|
||||
0, 255,
|
||||
// 2 bits
|
||||
0, 85, 170, 255,
|
||||
// 3 bits
|
||||
0, 36, 73, 109, 146, 182, 219, 255,
|
||||
// 4 bits
|
||||
0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255,
|
||||
// 5 bits
|
||||
0, 8, 16, 25, 33, 41, 49, 58, 66, 74, 82, 90, 99, 107, 115, 123, 132, 140,
|
||||
148, 156, 165, 173, 181, 189, 197, 206, 214, 222, 230, 239, 247, 255,
|
||||
// 6 bits
|
||||
0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 45, 49, 53, 57, 61, 65, 69, 73,
|
||||
77, 81, 85, 89, 93, 97, 101, 105, 109, 113, 117, 121, 125, 130, 134, 138,
|
||||
142, 146, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198,
|
||||
202, 206, 210, 215, 219, 223, 227, 231, 235, 239, 243, 247, 251, 255,
|
||||
// 7 bits
|
||||
0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38,
|
||||
40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76,
|
||||
78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110,
|
||||
112, 114, 116, 118, 120, 122, 124, 126, 129, 131, 133, 135, 137, 139, 141,
|
||||
143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171,
|
||||
173, 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201,
|
||||
203, 205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231,
|
||||
233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
* Convert an n bit component to an 8-bit component
|
||||
*
|
||||
*/
|
||||
static uint8_t convert_to_8(uint32_t component, uint32_t n) {
|
||||
if (0 == n) {
|
||||
return 0;
|
||||
} else if (8 > n) {
|
||||
return n_bit_to_8_bit_lookup_table[(1 << n) - 2 + component];
|
||||
} else {
|
||||
SkASSERT(8 == n);
|
||||
return component;
|
||||
}
|
||||
}
|
||||
|
||||
static uint8_t get_comp(uint32_t pixel, uint32_t mask, uint32_t shift,
|
||||
uint32_t size) {
|
||||
return convert_to_8((pixel & mask) >> shift, size);
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Get a color component
|
||||
*
|
||||
*/
|
||||
uint8_t SkMasks::getRed(uint32_t pixel) {
|
||||
return get_comp(pixel, fRed.mask, fRed.shift, fRed.size);
|
||||
}
|
||||
uint8_t SkMasks::getGreen(uint32_t pixel) {
|
||||
return get_comp(pixel, fGreen.mask, fGreen.shift, fGreen.size);
|
||||
}
|
||||
uint8_t SkMasks::getBlue(uint32_t pixel) {
|
||||
return get_comp(pixel, fBlue.mask, fBlue.shift, fBlue.size);
|
||||
}
|
||||
uint8_t SkMasks::getAlpha(uint32_t pixel) {
|
||||
return get_comp(pixel, fAlpha.mask, fAlpha.shift, fAlpha.size);
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Process an input mask to obtain the necessary information
|
||||
*
|
||||
*/
|
||||
const SkMasks::MaskInfo process_mask(uint32_t mask, uint32_t bpp) {
|
||||
// Trim the masks to the allowed number of bits
|
||||
if (bpp < 32) {
|
||||
mask &= (1 << bpp) - 1;
|
||||
}
|
||||
|
||||
// Determine properties of the mask
|
||||
uint32_t tempMask = mask;
|
||||
uint32_t shift = 0;
|
||||
uint32_t size = 0;
|
||||
if (tempMask != 0) {
|
||||
// Count trailing zeros on masks
|
||||
for (; (tempMask & 1) == 0; tempMask >>= 1) {
|
||||
shift++;
|
||||
}
|
||||
// Count the size of the mask
|
||||
for (; tempMask & 1; tempMask >>= 1) {
|
||||
size++;
|
||||
}
|
||||
// Check that the mask is continuous
|
||||
if (tempMask != 0) {
|
||||
SkDebugf("Warning: Bit masks is not continuous.\n");
|
||||
}
|
||||
// Truncate masks greater than 8 bits
|
||||
if (size > 8) {
|
||||
shift += size - 8;
|
||||
size = 8;
|
||||
}
|
||||
}
|
||||
|
||||
// Save the calculated values
|
||||
const SkMasks::MaskInfo info = { mask, shift, size };
|
||||
return info;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Create the masks object
|
||||
*
|
||||
*/
|
||||
SkMasks* SkMasks::CreateMasks(InputMasks masks, uint32_t bitsPerPixel) {
|
||||
// Trim the input masks according to bitsPerPixel
|
||||
if (bitsPerPixel < 32) {
|
||||
masks.red &= (1 << bitsPerPixel) - 1;
|
||||
masks.green &= (1 << bitsPerPixel) - 1;
|
||||
masks.blue &= (1 << bitsPerPixel) - 1;
|
||||
masks.alpha &= (1 << bitsPerPixel) - 1;
|
||||
}
|
||||
|
||||
// Check that masks do not overlap
|
||||
if (((masks.red & masks.green) | (masks.red & masks.blue) |
|
||||
(masks.red & masks.alpha) | (masks.green & masks.blue) |
|
||||
(masks.green & masks.alpha) | (masks.blue & masks.alpha)) != 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Collect information about the masks
|
||||
const MaskInfo red = process_mask(masks.red, bitsPerPixel);
|
||||
const MaskInfo green = process_mask(masks.green, bitsPerPixel);
|
||||
const MaskInfo blue = process_mask(masks.blue, bitsPerPixel);
|
||||
const MaskInfo alpha = process_mask(masks.alpha, bitsPerPixel);
|
||||
|
||||
return SkNEW_ARGS(SkMasks, (red, green, blue, alpha));
|
||||
}
|
||||
|
||||
|
||||
SkMasks::SkMasks(const MaskInfo red, const MaskInfo green,
|
||||
const MaskInfo blue, const MaskInfo alpha)
|
||||
: fRed(red)
|
||||
, fGreen(green)
|
||||
, fBlue(blue)
|
||||
, fAlpha(alpha)
|
||||
{}
|
@ -1,81 +0,0 @@
|
||||
/*
|
||||
* Copyright 2015 Google Inc.
|
||||
*
|
||||
* Use of this source code is governed by a BSD-style license that can be
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
#include "SkTypes.h"
|
||||
|
||||
/*
|
||||
*
|
||||
* Contains useful mask routines for SkMaskSwizzler
|
||||
*
|
||||
*/
|
||||
class SkMasks {
|
||||
public:
|
||||
|
||||
/*
|
||||
*
|
||||
* Input bit masks format
|
||||
*
|
||||
*/
|
||||
struct InputMasks {
|
||||
uint32_t red;
|
||||
uint32_t green;
|
||||
uint32_t blue;
|
||||
uint32_t alpha;
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
* Contains all of the information for a single mask
|
||||
*
|
||||
*/
|
||||
struct MaskInfo {
|
||||
uint32_t mask;
|
||||
uint32_t shift;
|
||||
uint32_t size;
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
* Create the masks object
|
||||
*
|
||||
*/
|
||||
static SkMasks* CreateMasks(InputMasks masks, uint32_t bpp);
|
||||
|
||||
/*
|
||||
*
|
||||
* Get a color component
|
||||
*
|
||||
*/
|
||||
uint8_t getRed(uint32_t pixel);
|
||||
uint8_t getGreen(uint32_t pixel);
|
||||
uint8_t getBlue(uint32_t pixel);
|
||||
uint8_t getAlpha(uint32_t pixel);
|
||||
|
||||
/*
|
||||
*
|
||||
* Getter for the alpha mask
|
||||
* The alpha mask may be used in other decoding modes
|
||||
*
|
||||
*/
|
||||
uint32_t getAlphaMask() {
|
||||
return fAlpha.mask;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
/*
|
||||
*
|
||||
* Constrcutor
|
||||
*
|
||||
*/
|
||||
SkMasks(const MaskInfo red, const MaskInfo green, const MaskInfo blue,
|
||||
const MaskInfo alpha);
|
||||
|
||||
const MaskInfo fRed;
|
||||
const MaskInfo fGreen;
|
||||
const MaskInfo fBlue;
|
||||
const MaskInfo fAlpha;
|
||||
};
|
@ -5,168 +5,105 @@
|
||||
* found in the LICENSE file.
|
||||
*/
|
||||
|
||||
#include "SkCodecPriv.h"
|
||||
#include "SkColorPriv.h"
|
||||
#include "SkSwizzler.h"
|
||||
#include "SkTemplates.h"
|
||||
|
||||
SkSwizzler::ResultAlpha SkSwizzler::GetResult(uint8_t zeroAlpha,
|
||||
uint8_t maxAlpha) {
|
||||
// In the transparent case, this returns 0x0000
|
||||
// In the opaque case, this returns 0xFFFF
|
||||
// If the row is neither transparent nor opaque, returns something else
|
||||
return (((uint16_t) maxAlpha) << 8) | zeroAlpha;
|
||||
}
|
||||
// index
|
||||
|
||||
// kIndex1, kIndex2, kIndex4
|
||||
#define A32_MASK_IN_PLACE (SkPMColor)(SK_A32_MASK << SK_A32_SHIFT)
|
||||
|
||||
static SkSwizzler::ResultAlpha swizzle_small_index_to_n32(
|
||||
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
|
||||
int bitsPerPixel, int y, const SkPMColor ctable[]) {
|
||||
|
||||
SkPMColor* SK_RESTRICT dst = (SkPMColor*) dstRow;
|
||||
INIT_RESULT_ALPHA;
|
||||
const uint32_t pixelsPerByte = 8 / bitsPerPixel;
|
||||
const size_t rowBytes = compute_row_bytes_ppb(width, pixelsPerByte);
|
||||
const uint8_t mask = (1 << bitsPerPixel) - 1;
|
||||
int x = 0;
|
||||
for (uint32_t byte = 0; byte < rowBytes; byte++) {
|
||||
uint8_t pixelData = src[byte];
|
||||
for (uint32_t p = 0; p < pixelsPerByte && x < width; p++) {
|
||||
uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
|
||||
SkPMColor c = ctable[index];
|
||||
UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
|
||||
dst[x] = c;
|
||||
pixelData <<= bitsPerPixel;
|
||||
x++;
|
||||
}
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
}
|
||||
|
||||
// kIndex
|
||||
|
||||
static SkSwizzler::ResultAlpha swizzle_index_to_n32(
|
||||
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
|
||||
int bytesPerPixel, int y, const SkPMColor ctable[]) {
|
||||
static bool swizzle_index_to_n32(void* SK_RESTRICT dstRow,
|
||||
const uint8_t* SK_RESTRICT src,
|
||||
int width, int deltaSrc, int, const SkPMColor ctable[]) {
|
||||
|
||||
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
|
||||
INIT_RESULT_ALPHA;
|
||||
SkPMColor cc = A32_MASK_IN_PLACE;
|
||||
for (int x = 0; x < width; x++) {
|
||||
SkPMColor c = ctable[*src];
|
||||
UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
|
||||
cc &= c;
|
||||
dst[x] = c;
|
||||
src++;
|
||||
src += deltaSrc;
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
return cc != A32_MASK_IN_PLACE;
|
||||
}
|
||||
|
||||
static SkSwizzler::ResultAlpha swizzle_index_to_n32_skipZ(
|
||||
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
|
||||
int bytesPerPixel, int y, const SkPMColor ctable[]) {
|
||||
static bool swizzle_index_to_n32_skipZ(void* SK_RESTRICT dstRow,
|
||||
const uint8_t* SK_RESTRICT src,
|
||||
int width, int deltaSrc, int,
|
||||
const SkPMColor ctable[]) {
|
||||
|
||||
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
|
||||
INIT_RESULT_ALPHA;
|
||||
SkPMColor cc = A32_MASK_IN_PLACE;
|
||||
for (int x = 0; x < width; x++) {
|
||||
SkPMColor c = ctable[*src];
|
||||
UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
|
||||
cc &= c;
|
||||
if (c != 0) {
|
||||
dst[x] = c;
|
||||
}
|
||||
src++;
|
||||
src += deltaSrc;
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
return cc != A32_MASK_IN_PLACE;
|
||||
}
|
||||
|
||||
#undef A32_MASK_IN_PLACE
|
||||
|
||||
static SkSwizzler::ResultAlpha swizzle_bgrx_to_n32(
|
||||
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
|
||||
int bytesPerPixel, int y, const SkPMColor ctable[]) {
|
||||
|
||||
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
|
||||
for (int x = 0; x < width; x++) {
|
||||
dst[x] = SkPackARGB32NoCheck(0xFF, src[2], src[1], src[0]);
|
||||
src += bytesPerPixel;
|
||||
}
|
||||
return SkSwizzler::kOpaque_ResultAlpha;
|
||||
}
|
||||
|
||||
// kBGRA
|
||||
|
||||
static SkSwizzler::ResultAlpha swizzle_bgra_to_n32(
|
||||
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
|
||||
int bytesPerPixel, int y, const SkPMColor ctable[]) {
|
||||
|
||||
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
|
||||
INIT_RESULT_ALPHA;
|
||||
for (int x = 0; x < width; x++) {
|
||||
uint8_t alpha = src[3];
|
||||
UPDATE_RESULT_ALPHA(alpha);
|
||||
dst[x] = SkPackARGB32NoCheck(alpha, src[2], src[1], src[0]);
|
||||
src += bytesPerPixel;
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
}
|
||||
|
||||
// n32
|
||||
static SkSwizzler::ResultAlpha swizzle_rgbx_to_n32(
|
||||
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
|
||||
int bytesPerPixel, int y, const SkPMColor ctable[]) {
|
||||
|
||||
static bool swizzle_rgbx_to_n32(void* SK_RESTRICT dstRow,
|
||||
const uint8_t* SK_RESTRICT src,
|
||||
int width, int deltaSrc, int, const SkPMColor[]) {
|
||||
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
|
||||
for (int x = 0; x < width; x++) {
|
||||
dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]);
|
||||
src += bytesPerPixel;
|
||||
src += deltaSrc;
|
||||
}
|
||||
return SkSwizzler::kOpaque_ResultAlpha;
|
||||
return false;
|
||||
}
|
||||
|
||||
static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul(
|
||||
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
|
||||
int bytesPerPixel, int y, const SkPMColor ctable[]) {
|
||||
|
||||
static bool swizzle_rgba_to_n32_premul(void* SK_RESTRICT dstRow,
|
||||
const uint8_t* SK_RESTRICT src,
|
||||
int width, int deltaSrc, int, const SkPMColor[]) {
|
||||
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
|
||||
INIT_RESULT_ALPHA;
|
||||
unsigned alphaMask = 0xFF;
|
||||
for (int x = 0; x < width; x++) {
|
||||
unsigned alpha = src[3];
|
||||
UPDATE_RESULT_ALPHA(alpha);
|
||||
dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
|
||||
src += bytesPerPixel;
|
||||
src += deltaSrc;
|
||||
alphaMask &= alpha;
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
return alphaMask != 0xFF;
|
||||
}
|
||||
|
||||
static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_unpremul(
|
||||
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
|
||||
int bytesPerPixel, int y, const SkPMColor ctable[]) {
|
||||
|
||||
static bool swizzle_rgba_to_n32_unpremul(void* SK_RESTRICT dstRow,
|
||||
const uint8_t* SK_RESTRICT src,
|
||||
int width, int deltaSrc, int,
|
||||
const SkPMColor[]) {
|
||||
uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
|
||||
INIT_RESULT_ALPHA;
|
||||
unsigned alphaMask = 0xFF;
|
||||
for (int x = 0; x < width; x++) {
|
||||
unsigned alpha = src[3];
|
||||
UPDATE_RESULT_ALPHA(alpha);
|
||||
dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
|
||||
src += bytesPerPixel;
|
||||
src += deltaSrc;
|
||||
alphaMask &= alpha;
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
return alphaMask != 0xFF;
|
||||
}
|
||||
|
||||
static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul_skipZ(
|
||||
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
|
||||
int bytesPerPixel, int y, const SkPMColor ctable[]) {
|
||||
|
||||
static bool swizzle_rgba_to_n32_premul_skipZ(void* SK_RESTRICT dstRow,
|
||||
const uint8_t* SK_RESTRICT src,
|
||||
int width, int deltaSrc, int,
|
||||
const SkPMColor[]) {
|
||||
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
|
||||
INIT_RESULT_ALPHA;
|
||||
unsigned alphaMask = 0xFF;
|
||||
for (int x = 0; x < width; x++) {
|
||||
unsigned alpha = src[3];
|
||||
UPDATE_RESULT_ALPHA(alpha);
|
||||
if (0 != alpha) {
|
||||
dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
|
||||
}
|
||||
src += bytesPerPixel;
|
||||
src += deltaSrc;
|
||||
alphaMask &= alpha;
|
||||
}
|
||||
return COMPUTE_RESULT_ALPHA;
|
||||
return alphaMask != 0xFF;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -177,7 +114,7 @@ static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul_skipZ(
|
||||
decide whether to switch to unpremul default.
|
||||
static bool swizzle_rgba_to_n32_unpremul_skipZ(void* SK_RESTRICT dstRow,
|
||||
const uint8_t* SK_RESTRICT src,
|
||||
int width, int bitsPerPixel,
|
||||
int width, int deltaSrc, int,
|
||||
const SkPMColor[]) {
|
||||
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
|
||||
unsigned alphaMask = 0xFF;
|
||||
@ -196,61 +133,31 @@ static bool swizzle_rgba_to_n32_unpremul_skipZ(void* SK_RESTRICT dstRow,
|
||||
}
|
||||
*/
|
||||
|
||||
SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
|
||||
const SkPMColor* ctable,
|
||||
SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc, const SkPMColor* ctable,
|
||||
const SkImageInfo& info, void* dst,
|
||||
size_t dstRowBytes, bool skipZeroes) {
|
||||
if (kUnknown_SkColorType == info.colorType()) {
|
||||
if (info.colorType() == kUnknown_SkColorType) {
|
||||
return NULL;
|
||||
}
|
||||
if (info.minRowBytes() > dstRowBytes) {
|
||||
return NULL;
|
||||
}
|
||||
if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
|
||||
&& NULL == ctable) {
|
||||
if (kIndex == sc && NULL == ctable) {
|
||||
return NULL;
|
||||
}
|
||||
RowProc proc = NULL;
|
||||
switch (sc) {
|
||||
case kIndex1:
|
||||
case kIndex2:
|
||||
case kIndex4:
|
||||
switch (info.colorType()) {
|
||||
case kN32_SkColorType:
|
||||
proc = &swizzle_small_index_to_n32;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case kIndex:
|
||||
switch (info.colorType()) {
|
||||
case kN32_SkColorType:
|
||||
// We assume the color premultiplied ctable (or not) as desired.
|
||||
if (skipZeroes) {
|
||||
proc = &swizzle_index_to_n32_skipZ;
|
||||
} else {
|
||||
proc = &swizzle_index_to_n32;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case kBGR:
|
||||
case kBGRX:
|
||||
switch (info.colorType()) {
|
||||
case kN32_SkColorType:
|
||||
proc = &swizzle_bgrx_to_n32;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case kBGRA:
|
||||
switch (info.colorType()) {
|
||||
case kN32_SkColorType:
|
||||
proc = &swizzle_bgra_to_n32;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -283,67 +190,32 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case kRGB:
|
||||
switch (info.colorType()) {
|
||||
case kN32_SkColorType:
|
||||
proc = &swizzle_rgbx_to_n32;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (NULL == proc) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Store deltaSrc in bytes if it is an even multiple, otherwise use bits
|
||||
int deltaSrc = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) :
|
||||
BitsPerPixel(sc);
|
||||
return SkNEW_ARGS(SkSwizzler, (proc, ctable, deltaSrc, info, dst,
|
||||
dstRowBytes));
|
||||
return SkNEW_ARGS(SkSwizzler, (proc, ctable, BytesPerPixel(sc), info, dst, dstRowBytes));
|
||||
}
|
||||
|
||||
SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable,
|
||||
int deltaSrc, const SkImageInfo& info, void* dst,
|
||||
size_t rowBytes)
|
||||
SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable, int srcBpp,
|
||||
const SkImageInfo& info, void* dst, size_t rowBytes)
|
||||
: fRowProc(proc)
|
||||
, fColorTable(ctable)
|
||||
, fDeltaSrc(deltaSrc)
|
||||
, fSrcPixelSize(srcBpp)
|
||||
, fDstInfo(info)
|
||||
, fDstRow(dst)
|
||||
, fDstRowBytes(rowBytes)
|
||||
, fCurrY(0)
|
||||
{
|
||||
SkDEBUGCODE(fNextMode = kUninitialized_NextMode);
|
||||
}
|
||||
|
||||
SkSwizzler::ResultAlpha SkSwizzler::next(const uint8_t* SK_RESTRICT src) {
|
||||
SkASSERT(0 <= fCurrY && fCurrY < fDstInfo.height());
|
||||
SkASSERT(kDesignateRow_NextMode != fNextMode);
|
||||
SkDEBUGCODE(fNextMode = kConsecutive_NextMode);
|
||||
|
||||
// Decode a row
|
||||
const ResultAlpha result = fRowProc(fDstRow, src, fDstInfo.width(),
|
||||
fDeltaSrc, fCurrY, fColorTable);
|
||||
|
||||
// Move to the next row and return the result
|
||||
bool SkSwizzler::next(const uint8_t* SK_RESTRICT src) {
|
||||
SkASSERT(fCurrY < fDstInfo.height());
|
||||
const bool hadAlpha = fRowProc(fDstRow, src, fDstInfo.width(), fSrcPixelSize,
|
||||
fCurrY, fColorTable);
|
||||
fCurrY++;
|
||||
fDstRow = SkTAddOffset<void>(fDstRow, fDstRowBytes);
|
||||
return result;
|
||||
}
|
||||
|
||||
SkSwizzler::ResultAlpha SkSwizzler::next(const uint8_t* SK_RESTRICT src,
|
||||
int y) {
|
||||
SkASSERT(0 <= y && y < fDstInfo.height());
|
||||
SkASSERT(kConsecutive_NextMode != fNextMode);
|
||||
SkDEBUGCODE(fNextMode = kDesignateRow_NextMode);
|
||||
|
||||
// Choose the row
|
||||
void* row = SkTAddOffset<void>(fDstRow, y*fDstRowBytes);
|
||||
|
||||
// Decode the row
|
||||
return fRowProc(row, src, fDstInfo.width(), fDeltaSrc, fCurrY,
|
||||
fColorTable);
|
||||
return hadAlpha;
|
||||
}
|
||||
|
@ -18,99 +18,32 @@ public:
|
||||
* Enum describing the config of the source data.
|
||||
*/
|
||||
enum SrcConfig {
|
||||
kGray,
|
||||
kIndex1,
|
||||
kIndex2,
|
||||
kIndex4,
|
||||
kIndex,
|
||||
kRGB,
|
||||
kBGR,
|
||||
kRGBX,
|
||||
kBGRX,
|
||||
kRGBA,
|
||||
kBGRA,
|
||||
kRGB_565,
|
||||
kGray, // 1 byte per pixel
|
||||
kIndex, // 1 byte per pixel
|
||||
kRGB, // 3 bytes per pixel
|
||||
kRGBX, // 4 byes per pixel (ignore 4th)
|
||||
kRGBA, // 4 bytes per pixel
|
||||
kRGB_565 // 2 bytes per pixel
|
||||
};
|
||||
|
||||
/*
|
||||
*
|
||||
* Result code for the alpha components of a row.
|
||||
*
|
||||
*/
|
||||
typedef uint16_t ResultAlpha;
|
||||
static const ResultAlpha kOpaque_ResultAlpha = 0xFFFF;
|
||||
static const ResultAlpha kTransparent_ResultAlpha = 0x0000;
|
||||
|
||||
/*
|
||||
*
|
||||
* Checks if the result of decoding a row indicates that the row was
|
||||
* transparent.
|
||||
*
|
||||
*/
|
||||
static bool IsTransparent(ResultAlpha r) {
|
||||
return kTransparent_ResultAlpha == r;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Checks if the result of decoding a row indicates that the row was
|
||||
* opaque.
|
||||
*
|
||||
*/
|
||||
static bool IsOpaque(ResultAlpha r) {
|
||||
return kOpaque_ResultAlpha == r;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Constructs the proper result code based on accumulated alpha masks
|
||||
*
|
||||
*/
|
||||
static ResultAlpha GetResult(uint8_t zeroAlpha, uint8_t maxAlpha);
|
||||
|
||||
/*
|
||||
*
|
||||
* Returns bits per pixel for source config
|
||||
*
|
||||
*/
|
||||
static int BitsPerPixel(SrcConfig sc) {
|
||||
static int BytesPerPixel(SrcConfig sc) {
|
||||
switch (sc) {
|
||||
case kIndex1:
|
||||
return 1;
|
||||
case kIndex2:
|
||||
return 2;
|
||||
case kIndex4:
|
||||
return 4;
|
||||
case kGray:
|
||||
case kIndex:
|
||||
return 8;
|
||||
case kRGB_565:
|
||||
return 16;
|
||||
return 1;
|
||||
case kRGB:
|
||||
case kBGR:
|
||||
return 24;
|
||||
return 3;
|
||||
case kRGBX:
|
||||
case kRGBA:
|
||||
case kBGRX:
|
||||
case kBGRA:
|
||||
return 32;
|
||||
return 4;
|
||||
case kRGB_565:
|
||||
return 2;
|
||||
default:
|
||||
SkASSERT(false);
|
||||
return 0;
|
||||
SkDebugf("invalid source config passed to BytesPerPixel\n");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* 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 sc SrcConfig
|
||||
@ -125,68 +58,36 @@ public:
|
||||
static SkSwizzler* CreateSwizzler(SrcConfig sc, const SkPMColor* ctable,
|
||||
const SkImageInfo& info, void* dst,
|
||||
size_t dstRowBytes, bool skipZeroes);
|
||||
|
||||
/**
|
||||
* Swizzle the next line. Call height times, once for each row of source.
|
||||
* @param src The next row of the source data.
|
||||
* @return A result code describing if the row was fully opaque, fully
|
||||
* transparent, or neither
|
||||
* @return Whether the row had non-opaque alpha.
|
||||
*/
|
||||
ResultAlpha next(const uint8_t* SK_RESTRICT src);
|
||||
|
||||
/**
|
||||
*
|
||||
* Alternate version of next that allows the caller to specify the row.
|
||||
* It is very important to only use one version of next. Since the other
|
||||
* version modifies the dst pointer, it will change the behavior of this
|
||||
* function. We will check this in Debug mode.
|
||||
*
|
||||
*/
|
||||
ResultAlpha next(const uint8_t* SK_RESTRICT src, int y);
|
||||
bool next(const uint8_t* SK_RESTRICT src);
|
||||
private:
|
||||
|
||||
#ifdef SK_DEBUG
|
||||
/*
|
||||
*
|
||||
* Keep track of which version of next the caller is using
|
||||
*
|
||||
*/
|
||||
enum NextMode {
|
||||
kUninitialized_NextMode,
|
||||
kConsecutive_NextMode,
|
||||
kDesignateRow_NextMode,
|
||||
};
|
||||
|
||||
NextMode fNextMode;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Method for converting raw data to Skia pixels.
|
||||
* @param dstRow Row in which to write the resulting pixels.
|
||||
* @param src Row of src data, in format specified by SrcConfig
|
||||
* @param width Width in pixels
|
||||
* @param deltaSrc if bitsPerPixel % 8 == 0, deltaSrc is bytesPerPixel
|
||||
* else, deltaSrc is bitsPerPixel
|
||||
* @param bpp bytes per pixel of the source.
|
||||
* @param y Line of source.
|
||||
* @param ctable Colors (used for kIndex source).
|
||||
*/
|
||||
typedef ResultAlpha (*RowProc)(void* SK_RESTRICT dstRow,
|
||||
const uint8_t* SK_RESTRICT src,
|
||||
int width, int deltaSrc, int y,
|
||||
const SkPMColor ctable[]);
|
||||
typedef bool (*RowProc)(void* SK_RESTRICT dstRow,
|
||||
const uint8_t* SK_RESTRICT src,
|
||||
int width, int bpp, int y,
|
||||
const SkPMColor ctable[]);
|
||||
|
||||
const RowProc fRowProc;
|
||||
const SkPMColor* fColorTable; // Unowned pointer
|
||||
const int fDeltaSrc; // if bitsPerPixel % 8 == 0
|
||||
// deltaSrc is bytesPerPixel
|
||||
// else
|
||||
// deltaSrc is bitsPerPixel
|
||||
const SkPMColor* fColorTable; // Unowned pointer
|
||||
const int fSrcPixelSize;
|
||||
const SkImageInfo fDstInfo;
|
||||
void* fDstRow;
|
||||
const size_t fDstRowBytes;
|
||||
int fCurrY;
|
||||
|
||||
SkSwizzler(RowProc proc, const SkPMColor* ctable, int deltaSrc,
|
||||
SkSwizzler(RowProc proc, const SkPMColor* ctable, int srcBpp,
|
||||
const SkImageInfo& info, void* dst, size_t rowBytes);
|
||||
|
||||
};
|
||||
|
Loading…
Reference in New Issue
Block a user