Scanline decoding for gifs

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 177 matching lines @@
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kScanline_Mode: {
             SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(
                     start_scanline_decoder(encoded.get(), decodeInfo, colorPtr, colorCountPtr));
             if (nullptr == scanlineDecoder) {
                 return Error::Nonfatal("Could not start scanline decoder");
             }
 
-            const SkCodec::Result result = scanlineDecoder->getScanlines(
-                    bitmap.getAddr(0, 0), decodeInfo.height(), bitmap.rowBytes());
+            SkCodec::Result result;
+            switch (scanlineDecoder->getScanlineOrder()) {
+                case SkScanlineDecoder::kTopDown_SkScanlineOrder:
+                case SkScanlineDecoder::kBottomUp_SkScanlineOrder:
+                case SkScanlineDecoder::kNone_SkScanlineOrder:
+                    result = scanlineDecoder->getScanlines(bitmap.getAddr(0, 0),
+                            decodeInfo.height(), bitmap.rowBytes());
+                    break;
+                case SkScanlineDecoder::kOutOfOrder_SkScanlineOrder: {
+                    for (int y = 0; y < decodeInfo.height(); y++) {
+                        int dstY = scanlineDecoder->getY();
+                        void* dstPtr = bitmap.getAddr(0, dstY);
+                        result = scanlineDecoder->getScanlines(dstPtr, 1, bitmap.rowBytes());
+                        if (SkCodec::kSuccess != result && SkCodec::kIncompleteInput != result) {

[scroggo, 2015/09/02 22:45:47]

The weird thing about allowing incomplete here is that we will have decoded some
scanlines, but left some uninitialized.

[msarett, 2015/09/03 17:13:30]

Actually the reason that we allow kIncomplete here is to avoid having
uninitialized scanlines.  We will keep going even if we have reached the end of
the image stream - that way all of the remaining scanlines will be filled by the
scanline decoder individually.

I don't think my refactor of the Fill() in a WIP CL will give us a better
solution than this.  But maybe it's not so bad to have this code in the dm test?

[scroggo, 2015/09/04 18:42:09]

Wait, so you're saying that the scanline decoder will return kIncomplete, but
then the client will continue to call getScanlines? And those calls will fill,
but also return kIncomplete, so the client can continue to fill the rest? That's
interesting. Maybe it's the right thing to do, but it's not what I expected.
When you say "this code", what do you mean? The code that's already here?

[msarett, 2015/09/04 19:52:47]

Yes that's what it does.
Yes that's what I mean.  In SkScaledCodec, we use the scanline decoder in a call
to onGetPixels().  Ideally, maybe the base class version of getPixels() would
handle filling if onGetPixels() returns kIncomplete.

Here, I'm not sure of a better strategy than keeping the code as is.

+                            return SkStringPrintf("%s failed with error message %d",
+                                                  fPath.c_str(), (int) result);
+                        }
+                    }
+                    break;
+                }
+            }
+
             switch (result) {
                 case SkCodec::kSuccess:
                 case SkCodec::kIncompleteInput:
                     break;
                 default:
                     return SkStringPrintf("%s failed with error message %d",
                                           fPath.c_str(), (int) result);
             }
             canvas->drawBitmap(bitmap, 0, 0);
             break;
@@ skipping 876 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM