Create an SkAndroidCodec API separate from SkCodec

dm/DM.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
@@ skipping 208 matching lines @@
     }
 }
 
 static void push_codec_src(Path path, CodecSrc::Mode mode, CodecSrc::DstColorType dstColorType,
         float scale) {
     SkString folder;
     switch (mode) {
         case CodecSrc::kCodec_Mode:
             folder.append("codec");
             break;
-        case CodecSrc::kScaledCodec_Mode:
-            folder.append("scaled_codec");
-            break;
         case CodecSrc::kScanline_Mode:
             folder.append("scanline");
             break;
         case CodecSrc::kScanline_Subset_Mode:
             folder.append("scanline_subset");
             break;
         case CodecSrc::kStripe_Mode:
             folder.append("stripe");
             break;
         case CodecSrc::kSubset_Mode:
@@ skipping 13 matching lines @@
     }
 
     if (1.0f != scale) {
         folder.appendf("_%.3f", scale);
     }
 
     CodecSrc* src = new CodecSrc(path, mode, dstColorType, scale);
     push_src("image", folder, src);
 }
 
+static void push_android_codec_src(Path path, AndroidCodecSrc::Mode mode,
+        CodecSrc::DstColorType dstColorType, int sampleSize) {
+    SkString folder;
+    switch (mode) {
+        case AndroidCodecSrc::kFullImage_Mode:
+            folder.append("scaled_codec");
+            break;
+        case AndroidCodecSrc::kDivisor_Mode:
+            folder.append("scaled_codec_divisor");
+            break;
+    }
+
+    switch (dstColorType) {
+        case CodecSrc::kGrayscale_Always_DstColorType:
+            folder.append("_kGray8");
+            break;
+        case CodecSrc::kIndex8_Always_DstColorType:
+            folder.append("_kIndex8");
+            break;
+        default:
+            break;
+    }
+
+    if (1 != sampleSize) {
+        folder.appendf("_%.3f", get_scale_from_sample_size(sampleSize));
+    }
+
+    AndroidCodecSrc* src = new AndroidCodecSrc(path, mode, dstColorType, sampleSize);
+    push_src("image", folder, src);
+}
+
 static void push_codec_srcs(Path path) {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
     if (!encoded) {
         SkDebugf("Couldn't read %s.", path.c_str());
         return;
     }
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
     if (nullptr == codec.get()) {
         SkDebugf("Couldn't create codec for %s.", path.c_str());
         return;
     }
 
     // Native Scales
     // TODO (msarett): Implement scaling tests for SkImageDecoder in order to compare with these
     //                 tests.  SkImageDecoder supports downscales by integer factors.
     // SkJpegCodec natively supports scaling to: 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875
     const float nativeScales[] = { 0.125f, 0.25f, 0.375f, 0.5f, 0.625f, 0.750f, 0.875f, 1.0f };
 
     const CodecSrc::Mode nativeModes[] = { CodecSrc::kCodec_Mode, CodecSrc::kScanline_Mode,
             CodecSrc::kScanline_Subset_Mode, CodecSrc::kStripe_Mode, CodecSrc::kSubset_Mode };
 
     CodecSrc::DstColorType colorTypes[3];
     uint32_t numColorTypes;
     switch (codec->getInfo().colorType()) {
         case kGray_8_SkColorType:
             // FIXME: Is this a long term solution for testing wbmps decodes to kIndex8?
-            // Further discussion on this topic is at skbug.com/3683
+            // Further discussion on this topic is at skbug.com/3683.
+            // This causes us to try to convert grayscale jpegs to kIndex8.  We currently
+            // fail non-fatally in this case.
             colorTypes[0] = CodecSrc::kGetFromCanvas_DstColorType;
             colorTypes[1] = CodecSrc::kGrayscale_Always_DstColorType;
             colorTypes[2] = CodecSrc::kIndex8_Always_DstColorType;
             numColorTypes = 3;
             break;
         case kIndex_8_SkColorType:
             colorTypes[0] = CodecSrc::kGetFromCanvas_DstColorType;
             colorTypes[1] = CodecSrc::kIndex8_Always_DstColorType;
             numColorTypes = 2;
             break;
         default:
             colorTypes[0] = CodecSrc::kGetFromCanvas_DstColorType;
             numColorTypes = 1;
             break;
     }
 
     for (float scale : nativeScales) {
         for (CodecSrc::Mode mode : nativeModes) {
             for (uint32_t i = 0; i < numColorTypes; i++) {
                 push_codec_src(path, mode, colorTypes[i], scale);
             }
         }
     }
 
-    if (path.endsWith(".ico") || path.endsWith(".ICO")) {
-        // FIXME: skbug.com/4404: ICO does not have the ability to decode scanlines, so we cannot
-        // use SkScaledCodec with it.
+    // skbug.com/4428
+    static const char* const exts[] = {
+        "jpg", "jpeg", "png", "webp",
+        "JPG", "JPEG", "PNG", "WEBP",
+    };
+    bool supported = false;
+    for (const char* ext : exts) {
+        if (path.endsWith(ext)) {
+            supported = true;
+            break;
+        }
+    }
+    if (!supported) {
         return;
     }
 
-    // SkScaledCodec Scales
-    // The native scales are included to make sure that SkScaledCodec defaults to the native
-    // scaling strategy when possible.
-    // 0.1, 0.16, 0.2 etc allow us to test SkScaledCodec with sampleSize 10, 6, 5, etc.
-    // 0.4, 0.7 etc allow to test what happens when the client requests a scale that
-    // does not exactly match a sampleSize or native scaling capability.
-    const float samplingScales[] = { 0.1f, 0.125f, 0.167f, 0.2f, 0.25f, 0.333f, 0.375f, 0.4f, 0.5f,
-            0.6f, 0.625f, 0.750f, 0.8f, 0.875f, 1.0f };
+    const int sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 
-    for (float scale : samplingScales) {
-        for (uint32_t i = 0; i < numColorTypes; i++) {
-            push_codec_src(path, CodecSrc::kScaledCodec_Mode, colorTypes[i], scale);
+    const AndroidCodecSrc::Mode androidModes[] = {
+            AndroidCodecSrc::kFullImage_Mode,
+            AndroidCodecSrc::kDivisor_Mode,
+    };
+
+    for (int sampleSize : sampleSizes) {
+        for (AndroidCodecSrc::Mode mode : androidModes) {
+            for (uint32_t i = 0; i < numColorTypes; i++) {
+                push_android_codec_src(path, mode, colorTypes[i], sampleSize);
+            }
         }
     }
 }
 
 static bool brd_color_type_supported(SkBitmapRegionDecoderInterface::Strategy strategy,
         CodecSrc::DstColorType dstColorType) {
     switch (strategy) {
         case SkBitmapRegionDecoderInterface::kCanvas_Strategy:
             if (CodecSrc::kGetFromCanvas_DstColorType == dstColorType) {
                 return true;
@@ skipping 764 matching lines @@
     #endif  // SK_PDF_IMAGE_STATS
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif