Update Subset benches to support interlacing and fix bugs

bench/subset/SubsetZoomBench.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 "CodecBenchPriv.h"
 #include "SubsetZoomBench.h"
 #include "SubsetBenchPriv.h"
@@ skipping 44 matching lines @@
 
 void SubsetZoomBench::onDraw(int n, SkCanvas* canvas) {
     // When the color type is kIndex8, we will need to store the color table.  If it is
     // used, it will be initialized by the codec.
     int colorCount;
     SkPMColor colors[256];
     if (fUseCodec) {
         for (int count = 0; count < n; count++) {
             SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(fStream->duplicate()));
             const SkImageInfo info = codec->getInfo().makeColorType(fColorType);
-            SkAutoTDeleteArray<uint8_t> row(new uint8_t[info.minRowBytes()]);
-            codec->startScanlineDecode(info, nullptr, colors, &colorCount);
+            SkAutoTDeleteArray<uint8_t> row(nullptr);
+            if (codec->getScanlineOrder() == SkCodec::kTopDown_SkScanlineOrder) {
+                row.reset(new uint8_t[info.minRowBytes()]);
+            }
 
             const int centerX = info.width() / 2;
             const int centerY = info.height() / 2;
             int w = fSubsetWidth;
             int h = fSubsetHeight;
             do {
+                SkDEBUGCODE(SkCodec::Result result = )
+                codec->startScanlineDecode(info, nullptr, colors, &colorCount);
+                SkASSERT(SkCodec::kSuccess == result);
+
                 const int subsetStartX = SkTMax(0, centerX - w / 2);
                 const int subsetStartY = SkTMax(0, centerY - h / 2);
                 const int subsetWidth = SkTMin(w, info.width() - subsetStartX);
                 const int subsetHeight = SkTMin(h, info.height() - subsetStartY);
                 // Note that if we subsetted and scaled in a single step, we could use the
                 // same bitmap - as is often done in actual use cases.
                 SkBitmap bitmap;
                 SkImageInfo subsetInfo = info.makeWH(subsetWidth, subsetHeight);
                 alloc_pixels(&bitmap, subsetInfo, colors, colorCount);

[scroggo, 2015/10/08 18:29:08]

Since we do a new allocation each time, we can always do this after
startScanlineDecode, so colorCount (as well as colors) is always initialized.

[msarett, 2015/10/08 18:52:42]

Acknowledged.

 
                 uint32_t bpp = info.bytesPerPixel();
-                codec->skipScanlines(subsetStartY);
-                for (int y = 0; y < subsetHeight; y++) {
-                    codec->getScanlines(row.get(), 1, 0);
-                    memcpy(bitmap.getAddr(0, y), row.get() + subsetStartX * bpp,
-                            subsetWidth * bpp);
+
+                SkDEBUGCODE(result = ) codec->skipScanlines(subsetStartY);
+                SkASSERT(SkCodec::kSuccess == result);
+
+                switch (codec->getScanlineOrder()) {
+                    case SkCodec::kTopDown_SkScanlineOrder:
+                        for (int y = 0; y < subsetHeight; y++) {
+                            SkDEBUGCODE(result = ) codec->getScanlines(row.get(), 1, 0);
+                            SkASSERT(SkCodec::kSuccess == result);
+
+                            memcpy(bitmap.getAddr(0, y), row.get() + subsetStartX * bpp,
+                                    subsetWidth * bpp);
+                        }
+                        break;
+                    case SkCodec::kNone_SkScanlineOrder: {
+                        // decode all scanlines that intersect the subset, and copy the subset
+                        // into the output.
+                        SkImageInfo stripeInfo = info.makeWH(info.width(), subsetHeight);
+                        SkBitmap stripeBm;
+                        alloc_pixels(&stripeBm, stripeInfo, colors, colorCount);

[scroggo, 2015/10/08 18:29:08]

Here and in SubsetTranslateBench, we're doing some extra work to create a bitmap
plus its colortable (in index8). We could instead just do some kind of malloc.
Then we'd have to write more code to do all the calculations that bitmap does
for us. I went with the simpler option, since this test had errors in the
past...

[msarett, 2015/10/08 18:52:41]

This is probably the right decision.

In general, I don't like SkBitmap and SkColorTable and use them as little as
possible.  I think we are stuck with Bitmaps anyway for the Android API so we
might as well benchmark them.

+
+                        SkDEBUGCODE(result = ) codec->getScanlines(stripeBm.getPixels(),
+                                subsetHeight, stripeBm.rowBytes());
+                        SkASSERT(SkCodec::kSuccess == result);
+
+                        for (int y = 0; y < subsetHeight; y++) {
+                            memcpy(bitmap.getAddr(0, y),
+                                   stripeBm.getAddr(subsetStartX, y),
+                                   subsetWidth * bpp);
+                        }
+                        break;
+                    }
+                    default:
+                        // We currently are only testing kTopDown and kNone, which are the only
+                        // two used by the subsets we care about. skbug.com/4428
+                        SkASSERT(false);
                 }
+
                 w <<= 1;
                 h <<= 1;
             } while (w < 2 * info.width() || h < 2 * info.height());
         }
     } else {
         for (int count = 0; count < n; count++) {
             int width, height;
             SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(fStream));
-            decoder->buildTileIndex(fStream->duplicate(), &width, &height);
+            SkAssertResult(decoder->buildTileIndex(fStream->duplicate(), &width, &height));
 
             const int centerX = width / 2;
             const int centerY = height / 2;
             int w = fSubsetWidth;
             int h = fSubsetHeight;
             do {
                 const int subsetStartX = SkTMax(0, centerX - w / 2);
                 const int subsetStartY = SkTMax(0, centerY - h / 2);
                 const int subsetWidth = SkTMin(w, width - subsetStartX);
                 const int subsetHeight = SkTMin(h, height - subsetStartY);
                 SkBitmap bitmap;
                 SkIRect rect = SkIRect::MakeXYWH(subsetStartX, subsetStartY, subsetWidth,
                         subsetHeight);
-                decoder->decodeSubset(&bitmap, rect, fColorType);
+                SkAssertResult(decoder->decodeSubset(&bitmap, rect, fColorType));
                 w <<= 1;
                 h <<= 1;
             } while (w < 2 * width || h < 2 * height);
         }
     }
 }