Use new jpeg_crop_scanlines() API to optimize jpeg subset decodes

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 224 matching lines @@
             break;
         case CodecSrc::kCodecZeroInit_Mode:
             folder.append("codec_zero_init");
             break;
         case CodecSrc::kScanline_Mode:
             folder.append("scanline");
             break;
         case CodecSrc::kStripe_Mode:
             folder.append("stripe");
             break;
+        case CodecSrc::kCroppedScanline_Mode:
+            folder.append("crop");
+            break;
         case CodecSrc::kSubset_Mode:
             folder.append("codec_subset");
             break;
         case CodecSrc::kGen_Mode:
             folder.append("gen");
             break;
     }
 
     switch (dstColorType) {
         case CodecSrc::kGrayscale_Always_DstColorType:
@@ skipping 84 matching lines @@
         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::kCodecZeroInit_Mode,
-            CodecSrc::kScanline_Mode, CodecSrc::kStripe_Mode, CodecSrc::kSubset_Mode,
-            CodecSrc::kGen_Mode };
+    SkTArray<CodecSrc::Mode> nativeModes;
+    nativeModes.push_back(CodecSrc::kCodec_Mode);
+    nativeModes.push_back(CodecSrc::kCodecZeroInit_Mode);
+    nativeModes.push_back(CodecSrc::kGen_Mode);
+    switch (codec->getEncodedFormat()) {
+        case SkEncodedFormat::kJPEG_SkEncodedFormat:
+            nativeModes.push_back(CodecSrc::kScanline_Mode);
+            nativeModes.push_back(CodecSrc::kStripe_Mode);
+            nativeModes.push_back(CodecSrc::kCroppedScanline_Mode);
+            break;
+        case SkEncodedFormat::kWEBP_SkEncodedFormat:
+            nativeModes.push_back(CodecSrc::kSubset_Mode);
+            break;
+        default:
+            nativeModes.push_back(CodecSrc::kScanline_Mode);
+            nativeModes.push_back(CodecSrc::kStripe_Mode);
+            break;
+    }
 
-    CodecSrc::DstColorType colorTypes[3];
-    uint32_t numColorTypes;
+    SkTArray<CodecSrc::DstColorType> colorTypes;
     switch (codec->getInfo().colorType()) {
         case kGray_8_SkColorType:
-            colorTypes[0] = CodecSrc::kGetFromCanvas_DstColorType;
-            colorTypes[1] = CodecSrc::kGrayscale_Always_DstColorType;
+            colorTypes.push_back(CodecSrc::kGetFromCanvas_DstColorType);

[scroggo, 2016/02/22 18:46:47]

nit: You could include this once outside of the switch statement, and then skip
it in the switch statement.

[msarett, 2016/02/22 19:07:43]

Done.

+            colorTypes.push_back(CodecSrc::kGrayscale_Always_DstColorType);
             if (kWBMP_SkEncodedFormat == codec->getEncodedFormat()) {
-                colorTypes[2] = CodecSrc::kIndex8_Always_DstColorType;
-                numColorTypes = 3;
-            } else {
-                numColorTypes = 2;
+                colorTypes.push_back(CodecSrc::kIndex8_Always_DstColorType);
             }
             break;
         case kIndex_8_SkColorType:
-            colorTypes[0] = CodecSrc::kGetFromCanvas_DstColorType;
-            colorTypes[1] = CodecSrc::kIndex8_Always_DstColorType;
-            numColorTypes = 2;
+            colorTypes.push_back(CodecSrc::kGetFromCanvas_DstColorType);
+            colorTypes.push_back(CodecSrc::kIndex8_Always_DstColorType);
             break;
         default:
-            colorTypes[0] = CodecSrc::kGetFromCanvas_DstColorType;
-            numColorTypes = 1;
+            colorTypes.push_back(CodecSrc::kGetFromCanvas_DstColorType);
             break;
     }
 
     SkTArray<SkAlphaType> alphaModes;
     alphaModes.push_back(kPremul_SkAlphaType);
     alphaModes.push_back(kUnpremul_SkAlphaType);
     if (codec->getInfo().alphaType() == kOpaque_SkAlphaType) {
         alphaModes.push_back(kOpaque_SkAlphaType);
     }
 
     for (CodecSrc::Mode mode : nativeModes) {
         // SkCodecImageGenerator only runs for the default colorType
         // recommended by SkCodec.  There is no need to generate multiple
         // tests for different colorTypes.
         // TODO (msarett): Add scaling support to SkCodecImageGenerator.
         if (CodecSrc::kGen_Mode == mode) {
             // FIXME: The gpu backend does not draw kGray sources correctly. (skbug.com/4822)
             if (kGray_8_SkColorType != codec->getInfo().colorType()) {
                 push_codec_src(path, mode, CodecSrc::kGetFromCanvas_DstColorType,
                                codec->getInfo().alphaType(), 1.0f);
             }
             continue;
         }
 
         for (float scale : nativeScales) {
-            for (uint32_t i = 0; i < numColorTypes; i++) {
+            for (CodecSrc::DstColorType colorType : colorTypes) {
                 for (SkAlphaType alphaType : alphaModes) {
-                    push_codec_src(path, mode, colorTypes[i], alphaType, scale);
+                    // Only test kCroppedScanline_Mode when the alpha type is opaque.  The test is
+                    // slow and won't be interestingly different with different alpha types.
+                    if (CodecSrc::kCroppedScanline_Mode == mode &&
+                            kOpaque_SkAlphaType != alphaType) {
+                        continue;
+                    }
+
+                    push_codec_src(path, mode, colorType, alphaType, scale);
                 }
             }
         }
     }
 
     // https://bug.skia.org/4428
     bool subset = false;
     // The following image types are supported by BitmapRegionDecoder,
     // so we will test full image decodes and subset decodes.
     static const char* const exts[] = {
         "jpg", "jpeg", "png", "webp",
         "JPG", "JPEG", "PNG", "WEBP",
     };
     for (const char* ext : exts) {
         if (path.endsWith(ext)) {
             subset = true;
             break;
         }
     }
 
     const int sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 
     for (int sampleSize : sampleSizes) {
-        for (uint32_t i = 0; i < numColorTypes; i++) {
+        for (CodecSrc::DstColorType colorType : colorTypes) {
             for (SkAlphaType alphaType : alphaModes) {
-                push_android_codec_src(path, AndroidCodecSrc::kFullImage_Mode, colorTypes[i],
+                push_android_codec_src(path, AndroidCodecSrc::kFullImage_Mode, colorType,
                         alphaType, sampleSize);
                 if (subset) {
-                    push_android_codec_src(path, AndroidCodecSrc::kDivisor_Mode, colorTypes[i],
+                    push_android_codec_src(path, AndroidCodecSrc::kDivisor_Mode, colorType,
                             alphaType, sampleSize);
                 }
             }
         }
     }
 }
 
 static bool brd_color_type_supported(SkBitmapRegionDecoder::Strategy strategy,
         CodecSrc::DstColorType dstColorType) {
     switch (strategy) {
@@ skipping 833 matching lines @@
                                                            Reporter* reporter,
                                                            GrContextFactory* factory);
 } // namespace skiatest
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif