AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

SkScaledCodec class

Browse Source 
This class does scaling by using a scanlineDecoder.
getScanlines and skipScanlines are used for y sampling,
the swizzler is used for x sampling

this class is currently only working for png and jpeg images
I will update other Codec types to work soon

For SkJpegCodec to implement width wise swizzling it now
uses a swizzler. I ran performance tests on this change.
Here are the performance test results:
https://docs.google.com/a/google.com/spreadsheets/d/1D7-Q_GXD_dI68LZO005NNvb8Wq2Ee0wEBEPG72671yw/edit?usp=sharing

BUG=skia:

Committed: https://skia.googlesource.com/skia/+/0944100ac89f797714eeae0cf2875e2335ff52ee

Review URL: https://codereview.chromium.org/1260673002
This commit is contained in:
emmaleer 2015-08-13 13:07:03 -07:00 committed by Commit bot
parent 1acf250f92
commit d518ea7927
16 changed files with 783 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
dm/DM.cpp
View File

@ -212,7 +212,12 @@ static void push_codec_srcs(Path path) {
// TODO (msarett): Add more scaling tests as we implement more flexible scaling.
// TODO (msarett): Implement scaling tests for SkImageDecoder in order to compare with these
// tests. SkImageDecoder supports downscales by integer factors.
const float scales[] = { 0.125f, 0.25f, 0.375f, 0.5f, 0.625f, 0.750f, 0.875f, 1.0f };
// SkJpegCodec natively supports scaling to: 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875
// 0.1, 0.16, 0.2 etc allow us to test SkScaledCodec with sampleSize 10, 6, 5, etc
// 0.4, 0.7 etc allow to test what happens when the client requests a scale that
// does not exactly match a sampleSize or native scaling capability
const float scales[] = { 0.1f, 0.125f, 0.166f, 0.2f, 0.25f, 0.333f, 0.375f, 0.4f, 0.5f, 0.6f,
0.625f, 0.750f, 0.8f, 0.875f, 1.0f };
for (float scale : scales) {
if (scale != 1.0f && (path.endsWith(".webp") || path.endsWith(".WEBP"))) {

24
dm/DMSrcSink.cpp
View File

@ -27,6 +27,7 @@
#include "SkScanlineDecoder.h"
#include "SkStream.h"
#include "SkXMLWriter.h"
#include "SkScaledCodec.h"
DEFINE_bool(multiPage, false, "For document-type backends, render the source"
" into multiple pages");
@ -84,9 +85,13 @@ Error CodecSrc::draw(SkCanvas* canvas) const {
if (!encoded) {
return SkStringPrintf("Couldn't read %s.", fPath.c_str());
}
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
SkAutoTDelete<SkCodec> codec(SkScaledCodec::NewFromData(encoded));
if (NULL == codec.get()) {
return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
// scaledCodec not supported, try normal codec
codec.reset(SkCodec::NewFromData(encoded));
if (NULL == codec.get()) {
return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
}
}
// Choose the color type to decode to
@ -446,13 +451,16 @@ Error CodecSrc::draw(SkCanvas* canvas) const {
SkISize CodecSrc::size() const {
SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (NULL != codec) {
SkISize size = codec->getScaledDimensions(fScale);
return size;
} else {
return SkISize::Make(0, 0);
SkAutoTDelete<SkCodec> codec(SkScaledCodec::NewFromData(encoded));
if (NULL == codec) {
// scaledCodec not supported, try regular codec
codec.reset(SkCodec::NewFromData(encoded));
if (NULL == codec) {
return SkISize::Make(0, 0);
}
}
SkISize size = codec->getScaledDimensions(fScale);
return size;
}
Name CodecSrc::name() const {

1
gyp/codec.gyp
View File

@ -47,6 +47,7 @@
'../src/codec/SkJpegUtility_codec.cpp',
'../src/codec/SkMaskSwizzler.cpp',
'../src/codec/SkMasks.cpp',
'../src/codec/SkScaledCodec.cpp',
'../src/codec/SkScanlineDecoder.cpp',
'../src/codec/SkSwizzler.cpp',
'../src/codec/SkWebpCodec.cpp',

2
include/codec/SkCodec.h
View File

@ -51,6 +51,8 @@ public:
* Return a size that approximately supports the desired scale factor.
* The codec may not be able to scale efficiently to the exact scale
* factor requested, so return a size that approximates that scale.
* The returned value is the codec's suggestion for the closest valid
* scale that it can natively support
*/
SkISize getScaledDimensions(float desiredScale) const {
return this->onGetScaledDimensions(desiredScale);

70
include/codec/SkScaledCodec.h Normal file
View File

@ -0,0 +1,70 @@
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkScaledCodec_DEFINED
#define SkScaledCodec_DEFINED
#include "SkCodec.h"
#include "SkScanlineDecoder.h"
class SkScanlineDecoder;
class SkStream;
/**
* This class implements scaling, by sampling scanlines in the y direction.
* x-wise sampling is implemented in the swizzler, when getScanlines() is called.
*/
class SkScaledCodec : public SkCodec {
public:
static SkCodec* NewFromStream(SkStream*);
static SkCodec* NewFromData(SkData*);
virtual ~SkScaledCodec();
/**
* returns whether a destination's dimensions are supported for down sampling
*/
static bool DimensionsSupportedForSampling(const SkImageInfo& srcInfo,
const SkImageInfo& dstInfo) {
// heights must be equal as no native y sampling is supported
if (dstInfo.height() != srcInfo.height()) {
return false;
}
// only support down sampling, dstWidth cannot be larger that srcWidth
if(dstInfo.width() > srcInfo.width()) {
return false;
}
return true;
}
static void ComputeSampleSize(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo,
int* sampleSizeX, int* sampleSizeY);
protected:
/**
* Recommend a set of destination dimensions given a requested scale
*/
SkISize onGetScaledDimensions(float desiredScale) const override;
Result onGetPixels(const SkImageInfo&, void*, size_t, const Options&, SkPMColor*, int*)
override;
SkEncodedFormat onGetEncodedFormat() const override {
return fScanlineDecoder->getEncodedFormat();
}
bool onReallyHasAlpha() const override {
return fScanlineDecoder->reallyHasAlpha();
}
private:
SkAutoTDelete<SkScanlineDecoder> fScanlineDecoder;
explicit SkScaledCodec(SkScanlineDecoder*);
typedef SkCodec INHERITED;
};
#endif // SkScaledCodec_DEFINED

42
include/codec/SkScanlineDecoder.h
View File

@ -45,6 +45,18 @@ public:
*/
virtual ~SkScanlineDecoder() {}
/**
* Return a size that approximately supports the desired scale factor.
* The codec may not be able to scale efficiently to the exact scale
* factor requested, so return a size that approximates that scale.
* The returned value is the codec's suggestion for the closest valid
* scale that it can natively support
* FIXME: share this with SkCodec
*/
SkISize getScaledDimensions(float desiredScale) {
return this->onGetScaledDimensions(desiredScale);
}
/**
* Returns the default info, corresponding to the encoded data.
*/
@ -135,14 +147,44 @@ public:
return this->onReallyHasAlpha();
}
/**
* Format of the encoded data.
*/
SkEncodedFormat getEncodedFormat() const { return this->onGetEncodedFormat(); }
/**
* returns true if the image must be scaled, in the y direction, after reading, not during.
* To scale afterwards, we first decode every line and then sample the lines we want afterwards.
* An example is interlaced pngs, where calling getScanlines once (regardless of the count
* used) needs to read the entire image, therefore it is inefficient to call
* getScanlines more than once. Instead, it should only ever be called with all the
* rows needed.
*/
bool requiresPostYSampling() {
return this->onRequiresPostYSampling();
}
protected:
SkScanlineDecoder(const SkImageInfo& srcInfo)
: fSrcInfo(srcInfo)
, fDstInfo()
, fCurrScanline(0) {}
virtual SkISize onGetScaledDimensions(float /* desiredScale */) {
// By default, scaling is not supported.
return this->getInfo().dimensions();
}
virtual SkEncodedFormat onGetEncodedFormat() const = 0;
virtual bool onReallyHasAlpha() const { return false; }
/**
* returns true if the image type is hard to sample and must be scaled after reading, not during
* An example is interlaced pngs, where the entire image must be read for each decode
*/
virtual bool onRequiresPostYSampling() { return false; }
const SkImageInfo& dstInfo() const { return fDstInfo; }
private:

2
src/codec/SkBmpStandardCodec.cpp
View File

@ -237,7 +237,7 @@ bool SkBmpStandardCodec::initializeSwizzler(const SkImageInfo& dstInfo,
// Create swizzler
fSwizzler.reset(SkSwizzler::CreateSwizzler(config,
colorPtr, dstInfo, opts.fZeroInitialized));
colorPtr, dstInfo, opts.fZeroInitialized, this->getInfo()));
if (NULL == fSwizzler.get()) {
return false;

5
src/codec/SkCodec_libgif.cpp
View File

@ -444,11 +444,12 @@ SkCodec::Result SkGifCodec::onGetPixels(const SkImageInfo& dstInfo,
// Create the subset swizzler
swizzler.reset(SkSwizzler::CreateSwizzler(
SkSwizzler::kIndex, colorTable, subsetDstInfo,
zeroInit));
zeroInit, this->getInfo()));
} else {
// Create the fully dimensional swizzler
swizzler.reset(SkSwizzler::CreateSwizzler(
SkSwizzler::kIndex, colorTable, dstInfo, zeroInit));
SkSwizzler::kIndex, colorTable, dstInfo,
zeroInit, this->getInfo()));
}
// Stores output from dgiflib and input to the swizzler

33
src/codec/SkCodec_libpng.cpp
View File

@ -11,6 +11,7 @@
#include "SkColorTable.h"
#include "SkBitmap.h"
#include "SkMath.h"
#include "SkScaledCodec.h"
#include "SkScanlineDecoder.h"
#include "SkSize.h"
#include "SkStream.h"
@ -462,7 +463,7 @@ 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.fZeroInitialized));
options.fZeroInitialized, this->getInfo()));
if (!fSwizzler) {
// FIXME: CreateSwizzler could fail for another reason.
return kUnimplemented;
@ -582,8 +583,7 @@ public:
SkCodec::Result onStart(const SkImageInfo& dstInfo,
const SkCodec::Options& options,
SkPMColor ctable[], int* ctableCount) override
{
SkPMColor ctable[], int* ctableCount) override {
if (!fCodec->rewindIfNeeded()) {
return SkCodec::kCouldNotRewind;
}
@ -594,7 +594,9 @@ public:
// Check to see if scaling was requested.
if (dstInfo.dimensions() != this->getInfo().dimensions()) {
return SkCodec::kInvalidScale;
if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
return SkCodec::kInvalidScale;
}
}
const SkCodec::Result result = fCodec->initializeSwizzler(dstInfo, options, ctable,
@ -604,7 +606,7 @@ public:
}
fHasAlpha = false;
fStorage.reset(dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig));
fStorage.reset(this->getInfo().width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig));
fSrcRow = static_cast<uint8_t*>(fStorage.get());
return SkCodec::kSuccess;
@ -643,6 +645,11 @@ public:
bool onReallyHasAlpha() const override { return fHasAlpha; }
SkEncodedFormat onGetEncodedFormat() const override {
return kPNG_SkEncodedFormat;
}
private:
SkAutoTDelete<SkPngCodec> fCodec;
bool fHasAlpha;
@ -673,12 +680,14 @@ public:
}
if (!conversion_possible(dstInfo, this->getInfo())) {
return SkCodec::kInvalidConversion;
return SkCodec::kInvalidConversion;
}
// Check to see if scaling was requested.
if (dstInfo.dimensions() != this->getInfo().dimensions()) {
return SkCodec::kInvalidScale;
if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
return SkCodec::kInvalidScale;
}
}
const SkCodec::Result result = fCodec->initializeSwizzler(dstInfo, options, ctable,
@ -690,7 +699,7 @@ public:
fHasAlpha = false;
fCurrentRow = 0;
fHeight = dstInfo.height();
fSrcRowBytes = dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig);
fSrcRowBytes = this->getInfo().width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig);
fGarbageRow.reset(fSrcRowBytes);
fGarbageRowPtr = static_cast<uint8_t*>(fGarbageRow.get());
fCanSkipRewind = true;
@ -753,6 +762,14 @@ public:
bool onReallyHasAlpha() const override { return fHasAlpha; }
bool onRequiresPostYSampling() override {
return true;
}
SkEncodedFormat onGetEncodedFormat() const override {
return kPNG_SkEncodedFormat;
}
private:
SkAutoTDelete<SkPngCodec> fCodec;
bool fHasAlpha;

