DM: lazy decoding on SKP playback

dm/DMSrcSink.cpp

 #include "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCommonFlags.h"
 #include "SkCodec.h"
+#include "SkData.h"
 #include "SkDocument.h"
 #include "SkError.h"
+#include "SkImageGenerator.h"
 #include "SkMultiPictureDraw.h"
 #include "SkNullCanvas.h"
 #include "SkOSFile.h"
 #include "SkPictureData.h"
 #include "SkPictureRecorder.h"
 #include "SkRandom.h"
 #include "SkSVGCanvas.h"
 #include "SkStream.h"
 #include "SkXMLWriter.h"
 
 DEFINE_bool(codec, false, "Use SkCodec instead of SkImageDecoder");
+DEFINE_bool(deferDecode, false, "if true, defer decoding of bitmaps until they are locked.");
+
+static bool lazy_decode_bitmap(const void* src, size_t size, SkBitmap* dst) {
+    SkAutoTUnref<SkData> encoded(SkData::NewWithCopy(src, size));
+    return encoded && SkInstallDiscardablePixelRef(encoded, dst);
+}
+
+static SkPicture* create_picture_from_stream(SkStream* stream) {
+    return FLAGS_deferDecode ? SkPicture::CreateFromStream(stream, &lazy_decode_bitmap)
+                             : SkPicture::CreateFromStream(stream);
+}
 
 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 "";
@@ skipping 48 matching lines @@
                 // 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());
             }
+        } else if (FLAGS_deferDecode) {
+            if (!SkInstallDiscardablePixelRef(encoded, &bitmap)) {
+                return SkStringPrintf("SkInstallDiscardablePixelRef failed for %s.",
+                                      fPath.c_str());
+            }
         } else {
             if (!SkImageDecoder::DecodeMemory(encoded->data(), encoded->size(), &bitmap,
                                               dstColorType, SkImageDecoder::kDecodePixels_Mode)) {
                 return SkStringPrintf("Couldn't decode %s.", fPath.c_str());
             }
             if (kRGB_565_SkColorType == dstColorType && !bitmap.isOpaque()) {
                 // Do not draw a bitmap with alpha to a destination without alpha.
                 return Error::Nonfatal("Uninteresting to decode image with alpha into 565.");
             }
         }
@@ skipping 48 matching lines @@
     if (FLAGS_codec) {
         SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
         if (!codec) {
             return SkISize::Make(0,0);
         }
         SkImageInfo info;
         if (!codec->getInfo(&info)) {
             return SkISize::Make(0,0);
         }
         return info.dimensions();
+    } else if (FLAGS_deferDecode) {
+        SkAutoTDelete<SkImageGenerator> gen(SkImageGenerator::NewFromData(encoded));
+        SkImageInfo info;
+        return gen && gen->getInfo(&info) ? info.dimensions() : SkISize::Make(0,0);
     } else {
         SkBitmap bitmap;
         if (!encoded || !SkImageDecoder::DecodeMemory(encoded->data(),
                                                       encoded->size(),
                                                       &bitmap,
                                                       kUnknown_SkColorType,
                                                       SkImageDecoder::kDecodeBounds_Mode)) {
             return SkISize::Make(0,0);
         }
         return bitmap.dimensions();
     }
 }
 
 Name ImageSrc::name() const {
     return SkOSPath::Basename(fPath.c_str());
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 static const SkRect kSKPViewport = {0,0, 1000,1000};
 
 SKPSrc::SKPSrc(Path path) : fPath(path) {}
 
 Error SKPSrc::draw(SkCanvas* canvas) const {
     SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(fPath.c_str()));
     if (!stream) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
-    SkAutoTUnref<SkPicture> pic(SkPicture::CreateFromStream(stream));
+    SkAutoTUnref<SkPicture> pic(create_picture_from_stream(stream));
     if (!pic) {
         return SkStringPrintf("Couldn't decode %s as a picture.", fPath.c_str());
     }
     stream.reset((SkStream*)NULL);  // Might as well drop this when we're done with it.
     canvas->clipRect(kSKPViewport);
     canvas->drawPicture(pic);
     return "";
 }
 
 SkISize SKPSrc::size() const {
@@ skipping 279 matching lines @@
     Error err = src.draw(recorder.beginRecording(size.width(), size.height()));
     if (!err.isEmpty()) {
         return err;
     }
     SkAutoTUnref<SkPicture> pic(recorder.endRecording());
 
     // Serialize it and then deserialize it.
     SkDynamicMemoryWStream wStream;
     pic->serialize(&wStream);
     SkAutoTDelete<SkStream> rStream(wStream.detachAsStream());
-    SkAutoTUnref<SkPicture> deserialized(SkPicture::CreateFromStream(rStream));
+    SkAutoTUnref<SkPicture> deserialized(create_picture_from_stream(rStream));
 
     // Turn that deserialized picture into a Src, draw it into our Sink to fill bitmap or stream.
     struct ProxySrc : public Src {
         const SkPicture* fPic;
         const SkISize fSize;
         ProxySrc(const SkPicture* pic, SkISize size) : fPic(pic), fSize(size) {}
 
         Error draw(SkCanvas* canvas) const SK_OVERRIDE {
             canvas->drawPicture(fPic);
             return "";
@@ skipping 64 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