Run CodecSrc DM.

dm/DM.cpp

 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
 #include "DMSrcSinkAndroid.h"
 #include "OverwriteLine.h"
 #include "ProcStats.h"
 #include "SkBBHFactory.h"
 #include "SkChecksum.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
+#include "SkImageInfo.h"
 #include "SkInstCnt.h"
 #include "SkMD5.h"
 #include "SkOSFile.h"
 #include "SkTHash.h"
 #include "SkTaskGroup.h"
 #include "Test.h"
 #include "Timer.h"
 
 DEFINE_string(src, "tests gm skp image subset", "Source types to test.");
 DEFINE_bool(nameByHash, false,
@@ skipping 85 matching lines @@
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 template <typename T>
 struct Tagged : public SkAutoTDelete<T> { const char* tag; };
 
 static const bool kMemcpyOK = true;
 
 static SkTArray<Tagged<Src>,  kMemcpyOK>  gSrcs;
-static SkTArray<Tagged<Sink>, kMemcpyOK> gSinks;
+static SkTArray<Tagged<Sink>, kMemcpyOK>  gSinks;
 
-static void push_src(const char* tag, Src* s) {
+// SkCodec uses a separate set of srcs and sinks, since we are testing decoding, rather than
+// drawing. For the same reason, we only want to draw to one particular sink (in particular,
+// kN32 for typical decodes - it is important that it accept alpha so images with alpha draw
+// reasonably; a GPU sink for GPU based decodes (e.g. YUV, not yet tested)).
+static SkTArray<Tagged<Src>,  kMemcpyOK>  gCodecSrcs;
+static SkTArray<Tagged<Sink>, kMemcpyOK>  gCodecSinks;
+
+static void push_src(const char* tag, Src* s, SkTArray<Tagged<Src>, kMemcpyOK>* srcList = &gSrcs) {
     SkAutoTDelete<Src> src(s);
     if (FLAGS_src.contains(tag) &&
         !SkCommandLineFlags::ShouldSkip(FLAGS_match, src->name().c_str())) {
-        Tagged<Src>& s = gSrcs.push_back();
+        Tagged<Src>& s = srcList->push_back();
         s.reset(src.detach());
         s.tag = tag;
     }
 }
 
+static void gather_codec_srcs(Path path) {
+    if (!FLAGS_src.contains("codec")) {
+        // push_src would skip adding theses sources anyway, but early exit so
+        // we don't bother checking all combinations.
+        return;
+    }
+    static const SkColorType gDstCTs[] = {
+        kN32_SkColorType,
+        kRGB_565_SkColorType,
+        kAlpha_8_SkColorType
+    };
+    static const SkAlphaType gDstATs[] = {
+        kOpaque_SkAlphaType,
+        kPremul_SkAlphaType
+        // FIXME: Support kUnpremul once that is supported as a source.
+        //kUnpremul_SkAlphaType
+    };
+    static const CodecSrc::SkipZeroes gSkips[] = {

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

Why don't we wait to land these options until the CL that supports other
options?  Seems like we're adding a lot of boilerplate before it's needed.

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

Sure! I wasn't ready to land this anyway, I just wanted to run the larger plan
by you.

+        // TODO: Once https://codereview.chromium.org/980903002/ lands, use
+        // its enum and run while skipping zeroes.
+        //CodecSrc::kSkipZeroes,
+        CodecSrc::kNo_SkipZeroes
+    };
+    static const CodecSrc::Scanlines gScanlines[] = {
+        CodecSrc::kNormal_Scanlines
+        // TODO: Support other modes
+    };
+
+    // Possible alternate approach?
+    // For an 8888 decode, we attempt all the alpha types, but in reality, two
+    // is the max for a given image. If we created an SkCodec first, we would
+    // know whether the image was opaque. If so, we would only need a task to
+    // decode to kOpaque. Otherwise, we need two tasks: one for kPremul and one
+    // for kUnpremul. This would mean creating the SkCodec on the main thread,
+    // but maybe that's a fair tradeoff for spawning less tasks.
+    for (size_t dstCTs = 0; dstCTs < SK_ARRAY_COUNT(gDstCTs); dstCTs++) {
+        const SkColorType ct = gDstCTs[dstCTs];
+        for (size_t dstATs = 0; dstATs < SK_ARRAY_COUNT(gDstATs); dstATs++) {
+            const SkAlphaType at = gDstATs[dstATs];
+            SkAlphaType canonical;
+            if (!SkColorTypeValidateAlphaType(ct, at, &canonical) || canonical != at) {

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

Don't we know ahead of time which pairs will pass this test?  The list won't
change very often, right?

struct { SkColorType ct; SkAlphaType at; } targets[] = {
  { kN32_SkColorType,     kPremul_SkAlphaType },
  { kN32_SkColorType,     kOpaque_SkAlphaType },
  { kAlpha_8_SkColorType, kPremul_SkAlphaType },
  { kRGB_565_SkColorType, kOpaque_SkAlphaType },
};
for (int i = 0; i < SK_ARRAY_COUNT(targets); i++) {
    push_src("codec", new CodecSrc(path, targets[i].ct, targets[i].at));
}

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

Yes, that will work. 

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

Leaving out for now, since we're using the config of the Sink, and we don't yet
have a choice between premul and unpremul (and I'm not sure it's necessary to
compare the same image decoded as opaque vs unpremul, since it should just be
one or the other).

+                // This alpha type does not match the color type. Skip it.
+                continue;
+            }
+            for (size_t scanlines = 0; scanlines < SK_ARRAY_COUNT(gScanlines); scanlines++) {
+                for (size_t skips = 0; skips < SK_ARRAY_COUNT(gSkips); skips++) {
+                    push_src("codec", new CodecSrc(path, ct, at, gSkips[skips],
+                                                   gScanlines[scanlines]),
+                             &gCodecSrcs);
+                }
+            }
+        }
+    }
+}
+
 static void gather_srcs() {
     for (const skiagm::GMRegistry* r = skiagm::GMRegistry::Head(); r; r = r->next()) {
         push_src("gm", new GMSrc(r->factory()));
     }
     for (int i = 0; i < FLAGS_skps.count(); i++) {
         const char* path = FLAGS_skps[i];
         if (sk_isdir(path)) {
             SkOSFile::Iter it(path, "skp");
             for (SkString file; it.next(&file); ) {
                 push_src("skp", new SKPSrc(SkOSPath::Join(path, file.c_str())));
             }
         } else {
             push_src("skp", new SKPSrc(path));
         }
     }
     static const char* const exts[] = {
         "bmp", "gif", "jpg", "jpeg", "png", "webp", "ktx", "astc", "wbmp", "ico",
         "BMP", "GIF", "JPG", "JPEG", "PNG", "WEBP", "KTX", "ASTC", "WBMP", "ICO",
     };
     for (int i = 0; i < FLAGS_images.count(); i++) {
         const char* flag = FLAGS_images[i];
         if (sk_isdir(flag)) {
             for (size_t j = 0; j < SK_ARRAY_COUNT(exts); j++) {
                 SkOSFile::Iter it(flag, exts[j]);
                 for (SkString file; it.next(&file); ) {
                     SkString path = SkOSPath::Join(flag, file.c_str());
                     push_src("image", new ImageSrc(path));     // Decode entire image.
                     push_src("subset", new ImageSrc(path, 2)); // Decode into 2 x 2 subsets
+                    gather_codec_srcs(path);
                 }
             }
         } else if (sk_exists(flag)) {
             // assume that FLAGS_images[i] is a valid image if it is a file.
             push_src("image", new ImageSrc(flag));     // Decode entire image.
             push_src("subset", new ImageSrc(flag, 2)); // Decode into 2 x 2 subsets
+            gather_codec_srcs(flag);
         }
     }
 }
 
 static GrGLStandard get_gpu_api() {
     if (FLAGS_gpuAPI.contains("gl"))   { return kGL_GrGLStandard; }
     if (FLAGS_gpuAPI.contains("gles")) { return kGLES_GrGLStandard; }
     return kNone_GrGLStandard;
 }
 
-static void push_sink(const char* tag, Sink* s) {
+static void push_sink(const char* tag, Sink* s, SkTArray<Tagged<Sink>,
+                      kMemcpyOK>* sinksArray = &gSinks) {
     SkAutoTDelete<Sink> sink(s);
-    if (!FLAGS_config.contains(tag)) {
+    if (!FLAGS_config.contains(tag)
+            // If we're running codec sources, and we're attempting to push one
+            // of its sinks, do it whether or not the configs include this sink.
+            && !(&gCodecSinks == sinksArray && FLAGS_src.contains("codec"))) {
         return;
     }
     // Try a noop Src as a canary.  If it fails, skip this sink.
     struct : public Src {
         Error draw(SkCanvas*) const SK_OVERRIDE { return ""; }
         SkISize size() const SK_OVERRIDE { return SkISize::Make(16, 16); }
         Name name() const SK_OVERRIDE { return "noop"; }
     } noop;
 
     SkBitmap bitmap;
     SkDynamicMemoryWStream stream;
     SkString log;
     Error err = sink->draw(noop, &bitmap, &stream, &log);
     if (err.isFatal()) {
         SkDebugf("Skipping %s: %s\n", tag, err.c_str());
         return;
     }
 
-    Tagged<Sink>& ts = gSinks.push_back();
+    Tagged<Sink>& ts = sinksArray->push_back();
     ts.reset(sink.detach());
     ts.tag = tag;
 }
 
 static bool gpu_supported() {
 #if SK_SUPPORT_GPU
     return FLAGS_gpu;
 #else
     return false;
 #endif
@@ skipping 318 matching lines @@
     if (FLAGS_leaks) {
         SkInstCountPrintLeaksOnExit();
     }
 
     gather_gold();
 
     gather_srcs();
     gather_sinks();
     gather_tests();
 
-    gPending = gSrcs.count() * gSinks.count() + gThreadedTests.count() + gGPUTests.count();
-    SkDebugf("%d srcs * %d sinks + %d tests == %d tasks\n",
-             gSrcs.count(), gSinks.count(), gThreadedTests.count() + gGPUTests.count(), gPending);
+    gPending = gSrcs.count() * gSinks.count() + gThreadedTests.count() + gGPUTests.count()
+               + gCodecSrcs.count();
+    SkDebugf("%d srcs * %d sinks + %d tests + %d codecs == %d tasks\n",
+             gSrcs.count(), gSinks.count(), gThreadedTests.count() + gGPUTests.count(),
+             gCodecSrcs.count(), gPending);
 
     // We try to exploit as much parallelism as is safe.  Most Src/Sink pairs run on any thread,
     // but Sinks that identify as part of a particular enclave run serially on a single thread.
     // CPU tests run on any thread.  GPU tests depend on --gpu_threading.
     SkTArray<Task> enclaves[kNumEnclaves];
     for (int j = 0; j < gSinks.count(); j++) {
         SkTArray<Task>& tasks = enclaves[gSinks[j]->enclave()];
         for (int i = 0; i < gSrcs.count(); i++) {
             tasks.push_back(Task(gSrcs[i], gSinks[j]));
         }
     }
 
+    // All CodecSrcs should run on 8888.
+    if (gCodecSrcs.count() > 0) {
+        push_sink("8888", new RasterSink(kN32_SkColorType), &gCodecSinks);
+        // TODO: Once we start testing GPU decodes, draw to GPU sinks
+        if (gCodecSinks.count() > 0) {
+            for (int i = 0; i < gCodecSrcs.count(); i++) {
+                SkTArray<Task>& tasks = enclaves[gCodecSinks[0]->enclave()];
+                tasks.push_back(Task(gCodecSrcs[i], gCodecSinks[0]));
+            }
+        }
+    }
+
     SkTaskGroup tg;
     tg.batch(run_test, gThreadedTests.begin(), gThreadedTests.count());
     for (int i = 0; i < kNumEnclaves; i++) {
         switch(i) {
             case kAnyThread_Enclave:
                 tg.batch(Task::Run, enclaves[i].begin(), enclaves[i].count());
                 break;
             case kGPU_Enclave:
                 tg.add(run_enclave_and_gpu_tests, &enclaves[i]);
                 break;
@@ skipping 20 matching lines @@
     }
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif