Add the ability to decode a subset 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 337 matching lines @@
                         case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("Cannot skip scanlines for %s.", fPath.c_str());
                     }
                 }
             }
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
+        case kSubset_Mode: {
+            // Arbitrarily choose a divisor.
+            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);
+            SkCodec::Options opts;
+            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.
+                    decodeInfo = decodeInfo.makeWH(SkTMin(w, W - x), SkTMin(h, H - y));
+                    opts.fSubset.setXYWH(x, y, decodeInfo.width(), decodeInfo.height());
+                    // And scale
+                    decodeInfo = decodeInfo.makeWH(decodeInfo.width() * fScale,

[emmaleer, 2015/07/17 22:31:05]

You could only call decodeInfo.makeWH() once instead of twice.
You would have to create variables for SkTMin(w, W - x) and SkTMin(h, H-y).
decodeInfo.makeWH() creates a new SkImageInfo object and returns it.
I'm not sure how expensive doing that is, but it might be worth changing. 

[scroggo, 2015/07/20 14:25:42]

SkImageInfo::makeWH() is likely pretty cheap (function call, constructor, copy
constructor, without doing any extra calculations), but you're right, it's not
free, and it's actually not even necessary - I'm essentially using it to store
temporary variables.

My excuse for doing it the way I did it was to cut down on variables. That said,
I don't think I've made anything clearer by doing it this way.

Fixed.

+                                                   decodeInfo.height() * fScale);
+                    size_t rowBytes = decodeInfo.minRowBytes();
+                    if (!subsetBm.installPixels(decodeInfo, pixels, rowBytes, colorTable.get(),
+                                                NULL, NULL)) {
+                        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:
+                            break;

[emmaleer, 2015/07/17 22:31:05]

What about the case SkCodec::kIncompleteInput.
All of the other tests treat kIncompleteInput as a success.
Maybe add in kIncompleteInput as a success, or add a comment saying why
kIncompleteInput is a failure in this test, but not the other tests.

[scroggo, 2015/07/20 14:25:42]

I think this goes back to my general concern about kIncompleteInput - where do
we cross the line between a failed decode and an incomplete image? If only a
couple of lines failed to decode, I think it's probably useful to see the
output, but if only one or two *did* decode, it may not be.

I also had a concern about seeing kIncompleteInput on the first subset, and
never getting a chance to attempt any more. That would still be incomplete,
though, so there's probably no good reason to draw the line there. More
importantly, the other cases consider kIncompleteInput a success, so we should
here as well.

Done.

+                        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, left, 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(SkCodec::NewFromData(encoded));
     if (NULL != codec) {
         SkISize size = codec->getScaledDimensions(fScale);
         return size;
@@ skipping 621 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM