Use new jpeg_crop_scanlines() API to optimize jpeg subset decodes

dm/DMSrcSink.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "DMSrcSink.h"
 #include "SkAndroidCodec.h"
 #include "SkCodec.h"
@@ skipping 504 matching lines @@
                 // Skip a stripe
                 const int linesToSkip = SkTMin(stripeHeight, height - (i + 1) * stripeHeight);
                 if (linesToSkip > 0) {
                     codec->skipScanlines(linesToSkip);
                 }
             }
             premultiply_if_necessary(bitmap);
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
+        case kCroppedScanline_Mode: {
+            const int width = decodeInfo.width();
+            const int height = decodeInfo.height();
+            // This value is chosen because, as we move across the image, it will sometimes
+            // align with the jpeg block sizes and it will sometimes not.  This allows us

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

Is this because it is not a multiple of 8? (But for after the second tile we'll
have a multiple of 8?)

Doesn't this mean that we'll always end up expanding the width (and every other
tile expanding the start) and only cover the case where we needed the swizzler?

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

The block size is generally 8 or 16.  And the requirement from libjpeg-turbo is
that startX be aligned to the block size.

There is no alignment requirement for the width - I think this wasn't clear.

So we should have:
startX = 0: Aligned no swizzler
startX = 36: Not-aligned
startX = 72: Maybe aligned (depending on if block size is 8 or 16)
startX = 108: Not-aligned
startX = 144: Aligned no swizzler
... 

[scroggo, 2016/02/22 19:20:20]

Ah, so if width changes, it will be to add originalStartX - alignedStartX. I
just looked back at the code in onStartScanlineDecode, and you actually do make
this clear in your comments before calling jpeg_crop_scanline

+            // to test interestingly different code paths in the implementation.
+            const int tileSize = 36;
+
+            SkCodec::Options opts;
+            SkIRect subset;
+            for (int x = 0; x < width; x += tileSize) {
+                subset = SkIRect::MakeXYWH(x, 0, SkTMin(tileSize, width - x), height);
+                opts.fSubset = &subset;
+                if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, &opts,
+                        colorPtr, colorCountPtr)) {
+                    return "Could not start scanline decoder.";
+                }
+
+                codec->getScanlines(bitmap.getAddr(x, 0), height, bitmap.rowBytes());
+            }
+
+            premultiply_if_necessary(bitmap);
+            canvas->drawBitmap(bitmap, 0, 0);
+            break;
+        }
         case kSubset_Mode: {
             // Arbitrarily choose a divisor.
             int divisor = 2;
             // Total width/height of the image.
             const int W = codec->getInfo().width();
             const int H = codec->getInfo().height();
             if (divisor > W || divisor > H) {
                 return Error::Nonfatal(SkStringPrintf("Cannot codec subset: divisor %d is too big "
                                                       "for %s with dimensions (%d x %d)", divisor,
                                                       fPath.c_str(), W, H));
@@ skipping 872 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return check_against_reference(bitmap, src, fSink);
     });
 }
 
 }  // namespace DM