Add scaled subset API to SkCodec

dm/DMSrcSink.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 "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCodec.h"
@@ skipping 231 matching lines @@
     return flags.type != SinkFlags::kRaster
         || flags.approach != SinkFlags::kDirect;
 }
 
 Error CodecSrc::draw(SkCanvas* canvas) const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     if (!encoded) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
     SkAutoTDelete<SkCodec> codec(NULL);
-    if (kScaledCodec_Mode == fMode) {
+    if (kScaledCodec_Mode == fMode || kSubset_Mode == fMode) {
         codec.reset(SkScaledCodec::NewFromData(encoded));
         // TODO (msarett): This should fall through to a fatal error once we support scaled
         //                 codecs for all image types.
         if (nullptr == codec.get()) {
             return Error::Nonfatal(SkStringPrintf("Couldn't create scaled codec for %s.",
                     fPath.c_str()));
         }
     } else {
         codec.reset(SkCodec::NewFromData(encoded));
     }
@@ skipping 242 matching lines @@
             int divisor = 2;
             // Total width/height of the image.
             const int W = codec->getInfo().width();
             const int H = codec->getInfo().height();
             if (divisor > W || divisor > H) {
                 return Error::Nonfatal(SkStringPrintf("Cannot codec subset: divisor %d is too big "
                                                       "for %s with dimensions (%d x %d)", divisor,
                                                       fPath.c_str(), W, H));
             }
             // subset dimensions
-            // SkWebpCodec, the only one that supports subsets, requires even top/left boundaries.
-            const int w = SkAlign2(W / divisor);
-            const int h = SkAlign2(H / divisor);
+            const int w = W / divisor;
+            const int h = H / divisor;
             SkIRect subset;
+            SkISize scaledSize;
+            SkIRect scaledSubset;
             SkCodec::Options opts;
             opts.fSubset = &subset;
+            opts.fScaledDimensions = &scaledSize;
+            opts.fScaledSubset = &scaledSubset;
             SkBitmap subsetBm;
             // We will reuse pixel memory from bitmap.
             void* pixels = bitmap.getPixels();
             // Keep track of left and top (for drawing subsetBm into canvas). We could use
             // fScale * x and fScale * y, but we want integers such that the next subset will start
             // where the last one ended. So we'll add decodeInfo.width() and height().
             int left = 0;
             for (int x = 0; x < W; x += w) {
                 int top = 0;
                 for (int y = 0; y < H; y+= h) {
                     // Do not make the subset go off the edge of the image.
                     const int preScaleW = SkTMin(w, W - x);
                     const int preScaleH = SkTMin(h, H - y);
                     subset.setXYWH(x, y, preScaleW, preScaleH);
                     // And scale
-                    // FIXME: Should we have a version of getScaledDimensions that takes a subset
-                    // into account?
-                    decodeInfo = decodeInfo.makeWH(
-                            SkTMax(1, SkScalarRoundToInt(preScaleW * fScale)),
-                            SkTMax(1, SkScalarRoundToInt(preScaleH * fScale)));
+                    if (!codec->getScaledSubsetDimensions(fScale, opts)) {
+                        return Error::Nonfatal("Subsetting not supported.\n");
+                    }
+                    decodeInfo = decodeInfo.makeWH(scaledSubset.width(), scaledSubset.height());
                     size_t rowBytes = decodeInfo.minRowBytes();
                     if (!subsetBm.installPixels(decodeInfo, pixels, rowBytes, colorTable.get(),
                                                 nullptr, nullptr)) {
                         return SkStringPrintf("could not install pixels for %s.", fPath.c_str());
                     }
                     const SkCodec::Result result = codec->getPixels(decodeInfo, pixels, rowBytes,
                             &opts, colorPtr, colorCountPtr);
                     switch (result) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         case SkCodec::kInvalidConversion:
                             if (0 == (x|y)) {
-                                // First subset is okay to return unimplemented.
+                                // First subset is okay to return invalid conversion.
                                 return Error::Nonfatal("Incompatible colortype conversion");
                             }
                             // If the first subset succeeded, a later one should not fail.
                             // fall through to failure
-                        case SkCodec::kUnimplemented:
-                            if (0 == (x|y)) {
-                                // First subset is okay to return unimplemented.
-                                return Error::Nonfatal("subset codec not supported");
-                            }
-                            // If the first subset succeeded, why would a later one fail?
-                            // fall through to failure
                         default:
                             return SkStringPrintf("subset codec failed to decode (%d, %d, %d, %d) "
                                                   "from %s with dimensions (%d x %d)\t error %d",
                                                   x, y, decodeInfo.width(), decodeInfo.height(),
                                                   fPath.c_str(), W, H, result);
                     }
                     canvas->drawBitmap(subsetBm, SkIntToScalar(left), SkIntToScalar(top));
                     // translate by the scaled height.
                     top += decodeInfo.height();
                 }
                 // translate by the scaled width.
                 left += decodeInfo.width();
             }
             return "";
         }
     }
     return "";
 }
 
 SkISize CodecSrc::size() const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     SkAutoTDelete<SkCodec> codec(nullptr);
 
-    if (kScaledCodec_Mode == fMode) {
+    if (kScaledCodec_Mode == fMode || kSubset_Mode == fMode) {
         codec.reset(SkScaledCodec::NewFromData(encoded));
     } else {
         codec.reset(SkCodec::NewFromData(encoded));
     }
 
     if (nullptr == codec) {
         return SkISize::Make(0, 0);
     }
     return codec->getScaledDimensions(fScale);
 }
@@ skipping 600 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM