Add the ability to decode a subset to SkCodec.

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 "SkWebpCodec.h"
 #include "SkTemplates.h"
 
@@ skipping 107 matching lines @@
         default:
             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;
+}
+
 SkCodec::Result SkWebpCodec::onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t rowBytes,
-                                         const Options&, SkPMColor*, int*) {
+                                         const Options& options, SkPMColor*, int*) {
     switch (this->rewindIfNeeded()) {
         case kCouldNotRewind_RewindState:
             return kCouldNotRewind;
         case kRewound_RewindState:
             // Rewound to the beginning. Since creation only does a peek, the stream is at the
             // correct position.
             break;
         case kNoRewindNecessary_RewindState:
             // Already at the right spot for decoding.
             break;
     }
 
     if (!conversion_possible(dstInfo, this->getInfo())) {
         return kInvalidConversion;
     }
 
     WebPDecoderConfig config;
     if (0 == WebPInitDecoderConfig(&config)) {
         // ABI mismatch.
         // FIXME: New enum for this?
         return kInvalidInput;
     }
 
     // Free any memory associated with the buffer. Must be called last, so we declare it first.
     SkAutoTCallVProc<WebPDecBuffer, WebPFreeDecBuffer> autoFree(&(config.output));
 
-    SkISize dimensions = dstInfo.dimensions();
-    if (this->getInfo().dimensions() != dimensions) {
+    SkIRect bounds = SkIRect::MakeSize(this->getInfo().dimensions());
+    if (options.fSubset) {
+        // Caller is requesting a subset.
+        if (!bounds.contains(*options.fSubset)) {
+            // The subset is out of bounds.
+            return kInvalidParameters;
+        }
+
+        bounds = *options.fSubset;
+
+        // This is tricky. libwebp snaps the top and left to even values. We could let libwebp
+        // do the snap, and return a subset which is a different one than requested. The problem
+        // with that approach is that the caller may try to stitch subsets together, and if we
+        // returned different subsets than requested, there would be artifacts at the boundaries.
+        // Instead, we report that we cannot support odd values for top and left..
+        if (!SkIsAlign2(bounds.fLeft) || !SkIsAlign2(bounds.fTop)) {
+            return kInvalidParameters;
+        }
+
+#ifdef SK_DEBUG
+        {
+            // Make a copy, since getValidSubset can change its input.
+            SkIRect subset(bounds);
+            // That said, getValidSubset should *not* change its input, in this case; otherwise
+            // getValidSubset does not match the actual subsets we can do.
+            SkASSERT(this->getValidSubset(&subset) && subset == bounds);
+        }
+#endif
+
+        config.options.use_cropping = 1;
+        config.options.crop_left = bounds.fLeft;
+        config.options.crop_top = bounds.fTop;
+        config.options.crop_width = bounds.width();
+        config.options.crop_height = bounds.height();
+    }
+
+    SkISize dstDimensions = dstInfo.dimensions();
+    if (bounds.size() != dstDimensions) {
         // Caller is requesting scaling.
         config.options.use_scaling = 1;
-        config.options.scaled_width = dimensions.width();
-        config.options.scaled_height = dimensions.height();
+        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);
     config.output.is_external_memory = 1;
 
     SkAutoTCallVProc<WebPIDecoder, WebPIDelete> idec(WebPIDecode(NULL, 0, &config));
@@ skipping 19 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) {}