SkScaledCodec class

src/codec/SkScaledCodec.cpp

Index: src/codec/SkScaledCodec.cpp
diff --git a/src/codec/SkScaledCodec.cpp b/src/codec/SkScaledCodec.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fe35b7e88f39f7948f0bfc80d4488c15531eaaa3
--- /dev/null
+++ b/src/codec/SkScaledCodec.cpp
@@ -0,0 +1,208 @@
+/*
+ * 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() {}
+
+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 = getScaledDimension(this->getInfo().width(), sampleSize);
+    int scaledHeight = getScaledDimension(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 SkScaledCodec::SampleSize& sampleSize,

[scroggo, 2015/08/13 16:10:45]

It seems a little odd to me that you pass a SampleSize to this method, which
could have instead computed the SampleSize inside.

It also seems weird that SampleSize would ever be created with invalid values.
Should this function be combined with the SampleSize constructor (/the function
that I suggested you turn it into)?

[emmaleer, 2015/08/13 17:49:11]

This function is still necessary, as when we call ComputeSampleSize in the
swizzler, we do not want to do call the scaling_supported function, as we pass
the srcHeight to the swizzler (as swizzler does not do any height sampling)
So, we need to have scaling_supported as it's own function.
I also thought we could combine them, and after I combined them I remembered why
it wouldn't work.

Do you think it's better to calculate sampleSize again inside scaling_supported?
I pass sampleSize to scaling_supported because I thought it would be a waste of
time to calculate it again, when we just previously calculated it.

[scroggo, 2015/08/13 18:01:21]

What if you did the following:

static bool scaling_supported(dstInfo, srcInfo, int* sampleX, int* sampleY) {
  SkScaledCodec::ComputeSampleSize(dstInfo, srcInfo, sampleX, sampleY);
  // rest of the function
}

Then you still only compute sampleSize once.

I prefer that a little bit, because it seems weird to pass sampleX and sampleY
to scaling_supported, when it could have been computed from the other
parameters.

+                               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
+     if (SkScaledCodec::getScaledDimension(srcWidth, sampleSize.sampleX) != dstWidth) {
+         return false;
+     }
+     // check that src height is scaled down by an integer value
+     if (SkScaledCodec::getScaledDimension(srcHeight, sampleSize.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 (sampleSize.sampleX != sampleSize.sampleY){
+         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) {
+
+    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
+    SampleSize sampleSize(fScanlineDecoder->getInfo(), requestedInfo);
+    if (!scaling_supported(sampleSize, requestedInfo, fScanlineDecoder->getInfo())) {
+        return kInvalidScale;
+    }
+
+    int dstHeight = requestedInfo.height();
+    int srcHeight = fScanlineDecoder->getInfo().height();
+
+    // set sample values in y direction
+    int sampleY = sampleSize.sampleY;
+    int Y0 = sampleY >> 1;
+    
+    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;
+}