Add subsetting to SkScaledCodec

src/codec/SkWebpCodec.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 "SkWebpCodec.h"
 #include "SkTemplates.h"
@@ skipping 122 matching lines @@
             return MODE_LAST;
     }
 }
 
 // The WebP decoding API allows us to incrementally pass chunks of bytes as we receive them to the
 // decoder with WebPIAppend. In order to do so, we need to read chunks from the SkStream. This size
 // is arbitrary.
 static const size_t BUFFER_SIZE = 4096;
 
 bool SkWebpCodec::onGetValidSubset(SkIRect* desiredSubset) const {
-    if (!desiredSubset) {
-        return false;
-    }
-
-    SkIRect bounds = SkIRect::MakeSize(this->getInfo().dimensions());
-    if (!desiredSubset->intersect(bounds)) {
-        return false;
-    }
-
     // As stated below, libwebp snaps to even left and top. Make sure top and left are even, so we
     // decode this exact subset.
     // Leave right and bottom unmodified, so we suggest a slightly larger subset than requested.
     desiredSubset->fLeft = (desiredSubset->fLeft >> 1) << 1;
     desiredSubset->fTop = (desiredSubset->fTop >> 1) << 1;
     return true;
 }
 
+bool SkWebpCodec::onGetScaledSubsetDimensions(float desiredScale, Options* options) const {
+    if (!this->onGetValidSubset(options->fSubset)) {
+        return false;
+    }
+    options->fScaledDimensions = SkISize::Make(
+            SkTMax(1, SkScalarRoundToInt(desiredScale * this->getInfo().width())),
+            SkTMax(1, SkScalarRoundToInt(desiredScale * this->getInfo().height())));
+    // Notice that we may round the size of the subset up to 1.  This means that we must
+    // floor the left and top offsets to ensure that we do not suggest a subset that is
+    // off the edge of the image.
+    options->fScaledSubset = SkIRect::MakeXYWH(
+            int (desiredScale * options->fSubset->left()),
+            int (desiredScale * options->fSubset->top()),
+            SkTMax(1, SkScalarRoundToInt(desiredScale * options->fSubset->width())),
+            SkTMax(1, SkScalarRoundToInt(desiredScale * options->fSubset->height())));
+
+    return true;
+}
+
 SkCodec::Result SkWebpCodec::onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t rowBytes,
                                          const Options& options, SkPMColor*, int*,
                                          int* rowsDecoded) {
     if (!webp_conversion_possible(dstInfo, this->getInfo())) {
         return kInvalidConversion;
     }
 
     WebPDecoderConfig config;
     if (0 == WebPInitDecoderConfig(&config)) {
         // ABI mismatch.
@@ skipping 45 matching lines @@
         // Caller is requesting scaling.
         config.options.use_scaling = 1;
         config.options.scaled_width = dstDimensions.width();
         config.options.scaled_height = dstDimensions.height();
     }
 
     config.output.colorspace = webp_decode_mode(dstInfo.colorType(),
             dstInfo.alphaType() == kPremul_SkAlphaType);
     config.output.u.RGBA.rgba = (uint8_t*) dst;
     config.output.u.RGBA.stride = (int) rowBytes;
-    config.output.u.RGBA.size = dstInfo.getSafeSize(rowBytes);
+    // TODO: We can use dstInfo.getSafeSize(rowBytes) here because
+    //       https://code.google.com/p/webp/issues/detail?id=258 has
+    //       been resolved, but it will require an update to libwebp.
+    config.output.u.RGBA.size = rowBytes * dstInfo.height();
     config.output.is_external_memory = 1;
 
     SkAutoTCallVProc<WebPIDecoder, WebPIDelete> idec(WebPIDecode(nullptr, 0, &config));
     if (!idec) {
         return kInvalidInput;
     }
 
     SkAutoMalloc storage(BUFFER_SIZE);
     uint8_t* buffer = static_cast<uint8_t*>(storage.get());
     while (true) {
@@ skipping 10 matching lines @@
                 // Break out of the switch statement. Continue the loop.
                 break;
             default:
                 return kInvalidInput;
         }
     }
 }
 
 SkWebpCodec::SkWebpCodec(const SkImageInfo& info, SkStream* stream)
     : INHERITED(info, stream) {}