Skia side RGB to YUV gpu conversion

src/images/SkImageDecoder_libjpeg.cpp

 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
@@ skipping 84 matching lines @@
     }
     /* To suppress error messages with a SK_DEBUG binary, set the
      * environment variable "skia_images_jpeg_suppressDecoderErrors"
      * to "true".  Inside a program that links to skia:
      * SK_CONF_SET("images.jpeg.suppressDecoderErrors", true); */
     if (c_suppressJPEGImageDecoderErrors) {
         cinfo->err->output_message = &do_nothing_output_message;
     }
 }
 
+static void compute_uv_size(const jpeg_decompress_struct& info, int& width, int& height)
+{
+    int h  = info.cur_comp_info[0]->h_samp_factor;
+    int v  = info.cur_comp_info[0]->v_samp_factor;
+    width  = (info.output_width + h - 1) / h;
+    height = (info.output_height + v - 1) / v;
+}
+
 #ifdef SK_BUILD_FOR_ANDROID
 class SkJPEGImageIndex {
 public:
     SkJPEGImageIndex(SkStreamRewindable* stream, SkImageDecoder* decoder)
         : fSrcMgr(stream, decoder)
         , fInfoInitialized(false)
         , fHuffmanCreated(false)
         , fDecompressStarted(false)
         {
             SkDEBUGCODE(fReadHeaderSucceeded = false;)
@@ skipping 95 matching lines @@
     huffman_index fHuffmanIndex;
     bool fInfoInitialized;
     bool fHuffmanCreated;
     bool fDecompressStarted;
     SkDEBUGCODE(bool fReadHeaderSucceeded;)
 };
 #endif
 
 class SkJPEGImageDecoder : public SkImageDecoder {
 public:
+    SkJPEGImageDecoder() {
 #ifdef SK_BUILD_FOR_ANDROID
-    SkJPEGImageDecoder() {
         fImageIndex = NULL;
         fImageWidth = 0;
         fImageHeight = 0;
+#endif
+        fYUVBuffers[0] = fYUVBuffers[1] = fYUVBuffers[2] = NULL;
+        fRowBytes[0] = fRowBytes[1] = fRowBytes[2] = 0;
     }
 
+#ifdef SK_BUILD_FOR_ANDROID
     virtual ~SkJPEGImageDecoder() {
         SkDELETE(fImageIndex);
     }
 #endif
 
     virtual Format getFormat() const {
         return kJPEG_Format;
     }
 
+    virtual bool getImageFormat(SkStream* stream, SkISize sizes[3]) SK_OVERRIDE;
+    virtual void setYUVBuffers(void* yuv[3], size_t rowBytes[3]) SK_OVERRIDE;
+
 protected:
 #ifdef SK_BUILD_FOR_ANDROID
     virtual bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) SK_OVERRIDE;
     virtual bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) SK_OVERRIDE;
 #endif
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
 
 private:
 #ifdef SK_BUILD_FOR_ANDROID
     SkJPEGImageIndex* fImageIndex;
     int fImageWidth;
     int fImageHeight;
 #endif
+    uint8_t* fYUVBuffers[3];
+    size_t fRowBytes[3];
+
+    bool isSupportedYUVFormat(jpeg_decompress_struct& cinfo) const {
+        if ((cinfo.jpeg_color_space == JCS_YCbCr) &&
+            (cinfo.num_components == 3) &&
+            (cinfo.scale_denom <= 8) &&
+            (cinfo.cur_comp_info[1]->h_samp_factor == 1) &&
+            (cinfo.cur_comp_info[1]->v_samp_factor == 1) &&
+            (cinfo.cur_comp_info[2]->h_samp_factor == 1) &&
+            (cinfo.cur_comp_info[2]->v_samp_factor == 1)) {
+            int h = cinfo.cur_comp_info[0]->h_samp_factor;
+            int v = cinfo.cur_comp_info[0]->v_samp_factor;
+            if (((h == 1) || (h == 2) || (h == 4)) &&
+                ((v == 1) || (v == 2))) {
+                cinfo.out_color_space = JCS_YCbCr;
+                cinfo.raw_data_out = TRUE;
+
+#ifdef SK_PRINT_YUV_FORMAT
+                printf("YUV 4:%d:%d\n", 4 / h, (v == 1) ? 4 / h : 0);

[scroggo, 2014/07/18 21:52:41]

SkDebugf?

+#endif
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool canDecodeToYUV(jpeg_decompress_struct& cinfo) const {
+        return ((NULL != fYUVBuffers[0]) &&
+                (NULL != fYUVBuffers[1]) &&
+                (NULL != fYUVBuffers[2]) &&
+                (fRowBytes[0] > 0) &&
+                (fRowBytes[1] > 0) &&
+                (fRowBytes[2] > 0) &&
+                isSupportedYUVFormat(cinfo));
+    }
 
     /**
      *  Determine the appropriate bitmap colortype and out_color_space based on
      *  both the preference of the caller and the jpeg_color_space on the
      *  jpeg_decompress_struct passed in.
      *  Must be called after jpeg_read_header.
      */
     SkColorType getBitmapColorType(jpeg_decompress_struct*);
 
+    bool decodeToBitmap(SkBitmap* bm,
+                        jpeg_decompress_struct& cinfo,
+                        SkScaledBitmapSampler& sampler);
+    bool decodeToYUV(jpeg_decompress_struct& cinfo);
+
     typedef SkImageDecoder INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////
 
 /* Automatically clean up after throwing an exception */
 class JPEGAutoClean {
 public:
     JPEGAutoClean(): cinfo_ptr(NULL) {}
     ~JPEGAutoClean() {
@@ skipping 50 matching lines @@
             return false;
         }
     }
     return true;
 }
 #endif
 
 // This guy exists just to aid in debugging, as it allows debuggers to just
 // set a break-point in one place to see all error exists.
 static bool return_false(const jpeg_decompress_struct& cinfo,
-                         const SkBitmap& bm, const char caller[]) {
+                         const SkBitmap* bm, const char caller[]) {
     if (!(c_suppressJPEGImageDecoderErrors)) {
         char buffer[JMSG_LENGTH_MAX];
         cinfo.err->format_message((const j_common_ptr)&cinfo, buffer);
         SkDebugf("libjpeg error %d <%s> from %s [%d %d]\n",
-                 cinfo.err->msg_code, buffer, caller, bm.width(), bm.height());
+                 cinfo.err->msg_code, buffer, caller,
+                 (NULL == bm) ? bm->width() : 0,

[scroggo, 2014/07/18 21:52:41]

This is backwards. If NULL == bm, you want to return 0. Otherwise you should
return bm->width()

+                 (NULL == bm) ? bm->height() : 0);
     }
     return false;   // must always return false
 }
 
 // Convert a scanline of CMYK samples to RGBX in place. Note that this
 // method moves the "scanline" pointer in its processing
 static void convert_CMYK_to_RGB(uint8_t* scanline, unsigned int width) {
     // At this point we've received CMYK pixels from libjpeg. We
     // perform a crude conversion to RGB (based on the formulae
     // from easyrgb.com):
@@ skipping 194 matching lines @@
 
     jpeg_decompress_struct  cinfo;
     skjpeg_source_mgr       srcManager(stream, this);
 
     skjpeg_error_mgr errorManager;
     set_error_mgr(&cinfo, &errorManager);
 
     // All objects need to be instantiated before this setjmp call so that
     // they will be cleaned up properly if an error occurs.
     if (setjmp(errorManager.fJmpBuf)) {
-        return return_false(cinfo, *bm, "setjmp");
+        return return_false(cinfo, bm, "setjmp");
     }
 
     initialize_info(&cinfo, &srcManager);
     autoClean.set(&cinfo);
 
     int status = jpeg_read_header(&cinfo, true);
     if (status != JPEG_HEADER_OK) {
-        return return_false(cinfo, *bm, "read_header");
+        return return_false(cinfo, bm, "read_header");
     }
 
     /*  Try to fulfill the requested sampleSize. Since jpeg can do it (when it
         can) much faster that we, just use their num/denom api to approximate
         the size.
     */
     int sampleSize = this->getSampleSize();
 
     set_dct_method(*this, &cinfo);
 
@@ skipping 34 matching lines @@
         if (SkImageDecoder::kDecodeBounds_Mode == mode && valid_output_dimensions(cinfo)) {
             SkScaledBitmapSampler smpl(cinfo.output_width, cinfo.output_height,
                                        recompute_sampleSize(sampleSize, cinfo));
             // Assume an A8 bitmap is not opaque to avoid the check of each
             // individual pixel. It is very unlikely to be opaque, since
             // an opaque A8 bitmap would not be very interesting.
             // Otherwise, a jpeg image is opaque.
             return bm->setInfo(SkImageInfo::Make(smpl.scaledWidth(), smpl.scaledHeight(),
                                                  colorType, alphaType));
         } else {
-            return return_false(cinfo, *bm, "start_decompress");
+            return return_false(cinfo, bm, "start_decompress");
         }
     }
     sampleSize = recompute_sampleSize(sampleSize, cinfo);
 
 #ifdef SK_SUPPORT_LEGACY_IMAGEDECODER_CHOOSER
     // should we allow the Chooser (if present) to pick a colortype for us???
     if (!this->chooseFromOneChoice(colorType, cinfo.output_width, cinfo.output_height)) {
-        return return_false(cinfo, *bm, "chooseFromOneChoice");
+        return return_false(cinfo, bm, "chooseFromOneChoice");
     }
 #endif
 
     SkScaledBitmapSampler sampler(cinfo.output_width, cinfo.output_height, sampleSize);
     // Assume an A8 bitmap is not opaque to avoid the check of each
     // individual pixel. It is very unlikely to be opaque, since
     // an opaque A8 bitmap would not be very interesting.
     // Otherwise, a jpeg image is opaque.
     bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(),
                                   colorType, alphaType));
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return true;
     }
+
+    return canDecodeToYUV(cinfo) ? decodeToYUV(cinfo) : decodeToBitmap(bm, cinfo, sampler);

[scroggo, 2014/07/18 21:52:41]

It seems awkward that if canDecodeToYUV is true we do decode into YUV, with no
apparent choice from the caller (I guess that comes earlier whey they called
setYUVBuffers).

This goes a little deeper though: it's strange that the caller called
SkImageDecoder::decode, passing in an SkBitmap, but the implementation ignored
that SkBitmap and filled out arrays that were passed in elsewhere.

+}
+
+bool SkJPEGImageDecoder::decodeToBitmap(SkBitmap* bm,
+                                        jpeg_decompress_struct& cinfo,
+                                        SkScaledBitmapSampler& sampler) {
     if (!this->allocPixelRef(bm, NULL)) {
-        return return_false(cinfo, *bm, "allocPixelRef");
+        return return_false(cinfo, bm, "allocPixelRef");
     }
 
     SkAutoLockPixels alp(*bm);
 
 #ifdef ANDROID_RGB
     /* short-circuit the SkScaledBitmapSampler when possible, as this gives
        a significant performance boost.
     */
     if (sampleSize == 1 &&
         ((kN32_SkColorType == colorType && cinfo.out_color_space == JCS_RGBA_8888) ||
          (kRGB_565_SkColorType == colorType && cinfo.out_color_space == JCS_RGB_565)))
     {
         JSAMPLE* rowptr = (JSAMPLE*)bm->getPixels();
         INT32 const bpr =  bm->rowBytes();
 
         while (cinfo.output_scanline < cinfo.output_height) {
             int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1);
             if (0 == row_count) {
                 // if row_count == 0, then we didn't get a scanline,
                 // so return early.  We will return a partial image.
                 fill_below_level(cinfo.output_scanline, bm);
                 cinfo.output_scanline = cinfo.output_height;
                 break;  // Skip to jpeg_finish_decompress()
             }
             if (this->shouldCancelDecode()) {
-                return return_false(cinfo, *bm, "shouldCancelDecode");
+                return return_false(cinfo, bm, "shouldCancelDecode");
             }
             rowptr += bpr;
         }
         jpeg_finish_decompress(&cinfo);
         return true;
     }
 #endif
 
     // check for supported formats
     SkScaledBitmapSampler::SrcConfig sc;
     int srcBytesPerPixel;
 
     if (!get_src_config(cinfo, &sc, &srcBytesPerPixel)) {
-        return return_false(cinfo, *bm, "jpeg colorspace");
+        return return_false(cinfo, bm, "jpeg colorspace");
     }
 
     if (!sampler.begin(bm, sc, *this)) {
-        return return_false(cinfo, *bm, "sampler.begin");
+        return return_false(cinfo, bm, "sampler.begin");
     }
 
     SkAutoMalloc srcStorage(cinfo.output_width * srcBytesPerPixel);
     uint8_t* srcRow = (uint8_t*)srcStorage.get();
 
     //  Possibly skip initial rows [sampler.srcY0]
     if (!skip_src_rows(&cinfo, srcRow, sampler.srcY0())) {
-        return return_false(cinfo, *bm, "skip rows");
+        return return_false(cinfo, bm, "skip rows");
     }
 
     // now loop through scanlines until y == bm->height() - 1
     for (int y = 0;; y++) {
         JSAMPLE* rowptr = (JSAMPLE*)srcRow;
         int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1);
         if (0 == row_count) {
             // if row_count == 0, then we didn't get a scanline,
             // so return early.  We will return a partial image.
             fill_below_level(y, bm);
             cinfo.output_scanline = cinfo.output_height;
             break;  // Skip to jpeg_finish_decompress()
         }
         if (this->shouldCancelDecode()) {
-            return return_false(cinfo, *bm, "shouldCancelDecode");
+            return return_false(cinfo, bm, "shouldCancelDecode");
         }
 
         if (JCS_CMYK == cinfo.out_color_space) {
             convert_CMYK_to_RGB(srcRow, cinfo.output_width);
         }
 
         sampler.next(srcRow);
         if (bm->height() - 1 == y) {
             // we're done
             break;
         }
 
         if (!skip_src_rows(&cinfo, srcRow, sampler.srcDY() - 1)) {
-            return return_false(cinfo, *bm, "skip rows");
+            return return_false(cinfo, bm, "skip rows");
         }
     }
 
     // we formally skip the rest, so we don't get a complaint from libjpeg
     if (!skip_src_rows(&cinfo, srcRow,
                        cinfo.output_height - cinfo.output_scanline)) {
-        return return_false(cinfo, *bm, "skip rows");
+        return return_false(cinfo, bm, "skip rows");
     }
     jpeg_finish_decompress(&cinfo);
 
     return true;
 }
 
+bool SkJPEGImageDecoder::decodeToYUV(jpeg_decompress_struct& cinfo) {
+    uint8_t* bufferraw[3];
+    uint8_t* bufferraw2[32];
+    bufferraw[0] = (uint8_t*)&bufferraw2[0];
+    bufferraw[1] = (uint8_t*)&bufferraw2[16];
+    bufferraw[2] = (uint8_t*)&bufferraw2[24];
+    int yWidth   = cinfo.output_width;
+    int yHeight  = cinfo.output_height;
+    int yMaxH    = yHeight - 1;
+    int v        = cinfo.cur_comp_info[0]->v_samp_factor;
+    int uvWidth(0), uvHeight(0);
+    compute_uv_size(cinfo, uvWidth, uvHeight);
+    int uvMaxH   = uvHeight - 1;
+
+    SkAutoMalloc lastRowStorage(yWidth * 8);
+    uint8_t* yLastRow = (uint8_t*)lastRowStorage.get();
+    uint8_t* uLastRow = yLastRow + 2 * yWidth;
+    uint8_t* vLastRow = uLastRow + 2 * yWidth;
+    uint8_t* dummyRow = vLastRow + 2 * yWidth;
+
+    int scanlinesToRead = DCTSIZE * v;
+    while (cinfo.output_scanline < cinfo.output_height) {
+        // Request 8 or 16 scanlines: returns 0 or more scanlines.
+        bool hasYLastRow(false), hasUVLastRow(false);
+        for (int i = 0; i < scanlinesToRead; ++i) {
+            int scanline  = (cinfo.output_scanline + i);
+            if (scanline < yMaxH) {
+                bufferraw2[i] = &fYUVBuffers[0][scanline * fRowBytes[0]];
+            } else if (scanline == yMaxH) {
+                bufferraw2[i] = yLastRow;
+                hasYLastRow = true;
+            } else {
+                bufferraw2[i] = dummyRow;
+            }
+        }
+        int scaledScanline = cinfo.output_scanline / v;
+        for (int i = 0; i < 8; ++i) {
+            int scanline = (scaledScanline + i);
+            if (scanline < uvMaxH) {
+                bufferraw2[16+i] = &fYUVBuffers[1][scanline * fRowBytes[1]];
+                bufferraw2[24+i] = &fYUVBuffers[2][scanline * fRowBytes[2]];
+            } else if (scanline == uvMaxH) {
+                bufferraw2[16+i] = uLastRow;
+                bufferraw2[24+i] = vLastRow;
+                hasUVLastRow = true;
+            } else {
+                bufferraw2[16+i] = dummyRow;
+                bufferraw2[24+i] = dummyRow;
+            }
+        }
+        JDIMENSION scanlinesRead = jpeg_read_raw_data(&cinfo, (JSAMPIMAGE)bufferraw, scanlinesToRead);

[scroggo, 2014/07/18 21:52:41]

100 chars

+        if (scanlinesRead == 0) {
+            return false;
+        }
+        if (hasYLastRow) {
+            memcpy(&fYUVBuffers[0][ yMaxH *  yWidth], yLastRow, yWidth);
+        }
+        if (hasUVLastRow) {
+            memcpy(&fYUVBuffers[1][uvMaxH * uvWidth], uLastRow, uvWidth);
+            memcpy(&fYUVBuffers[2][uvMaxH * uvWidth], vLastRow, uvWidth);
+        }
+    }
+
+    if (cinfo.output_scanline > cinfo.output_height) {
+        cinfo.output_scanline = cinfo.output_height;
+    }
+
+    jpeg_finish_decompress(&cinfo);
+
+    return true;
+}
+
+void SkJPEGImageDecoder::setYUVBuffers(void* yuv[3], size_t rowBytes[3]) {
+    for (int i = 0; i < 3; ++i) {
+        fYUVBuffers[i] = (uint8_t*)yuv[i];
+        fRowBytes[i] = rowBytes[i];
+    }
+}
+
+bool SkJPEGImageDecoder::getImageFormat(SkStream* stream, SkISize sizes[3]) {
+    JPEGAutoClean autoClean;
+
+    jpeg_decompress_struct  cinfo;
+    skjpeg_source_mgr       srcManager(stream, this);
+
+    skjpeg_error_mgr errorManager;
+    set_error_mgr(&cinfo, &errorManager);
+
+    // All objects need to be instantiated before this setjmp call so that
+    // they will be cleaned up properly if an error occurs.
+    if (setjmp(errorManager.fJmpBuf)) {
+        return return_false(cinfo, NULL, "setjmp");
+    }
+
+    initialize_info(&cinfo, &srcManager);
+    autoClean.set(&cinfo);
+
+    int status = jpeg_read_header(&cinfo, true);
+    if (status != JPEG_HEADER_OK) {
+        return return_false(cinfo, NULL, "read_header");
+    }
+
+    if (isSupportedYUVFormat(cinfo)) {
+        jpeg_start_decompress(&cinfo); // Compute output width
+        sizes[0].set(cinfo.output_width, cinfo.output_height);
+        int w(0), h(0);
+        compute_uv_size(cinfo, w, h);
+        sizes[1].set(w, h);
+        sizes[2].set(w, h);
+        jpeg_abort_decompress(&cinfo);
+        return true;
+    }
+    return false;
+}
+
 #ifdef SK_BUILD_FOR_ANDROID
 bool SkJPEGImageDecoder::onBuildTileIndex(SkStreamRewindable* stream, int *width, int *height) {
 
     SkAutoTDelete<SkJPEGImageIndex> imageIndex(SkNEW_ARGS(SkJPEGImageIndex, (stream, this)));
     jpeg_decompress_struct* cinfo = imageIndex->cinfo();
 
     skjpeg_error_mgr sk_err;
     set_error_mgr(cinfo, &sk_err);
 
     // All objects need to be instantiated before this setjmp call so that
@@ skipping 103 matching lines @@
     // swap happening. If no, then we will use alloc to allocate pixels to
     // prevent garbage collection.
     int w = rect.width() / actualSampleSize;
     int h = rect.height() / actualSampleSize;
     bool swapOnly = (rect == region) && bm->isNull() &&
                     (w == bitmap.width()) && (h == bitmap.height()) &&
                     ((startX - rect.x()) / actualSampleSize == 0) &&
                     ((startY - rect.y()) / actualSampleSize == 0);
     if (swapOnly) {
         if (!this->allocPixelRef(&bitmap, NULL)) {
-            return return_false(*cinfo, bitmap, "allocPixelRef");
+            return return_false(*cinfo, &bitmap, "allocPixelRef");
         }
     } else {
         if (!bitmap.allocPixels()) {
-            return return_false(*cinfo, bitmap, "allocPixels");
+            return return_false(*cinfo, &bitmap, "allocPixels");
         }
     }
 
     SkAutoLockPixels alp(bitmap);
 
 #ifdef ANDROID_RGB
     /* short-circuit the SkScaledBitmapSampler when possible, as this gives
        a significant performance boost.
     */
     if (skiaSampleSize == 1 &&
         ((kN32_SkColorType == colorType && cinfo->out_color_space == JCS_RGBA_8888) ||
          (kRGB_565_SkColorType == colorType && cinfo->out_color_space == JCS_RGB_565)))
     {
         JSAMPLE* rowptr = (JSAMPLE*)bitmap.getPixels();
         INT32 const bpr = bitmap.rowBytes();
         int rowTotalCount = 0;
 
         while (rowTotalCount < height) {
             int rowCount = jpeg_read_tile_scanline(cinfo,
                                                    fImageIndex->huffmanIndex(),
                                                    &rowptr);
             // if rowCount == 0, then we didn't get a scanline, so abort.
             // onDecodeSubset() relies on onBuildTileIndex(), which
             // needs a complete image to succeed.
             if (0 == rowCount) {
-                return return_false(*cinfo, bitmap, "read_scanlines");
+                return return_false(*cinfo, &bitmap, "read_scanlines");
             }
             if (this->shouldCancelDecode()) {
-                return return_false(*cinfo, bitmap, "shouldCancelDecode");
+                return return_false(*cinfo, &bitmap, "shouldCancelDecode");
             }
             rowTotalCount += rowCount;
             rowptr += bpr;
         }
 
         if (swapOnly) {
             bm->swap(bitmap);
         } else {
             cropBitmap(bm, &bitmap, actualSampleSize, region.x(), region.y(),
                        region.width(), region.height(), startX, startY);
         }
         return true;
     }
 #endif
 
     // check for supported formats
     SkScaledBitmapSampler::SrcConfig sc;
     int srcBytesPerPixel;
 
     if (!get_src_config(*cinfo, &sc, &srcBytesPerPixel)) {
-        return return_false(*cinfo, *bm, "jpeg colorspace");
+        return return_false(*cinfo, bm, "jpeg colorspace");
     }
 
     if (!sampler.begin(&bitmap, sc, *this)) {
-        return return_false(*cinfo, bitmap, "sampler.begin");
+        return return_false(*cinfo, &bitmap, "sampler.begin");
     }
 
     SkAutoMalloc  srcStorage(width * srcBytesPerPixel);
     uint8_t* srcRow = (uint8_t*)srcStorage.get();
 
     //  Possibly skip initial rows [sampler.srcY0]
     if (!skip_src_rows_tile(cinfo, fImageIndex->huffmanIndex(), srcRow, sampler.srcY0())) {
-        return return_false(*cinfo, bitmap, "skip rows");
+        return return_false(*cinfo, &bitmap, "skip rows");
     }
 
     // now loop through scanlines until y == bitmap->height() - 1
     for (int y = 0;; y++) {
         JSAMPLE* rowptr = (JSAMPLE*)srcRow;
         int row_count = jpeg_read_tile_scanline(cinfo, fImageIndex->huffmanIndex(), &rowptr);
         // if row_count == 0, then we didn't get a scanline, so abort.
         // onDecodeSubset() relies on onBuildTileIndex(), which
         // needs a complete image to succeed.
         if (0 == row_count) {
-            return return_false(*cinfo, bitmap, "read_scanlines");
+            return return_false(*cinfo, &bitmap, "read_scanlines");
         }
         if (this->shouldCancelDecode()) {
-            return return_false(*cinfo, bitmap, "shouldCancelDecode");
+            return return_false(*cinfo, &bitmap, "shouldCancelDecode");
         }
 
         if (JCS_CMYK == cinfo->out_color_space) {
             convert_CMYK_to_RGB(srcRow, width);
         }
 
         sampler.next(srcRow);
         if (bitmap.height() - 1 == y) {
             // we're done
             break;
         }
 
         if (!skip_src_rows_tile(cinfo, fImageIndex->huffmanIndex(), srcRow,
                                 sampler.srcDY() - 1)) {
-            return return_false(*cinfo, bitmap, "skip rows");
+            return return_false(*cinfo, &bitmap, "skip rows");
         }
     }
     if (swapOnly) {
         bm->swap(bitmap);
     } else {
         cropBitmap(bm, &bitmap, actualSampleSize, region.x(), region.y(),
                    region.width(), region.height(), startX, startY);
     }
     return true;
 }
@@ skipping 275 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageEncoder* sk_libjpeg_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kJPEG_Type == t) ? SkNEW(SkJPEGImageEncoder) : NULL;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libjpeg_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_jpeg);
 static SkImageEncoder_EncodeReg gEReg(sk_libjpeg_efactory);