SkScaledCodec class

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 171 matching lines @@
     dinfo.global_state = DSTATE_READY;
     dinfo.num_components = 0;
     dinfo.scale_num = num;
     dinfo.scale_denom = denom;
     turbo_jpeg_calc_output_dimensions(&dinfo);
 
     // Return the calculated output dimensions for the given scale
     return SkISize::Make(dinfo.output_width, dinfo.output_height);
 }
 
+SkCodec::Result SkJpegCodec::initializeSwizzler(const SkImageInfo& requestedInfo,
+                                               void* dst, size_t rowBytes,
+                                               const Options& options,
+                                               SkPMColor ctable[],
+                                               int* ctableCount) {
+
+    const SkColorType srcColorType = requestedInfo.colorType();
+    SkSwizzler::SrcConfig srcConfig;
+    switch (srcColorType) {
+        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:
+            //would have exited before now if the colorType was supported by jpeg
+            SkASSERT(false);
+    }
+    int sampleX = this->getInfo().width() / requestedInfo.width();

[scroggo, 2015/07/30 17:53:01]

I think this should be shared with png, etc.

+
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, NULL, requestedInfo, dst, rowBytes,
+                                               options.fZeroInitialized, sampleX));
+    if (!fSwizzler) {
+        // FIXME: CreateSwizzler could fail for another reason.
+        return kUnimplemented;
+    }
+    return kSuccess;
+}
+
 /*
  * Handles rewinding the input stream if it is necessary
  */
 bool SkJpegCodec::handleRewind() {
     switch(this->rewindIfNeeded()) {
         case kCouldNotRewind_RewindState:
             return fDecoderMgr->returnFalse("could not rewind");
         case kRewound_RewindState: {
             JpegDecoderMgr* decoderMgr = NULL;
             if (!ReadHeader(this->stream(), NULL, &decoderMgr)) {
@@ skipping 78 matching lines @@
     fDecoderMgr->dinfo()->scale_denom = 8;
     fDecoderMgr->dinfo()->scale_num = 8;
     turbo_jpeg_calc_output_dimensions(fDecoderMgr->dinfo());
     while (fDecoderMgr->dinfo()->output_width != dstWidth ||
             fDecoderMgr->dinfo()->output_height != dstHeight) {
 
         // Return a failure if we have tried all of the possible scales
         if (1 == fDecoderMgr->dinfo()->scale_num ||
                 dstWidth > fDecoderMgr->dinfo()->output_width ||
                 dstHeight > fDecoderMgr->dinfo()->output_height) {
+            this->fDecoderMgr->dinfo()->scale_num = 8;

[scroggo, 2015/07/30 17:53:01]

Could you add a comment explaining this? I think the idea is that we reset to a
1:1 decode, and let the swizzler take care of sampling?

[emmaleer, 2015/07/30 22:27:55]

Yes, the idea is if scaleToDimensions fails, then the native scaling settings
should not be set. (before they were being set, but we failed creating the
scanline decoder so it didn't matter)
I think it makes sense for no scaling settings to change if the function fails. 

+            turbo_jpeg_calc_output_dimensions(this->fDecoderMgr->dinfo());
             return fDecoderMgr->returnFalse("could not scale to requested dimensions");
         }
 
         // Try the next scale
         fDecoderMgr->dinfo()->scale_num -= 1;
         turbo_jpeg_calc_output_dimensions(fDecoderMgr->dinfo());
     }
     return true;
 }
 
@@ skipping 78 matching lines @@
 }
 
 /*
  * Enable scanline decoding for jpegs
  */
 class SkJpegScanlineDecoder : public SkScanlineDecoder {
 public:
     SkJpegScanlineDecoder(const SkImageInfo& dstInfo, SkJpegCodec* codec)
         : INHERITED(dstInfo)
         , fCodec(codec)
-    {}
+    {
+        fStorage.reset(fCodec->getInfo().width() * dstInfo.minRowBytes());
+        fSrcRow = static_cast<uint8_t*>(fStorage.get());
+    }
 
     virtual ~SkJpegScanlineDecoder() {
         if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
             SkCodecPrintf("setjmp: Error in libjpeg finish_decompress\n");
             return;
         }
 
         // We may not have decoded the entire image.  Prevent libjpeg-turbo from failing on a
         // partial decode.
         fCodec->fDecoderMgr->dinfo()->output_scanline = fCodec->getInfo().height();
         turbo_jpeg_finish_decompress(fCodec->fDecoderMgr->dinfo());
     }
 
     SkCodec::Result onGetScanlines(void* dst, int count, size_t rowBytes) override {
         // Set the jump location for libjpeg errors
         if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
             return fCodec->fDecoderMgr->returnFailure("setjmp", SkCodec::kInvalidInput);
         }
+        // Read rows one at a time
+        JSAMPLE* dstRow;
+        if (fCodec->fSwizzler) {
+            // write data to storage row, then sample using swizzler         
+            dstRow = fSrcRow;
+        } else {
+            // write data directly to dst
+            dstRow = (JSAMPLE*) dst;
+        }
 
-        // Read rows one at a time
-        JSAMPLE* dstRow = (JSAMPLE*) dst;
         for (int y = 0; y < count; y++) {
             // Read row of the image
             uint32_t rowsDecoded =
                     turbo_jpeg_read_scanlines(fCodec->fDecoderMgr->dinfo(), &dstRow, 1);
             if (rowsDecoded != 1) {
                 SkSwizzler::Fill(
                         dstRow, this->dstInfo(), rowBytes, count - y, SK_ColorBLACK, NULL);
                 fCodec->fDecoderMgr->dinfo()->output_scanline = this->dstInfo().height();
                 return SkCodec::kIncompleteInput;
             }
 
             // Convert to RGBA if necessary
             if (JCS_CMYK == fCodec->fDecoderMgr->dinfo()->out_color_space) {
                 convert_CMYK_to_RGBA(dstRow, this->dstInfo().width());
             }
 
-            // Move to the next row
-            dstRow = SkTAddOffset<JSAMPLE>(dstRow, rowBytes);
+            if(fCodec->fSwizzler) {
+                // use swizzler to sample row
+                fCodec->fSwizzler->setDstRow(dst);
+                fCodec->fSwizzler->next(dstRow);
+                dst += rowBytes;
+            } else {
+                dstRow = SkTAddOffset<JSAMPLE>(dstRow, rowBytes);
+            }
         }
-
         return SkCodec::kSuccess;
     }
 
 #ifndef TURBO_HAS_SKIP
 #define turbo_jpeg_skip_scanlines(dinfo, count)                              \
     SkAutoMalloc storage(dinfo->output_width * dinfo->out_color_components); \
     uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());              \
     for (int y = 0; y < count; y++) {                                        \
         turbo_jpeg_read_scanlines(dinfo, &storagePtr, 1);                    \
     }
 #endif
 
     SkCodec::Result onSkipScanlines(int count) override {
         // Set the jump location for libjpeg errors
         if (setjmp(fCodec->fDecoderMgr->getJmpBuf())) {
             return fCodec->fDecoderMgr->returnFailure("setjmp", SkCodec::kInvalidInput);
         }
 
         turbo_jpeg_skip_scanlines(fCodec->fDecoderMgr->dinfo(), count);
 
         return SkCodec::kSuccess;
     }
 
 private:
     SkAutoTDelete<SkJpegCodec> fCodec;
+    SkAutoMalloc                fStorage;

[msarett, 2015/07/30 13:55:38]

nit: off by a space

[emmaleer, 2015/07/30 17:50:39]

Acknowledged.

+    uint8_t*                    fSrcRow;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkJpegCodec::onGetScanlineDecoder(const SkImageInfo& dstInfo,
         const Options& options, SkPMColor ctable[], int* ctableCount) {
 
     // Rewind the stream if needed
     if (!this->handleRewind()) {
         SkCodecPrintf("Could not rewind\n");
@@ skipping 16 matching lines @@
     }
 
     // Check if we can decode to the requested destination and set the output color space
     if (!codec->setOutputColorSpace(dstInfo)) {
         SkCodecPrintf("Cannot convert to output type\n");
         return NULL;
     }
 
     // Perform the necessary scaling
     if (!codec->scaleToDimensions(dstInfo.width(), dstInfo.height())) {
-        SkCodecPrintf("Cannot scale to output dimensions\n");
-        return NULL;
+        // native scaling to dstInfo dimensions not supported
+
+        if (dstInfo.height() != this->getInfo().height()) {
+            // no non-native height sampling supported
+            return NULL;
+        }
+        // create swizzler for sampling
+        if (codec->initializeSwizzler(dstInfo, NULL, dstInfo.minRowBytes(), options, ctable,
+                                      ctableCount) != kSuccess) {
+            SkCodecPrintf("failed to initialize the swizzler.\n");
+            return NULL;
+        }
     }
 
     // Now, given valid output dimensions, we can start the decompress
     if (!turbo_jpeg_start_decompress(codec->fDecoderMgr->dinfo())) {
         SkCodecPrintf("start decompress failed\n");
         return NULL;
     }
 
     // Return the new scanline decoder
     return SkNEW_ARGS(SkJpegScanlineDecoder, (dstInfo, codec.detach()));
 }