Scanline decoding for bmp

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 61 matching lines @@
 {}
 
 bool CodecSrc::veto(SinkFlags flags) const {
     // No need to test decoding to non-raster or indirect backend.
     // TODO: Once we implement GPU paths (e.g. JPEG YUV), we should use a deferred decode to
     // let the GPU handle it.
     return flags.type != SinkFlags::kRaster
         || flags.approach != SinkFlags::kDirect;
 }
 
+SkScanlineDecoder* start_scanline_decoder(SkData* encoded, const SkImageInfo& info,
+        SkPMColor* colorPtr, int* colorCountPtr) {
+    SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(SkScanlineDecoder::NewFromData(encoded));
+    if (NULL == scanlineDecoder) {
+        return NULL;
+    }
+    // DM scanline test assume kTopDown scanline ordering.  Other orderings are
+    // tested from within SkScaledCodec.
+    if (SkScanlineDecoder::kTopDown_SkScanlineOrder != scanlineDecoder->getScanlineOrder()) {
+        return NULL;
+    }
+    if (SkCodec::kSuccess != scanlineDecoder->start(info, NULL, colorPtr, colorCountPtr)) {
+        return NULL;
+    }
+    return scanlineDecoder.detach();
+}
+
 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(SkScaledCodec::NewFromData(encoded));
     if (NULL == codec.get()) {
         // scaledCodec not supported, try normal codec
         codec.reset(SkCodec::NewFromData(encoded));
         if (NULL == codec.get()) {
@@ skipping 71 matching lines @@
                     return Error::Nonfatal("Incompatible colortype conversion");
                 default:
                     // Everything else is considered a failure.
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kScanline_Mode: {
             SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(
-                    SkScanlineDecoder::NewFromData(encoded));
-            if (NULL == scanlineDecoder || SkCodec::kSuccess !=
-                    scanlineDecoder->start(decodeInfo, NULL, colorPtr, colorCountPtr)) {
-                return Error::Nonfatal("Cannot use scanline decoder for all images");
+                    start_scanline_decoder(encoded.get(), decodeInfo, colorPtr, colorCountPtr));
+            if (NULL == scanlineDecoder) {
+                return Error::Nonfatal("Could not start top-down scanline decoder");
             }
 
             const SkCodec::Result result = scanlineDecoder->getScanlines(
                     bitmap.getAddr(0, 0), decodeInfo.height(), bitmap.rowBytes());
             switch (result) {
                 case SkCodec::kSuccess:
                 case SkCodec::kIncompleteInput:
                     break;
                 default:
                     return SkStringPrintf("%s failed with error message %d",
@@ skipping 40 matching lines @@
                 const int currentSubsetWidth = (col + 1 == divisor) ?
                         subsetWidth + extraX : subsetWidth;
                 const int x = col * subsetWidth;
                 for (int row = 0; row < divisor; row++) {
                     //currentSubsetHeight may be larger than subsetHeight for bottom subsets
                     const int currentSubsetHeight = (row + 1 == divisor) ?
                             subsetHeight + extraY : subsetHeight;
                     const int y = row * subsetHeight;
                     //create scanline decoder for each subset
                     SkAutoTDelete<SkScanlineDecoder> subsetScanlineDecoder(
-                            SkScanlineDecoder::NewFromData(encoded));
-                    if (NULL == subsetScanlineDecoder || SkCodec::kSuccess !=
-                            subsetScanlineDecoder->start(
-                            decodeInfo, NULL, colorPtr, colorCountPtr))
-                    {
+                            start_scanline_decoder(encoded.get(), decodeInfo,
+                                    colorPtr, colorCountPtr));
+                    if (NULL == subsetScanlineDecoder) {
                         if (x == 0 && y == 0) {
                             //first try, image may not be compatible
-                            return Error::Nonfatal("Cannot use scanline decoder for all images");
+                            return Error::Nonfatal("Could not start top-down scanline decoder");
                         } else {
                             return "Error scanline decoder is NULL";
                         }
                     }
+                    if (SkScanlineDecoder::kTopDown_SkScanlineOrder !=
+                            subsetScanlineDecoder->getScanlineOrder()) {
+                        return Error::Nonfatal("Test mode not supported");

[scroggo, 2015/08/27 20:14:22]

Wait, why do we require kTopDown? Don't we know how many scanlines we need? It
seems like for kNone we should not have to do anything to support this. For
kOutOfOrder, we would need to write separate code for this, but maybe that could
be a TODO? (FWIW, we might want some common code somewhere that handles that
case.)

[msarett, 2015/08/27 21:21:46]

First, this check should be deleted because it is a duplicate of the one in
start_scanline_decoder().

However, I am adding a TODO.  I think you're right that we want common code to
deal with kOutOfOrder etc.  I think you can find that code in SkScaledCodec in
the gif scanline decoder review :/

I'm hesitant to make the change in this patchset because I think we need a more
serious redesign of our test cases here.  If we share the code used in
SkScaledCodec throughout these tests, we may have a bit of duplication of our
test cases.

[scroggo, 2015/08/28 13:28:46]

sgtm

+                    }
                     //skip to first line of subset
                     const SkCodec::Result skipResult =
                             subsetScanlineDecoder->skipScanlines(y);
                     switch (skipResult) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("%s failed after attempting to skip %d scanlines"
                                     "with error message %d", fPath.c_str(), y, (int) skipResult);
@@ skipping 38 matching lines @@
             break;
         }
         case kStripe_Mode: {
             const int height = decodeInfo.height();
             // This value is chosen arbitrarily.  We exercise more cases by choosing a value that
             // does not align with image blocks.
             const int stripeHeight = 37;
             const int numStripes = (height + stripeHeight - 1) / stripeHeight;
 
             // Decode odd stripes
-            SkAutoTDelete<SkScanlineDecoder> decoder(SkScanlineDecoder::NewFromData(encoded));
-            if (NULL == decoder || SkCodec::kSuccess !=
-                    decoder->start(decodeInfo, NULL, colorPtr, colorCountPtr)) {
-                return Error::Nonfatal("Cannot use scanline decoder for all images");
+            SkAutoTDelete<SkScanlineDecoder> decoder(
+                    start_scanline_decoder(encoded.get(), decodeInfo, colorPtr, colorCountPtr));
+            if (NULL == decoder) {
+                return Error::Nonfatal("Could not start top-down scanline decoder");
             }
             for (int i = 0; i < numStripes; i += 2) {
                 // Skip a stripe
                 const int linesToSkip = SkTMin(stripeHeight, height - i * stripeHeight);
                 SkCodec::Result result = decoder->skipScanlines(linesToSkip);
                 switch (result) {
                     case SkCodec::kSuccess:
                     case SkCodec::kIncompleteInput:
                         break;
                     default:
@@ skipping 743 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM