Test scanline decoding in DM.

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 "SkCommonFlags.h"
 #include "SkCodec.h"
 #include "SkDocument.h"
 #include "SkError.h"
 #include "SkMultiPictureDraw.h"
 #include "SkNullCanvas.h"
 #include "SkOSFile.h"
 #include "SkPictureData.h"
 #include "SkPictureRecorder.h"
 #include "SkRandom.h"
+#include "SkScanlineDecoder.h"
 #include "SkSVGCanvas.h"
 #include "SkStream.h"
 #include "SkXMLWriter.h"
 
 namespace DM {
 
 GMSrc::GMSrc(skiagm::GMRegistry::Factory factory) : fFactory(factory) {}
 
 Error GMSrc::draw(SkCanvas* canvas) const {
     SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
     canvas->concat(gm->getInitialTransform());
     gm->draw(canvas);
     return "";
 }
 
 SkISize GMSrc::size() const {
     SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
     return gm->getISize();
 }
 
 Name GMSrc::name() const {
     SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
     return gm->getName();
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
-CodecSrc::CodecSrc(Path path) : fPath(path) {}
+CodecSrc::CodecSrc(Path path, Mode mode) : fPath(path), fMode(mode) {}
 
 Error CodecSrc::draw(SkCanvas* canvas) const {
     SkImageInfo canvasInfo;
     if (NULL == canvas->peekPixels(&canvasInfo, NULL)) {
         // TODO: Once we implement GPU paths (e.g. JPEG YUV), we should use a deferred decode to
         // let the GPU handle it.
         return Error::Nonfatal("No need to test decoding to non-raster backend.");
     }
 
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
@@ skipping 11 matching lines @@
         // FIXME: Currently we cannot draw unpremultiplied sources.
         decodeInfo = decodeInfo.makeAlphaType(kPremul_SkAlphaType);
     }
 
     SkBitmap bitmap;
     if (!bitmap.tryAllocPixels(decodeInfo)) {
         return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
                               decodeInfo.width(), decodeInfo.height());
     }
 
-    SkAutoLockPixels alp(bitmap);
-    switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes())) {
-        case SkImageGenerator::kSuccess:
-        // We consider incomplete to be valid, since we should still decode what is
-        // available.
-        case SkImageGenerator::kIncompleteInput:
-            canvas->drawBitmap(bitmap, 0, 0);
-            return "";
-        case SkImageGenerator::kInvalidConversion:
-            return Error::Nonfatal("Incompatible colortype conversion");
-        default:
-            // Everything else is considered a failure.
-            return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
+    switch (fMode) {
+        case kNormal_Mode:
+            switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes())) {
+                case SkImageGenerator::kSuccess:
+                    // We consider incomplete to be valid, since we should still decode what is
+                    // available.
+                case SkImageGenerator::kIncompleteInput:
+                    break;
+                case SkImageGenerator::kInvalidConversion:
+                    return Error::Nonfatal("Incompatible colortype conversion");
+                default:
+                    // Everything else is considered a failure.
+                    return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
+            }
+            break;
+        case kScanline_Mode: {
+            SkScanlineDecoder* scanlineDecoder = codec->getScanlineDecoder(decodeInfo);
+            if (NULL == scanlineDecoder) {
+                return Error::Nonfatal("Cannot use scanline decoder for all images");
+            }
+            for (int y = 0; y < decodeInfo.height(); ++y) {
+                const SkImageGenerator::Result result = scanlineDecoder->getScanlines(
+                        bitmap.getAddr(0, y), 1, 0);
+                switch (result) {
+                    case SkImageGenerator::kSuccess:
+                    case SkImageGenerator::kIncompleteInput:
+                        break;
+                    default:
+                        return SkStringPrintf("%s failed after %d scanlines with error message %d",
+                                              fPath.c_str(), y-1, (int) result);
+                }
+            }
+            break;
+        }
     }
+    canvas->drawBitmap(bitmap, 0, 0);
+    return "";
 }
 
 SkISize CodecSrc::size() const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
     if (NULL != codec) {
         return codec->getInfo().dimensions();
     } else {
         return SkISize::Make(0, 0);
     }
@@ skipping 482 matching lines @@
             surfaces.unrefAll();
             return "";
         }
         SkISize size() const SK_OVERRIDE { return fSize; }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(fW, fH, pic, src.size());
     return fSink->draw(proxy, bitmap, stream, log);
 }
 
 }  // namespace DM