Index: src/codec/SkScaledCodec.cpp |
diff --git a/src/codec/SkScaledCodec.cpp b/src/codec/SkScaledCodec.cpp |
deleted file mode 100644 |
index e0158b6b4ef005d035ac6ef54576debdb28b7b98..0000000000000000000000000000000000000000 |
--- a/src/codec/SkScaledCodec.cpp |
+++ /dev/null |
@@ -1,261 +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 "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; |
-} |