2
src/codec/SkCodec_libpng.h
View File

@ -37,6 +37,7 @@ protected:
SkEncodedFormat onGetEncodedFormat() const override { return kPNG_SkEncodedFormat; }
bool onRewind() override;
bool onReallyHasAlpha() const override { return fReallyHasAlpha; }
private:
png_structp fPng_ptr;
png_infop fInfo_ptr;
@ -52,7 +53,6 @@ private:
SkPngCodec(const SkImageInfo&, SkStream*, png_structp, png_infop, int);
// Helper to set up swizzler and color table. Also calls png_read_update_info.
Result initializeSwizzler(const SkImageInfo& requestedInfo, const Options&,
SkPMColor*, int* ctableCount);

15
src/codec/SkCodec_wbmp.cpp
View File

@ -9,6 +9,7 @@
#include "SkCodecPriv.h"
#include "SkColorPriv.h"
#include "SkColorTable.h"
#include "SkScaledCodec.h"
#include "SkStream.h"
#include "SkCodec_wbmp.h"
@ -80,8 +81,8 @@ SkSwizzler* SkWbmpCodec::initializeSwizzler(const SkImageInfo& info,
case kIndex_8_SkColorType:
case kN32_SkColorType:
case kGray_8_SkColorType:
return SkSwizzler::CreateSwizzler(
SkSwizzler::kBit, ctable, info, opts.fZeroInitialized);
return SkSwizzler::CreateSwizzler(SkSwizzler::kBit, ctable, info, opts.fZeroInitialized,
this->getInfo());
default:
return NULL;
}
@ -201,7 +202,9 @@ public:
return SkCodec::kUnimplemented;
}
if (dstInfo.dimensions() != this->getInfo().dimensions()) {
return SkCodec::kInvalidScale;
if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
return SkCodec::kInvalidScale;
}
}
if (!valid_alpha(dstInfo.alphaType(), this->getInfo().alphaType())) {
@ -220,12 +223,16 @@ public:
fSwizzler.reset(fCodec->initializeSwizzler(dstInfo,
get_color_ptr(fColorTable.get()), options));
if (NULL == fSwizzler.get()) {
return SkCodec::kInvalidInput;
return SkCodec::kInvalidConversion;
}
return SkCodec::kSuccess;
}
SkEncodedFormat onGetEncodedFormat() const {
return kWBMP_SkEncodedFormat;
}
private:
SkAutoTDelete<SkWbmpCodec> fCodec;
SkAutoTUnref<SkColorTable> fColorTable;

117
src/codec/SkJpegCodec.cpp
View File

@ -11,6 +11,7 @@
#include "SkJpegUtility_codec.h"
#include "SkCodecPriv.h"
#include "SkColorPriv.h"
#include "SkScaledCodec.h"
#include "SkScanlineDecoder.h"
#include "SkStream.h"
#include "SkTemplates.h"
@ -148,6 +149,14 @@ SkJpegCodec::SkJpegCodec(const SkImageInfo& srcInfo, SkStream* stream,
, fDecoderMgr(decoderMgr)
{}
/*
* Return the row bytes of a particular image type and width
*/
static int get_row_bytes(const j_decompress_ptr dinfo) {
int colorBytes = (dinfo->out_color_space == JCS_RGB565) ? 2 : dinfo->out_color_components;
return dinfo->output_width * colorBytes;
}
/*
* Return a valid set of output dimensions for this decoder, given an input scale
*/
@ -258,10 +267,10 @@ bool SkJpegCodec::setOutputColorSpace(const SkImageInfo& dst) {
}
/*
* Checks if we can scale to the requested dimensions and scales the dimensions
* if possible
* Checks if we can natively scale to the requested dimensions and natively scales the
* dimensions if possible
*/
bool SkJpegCodec::scaleToDimensions(uint32_t dstWidth, uint32_t dstHeight) {
bool SkJpegCodec::nativelyScaleToDimensions(uint32_t dstWidth, uint32_t dstHeight) {
// libjpeg-turbo can scale to 1/8, 1/4, 3/8, 1/2, 5/8, 3/4, 7/8, and 1/1
fDecoderMgr->dinfo()->scale_denom = 8;
fDecoderMgr->dinfo()->scale_num = 8;
@ -273,7 +282,10 @@ bool SkJpegCodec::scaleToDimensions(uint32_t dstWidth, uint32_t dstHeight) {
if (1 == fDecoderMgr->dinfo()->scale_num ||
dstWidth > fDecoderMgr->dinfo()->output_width ||
dstHeight > fDecoderMgr->dinfo()->output_height) {
return fDecoderMgr->returnFalse("could not scale to requested dimensions");
// reset native scale settings on failure because this may be supported by the swizzler
this->fDecoderMgr->dinfo()->scale_num = 8;
chromium_jpeg_calc_output_dimensions(this->fDecoderMgr->dinfo());
return false;
}
// Try the next scale
@ -313,7 +325,7 @@ SkCodec::Result SkJpegCodec::onGetPixels(const SkImageInfo& dstInfo,
}
// Perform the necessary scaling
if (!this->scaleToDimensions(dstInfo.width(), dstInfo.height())) {
if (!this->nativelyScaleToDimensions(dstInfo.width(), dstInfo.height())) {
return fDecoderMgr->returnFailure("cannot scale to requested dims", kInvalidScale);
}
@ -381,6 +393,47 @@ public:
, fOpts()
{}
/*
* Return a valid set of output dimensions for this decoder, given an input scale
*/
SkISize onGetScaledDimensions(float desiredScale) override {
return fCodec->onGetScaledDimensions(desiredScale);
}
/*
* Create the swizzler based on the encoded format.
* The swizzler is only used for sampling in the x direction.
*/
SkCodec::Result initializeSwizzler(const SkImageInfo& info, const SkCodec::Options& options) {
SkSwizzler::SrcConfig srcConfig;
switch (info.colorType()) {
case kGray_8_SkColorType:
srcConfig = SkSwizzler::kGray;
break;
case kRGBA_8888_SkColorType:
srcConfig = SkSwizzler::kRGBX;
break;
case kBGRA_8888_SkColorType:
srcConfig = SkSwizzler::kBGRX;
break;
case kRGB_565_SkColorType:
srcConfig = SkSwizzler::kRGB_565;
break;
default:
//would have exited before now if the colorType was supported by jpeg
SkASSERT(false);
}
fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, NULL, info, options.fZeroInitialized,
this->getInfo()));
if (!fSwizzler) {
// FIXME: CreateSwizzler could fail for another reason.
return SkCodec::kUnimplemented;
}
return SkCodec::kSuccess;
}
SkCodec::Result onStart(const SkImageInfo& dstInfo, const SkCodec::Options& options,
SkPMColor ctable[], int* ctableCount) override {
@ -401,8 +454,23 @@ public:
}
// Perform the necessary scaling
if (!fCodec->scaleToDimensions(dstInfo.width(), dstInfo.height())) {
return SkCodec::kInvalidScale;
if (!fCodec->nativelyScaleToDimensions(dstInfo.width(), dstInfo.height())) {
// full native scaling to dstInfo dimensions not supported
if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
return SkCodec::kInvalidScale;
}
// create swizzler for sampling
SkCodec::Result result = this->initializeSwizzler(dstInfo, options);
if (SkCodec::kSuccess != result) {
SkCodecPrintf("failed to initialize the swizzler.\n");
return result;
}
fStorage.reset(get_row_bytes(fCodec->fDecoderMgr->dinfo()));
fSrcRow = static_cast<uint8_t*>(fStorage.get());
} else {
fSrcRow = NULL;
fSwizzler.reset(NULL);
}
// Now, given valid output dimensions, we can start the decompress
@ -433,9 +501,16 @@ public:
if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
return fCodec->fDecoderMgr->returnFailure("setjmp", SkCodec::kInvalidInput);
}
// Read rows one at a time
JSAMPLE* dstRow = (JSAMPLE*) dst;
JSAMPLE* dstRow;
if (fSwizzler) {
// write data to storage row, then sample using swizzler
dstRow = fSrcRow;
} else {
// write data directly to dst
dstRow = (JSAMPLE*) dst;
}
for (int y = 0; y < count; y++) {
// Read row of the image
uint32_t rowsDecoded =
@ -452,13 +527,17 @@ public:
// Convert to RGBA if necessary
if (JCS_CMYK == fCodec->fDecoderMgr->dinfo()->out_color_space) {
convert_CMYK_to_RGBA(dstRow, this->dstInfo().width());
convert_CMYK_to_RGBA(dstRow, fCodec->fDecoderMgr->dinfo()->output_width);
}
// Move to the next row
dstRow = SkTAddOffset<JSAMPLE>(dstRow, rowBytes);
if(fSwizzler) {
// use swizzler to sample row
fSwizzler->swizzle(dst, dstRow);
dst = SkTAddOffset<JSAMPLE>(dst, rowBytes);
} else {
dstRow = SkTAddOffset<JSAMPLE>(dstRow, rowBytes);
}
}
return SkCodec::kSuccess;
}
@ -466,7 +545,7 @@ public:
// TODO (msarett): Make this a member function and avoid reallocating the
// memory buffer on each call to skip.
#define chromium_jpeg_skip_scanlines(dinfo, count) \
SkAutoMalloc storage(dinfo->output_width * dinfo->out_color_components); \
SkAutoMalloc storage(get_row_bytes(dinfo)); \
uint8_t* storagePtr = static_cast<uint8_t*>(storage.get()); \
for (int y = 0; y < count; y++) { \
chromium_jpeg_read_scanlines(dinfo, &storagePtr, 1); \
@ -484,13 +563,16 @@ public:
return SkCodec::kSuccess;
}
#ifndef TURBO_HAS_SKIP
#undef chromium_jpeg_skip_scanlines
#endif
SkEncodedFormat onGetEncodedFormat() const override {
return kJPEG_SkEncodedFormat;
}
private:
SkAutoTDelete<SkJpegCodec> fCodec;
SkAutoMalloc fStorage; // Only used if sampling is needed
uint8_t* fSrcRow; // Only used if sampling is needed
SkCodec::Options fOpts;
SkAutoTDelete<SkSwizzler> fSwizzler;
typedef SkScanlineDecoder INHERITED;
};
@ -502,6 +584,7 @@ SkScanlineDecoder* SkJpegCodec::NewSDFromStream(SkStream* stream) {
}
const SkImageInfo& srcInfo = codec->getInfo();
// Return the new scanline decoder
return SkNEW_ARGS(SkJpegScanlineDecoder, (srcInfo, codec.detach()));
}

