Provides multiple implementations of Android's SkBitmapRegionDecoder

src/utils/SkBitmapRegionCanvas.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 "SkBitmapRegionCanvas.h"
+#include "SkCanvas.h"
+#include "SkScanlineDecoder.h"
+
+SkBitmapRegionCanvas::SkBitmapRegionCanvas(SkScanlineDecoder* decoder)
+    : INHERITED(decoder->getInfo().width(), decoder->getInfo().height())
+    , fDecoder(decoder)
+{}
+
+/*
+ * This has several key differences from the Android version:
+ *     Returns a Skia bitmap instead of an Android bitmap.
+ *     Android version attempts to reuse a recycled bitmap.
+ */
+SkBitmap* SkBitmapRegionCanvas::decodeRegion(int input_x, int input_y,
+                                             int input_w, int input_h,
+                                             int sampleSize,
+                                             SkColorType dstColorType) {
+    // Reject color types not supported by this method
+    if (kIndex_8_SkColorType == dstColorType || kGray_8_SkColorType == dstColorType) {
+        SkDebugf("Error: Color type not supported.\n");
+        return NULL;
+    }
+
+    // Correct the output region if necessary
+    int left = SkTMax(0, input_x);
+    int leftOffset = left - input_x;
+    int top = SkTMax(0, input_y);
+    int topOffset = top - input_y;
+    int width = SkTMin(this->width() - left, input_w - leftOffset);
+    int height = SkTMin(this->height() - top, input_h - topOffset);
+    if (width <= 0 || height <= 0) {
+        SkDebugf("Error: Region must intersect part of the image.\n");
+        return NULL;
+    }
+
+    // Create the image info the decode
+    SkAlphaType dstAlphaType = fDecoder->getInfo().alphaType();
+    if (kUnpremul_SkAlphaType == dstAlphaType) {
+        dstAlphaType = kPremul_SkAlphaType;
+    }
+    SkImageInfo decodeInfo = SkImageInfo::Make(this->width(), this->height(),
+            dstColorType, dstAlphaType);
+    
+    // Start the scanline decoder
+    SkCodec::Result r = fDecoder->start(decodeInfo);
+    if (SkCodec::kSuccess != r) {
+        SkDebugf("Error: Could not start scanline decoder.\n");
+        return NULL;
+    }
+
+    // Allocate a bitmap for the unscaled decode
+    SkBitmap tmp;
+    SkImageInfo tmpInfo = decodeInfo.makeWH(this->width(), height);
+    if (!tmp.tryAllocPixels(tmpInfo)) {
+        SkDebugf("Error: Could not allocate pixels.\n");
+        return NULL;
+    }
+
+    // Skip the unneeded rows
+    SkCodec::Result result =
+            fDecoder->skipScanlines(top);

[scroggo, 2015/08/28 13:49:43]

nit: could fit on one line?

[msarett, 2015/08/28 18:45:50]

Done.

+    switch (result) {
+        case SkCodec::kSuccess:

[scroggo, 2015/08/28 13:49:44]

Perhaps this can be

if (fDecoder->skipScanlines(top) != kSuccess) {
  return NULL;
}

[msarett, 2015/08/28 18:45:50]

Done.

+            break;
+        default:
+            SkDebugf("Error: Failed to skip scanlines.\n");
+            return NULL;
+    }
+
+    // Decode the necessary rows
+    result = fDecoder->getScanlines(tmp.getAddr(0, 0), height,
+            tmp.rowBytes());
+    switch (result) {
+        case SkCodec::kSuccess:
+        case SkCodec::kIncompleteInput:
+            break;
+        default:
+            SkDebugf("Error: Failed to get scanlines.\n");
+            return NULL;
+    }
+
+    // Calculate the size of the output
+    int outWidth = SkTMax(1, input_w / sampleSize);
+    int outHeight = SkTMax(1, input_h / sampleSize);
+
+    // Initialize the destination bitmap
+    SkAutoTDelete<SkBitmap> bitmap(SkNEW(SkBitmap));
+    SkImageInfo dstInfo = decodeInfo.makeWH(outWidth, outHeight);
+    if (!bitmap->tryAllocPixels(dstInfo)) {
+        SkDebugf("Error: Could not allocate pixels.\n");
+        return NULL;
+    }
+
+    // Zero the bitmap if the region is not completely within the image.
+    // TODO (msarett): We could implement this to the only zero the parts of
+    //                 the bitmap that we won't overwrite with image data.
+    //                 However, it's not certain that this would be faster,
+    //                 it would be more complex (requires creating rects with
+    //                 bounds scaled by sampleSize), and performance probably
+    //                 isn't critical for clients who call this API with

[scroggo, 2015/08/28 13:49:44]

Why not? Don't clients actually use it in this way? Or will we convert the
clients to not use it that way?

[msarett, 2015/08/28 18:45:50]

Revising this comment.

+    //                 "invalid" values.
+    // TODO (msarett): This could be skipped if memory is zero initialized.
+    //                 This would matter if this code is moved to Android and
+    //                 uses Android bitmaps.
+    if (0 != leftOffset || 0 != topOffset ||
+            input_x + input_w > this->width() ||
+            input_y + input_h > this->height()) {
+        bitmap->eraseColor(0);

[scroggo, 2015/08/28 13:49:43]

Why zero? I thought you said we should draw black where the subset is outside
the original image?

[msarett, 2015/08/28 18:45:50]

Yeah I did say that.  I thought I saw a comment in SkImageDecoder about that. 
But I've since not been able to find that comment anywhere and running tests
shows that SkImageDecoder actually leaves the memory uninitialized.

This may not be a huge issue if the client is using a zero initialized bitmap.

I think for us, zero is the right choice (transparent for kN32, black for 565)
in case anybody was depending on zero init bitmaps.

In looking at use cases, I don't think I saw anybody intentionally reading
outside of the image, but I wouldn't rule it out.

I do think my comment is a bit harsh.  We should try to zero the bitmap
efficiently - I will word things more appropriately :).

+    }
+
+    // Use a canvas to crop and scale to the destination bitmap
+    SkAutoTDelete<SkCanvas> canvas(SkNEW_ARGS(SkCanvas, (*bitmap)));
+    SkRect src = SkRect::MakeXYWH(left, 0, width, height);
+    SkRect dst = SkRect::MakeXYWH(leftOffset / sampleSize, topOffset / sampleSize,
+            SkTMax(1, width / sampleSize), SkTMax(1, height / sampleSize));
+    SkPaint* paint = new SkPaint();
+    // Overwrite the dst with the src pixels
+    paint->setXfermodeMode(SkXfermode::kSrc_Mode);
+    // Set the scaling quality, kNone is the default

[scroggo, 2015/08/28 13:49:44]

// TODO: Use other qualities?

It seems like we can skip this if we just use the default.

[msarett, 2015/08/28 18:45:50]

Yep this is unnecessary.  I think I was just teaching myself how to change the
quality haha.

+    paint->setFilterQuality(SkFilterQuality::kNone_SkFilterQuality);
+    canvas->drawBitmapRect(tmp, src, dst, paint);
+
+    return bitmap.detach();
+}