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() {}
+
+/*
+ * Return a valid set of output dimensions for this decoder, given an input scale
+ */
+SkISize SkScaledCodec::onGetScaledDimensions(float desiredScale) const {
+    // support scaling down by integer numbers. Ex: 1/2, 1/3, 1/4 ...
+
+    if (desiredScale > 0.5f) {
+        // sampleSize = 1
+        return 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;
+
+    // if sampleSize > width or height, will only sample 1 pixel in that direction
+    int sampleX = SkMin32(sampleSize, this->getInfo().width());
+    int sampleY = SkMin32(sampleSize, this->getInfo().height());
+
+    // NOTE: we round down here for scaledWidth and scaledHeight
+    // Can be changed in the future to round up, or round to closest integer if we want

[scroggo, 2015/07/28 15:58:10]

FWIW, I think you would need to update your code that is used for sampling as
well. Ideally, we'd like it to behave the same way as the old code
(SkImageDecoder), so we can drop in replace.

[emmaleer, 2015/07/29 21:55:08]

Okay. Do you think I should remove the comment saying it can be changed in the
future if we want?
Since we want it to behave the same as SkImageDecoder, and SkImageDecoder rounds
down.

[scroggo, 2015/07/30 17:53:01]

I would probably keep it simple. Something like "We chose to round down because
it matches the behavior of SkImageDecoder".

[emmaleer, 2015/07/30 22:27:55]

Acknowledged.

+    int scaledWidth = this->getInfo().width() / sampleX;
+    int scaledHeight = this->getInfo().height() / sampleY;
+
+    // Return the calculated output dimensions for the given scale
+    return SkISize::Make(scaledWidth, scaledHeight);
+}
+
+// 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 = srcWidth / dstWidth;
+    if (srcWidth / sampleSizeX != dstWidth) {
+        return false;
+    }
+    // check that src height is scaled down by an integer value
+    int sampleSizeY = srcHeight / dstHeight;
+    if (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 = srcHeight / dstHeight;

[scroggo, 2015/07/28 15:58:10]

I think we need to consolidate our calculations (along with their assumptions),
to make sure they do not get out of sync.

[emmaleer, 2015/07/29 21:55:08]

Do you mean consolidate the calculations of sampleY here and in
scaling_supported()?

 

[emmaleer, 2015/07/30 17:50:39]

I've created a function called get_sample_size() which is used to calculate the
sampleSize.

Also, I've moved calculating sampleX into the createSwizzler function, and have
added a get_sample_size() function there too.
This way we will only have to change the function in one place.

[scroggo, 2015/07/30 17:53:01]

I'm not sure where all we have it, but we should just make sure that if we ever
decide to change how we compute the sampling parameters (for example, if we
decided we wanted to round up instead of down), we only need to change one
isolated part of the code.

+    int Y0 = sampleY >> 1;
+
+    Options scaledOptions = options;
+    scaledOptions.fSampleX = fCodec->getInfo().width() / requestedInfo.width();
+    
+    SkImageInfo info = requestedInfo;
+    // use original height as scanlineDecoder does not support y sampling natively
+    info = info.makeWH(requestedInfo.width(), srcHeight);
+
+    SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(fCodec->getScanlineDecoder(info, 
+                                                     &scaledOptions, ctable, ctableCount));
+    if (NULL == scanlineDecoder) {
+        SkCodecPrintf("failed to create scanline decoder.\n");
+        return kInvalidInput;
+    }
+    
+    bool isInterlaced = scanlineDecoder->isInterlaced();
+
+    if (isInterlaced) {
+        SkAutoMalloc storage(srcHeight * rowBytes);
+        void* storagePtr = storage.get();
+        result = scanlineDecoder->getScanlines(storagePtr, srcHeight, rowBytes);
+
+        storagePtr += Y0 * rowBytes;
+        for (int y = 0; y < dstHeight; y++) {
+            memcpy(dst, storagePtr, rowBytes);
+            storagePtr += sampleY * rowBytes;
+            dst += rowBytes;
+        }
+    } else {
+        // not interlaced
+        scanlineDecoder->skipScanlines(Y0);
+        for (int y = 0; y < dstHeight; y++) {
+            scanlineDecoder->getScanlines(dst, 1, rowBytes);
+            if (y < dstHeight - 1) {
+                scanlineDecoder->skipScanlines(sampleY - 1);
+            }
+            dst += rowBytes;
+        }
+    }
+    return kSuccess;
+}