14
src/codec/SkJpegCodec.h
View File

@ -110,19 +110,13 @@ private:
bool setOutputColorSpace(const SkImageInfo& dst);
/*
* Checks if we can scale to the requested dimensions and scales the dimensions
* if possible
* Checks if we can natively scale to the requested dimensions and natively scales the
* dimensions if possible
*/
bool scaleToDimensions(uint32_t width, uint32_t height);
/*
* Create the swizzler based on the encoded format
*/
void initializeSwizzler(const SkImageInfo& dstInfo, void* dst, size_t dstRowBytes,
const Options& options);
bool nativelyScaleToDimensions(uint32_t width, uint32_t height);
SkAutoTDelete<JpegDecoderMgr> fDecoderMgr;
friend class SkJpegScanlineDecoder;
typedef SkCodec INHERITED;

261
src/codec/SkScaledCodec.cpp Normal file
View File

@ -0,0 +1,261 @@
/*
* 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 "SkScaledCodec.h"
#include "SkStream.h"
#include "SkWebpCodec.h"
SkCodec* SkScaledCodec::NewFromStream(SkStream* stream) {
bool isWebp = SkWebpCodec::IsWebp(stream);
if (!stream->rewind()) {
return NULL;
}
if (isWebp) {
// Webp codec supports scaling and subsetting natively
return SkWebpCodec::NewFromStream(stream);
}
SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(SkScanlineDecoder::NewFromStream(stream));
if (NULL == scanlineDecoder) {
return NULL;
}
// wrap in new SkScaledCodec
return SkNEW_ARGS(SkScaledCodec, (scanlineDecoder.detach()));
}
SkCodec* SkScaledCodec::NewFromData(SkData* data) {
if (!data) {
return NULL;
}
return NewFromStream(SkNEW_ARGS(SkMemoryStream, (data)));
}
SkScaledCodec::SkScaledCodec(SkScanlineDecoder* scanlineDecoder)
: INHERITED(scanlineDecoder->getInfo(), NULL)
, fScanlineDecoder(scanlineDecoder)
{}
SkScaledCodec::~SkScaledCodec() {}
// returns a scaled dimension based on the original dimension and the sampleSize
// NOTE: we round down here for scaled dimension to match the behavior of SkImageDecoder
static int get_scaled_dimension(int srcDimension, int sampleSize) {
if (sampleSize > srcDimension) {
return 1;
}
return srcDimension / sampleSize;
}
static SkISize best_scaled_dimensions(const SkISize& origDims, const SkISize& nativeDims,
const SkISize& scaledCodecDims, float desiredScale) {
if (nativeDims == scaledCodecDims) {
// does not matter which to return if equal. Return here to skip below calculations
return nativeDims;
}
float idealWidth = origDims.width() * desiredScale;
float idealHeight = origDims.height() * desiredScale;
// calculate difference between native dimensions and ideal dimensions
float nativeWDiff = SkTAbs(idealWidth - nativeDims.width());
float nativeHDiff = SkTAbs(idealHeight - nativeDims.height());
float nativeDiff = (nativeWDiff + nativeHDiff) / 2;
// calculate difference between scaledCodec dimensions and ideal dimensions
float scaledCodecWDiff = SkTAbs(idealWidth - scaledCodecDims.width());
float scaledCodecHDiff = SkTAbs(idealHeight - scaledCodecDims.height());
float scaledCodecDiff = (scaledCodecWDiff + scaledCodecHDiff) / 2;
// return dimensions closest to ideal dimensions.
// If the differences are equal, return nativeDims, as native scaling is more efficient.
return nativeDiff > scaledCodecDiff ? scaledCodecDims : nativeDims;
}
/*
* Return a valid set of output dimensions for this decoder, given an input scale
*/
SkISize SkScaledCodec::onGetScaledDimensions(float desiredScale) const {
SkISize nativeDimensions = fScanlineDecoder->getScaledDimensions(desiredScale);
// support scaling down by integer numbers. Ex: 1/2, 1/3, 1/4 ...
SkISize scaledCodecDimensions;
if (desiredScale > 0.5f) {
// sampleSize = 1
scaledCodecDimensions = fScanlineDecoder->getInfo().dimensions();
}
// sampleSize determines the step size between samples
// Ex: sampleSize = 2, sample every second pixel in x and y directions
int sampleSize = int(1 / desiredScale);
int scaledWidth = get_scaled_dimension(this->getInfo().width(), sampleSize);
int scaledHeight = get_scaled_dimension(this->getInfo().height(), sampleSize);
// Return the calculated output dimensions for the given scale
scaledCodecDimensions = SkISize::Make(scaledWidth, scaledHeight);
return best_scaled_dimensions(this->getInfo().dimensions(), nativeDimensions,
scaledCodecDimensions, desiredScale);
}
// check if scaling to dstInfo size from srcInfo size using sampleSize is possible
static bool scaling_supported(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo,
int* sampleX, int* sampleY) {
SkScaledCodec::ComputeSampleSize(dstInfo, srcInfo, sampleX, sampleY);
const int dstWidth = dstInfo.width();
const int dstHeight = dstInfo.height();
const int srcWidth = srcInfo.width();
const int srcHeight = srcInfo.height();
// only support down sampling, not up sampling
if (dstWidth > srcWidth || dstHeight > srcHeight) {
return false;
}
// check that srcWidth is scaled down by an integer value
if (get_scaled_dimension(srcWidth, *sampleX) != dstWidth) {
return false;
}
// check that src height is scaled down by an integer value
if (get_scaled_dimension(srcHeight, *sampleY) != dstHeight) {
return false;
}
// sampleX and sampleY should be equal unless the original sampleSize requested was larger
// than srcWidth or srcHeight. If so, the result of this is dstWidth or dstHeight = 1.
// This functionality allows for tall thin images to still be scaled down by scaling factors.
if (*sampleX != *sampleY){
if (1 != dstWidth && 1 != dstHeight) {
return false;
}
}
return true;
}
// calculates sampleSize in x and y direction
void SkScaledCodec::ComputeSampleSize(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo,
int* sampleXPtr, int* sampleYPtr) {
int srcWidth = srcInfo.width();
int dstWidth = dstInfo.width();
int srcHeight = srcInfo.height();
int dstHeight = dstInfo.height();
int sampleX = srcWidth / dstWidth;
int sampleY = srcHeight / dstHeight;
// only support down sampling, not up sampling
SkASSERT(dstWidth <= srcWidth);
SkASSERT(dstHeight <= srcHeight);
// sampleX and sampleY should be equal unless the original sampleSize requested was
// larger than srcWidth or srcHeight.
// If so, the result of this is dstWidth or dstHeight = 1. This functionality
// allows for tall thin images to still be scaled down by scaling factors.
if (sampleX != sampleY){
if (1 != dstWidth && 1 != dstHeight) {
// rounding during onGetScaledDimensions can cause different sampleSizes
// Ex: srcWidth = 79, srcHeight = 20, sampleSize = 10
// dstWidth = 7, dstHeight = 2, sampleX = 79/7 = 11, sampleY = 20/2 = 10
// correct for this rounding by comparing width to sampleY and height to sampleX
if (get_scaled_dimension(srcWidth, sampleY) == dstWidth) {
sampleX = sampleY;
} else if (get_scaled_dimension(srcHeight, sampleX) == dstHeight) {
sampleY = sampleX;
}
}
}
if (sampleXPtr) {
*sampleXPtr = sampleX;
}
if (sampleYPtr) {
*sampleYPtr = sampleY;
}
}
// TODO: Implement subsetting in onGetPixels which works when and when not sampling
SkCodec::Result SkScaledCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
size_t rowBytes, const Options& options,
SkPMColor ctable[], int* ctableCount) {
if (options.fSubset) {
// Subsets are not supported.
return kUnimplemented;
}
Result result = fScanlineDecoder->start(requestedInfo, &options, ctable, ctableCount);
if (kSuccess == result) {
// native decode supported
return fScanlineDecoder->getScanlines(dst, requestedInfo.height(), rowBytes);
}
if (kInvalidScale != result) {
// no scaling requested
return result;
}
// scaling requested
int sampleX;
int sampleY;
if (!scaling_supported(requestedInfo, fScanlineDecoder->getInfo(), &sampleX, &sampleY)) {
return kInvalidScale;
}
// set first sample pixel in y direction
int Y0 = sampleY >> 1;
int dstHeight = requestedInfo.height();
int srcHeight = fScanlineDecoder->getInfo().height();
SkImageInfo info = requestedInfo;
// use original height as scanlineDecoder does not support y sampling natively
info = info.makeWH(requestedInfo.width(), srcHeight);
// update scanlineDecoder with new info
result = fScanlineDecoder->start(info, &options, ctable, ctableCount);
if (kSuccess != result) {
return result;
}
const bool requiresPostYSampling = fScanlineDecoder->requiresPostYSampling();
if (requiresPostYSampling) {
SkAutoMalloc storage(srcHeight * rowBytes);
uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());
result = fScanlineDecoder->getScanlines(storagePtr, srcHeight, rowBytes);
if (kSuccess != result) {
return result;
}
storagePtr += Y0 * rowBytes;
for (int y = 0; y < dstHeight; y++) {
memcpy(dst, storagePtr, rowBytes);
storagePtr += sampleY * rowBytes;
dst = SkTAddOffset<void>(dst, rowBytes);
}
} else {
// does not require post y sampling
result = fScanlineDecoder->skipScanlines(Y0);
if (kSuccess != result) {
return result;
}
for (int y = 0; y < dstHeight; y++) {
result = fScanlineDecoder->getScanlines(dst, 1, rowBytes);
if (kSuccess != result) {
return result;
}
if (y < dstHeight - 1) {
result = fScanlineDecoder->skipScanlines(sampleY - 1);
if (kSuccess != result) {
return result;
}
}
dst = SkTAddOffset<void>(dst, rowBytes);
}
}
return kSuccess;
}

