SkScaledCodec class

src/codec/SkScaledCodec.cpp

+/*
+ * 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) {
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream));
+    if (NULL == codec) {
+        return NULL;
+    }
+    if (codec->getEncodedFormat() == SkEncodedFormat::kWEBP_SkEncodedFormat) {
+        // Webp codec supports scaling and subsetting natively
+        return codec.detach();  
+    }
+    // wrap in new SkScaledCodec
+    return SkNEW_ARGS(SkScaledCodec, (codec.detach()));
+}
+
+SkCodec* SkScaledCodec::NewFromData(SkData* data) {
+    if (!data) {
+        return NULL;
+    }
+    return NewFromStream(SkNEW_ARGS(SkMemoryStream, (data)));
+}
+
+SkScaledCodec::SkScaledCodec(SkCodec* codec)
+    : INHERITED(codec->getInfo(), NULL)
+    , fCodec(codec)
+{}
+
+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 = fCodec->getScaledDimensions(desiredScale);
+    // support scaling down by integer numbers. Ex: 1/2, 1/3, 1/4 ...
+    SkISize scaledCodecDimensions;
+    if (desiredScale > 0.5f) {
+        // sampleSize = 1
+        scaledCodecDimensions = fCodec->getInfo().dimensions();
+    }
+    // sampleSize determines the step size between samples
+    // Ex: sampleSize = 2, sample every second pixel in x and y directions
+    int sampleSize = 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 is possible
+static bool scaling_supported(const SkImageInfo&  dstInfo, const SkImageInfo& srcInfo){
+    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
+    int sampleSizeX = SkScaledCodec::GetSampleSize(srcWidth, dstWidth);
+    if (get_scaled_dimension(srcWidth, sampleSizeX) != dstWidth) {
+        return false;
+    }
+    // check that src height is scaled down by an integer value
+    int sampleSizeY = SkScaledCodec::GetSampleSize(srcHeight, dstHeight);
+    if (get_scaled_dimension(srcHeight, sampleSizeY) != 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 (sampleSizeX != sampleSizeY){
+        if (1 != dstWidth && 1 != dstHeight) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// 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) {
+
+    // try to do a fCodec native decode, as some types of code support scaling and subsetting
+    Result result = fCodec->getPixels(requestedInfo, dst, rowBytes, &options, ctable, ctableCount);
+    if (kInvalidScale != result) {
+        // no scaling requested
+        return result;
+    }
+    // scaling requested
+    if (!scaling_supported(requestedInfo, fCodec->getInfo())) {
+        return kInvalidScale;
+    }
+
+    int dstHeight = requestedInfo.height();
+    int srcHeight = fCodec->getInfo().height();
+
+    // set sample values in x and y directions
+    int sampleY = GetSampleSize(srcHeight, dstHeight);
+    int Y0 = sampleY >> 1;
+    
+    SkImageInfo info = requestedInfo;
+    // attempt to partially natively scale
+    int newSampleSize = fCodec->partiallyNativelyScale(1 / (float)sampleY);
+    if (newSampleSize != -1) {
+        // partial scale supported
+        sampleY = newSampleSize;
+        Y0 = sampleY >> 1;
+        // update info for partial native scaling
+        info = info.makeWH(requestedInfo.width(), requestedInfo.height());
+    } else {
+        // use original height as scanlineDecoder does not support y sampling natively
+        info = info.makeWH(requestedInfo.width(), srcHeight);
+    }
+
+    SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(fCodec->getScanlineDecoder(info, 
+                                                     &options, ctable, ctableCount));
+
+    if (NULL == scanlineDecoder) {
+        SkCodecPrintf("failed to create scanline decoder.\n");
+        return kInvalidInput;
+    }
+    
+    const bool requiresPostYSampling = scanlineDecoder->requiresPostYSampling();
+
+    if (requiresPostYSampling) {
+        SkAutoMalloc storage(srcHeight * rowBytes);
+        void* storagePtr = storage.get();
+        result = scanlineDecoder->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 += rowBytes;
+        }
+    } else {
+        // does not require post y sampling
+        scanlineDecoder->skipScanlines(Y0);

[scroggo, 2015/08/04 20:05:21]

Can't this return a result other than success? I think this should return if we
could not skip.

[emmaleer, 2015/08/05 14:47:51]

Acknowledged.

+        for (int y = 0; y < dstHeight; y++) {
+            result = scanlineDecoder->getScanlines(dst, 1, rowBytes);
+            if (kSuccess != result) {
+                return result;
+            }
+            if (y < dstHeight - 1) {
+                result = scanlineDecoder->skipScanlines(sampleY - 1);
+                if (kSuccess != result) {
+                    return result;
+                }
+            }
+            dst += rowBytes;
+        }
+    }
+    return kSuccess;
+}