Add scaled subset API 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 "SkCodecPriv.h"
 #include "SkWebpCodec.h"
 #include "SkTemplates.h"
@@ skipping 102 matching lines @@
     dim.fHeight = SkTMax(1, SkScalarRoundToInt(desiredScale * dim.fHeight));
     return dim;
 }
 
 bool SkWebpCodec::onDimensionsSupported(const SkISize& dim) {
     const SkImageInfo& info = this->getInfo();
     return dim.width() >= 1 && dim.width() <= info.width()
             && dim.height() >= 1 && dim.height() <= info.height();
 }
 
+bool SkWebpCodec::onSubsetSupported(const SkIRect& subset, bool isScanlineDecode) {
+    return !((subset.left() & 1) || (subset.top() & 1));

[scroggo, 2015/10/12 20:47:07]

Could you add a comment explaining this? (Left and top must be even.)

I suppose we don't need to worry about containment, because that was checked in
in subsetSupported?

+}
+
+bool SkWebpCodec::onScaledSubsetSupported(const Options& options, bool isScanlineDecode) {
+    return this->onSubsetSupported(*options.fSubset, isScanlineDecode);
+}
 
 static WEBP_CSP_MODE webp_decode_mode(SkColorType ct, bool premultiply) {
     switch (ct) {
         case kBGRA_8888_SkColorType:
             return premultiply ? MODE_bgrA : MODE_BGRA;
         case kRGBA_8888_SkColorType:
             return premultiply ? MODE_rgbA : MODE_RGBA;
         case kRGB_565_SkColorType:
             return MODE_RGB_565;
         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;
-    }
+bool SkWebpCodec::onGetScaledSubsetDimensions(float desiredScale, const Options& options) const {
+    options.fSubset->fLeft = (options.fSubset->fLeft >> 1) << 1;
+    options.fSubset->fTop = (options.fSubset->fTop >> 1) << 1;
 
-    SkIRect dimensions  = SkIRect::MakeSize(this->getInfo().dimensions());
-    if (!dimensions.contains(*desiredSubset)) {
-        return false;
-    }
+    // Notice that we may round the size of the subset up to 1.  This means that we must
+    // round up the scaled output dimensions to avoid suggesting a subset that is off the
+    // edge of the image.  This rounding behvaior is consistent with SkJpegCodec.
+    *(options.fScaledDimensions) = SkISize::Make(
+            sk_float_ceil2int(desiredScale * this->getInfo().width()),
+            sk_float_ceil2int(desiredScale * this->getInfo().height()));
 
-    // 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;
+    // 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;
     }
 
@@ skipping 19 matching lines @@
 
         // 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

[msarett, 2015/10/12 18:33:29]

I tried to keep a debug check here, but it is too tricky now that we use
getScaledSubsetDimensions() instead of getValidSubset().

We would need to somehow calculate the float scale that we are using in order to
call the getScaledSubsetDimensions() API.

-        {
-            // 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.
@@ skipping 30 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) {}