391
src/codec/SkSwizzler.cpp
View File

@ -7,6 +7,7 @@
#include "SkCodecPriv.h"
#include "SkColorPriv.h"
#include "SkScaledCodec.h"
#include "SkSwizzler.h"
#include "SkTemplates.h"
#include "SkUtils.h"
@ -19,114 +20,107 @@ SkSwizzler::ResultAlpha SkSwizzler::GetResult(uint8_t zeroAlpha,
return (((uint16_t) maxAlpha) << 8) | zeroAlpha;
}
// samples the row. Does not do anything else but sampling
static SkSwizzler::ResultAlpha sample565(void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src,
int width, int deltaSrc, int offset, const SkPMColor ctable[]){
src += offset;
uint16_t* SK_RESTRICT dst = (uint16_t*) dstRow;
for (int x = 0; x < width; x++) {
dst[x] = src[1] << 8 | src[0];
src += deltaSrc;
}
// 565 is always opaque
return SkSwizzler::kOpaque_ResultAlpha;
}
// kBit
// These routines exclusively choose between white and black
#define GRAYSCALE_BLACK 0
#define GRAYSCALE_WHITE 0xFF
// same as swizzle_bit_to_index and swizzle_bit_to_n32 except for value assigned to dst[x]
static SkSwizzler::ResultAlpha swizzle_bit_to_grayscale(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int /*bitsPerPixel*/, const SkPMColor* /*ctable*/) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
// Determine how many full bytes are in the row
int bytesInRow = width >> 3;
int i;
for (i = 0; i < bytesInRow; i++) {
U8CPU currByte = src[i];
for (int j = 0; j < 8; j++) {
dst[j] = ((currByte >> (7 - j)) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
}
dst += 8;
// increment src by byte offset and bitIndex by bit offset
src += offset / 8;
int bitIndex = offset % 8;
uint8_t currByte = *src;
for (int x = 0; x < dstWidth; x++) {
dst[x] = ((currByte >> (7-bitIndex)) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
int bitOffset = bitIndex + deltaSrc;
bitIndex = bitOffset % 8;
currByte = *(src += bitOffset / 8);
}
// Finish the remaining bits
width &= 7;
if (width > 0) {
U8CPU currByte = src[i];
for (int j = 0; j < width; j++) {
dst[j] = ((currByte >> 7) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
currByte <<= 1;
}
}
return SkSwizzler::kOpaque_ResultAlpha;
}
#undef GRAYSCALE_BLACK
#undef GRAYSCALE_WHITE
// same as swizzle_bit_to_grayscale and swizzle_bit_to_n32 except for value assigned to dst[x]
static SkSwizzler::ResultAlpha swizzle_bit_to_index(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int /*bitsPerPixel*/, const SkPMColor* /*ctable*/) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
// Determine how many full bytes are in the row
int bytesInRow = width >> 3;
int i;
for (i = 0; i < bytesInRow; i++) {
U8CPU currByte = src[i];
for (int j = 0; j < 8; j++) {
dst[j] = (currByte >> (7 - j)) & 1;
}
dst += 8;
// increment src by byte offset and bitIndex by bit offset
src += offset / 8;
int bitIndex = offset % 8;
uint8_t currByte = *src;
for (int x = 0; x < dstWidth; x++) {
dst[x] = ((currByte >> (7-bitIndex)) & 1);
int bitOffset = bitIndex + deltaSrc;
bitIndex = bitOffset % 8;
currByte = *(src += bitOffset / 8);
}
// Finish the remaining bits
width &= 7;
if (width > 0) {
U8CPU currByte = src[i];
for (int j = 0; j < width; j++) {
dst[j] = ((currByte >> 7) & 1);
currByte <<= 1;
}
}
return SkSwizzler::kOpaque_ResultAlpha;
}
// same as swizzle_bit_to_grayscale and swizzle_bit_to_index except for value assigned to dst[x]
static SkSwizzler::ResultAlpha swizzle_bit_to_n32(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int /*bitsPerPixel*/, const SkPMColor* /*ctable*/) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
SkPMColor* SK_RESTRICT dst = (SkPMColor*) dstRow;
// Determine how many full bytes are in the row
int bytesInRow = width >> 3;
int i;
for (i = 0; i < bytesInRow; i++) {
U8CPU currByte = src[i];
for (int j = 0; j < 8; j++) {
dst[j] = ((currByte >> (7 - j)) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
}
dst += 8;
// increment src by byte offset and bitIndex by bit offset
src += offset / 8;
int bitIndex = offset % 8;
uint8_t currByte = *src;
for (int x = 0; x < dstWidth; x++) {
dst[x] = ((currByte >> (7 - bitIndex)) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
int bitOffset = bitIndex + deltaSrc;
bitIndex = bitOffset % 8;
currByte = *(src += bitOffset / 8);
}
// Finish the remaining bits
width &= 7;
if (width > 0) {
U8CPU currByte = src[i];
for (int j = 0; j < width; j++) {
dst[j] = ((currByte >> 7) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
currByte <<= 1;
}
}
return SkSwizzler::kOpaque_ResultAlpha;
}
// kIndex1, kIndex2, kIndex4
static SkSwizzler::ResultAlpha swizzle_small_index_to_index(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bitsPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bitsPerPixel, int offset, const SkPMColor ctable[]) {
src += offset;
uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
INIT_RESULT_ALPHA;
const uint32_t pixelsPerByte = 8 / bitsPerPixel;
const size_t rowBytes = compute_row_bytes_ppb(width, pixelsPerByte);
const size_t rowBytes = compute_row_bytes_ppb(dstWidth, 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++) {
for (uint32_t p = 0; p < pixelsPerByte && x < dstWidth; p++) {
uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
UPDATE_RESULT_ALPHA(ctable[index] >> SK_A32_SHIFT);
dst[x] = index;
@ -138,18 +132,19 @@ static SkSwizzler::ResultAlpha swizzle_small_index_to_index(
}
static SkSwizzler::ResultAlpha swizzle_small_index_to_n32(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bitsPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bitsPerPixel, int offset, const SkPMColor ctable[]) {
src += offset;
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 size_t rowBytes = compute_row_bytes_ppb(dstWidth, 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++) {
for (uint32_t p = 0; p < pixelsPerByte && x < dstWidth; p++) {
uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
SkPMColor c = ctable[index];
UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
@ -164,58 +159,75 @@ static SkSwizzler::ResultAlpha swizzle_small_index_to_n32(
// kIndex
static SkSwizzler::ResultAlpha swizzle_index_to_index(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
memcpy(dst, src, width);
INIT_RESULT_ALPHA;
// TODO (msarett): Should we skip the loop here and guess that the row is opaque/not opaque?
// SkScaledBitmap sampler just guesses that it is opaque. This is dangerous
// and probably wrong since gif and bmp (rarely) may have alpha.
INIT_RESULT_ALPHA;
for (int x = 0; x < width; x++) {
UPDATE_RESULT_ALPHA(ctable[src[x]] >> SK_A32_SHIFT);
}
return COMPUTE_RESULT_ALPHA;
}
static SkSwizzler::ResultAlpha swizzle_index_to_n32(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
INIT_RESULT_ALPHA;
for (int x = 0; x < width; x++) {
SkPMColor c = ctable[src[x]];
UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
dst[x] = c;
}
return COMPUTE_RESULT_ALPHA;
}
static SkSwizzler::ResultAlpha swizzle_index_to_n32_skipZ(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
INIT_RESULT_ALPHA;
for (int x = 0; x < width; x++) {
SkPMColor c = ctable[src[x]];
UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
if (c != 0) {
dst[x] = c;
if (1 == deltaSrc) {
// A non-zero offset is only used when sampling, meaning that deltaSrc will be
// greater than 1. The below loop relies on the fact that src remains unchanged.
SkASSERT(0 == offset);
memcpy(dst, src, dstWidth);
for (int x = 0; x < dstWidth; x++) {
UPDATE_RESULT_ALPHA(ctable[src[x]] >> SK_A32_SHIFT);
}
} else {
for (int x = 0; x < dstWidth; x++) {
dst[x] = *src;
UPDATE_RESULT_ALPHA(ctable[*src] >> SK_A32_SHIFT);
src += deltaSrc;
}
}
return COMPUTE_RESULT_ALPHA;
}
static SkSwizzler::ResultAlpha swizzle_index_to_n32(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
INIT_RESULT_ALPHA;
for (int x = 0; x < dstWidth; x++) {
SkPMColor c = ctable[*src];
UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
dst[x] = c;
src += deltaSrc;
}
return COMPUTE_RESULT_ALPHA;
}
static SkSwizzler::ResultAlpha swizzle_index_to_n32_skipZ(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
INIT_RESULT_ALPHA;
for (int x = 0; x < dstWidth; x++) {
SkPMColor c = ctable[*src];
UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
if (c != 0) {
dst[x] = c;
}
src += deltaSrc;
}
return COMPUTE_RESULT_ALPHA;
}
static SkSwizzler::ResultAlpha swizzle_index_to_565(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bytesPerPixel, int offset, const SkPMColor ctable[]) {
// FIXME: Support dithering? Requires knowing y, which I think is a bigger
// change.
src += offset;
uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
dst[x] = SkPixel32ToPixel16(ctable[*src]);
src += bytesPerPixel;
}
@ -228,29 +240,42 @@ static SkSwizzler::ResultAlpha swizzle_index_to_565(
// kGray
static SkSwizzler::ResultAlpha swizzle_gray_to_n32(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
for (int x = 0; x < width; x++) {
dst[x] = SkPackARGB32NoCheck(0xFF, src[x], src[x], src[x]);
for (int x = 0; x < dstWidth; x++) {
dst[x] = SkPackARGB32NoCheck(0xFF, *src, *src, *src);
src += deltaSrc;
}
return SkSwizzler::kOpaque_ResultAlpha;
}
static SkSwizzler::ResultAlpha swizzle_gray_to_gray(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
memcpy(dstRow, src, width);
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
if (1 == deltaSrc) {
memcpy(dstRow, src, dstWidth);
} else {
for (int x = 0; x < dstWidth; x++) {
dst[x] = src[0];
src += deltaSrc;
}
}
return SkSwizzler::kOpaque_ResultAlpha;
}
static SkSwizzler::ResultAlpha swizzle_gray_to_565(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bytesPerPixel, int offset, const SkPMColor ctable[]) {
// FIXME: Support dithering?
src += offset;
uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
dst[x] = SkPack888ToRGB16(src[0], src[0], src[0]);
src += bytesPerPixel;
}
@ -260,13 +285,14 @@ static SkSwizzler::ResultAlpha swizzle_gray_to_565(
// kBGRX
static SkSwizzler::ResultAlpha swizzle_bgrx_to_n32(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
dst[x] = SkPackARGB32NoCheck(0xFF, src[2], src[1], src[0]);
src += bytesPerPixel;
src += deltaSrc;
}
return SkSwizzler::kOpaque_ResultAlpha;
}
@ -274,54 +300,58 @@ static SkSwizzler::ResultAlpha swizzle_bgrx_to_n32(
// kBGRA
static SkSwizzler::ResultAlpha swizzle_bgra_to_n32_unpremul(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
INIT_RESULT_ALPHA;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
uint8_t alpha = src[3];
UPDATE_RESULT_ALPHA(alpha);
dst[x] = SkPackARGB32NoCheck(alpha, src[2], src[1], src[0]);
src += bytesPerPixel;
src += deltaSrc;
}
return COMPUTE_RESULT_ALPHA;
}
static SkSwizzler::ResultAlpha swizzle_bgra_to_n32_premul(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
INIT_RESULT_ALPHA;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
uint8_t alpha = src[3];
UPDATE_RESULT_ALPHA(alpha);
dst[x] = SkPreMultiplyARGB(alpha, src[2], src[1], src[0]);
src += bytesPerPixel;
src += deltaSrc;
}
return COMPUTE_RESULT_ALPHA;
}
// kRGBX
static SkSwizzler::ResultAlpha swizzle_rgbx_to_n32(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]);
src += bytesPerPixel;
src += deltaSrc;
}
return SkSwizzler::kOpaque_ResultAlpha;
}
static SkSwizzler::ResultAlpha swizzle_rgbx_to_565(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int bytesPerPixel, int offset, const SkPMColor ctable[]) {
// FIXME: Support dithering?
src += offset;
uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
dst[x] = SkPack888ToRGB16(src[0], src[1], src[2]);
src += bytesPerPixel;
}
@ -331,48 +361,51 @@ static SkSwizzler::ResultAlpha swizzle_rgbx_to_565(
// kRGBA
static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
INIT_RESULT_ALPHA;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
unsigned alpha = src[3];
UPDATE_RESULT_ALPHA(alpha);
dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
src += bytesPerPixel;
src += deltaSrc;
}
return COMPUTE_RESULT_ALPHA;
}
static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_unpremul(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
INIT_RESULT_ALPHA;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
unsigned alpha = src[3];
UPDATE_RESULT_ALPHA(alpha);
dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
src += bytesPerPixel;
src += deltaSrc;
}
return COMPUTE_RESULT_ALPHA;
}
static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul_skipZ(
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
int bytesPerPixel, const SkPMColor ctable[]) {
void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
int deltaSrc, int offset, const SkPMColor ctable[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
INIT_RESULT_ALPHA;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; 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;
}
return COMPUTE_RESULT_ALPHA;
}
@ -385,11 +418,12 @@ 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 dstWidth, int bitsPerPixel, int offset,
const SkPMColor[]) {
src += offset;
SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
unsigned alphaMask = 0xFF;
for (int x = 0; x < width; x++) {
for (int x = 0; x < dstWidth; x++) {
unsigned alpha = src[3];
// NOTE: We cheat here. The caller requested unpremul and skip zeroes. It's possible
// the color components are not zero, but we skip them anyway, meaning they'll remain
@ -406,9 +440,10 @@ static bool swizzle_rgba_to_n32_unpremul_skipZ(void* SK_RESTRICT dstRow,
SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
const SkPMColor* ctable,
const SkImageInfo& info,
SkCodec::ZeroInitialized zeroInit) {
if (info.colorType() == kUnknown_SkColorType || kUnknown == sc) {
const SkImageInfo& dstInfo,
SkCodec::ZeroInitialized zeroInit,
const SkImageInfo& srcInfo) {
if (dstInfo.colorType() == kUnknown_SkColorType || kUnknown == sc) {
return NULL;
}
if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
@ -416,9 +451,10 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
return NULL;
}
RowProc proc = NULL;
switch (sc) {
case kBit:
switch (info.colorType()) {
switch (dstInfo.colorType()) {
case kN32_SkColorType:
proc = &swizzle_bit_to_n32;
break;
@ -435,7 +471,7 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
case kIndex1:
case kIndex2:
case kIndex4:
switch (info.colorType()) {
switch (dstInfo.colorType()) {
case kN32_SkColorType:
proc = &swizzle_small_index_to_n32;
break;
@ -447,7 +483,7 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
}
break;
case kIndex:
switch (info.colorType()) {
switch (dstInfo.colorType()) {
case kN32_SkColorType:
// We assume the color premultiplied ctable (or not) as desired.
if (SkCodec::kYes_ZeroInitialized == zeroInit) {
@ -469,7 +505,7 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
}
break;
case kGray:
switch (info.colorType()) {
switch (dstInfo.colorType()) {
case kN32_SkColorType:
proc = &swizzle_gray_to_n32;
break;
@ -485,7 +521,7 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
break;
case kBGR:
case kBGRX:
switch (info.colorType()) {
switch (dstInfo.colorType()) {
case kN32_SkColorType:
proc = &swizzle_bgrx_to_n32;
break;
@ -494,9 +530,9 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
}
break;
case kBGRA:
switch (info.colorType()) {
switch (dstInfo.colorType()) {
case kN32_SkColorType:
switch (info.alphaType()) {
switch (dstInfo.alphaType()) {
case kUnpremul_SkAlphaType:
proc = &swizzle_bgra_to_n32_unpremul;
break;
@ -513,7 +549,7 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
break;
case kRGBX:
// TODO: Support other swizzles.
switch (info.colorType()) {
switch (dstInfo.colorType()) {
case kN32_SkColorType:
proc = &swizzle_rgbx_to_n32;
break;
@ -524,9 +560,9 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
}
break;
case kRGBA:
switch (info.colorType()) {
switch (dstInfo.colorType()) {
case kN32_SkColorType:
if (info.alphaType() == kUnpremul_SkAlphaType) {
if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
// Respect zeroInit?
proc = &swizzle_rgba_to_n32_unpremul;
} else {
@ -542,7 +578,7 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
}
break;
case kRGB:
switch (info.colorType()) {
switch (dstInfo.colorType()) {
case kN32_SkColorType:
proc = &swizzle_rgbx_to_n32;
break;
@ -550,6 +586,14 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
break;
}
break;
case kRGB_565:
switch (dstInfo.colorType()) {
case kRGB_565_SkColorType:
proc = &sample565;
break;
default:
break;
}
default:
break;
}
@ -558,22 +602,31 @@ SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
}
// 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));
int deltaSrc = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) : BitsPerPixel(sc);
// get sampleX based on srcInfo and dstInfo dimensions
int sampleX;
SkScaledCodec::ComputeSampleSize(dstInfo, srcInfo, &sampleX, NULL);
return SkNEW_ARGS(SkSwizzler, (proc, ctable, deltaSrc, dstInfo, sampleX));
}
SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable,
int deltaSrc, const SkImageInfo& info)
int deltaSrc, const SkImageInfo& info, int sampleX)
: fRowProc(proc)
, fColorTable(ctable)
, fDeltaSrc(deltaSrc)
, fDstInfo(info)
{}
, fSampleX(sampleX)
, fX0(sampleX == 1 ? 0 : sampleX >> 1)
{
// check that fX0 is less than original width
SkASSERT(fX0 >= 0 && fX0 < fDstInfo.width() * fSampleX);
}
SkSwizzler::ResultAlpha SkSwizzler::swizzle(void* dst, const uint8_t* SK_RESTRICT src) {
SkASSERT(NULL != dst && NULL != src);
return fRowProc(dst, src, fDstInfo.width(), fDeltaSrc, fColorTable);
return fRowProc(dst, src, fDstInfo.width(), fSampleX * fDeltaSrc, fX0 * fDeltaSrc, fColorTable);
}
void SkSwizzler::Fill(void* dstStartRow, const SkImageInfo& dstInfo, size_t dstRowBytes,

27
src/codec/SkSwizzler.h
View File

@ -117,16 +117,22 @@ public:
/**
* Create a new SkSwizzler.
* @param SrcConfig Description of the format of the source.
* @param SkImageInfo dimensions() describe both the src and the dst.
* Other fields describe the dst.
* @param dstInfo describes the destination.
* @param ZeroInitialized Whether dst is zero-initialized. The
implementation may choose to skip writing zeroes
* if set to kYes_ZeroInitialized.
* @param srcInfo is the info of the source. Used to calculate the width samplesize.
* Width sampling is supported by the swizzler, by skipping pixels when
swizzling the row. Height sampling is not supported by the swizzler,
but is implemented in SkScaledCodec.
Sampling in Y can be done by a client with a scanline decoder,
but sampling in X allows the swizzler to skip swizzling pixels and
reading from and writing to memory.
* @return A new SkSwizzler or NULL on failure.
*/
static SkSwizzler* CreateSwizzler(SrcConfig, const SkPMColor* ctable,
const SkImageInfo&, SkCodec::ZeroInitialized);
const SkImageInfo& dstInfo, SkCodec::ZeroInitialized,
const SkImageInfo& srcInfo);
/**
* Fill the remainder of the destination with a single color
*
@ -181,14 +187,16 @@ private:
* 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 dstWidth Width in pixels of the destination
* @param deltaSrc if bitsPerPixel % 8 == 0, deltaSrc is bytesPerPixel
* else, deltaSrc is bitsPerPixel
* @param ctable Colors (used for kIndex source).
* @param offset The offset before the first pixel to sample.
Is in bytes or bits based on what deltaSrc is in.
*/
typedef ResultAlpha (*RowProc)(void* SK_RESTRICT dstRow,
const uint8_t* SK_RESTRICT src,
int width, int deltaSrc,
int dstWidth, int deltaSrc, int offset,
const SkPMColor ctable[]);
const RowProc fRowProc;
@ -199,9 +207,10 @@ private:
// deltaSrc is bitsPerPixel
const SkImageInfo fDstInfo;
int fCurrY;
const int fX0; // first X coord to sample
const int fSampleX; // step between X samples
SkSwizzler(RowProc proc, const SkPMColor* ctable, int deltaSrc,
const SkImageInfo& info);
SkSwizzler(RowProc proc, const SkPMColor* ctable, int deltaSrc, const SkImageInfo& info,
int sampleX);
};
#endif // SkSwizzler_DEFINED