Run CodecSrc DM.

dm/DMSrcSink.cpp

 #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 "SkPictureRecorder.h"
 #include "SkRandom.h"
 #include "SkSVGCanvas.h"
 #include "SkStream.h"
 #include "SkXMLWriter.h"
 
-DEFINE_bool(codec, false, "Use SkCodec instead of SkImageDecoder");
-
 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, SkColorType dstCT, SkAlphaType dstAT, SkipZeroes skip,
+                   Scanlines scanlines)
+    : fPath(path)
+    , fDstColorType(dstCT)
+    , fDstAlphaType(dstAT)
+    , fSkipZeroes(skip)
+    , fScanlines(scanlines) {}
+
+Error CodecSrc::draw(SkCanvas* canvas) const {

[mtklein, 2015/03/06 00:25:25]

Can we use non-fatal errors here to have this CodecSrc restrict itself to its
targets of choice, rather than having to have DM.cpp do it?  E.g.

SkImageInfo info;
if (!canvas->peekPixels(&info, NULL) || info.colorType() != kN32_SkColorType) {
    return Error::Nonfatal("unsupported decode target");
}

Then just append the lot of CodecSrcs to the main source list?

[scroggo, 2015/03/06 20:40:27]

That could work. Although I'm still trying to wrap my head around making each
flavor of CodecSrc have the same name, but not overwrite each other. I was
thinking maybe I wanted a different kind of Sink (or via), but maybe I should
just call push_src with a different tag? That could make the Corpus dropdown in
Gold get much bigger, but maybe that's okay?

[scroggo, 2015/03/06 20:43:45]

My other thought is that the config you choose will then determine whether you
test the codecs. That's probably okay, since we probably have the following
non-overlapping sets of use cases:

bots: run everything
most skia developers: run exactly what they want (i.e. not codec)
matt and I, only when changing codec: run codec

[scroggo, 2015/03/13 21:34:33]

Done.

+    SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
+    if (!encoded) {
+        return SkStringPrintf("Couldn't read %s.", fPath.c_str());
+    }
+
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
+    if (!codec) {
+        return SkStringPrintf("Couldn't decode %s.", fPath.c_str());
+    }
+    SkImageInfo info;
+    if (!codec->getInfo(&info)) {
+        return SkStringPrintf("Couldn't getInfo %s.", fPath.c_str());
+    }
+    info = SkImageInfo::Make(info.width(), info.height(), fDstColorType,
+                             fDstAlphaType, info.profileType());
+    SkBitmap bitmap;
+    if (!bitmap.tryAllocPixels(info)) {
+        return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
+                              info.width(), info.height());
+    }
+
+    SkAutoLockPixels alp(bitmap);
+    if (kSkipZeroes == fSkipZeroes) {
+        memset(bitmap.getPixels(), 0, bitmap.getSafeSize());
+        // TODO: modify the setting on codec.
+    }
+
+    // TODO: Support other scanline modes.
+    SkASSERT(kNormal_Scanlines == fScanlines);
+
+    const SkImageGenerator::Result result = codec->getPixels(info, bitmap.getPixels(),
+                                                             bitmap.rowBytes());
+    switch (result) {
+        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());
+    }
+}
+
+SkISize CodecSrc::size() const {
+    SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
+    SkImageInfo info;
+    if (codec && codec->getInfo(&info)) {
+        return info.dimensions();
+    }
+    return SkISize::Make(0,0);
+}
+
+// This code mimics code in DecodingBench. Can we unify?
+const char* color_type_name(SkColorType colorType) {
+    switch(colorType) {
+        case kN32_SkColorType:
+            return "N32";
+        case kRGB_565_SkColorType:
+            return "565";
+        case kAlpha_8_SkColorType:
+            return "Alpha8";
+        default:
+            return "Unknown";
+    }
+}
+
+const char* alpha_type_name(SkAlphaType alphaType) {
+    switch (alphaType) {
+        case kUnpremul_SkAlphaType:
+            return "Unpremul";
+        case kPremul_SkAlphaType:
+            return "Premul";
+        case kOpaque_SkAlphaType:
+            return "Opaque";
+        default:
+            // We only support the above three.
+            SkASSERT(false);
+            return "";
+    }
+}
+
+Name CodecSrc::name() const {
+    return SkStringPrintf("%s_%s_%s", SkOSPath::Basename(fPath.c_str()).c_str(),
+                          color_type_name(fDstColorType),
+                          alpha_type_name(fDstAlphaType));
+}
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
 ImageSrc::ImageSrc(Path path, int divisor) : fPath(path), fDivisor(divisor) {}
 
 Error ImageSrc::draw(SkCanvas* canvas) const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     if (!encoded) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
     const SkColorType dstColorType = canvas->imageInfo().colorType();
     if (fDivisor == 0) {
         // Decode the full image.
         SkBitmap bitmap;
-        if (FLAGS_codec) {
-            SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
-            if (!codec) {
-                return SkStringPrintf("Couldn't decode %s.", fPath.c_str());
-            }
-            SkImageInfo info;
-            if (!codec->getInfo(&info)) {
-                return SkStringPrintf("Couldn't getInfo %s.", fPath.c_str());
-            }
-            info = info.makeColorType(dstColorType);
-            if (info.alphaType() == kUnpremul_SkAlphaType) {
-                // FIXME: Currently we cannot draw unpremultiplied sources.
-                info = info.makeAlphaType(kPremul_SkAlphaType);
-            }
-            if (!bitmap.tryAllocPixels(info)) {
-                return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
-                                      info.width(), info.height());
-            }
-            SkAutoLockPixels alp(bitmap);
-            const SkImageGenerator::Result result = codec->getPixels(info, bitmap.getPixels(),
-                                                                     bitmap.rowBytes());
-            switch (result) {
-                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());
-            }
-        } 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.");
-            }
+        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.");
         }
         encoded.reset((SkData*)NULL);  // Might as well drop this when we're done with it.
         canvas->drawBitmap(bitmap, 0,0);
         return "";
     }
     // Decode subsets.  This is a little involved.
     SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(encoded));
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream.get()));
     if (!decoder) {
         return SkStringPrintf("Can't find a good decoder for %s.", fPath.c_str());
@@ skipping 429 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