Add subsetting to SkScaledCodec

src/codec/SkJpegCodec.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 "SkCodec.h"
 #include "SkJpegCodec.h"
 #include "SkJpegDecoderMgr.h"
@@ skipping 145 matching lines @@
 
 }
 /*
  * Return a valid set of output dimensions for this decoder, given an input scale
  */
 SkISize SkJpegCodec::onGetScaledDimensions(float desiredScale) const {
     // libjpeg-turbo supports scaling by 1/8, 1/4, 3/8, 1/2, 5/8, 3/4, 7/8, and 1/1, so we will
     // support these as well
     long num;
     long denom = 8;
-    if (desiredScale > 0.875f) {
+    if (desiredScale >= 0.9375) {

[scroggo, 2015/10/02 18:27:03]

why did this change?

[msarett, 2015/10/06 23:01:27]

IMO, it used to make sense to always round up, since libjpeg-turbo also always
rounds up, we could be consistent in a sense.

Now we have completing scaling strategies, some of which round up and others of
which round down.  I think we should try to get as close as possible to the
requested scale, since we will be comparing this scaling option with other
scaling options, and choosing the best one.

         num = 8;
-    } else if (desiredScale > 0.75f) {
+    } else if (desiredScale >= 0.8125) {
         num = 7;
-    } else if (desiredScale > 0.625f) {
+    } else if (desiredScale >= 0.6875f) {
         num = 6;
-    } else if (desiredScale > 0.5f) {
+    } else if (desiredScale >= 0.5625f) {
         num = 5;
-    } else if (desiredScale > 0.375f) {
+    } else if (desiredScale >= 0.4375f) {
         num = 4;
-    } else if (desiredScale > 0.25f) {
+    } else if (desiredScale >= 0.3125f) {
         num = 3;
-    } else if (desiredScale > 0.125f) {
+    } else if (desiredScale >= 0.1875f) {
         num = 2;
     } else {
         num = 1;
     }
 
     // Set up a fake decompress struct in order to use libjpeg to calculate output dimensions
     jpeg_decompress_struct dinfo;
     sk_bzero(&dinfo, sizeof(dinfo));
     dinfo.image_width = this->getInfo().width();
     dinfo.image_height = this->getInfo().height();
@@ skipping 172 matching lines @@
         }
 
         // Move to the next row
         dstRow = SkTAddOffset<JSAMPLE>(dstRow, dstRowBytes);
     }
     jpeg_finish_decompress(dinfo);
 
     return kSuccess;
 }
 
-SkCodec::Result SkJpegCodec::initializeSwizzler(const SkImageInfo& info, const Options& options) {
+SkCodec::Result SkJpegCodec::initializeSwizzler(const SkImageInfo& info, const Options& options,
+        int subsetLeft, int subsetWidth) {
     SkSwizzler::SrcConfig srcConfig;
     switch (info.colorType()) {
         case kGray_8_SkColorType:
             srcConfig = SkSwizzler::kGray;
             break;
         case kRGBA_8888_SkColorType:
             srcConfig = SkSwizzler::kRGBX;
             break;
         case kBGRA_8888_SkColorType:
             srcConfig = SkSwizzler::kBGRX;
             break;
         case kRGB_565_SkColorType:
             srcConfig = SkSwizzler::kRGB_565;
             break;
         default:
             // This function should only be called if the colorType is supported by jpeg
             SkASSERT(false);
     }
 
-    fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, info, options.fZeroInitialized, 
-                                               this->getInfo()));
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, info, options.fZeroInitialized,
+                                               this->getInfo(), subsetLeft, subsetWidth));
     if (!fSwizzler) {
         return SkCodec::kUnimplemented;
     }
 
     return kSuccess;
 }
 
 SkCodec::Result SkJpegCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
-        const Options& options, SkPMColor ctable[], int* ctableCount) {
+        const Options& options, SkPMColor ctable[], int* ctableCount, int subsetLeft,
+        int subsetWidth) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         SkCodecPrintf("setjmp: Error from libjpeg\n");
         return kInvalidInput;
     }
 
     // Check if we can decode to the requested destination and set the output color space
     if (!this->setOutputColorSpace(dstInfo)) {
         return kInvalidConversion;
     }
 
     // Perform the necessary scaling
     if (!this->nativelyScaleToDimensions(dstInfo.width(), dstInfo.height())) {
         // full native scaling to dstInfo dimensions not supported
 
         if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
             return kInvalidScale;
         }
+
         // create swizzler for sampling
-        Result result = this->initializeSwizzler(dstInfo, options);
-        if (kSuccess != result) {
+        SkCodec::Result result = this->initializeSwizzler(dstInfo, options, subsetLeft,
+                subsetWidth);
+        if (SkCodec::kSuccess != result) {
             SkCodecPrintf("failed to initialize the swizzler.\n");
             return result;
         }
-        fStorage.reset(get_row_bytes(fDecoderMgr->dinfo()));
+        fStorage.reset(get_row_bytes(this->fDecoderMgr->dinfo()));
+        fSrcRow = static_cast<uint8_t*>(fStorage.get());
+    } else if (0 != subsetLeft || dstInfo.width() != subsetWidth) {
+        // TODO (msarett): If we implement a read partial scanlines API in libjpeg-turbo, we
+        //                 won't need to use the swizzler here.
+        // Create swizzler for subsetting.  We pass in the original info because scaling is
+        // handlded natively.
+        SkCodec::Result result = this->initializeSwizzler(
+                dstInfo.makeWH(this->getInfo().width(), this->getInfo().height()), options,
+                subsetLeft, subsetWidth);
+        if (SkCodec::kSuccess != result) {
+            SkCodecPrintf("failed to initialize the swizzler.\n");
+            return result;
+        }
+        fStorage.reset(get_row_bytes(this->fDecoderMgr->dinfo()));
         fSrcRow = static_cast<uint8_t*>(fStorage.get());
     } else {
         fSrcRow = nullptr;
         fSwizzler.reset(nullptr);
     }
 
     // Now, given valid output dimensions, we can start the decompress
     if (!jpeg_start_decompress(fDecoderMgr->dinfo())) {
         SkCodecPrintf("start decompress failed\n");
         return kInvalidInput;
@@ skipping 67 matching lines @@
 #endif
 
 bool SkJpegCodec::onSkipScanlines(int count) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         return fDecoderMgr->returnFailure("setjmp", kInvalidInput);
     }
 
     return count == jpeg_skip_scanlines(fDecoderMgr->dinfo(), count);
 }