Allowing YUV data to be retrieved from the JPEG Decoder.

Source/platform/image-decoders/jpeg/JPEGImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  *
  * Portions are Copyright (C) 2001-6 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * Copyright (C) 2007-2009 Torch Mobile, Inc.
  *
@@ skipping 55 matching lines @@
 inline J_COLOR_SPACE rgbOutputColorSpace() { return JCS_EXT_RGBA; }
 #else // Output little-endian BGRA pixels.
 inline J_COLOR_SPACE rgbOutputColorSpace() { return JCS_EXT_BGRA; }
 #endif
 inline bool turboSwizzled(J_COLOR_SPACE colorSpace) { return colorSpace == JCS_EXT_RGBA || colorSpace == JCS_EXT_BGRA; }
 inline bool colorSpaceHasAlpha(J_COLOR_SPACE colorSpace) { return turboSwizzled(colorSpace); }
 #else
 inline J_COLOR_SPACE rgbOutputColorSpace() { return JCS_RGB; }
 inline bool colorSpaceHasAlpha(J_COLOR_SPACE) { return false; }
 #endif
 

[Noel Gordon, 2014/07/25 15:55:01]

I think we need to define yuvOutputColorSpace() somewhere around here, and use
it everywhere.

 #if USE(LOW_QUALITY_IMAGE_NO_JPEG_DITHERING)
 inline J_DCT_METHOD dctMethod() { return JDCT_IFAST; }
 inline J_DITHER_MODE ditherMode() { return JDITHER_NONE; }
 #else
 inline J_DCT_METHOD dctMethod() { return JDCT_ISLOW; }
 inline J_DITHER_MODE ditherMode() { return JDITHER_FS; }
 #endif
 
 #if USE(LOW_QUALITY_IMAGE_NO_JPEG_FANCY_UPSAMPLING)
 inline bool doFancyUpsampling() { return false; }
@@ skipping 148 matching lines @@
         ignoreProfile = true;
 
     ASSERT(colorProfile.isEmpty());
     if (!ignoreProfile)
         colorProfile.append(profileData, profileLength);
     free(profile);
 #endif
 }
 #endif
 
+static void computeUVSize(const jpeg_decompress_struct* info, int* width, int* height)
+{

[Noel Gordon, 2014/07/25 15:55:01]

How about this: make this routine return an IntSize?  Also, should the routine
by called yuvSize() (you only mention uv in its current name, so what's the
difference).

[sugoi1, 2014/07/25 16:56:48]

Done.
This computes the size of the U and V planes (which are always the same size in
the supported subsampling modes), so it does compute specifically the UV planes
size.

+    int h = info->cur_comp_info[0]->h_samp_factor;

[Noel Gordon, 2014/07/25 15:55:01]

h -> u?

[sugoi1, 2014/07/25 16:56:48]

In this case:
h -> horizontal
v -> vertical

+    int v = info->cur_comp_info[0]->v_samp_factor;
+    *width = (info->output_width + h - 1) / h;
+    *height = (info->output_height + v - 1) / v;
+}
+
 class JPEGImageReader {
     WTF_MAKE_FAST_ALLOCATED;
 public:
     JPEGImageReader(JPEGImageDecoder* decoder)
         : m_decoder(decoder)
         , m_bufferLength(0)
         , m_bytesToSkip(0)
         , m_state(JPEG_HEADER)
         , m_samples(0)
 #if USE(QCMSLIB)
@@ skipping 85 matching lines @@
         if (setjmp(m_err.setjmp_buffer))
             return m_decoder->setFailed();
 
         switch (m_state) {
         case JPEG_HEADER:
             // Read file parameters with jpeg_read_header().
             if (jpeg_read_header(&m_info, true) == JPEG_SUSPENDED)
                 return false; // I/O suspension.
 
             switch (m_info.jpeg_color_space) {
+            case JCS_YCbCr:
+                // libjpeg can convert YCbCr image pixels to RGB.
+                m_info.out_color_space = rgbOutputColorSpace();
+                if (m_decoder->acceleratedYUVDecoding()

[Alpha Left Google, 2014/07/24 23:30:56]

What about by default output RGB and only change out_color_space when YUV
decoding is enabled? It will be more clear that YUV path is separate.

[sugoi1, 2014/07/25 02:55:13]

Isn't that what's already happening here? RGB is set by default at line 360 and
when YUV decoding is enabled, we may set it to YUV, if the format is supported.

[Noel Gordon, 2014/07/25 15:55:01]

The code following here could be moved to it's own function, and somewhere
around line 251 would be a good place to define it.

[sugoi1, 2014/07/25 16:56:48]

Already done in current patch

+                    && (DCTSIZE == 8)
+                    && (m_info.num_components == 3)
+                    && (m_info.scale_denom <= 8)
+                    && (m_info.cur_comp_info[1]->h_samp_factor == 1)
+                    && (m_info.cur_comp_info[1]->v_samp_factor == 1)
+                    && (m_info.cur_comp_info[2]->h_samp_factor == 1)
+                    && (m_info.cur_comp_info[2]->v_samp_factor == 1)) {
+                    int h = m_info.cur_comp_info[0]->h_samp_factor;
+                    int v = m_info.cur_comp_info[0]->v_samp_factor;
+                    // Only set YUV mode if the format is supported

[Alpha Left Google, 2014/07/24 22:07:27]

nit: period at the end of sentence.

[sugoi1, 2014/07/24 23:16:37]

Acknowledged.

+                    // 4:4:4 : (h == 1) && (v == 1)
+                    // 4:4:0 : (h == 1) && (v == 2)
+                    // 4:2:2 : (h == 2) && (v == 1)
+                    // 4:2:0 : (h == 2) && (v == 2)
+                    // 4:1:1 : (h == 4) && (v == 1)
+                    // 4:1:0 : (h == 4) && (v == 2)
+                    if (((h == 1) || (h == 2) || (h == 4)) && ((v == 1) || (v == 2))) {
+                        m_info.out_color_space = JCS_YCbCr;
+                        m_info.raw_data_out = TRUE;
+                    }
+                }
+                break;
             case JCS_GRAYSCALE:
             case JCS_RGB:
-            case JCS_YCbCr:
-                // libjpeg can convert GRAYSCALE and YCbCr image pixels to RGB.
+                // libjpeg can convert GRAYSCALE image pixels to RGB.
                 m_info.out_color_space = rgbOutputColorSpace();
 #if defined(TURBO_JPEG_RGB_SWIZZLE)
                 if (m_info.saw_JFIF_marker)
                     break;
                 // FIXME: Swizzle decoding does not support Adobe transform=0
                 // images (yet), so revert to using JSC_RGB in that case.
                 if (m_info.saw_Adobe_marker && !m_info.Adobe_transform)
                     m_info.out_color_space = JCS_RGB;
 #endif
                 break;
@@ skipping 16 matching lines @@
             // Calculate and set decoded size.
             m_info.scale_num = m_decoder->desiredScaleNumerator();
             m_info.scale_denom = scaleDenominator;
             jpeg_calc_output_dimensions(&m_info);
             m_decoder->setDecodedSize(m_info.output_width, m_info.output_height);
 
             m_decoder->setOrientation(readImageOrientation(info()));
 
 #if USE(QCMSLIB)
             // Allow color management of the decoded RGBA pixels if possible.
             if (!m_decoder->ignoresGammaAndColorProfile()) {

[Noel Gordon, 2014/07/25 15:55:01]

Most web jpeg images are YCbCr, and many are photographic images 4:2:2, which
come form digital cameras, with a color profile whether the user knows it or
not. This YCbCr decoding change breaks all color profiled JPEG web images.

[sugoi1, 2014/07/25 17:20:26]

Oh yeah, I know about the color profiles, I don't have an implementation for it
yet, but it doesn't seem too complicated in most cases. I'll add a condition for
now to exit early when we have a color profile.

                 ColorProfile colorProfile;
                 readColorProfile(info(), colorProfile);
                 createColorTransform(colorProfile, colorSpaceHasAlpha(m_info.out_color_space));
 #if defined(TURBO_JPEG_RGB_SWIZZLE)
                 // Input RGBA data to qcms. Note: restored to BGRA on output.
                 if (m_transform && m_info.out_color_space == JCS_EXT_BGRA)
                     m_info.out_color_space = JCS_EXT_RGBA;
 #endif
                 m_decoder->setHasColorProfile(!!m_transform);
             }
@@ skipping 19 matching lines @@
             m_info.do_fancy_upsampling = doFancyUpsampling();
             m_info.enable_2pass_quant = false;
             m_info.do_block_smoothing = true;
 
             // Make a one-row-high sample array that will go away when done with
             // image. Always make it big enough to hold an RGB row. Since this
             // uses the IJG memory manager, it must be allocated before the call
             // to jpeg_start_compress().
             // FIXME: note that some output color spaces do not need the samples
             // buffer. Remove this allocation for those color spaces.
-            m_samples = (*m_info.mem->alloc_sarray)(reinterpret_cast<j_common_ptr>(&m_info), JPOOL_IMAGE, m_info.output_width * 4, 1);
+            m_samples = (*m_info.mem->alloc_sarray)(reinterpret_cast<j_common_ptr>(&m_info), JPOOL_IMAGE, m_info.output_width * 4, m_info.out_color_space == JCS_YCbCr ? 2 : 1);
 
             // Start decompressor.
             if (!jpeg_start_decompress(&m_info))
                 return false; // I/O suspension.
 
             // If this is a progressive JPEG ...
             m_state = (m_info.buffered_image) ? JPEG_DECOMPRESS_PROGRESSIVE : JPEG_DECOMPRESS_SEQUENTIAL;
         // FALL THROUGH
 
         case JPEG_DECOMPRESS_SEQUENTIAL:
@@ skipping 149 matching lines @@
 {
     decoder_source_mgr *src = (decoder_source_mgr *)jd->src;
     src->decoder->decoder()->jpegComplete();
 }
 
 JPEGImageDecoder::JPEGImageDecoder(ImageSource::AlphaOption alphaOption,
     ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption,
     size_t maxDecodedBytes)
     : ImageDecoder(alphaOption, gammaAndColorProfileOption, maxDecodedBytes)
     , m_hasColorProfile(false)
+    , m_acceleratedYUVDecoding(false)
 {
 }
 
 JPEGImageDecoder::~JPEGImageDecoder()
 {
 }
 
 bool JPEGImageDecoder::isSizeAvailable()
 {
     if (!ImageDecoder::isSizeAvailable())
@@ skipping 12 matching lines @@
 
     setDecodedSize(width, height);
     return true;
 }
 
 void JPEGImageDecoder::setDecodedSize(unsigned width, unsigned height)
 {
     m_decodedSize = IntSize(width, height);
 }
 
+IntSize JPEGImageDecoder::decodedSize(int component) const
+{

[Noel Gordon, 2014/07/25 15:55:01]

Did you consider using a separate function that explicitly returned the yuv
decoded size and if that'd work better at the call sites?

I'm not sure what |component| means -- it needs a better name -- but why is an
int?  The computed size returned by the function for the yuv case does not seem
to depend on it's value.  Are there other types of component values > 2 that
need decoding in future?  If so, what are they?

[sugoi1, 2014/07/25 16:56:48]

Already done in current patch.
"Component" as in "color component"

0: Y
1: U
2: V

See newest patch

+    if (((component == 1) || (component == 2)) && m_reader.get()) { // Asking for U or V
+        const jpeg_decompress_struct* info = m_reader->info();
+        if (info && (info->out_color_space == JCS_YCbCr)) {
+            int w, h;
+            computeUVSize(info, &w, &h);
+            return IntSize(w, h);
+        }
+    }
+
+    return m_decodedSize;
+}
+
 unsigned JPEGImageDecoder::desiredScaleNumerator() const
 {
     size_t originalBytes = size().width() * size().height() * 4;
     if (originalBytes <= m_maxDecodedBytes) {
         return scaleDenominator;
     }
 
     // Downsample according to the maximum decoded size.
     unsigned scaleNumerator = static_cast<unsigned>(floor(sqrt(
         // MSVC needs explicit parameter type for sqrt().
         static_cast<float>(m_maxDecodedBytes * scaleDenominator * scaleDenominator / originalBytes))));
 
     return scaleNumerator;
 }
 
+bool JPEGImageDecoder::doAcceleratedYUVDecoding()
+{

[Noel Gordon, 2014/07/25 15:55:01]

Would yuvDecode() or decodeToYUV() better describe the purpose of this function?
Not sure what Accelerated means here.

[sugoi1, 2014/07/25 16:56:48]

Accelerated has already been removed from the names.
I can change it to decodeToYUV(), no problem

+    setAcceleratedYUVDecoding(true);
+    PlatformInstrumentation::willDecodeImage("JPEG");
+    decode(false);
+    PlatformInstrumentation::didDecodeImage();
+    return !failed();
+}
+
 ImageFrame* JPEGImageDecoder::frameBufferAtIndex(size_t index)
 {
     if (index)
         return 0;
 
     if (m_frameBufferCache.isEmpty()) {
         m_frameBufferCache.resize(1);
         m_frameBufferCache[0].setPremultiplyAlpha(m_premultiplyAlpha);
     }
 
     ImageFrame& frame = m_frameBufferCache[0];
     if (frame.status() != ImageFrame::FrameComplete) {
         PlatformInstrumentation::willDecodeImage("JPEG");
         decode(false);
         PlatformInstrumentation::didDecodeImage();
     }
 
     frame.notifyBitmapIfPixelsChanged();
     return &frame;
 }
 
 bool JPEGImageDecoder::setFailed()
 {
     m_reader.clear();
     return ImageDecoder::setFailed();
 }
 
+void JPEGImageDecoder::setDecodingBuffers(OwnPtr<DecodingBuffers>& decodingBuffers)
+{
+    m_decodingBuffers = decodingBuffers.release();
+}
+
 template <J_COLOR_SPACE colorSpace> void setPixel(ImageFrame& buffer, ImageFrame::PixelData* pixel, JSAMPARRAY samples, int column)
 {
-    JSAMPLE* jsample = *samples + column * (colorSpace == JCS_RGB ? 3 : 4);
+    ASSERT_NOT_REACHED();
+}
 
-    switch (colorSpace) {
-    case JCS_RGB:
-        buffer.setRGBARaw(pixel, jsample[0], jsample[1], jsample[2], 255);
-        break;
-    case JCS_CMYK:
-        // Source is 'Inverted CMYK', output is RGB.
-        // See: http://www.easyrgb.com/math.php?MATH=M12#text12
-        // Or: http://www.ilkeratalay.com/colorspacesfaq.php#rgb
-        // From CMYK to CMY:
-        // X =   X    * (1 -   K   ) +   K  [for X = C, M, or Y]
-        // Thus, from Inverted CMYK to CMY is:
-        // X = (1-iX) * (1 - (1-iK)) + (1-iK) => 1 - iX*iK
-        // From CMY (0..1) to RGB (0..1):
-        // R = 1 - C => 1 - (1 - iC*iK) => iC*iK  [G and B similar]
-        unsigned k = jsample[3];
-        buffer.setRGBARaw(pixel, jsample[0] * k / 255, jsample[1] * k / 255, jsample[2] * k / 255, 255);
-        break;
-    }
+template <> void setPixel<JCS_RGB>(ImageFrame& buffer, ImageFrame::PixelData* pixel, JSAMPARRAY samples, int column)

[Noel Gordon, 2014/07/25 15:55:01]

The setPixel() code from lines 736-762 changed, I'm not sure why.  You don't
seem to call or use it for the yuv decoding case, so why change it?

[sugoi1, 2014/07/25 16:56:48]

This is cleanup. Using template arguments in conditions and switches generated
unnecessary code. I simply simplified each case by using the template argument.

+{
+    JSAMPLE* jsample = *samples + column * 3;
+    buffer.setRGBARaw(pixel, jsample[0], jsample[1], jsample[2], 255);
+}
+
+template <> void setPixel<JCS_CMYK>(ImageFrame& buffer, ImageFrame::PixelData* pixel, JSAMPARRAY samples, int column)
+{
+    JSAMPLE* jsample = *samples + column * 4;
+
+    // Source is 'Inverted CMYK', output is RGB.
+    // See: http://www.easyrgb.com/math.php?MATH=M12#text12
+    // Or: http://www.ilkeratalay.com/colorspacesfaq.php#rgb
+    // From CMYK to CMY:
+    // X =   X    * (1 -   K   ) +   K  [for X = C, M, or Y]
+    // Thus, from Inverted CMYK to CMY is:
+    // X = (1-iX) * (1 - (1-iK)) + (1-iK) => 1 - iX*iK
+    // From CMY (0..1) to RGB (0..1):
+    // R = 1 - C => 1 - (1 - iC*iK) => iC*iK  [G and B similar]
+    unsigned k = jsample[3];
+    buffer.setRGBARaw(pixel, jsample[0] * k / 255, jsample[1] * k / 255, jsample[2] * k / 255, 255);
 }
 
 template <J_COLOR_SPACE colorSpace> bool outputRows(JPEGImageReader* reader, ImageFrame& buffer)
 {
     JSAMPARRAY samples = reader->samples();
     jpeg_decompress_struct* info = reader->info();
     int width = info->output_width;
 
     while (info->output_scanline < info->output_height) {
         // jpeg_read_scanlines will increase the scanline counter, so we
         // save the scanline before calling it.
         int y = info->output_scanline;
         // Request one scanline: returns 0 or 1 scanlines.
         if (jpeg_read_scanlines(info, samples, 1) != 1)
             return false;
 #if USE(QCMSLIB)
         if (reader->colorTransform() && colorSpace == JCS_RGB)
             qcms_transform_data(reader->colorTransform(), *samples, *samples, width);
 #endif
         ImageFrame::PixelData* pixel = buffer.getAddr(0, y);
         for (int x = 0; x < width; ++pixel, ++x)
             setPixel<colorSpace>(buffer, pixel, samples, x);
     }
 
     buffer.setPixelsChanged(true);
     return true;
 }
 
+static bool outputRawData(JPEGImageReader* reader, DecodingBuffers* decodingBuffers)
+{
+    JSAMPARRAY samples = reader->samples();
+    jpeg_decompress_struct* info = reader->info();
+    JSAMPARRAY bufferraw[3];
+    JSAMPROW bufferraw2[32];
+    bufferraw[0] = &bufferraw2[0];

[Alpha Left Google, 2014/07/24 22:07:27]

Please document why.

+    bufferraw[1] = &bufferraw2[16];
+    bufferraw[2] = &bufferraw2[24];
+    int yWidth = info->output_width;
+    int yHeight = info->output_height;
+    int yMaxH = yHeight - 1;
+    int v = info->cur_comp_info[0]->v_samp_factor;
+    int uvWidth(0), uvHeight(0);
+    computeUVSize(info, &uvWidth, &uvHeight);
+    int uvMaxH = uvHeight - 1;
+    JSAMPROW outputY = static_cast<JSAMPROW>(decodingBuffers->getPlane(0));
+    JSAMPROW outputU = static_cast<JSAMPROW>(decodingBuffers->getPlane(1));
+    JSAMPROW outputV = static_cast<JSAMPROW>(decodingBuffers->getPlane(2));
+    size_t rowBytesY = decodingBuffers->getRowBytes(0);
+    size_t rowBytesU = decodingBuffers->getRowBytes(1);
+    size_t rowBytesV = decodingBuffers->getRowBytes(2);
+
+    int scanlinesToRead = DCTSIZE * v;

[Alpha Left Google, 2014/07/24 22:07:27]

nit: This should be yScanlinesToRead.

[sugoi1, 2014/07/24 23:16:36]

Acknowledged.

+    JSAMPROW yLastRow = *samples;
+    JSAMPROW uLastRow = yLastRow + 2 * yWidth;
+    JSAMPROW vLastRow = uLastRow + 2 * yWidth;
+    JSAMPROW dummyRow = vLastRow + 2 * yWidth;
+
+    while (info->output_scanline < info->output_height) {
+        // Request 8 or 16 scanlines: returns 0 or more scanlines.
+        bool hasYLastRow(false), hasUVLastRow(false);
+        for (int i = 0; i < scanlinesToRead; ++i) {

[Alpha Left Google, 2014/07/24 22:07:27]

nit: Add a comment that this is reading the Y scanlines.

[sugoi1, 2014/07/24 23:16:37]

Acknowledged.

+            int scanline = (info->output_scanline + i);
+            if (scanline < yMaxH) {
+                bufferraw2[i] = &outputY[scanline * rowBytesY];
+            } else if (scanline == yMaxH) {
+                bufferraw2[i] = yLastRow;
+                hasYLastRow = true;
+            } else {
+                bufferraw2[i] = dummyRow;
+            }
+        }
+        int scaledScanline = info->output_scanline / v;
+        for (int i = 0; i < 8; ++i) {

[Alpha Left Google, 2014/07/24 22:07:27]

Add a comment saying this is reading the UV scanlines.

[sugoi1, 2014/07/24 23:16:36]

Acknowledged.

+            int scanline = (scaledScanline + i);
+            if (scanline < uvMaxH) {
+                bufferraw2[16 + i] = &outputU[scanline * rowBytesU];
+                bufferraw2[24 + i] = &outputV[scanline * rowBytesV];
+            } 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(info, bufferraw, scanlinesToRead);
+
+        if (scanlinesRead == 0)
+            return false;
+
+        if (hasYLastRow) {
+            memcpy(&outputY[yMaxH * rowBytesY], yLastRow, yWidth);

[Noel Gordon, 2014/07/25 15:55:01]

memcpy: it's perhaps the best way to kill decoding performance. For the RGB[A]
and BRG[A] cases, we decoded directly to the frame buffer to avoid memcpy.  That
alone doubles decoding performance by halving the decoding time compared to
copying decoded rows to the frame buffer.

That should give you an idea of the cost of a turbo JPEG decode - it's about a
memcpy if you've ever wondered about it.  Since the decoder can decode direct to
whatever buffers you provide, why not organize your planes such that it can?

It also occurs to me that you have not measured speed at all, given no evidence
of any purpose / gain in your change description.  Additional memcpy's of any
size tell me there will be a decoding speed regression ...

[sugoi1, 2014/07/25 16:56:48]

This is only the last row of a jpeg image, if the jpeg's height is not a
multiple of 8, not all the rows.
It is done this way because reading the last row can overflow buffer memory. A
single row of an image, in a special case, probably won't affect performance
significantly.

For the gains, take 4:2:0, for example. This format has a U and V channel of 1/2
width and 1/2 height, so 1/4 size, which means that the whole YUV image uses the
equivalent of 1 1/2 channels of memory compared to 4 channels for an RGBA
texture upload, saving 62.5% of the memory uploaded to the GPU. On bandwidth
limited devices (like mobile devices), this should be significant.

+        }
+        if (hasUVLastRow) {
+            memcpy(&outputU[uvMaxH * rowBytesU], uLastRow, uvWidth);
+            memcpy(&outputV[uvMaxH * rowBytesV], vLastRow, uvWidth);
+        }
+    }
+
+    info->output_scanline = std::min(info->output_scanline, info->output_height);
+
+    return true;
+}
+
 bool JPEGImageDecoder::outputScanlines()
 {
     if (m_frameBufferCache.isEmpty())
         return false;

[Noel Gordon, 2014/07/25 15:55:02]

If you pass this point and go on to yuv decode, a w x h frame buffer of RGBA
must have been allocated.  So the memory cost of a yuv decode is an RGBA frame
buffer _plus_ the decoding planes caller provides for yuv decoding.

So I see a speed regression and an increase in memory costs. If you have you
analysed the speed / memory costs (where is that exactly?) and expect them to be
better, then the code I see here is not showing any such improvements.

 
     jpeg_decompress_struct* info = m_reader->info();
 
+    if ((JCS_YCbCr == info->out_color_space) && (m_decodingBuffers.get())) {

[Alpha Left Google, 2014/07/24 22:07:27]

If you have set YUV decoding but didn't assign the buffers then the following
decoding will fail. I suggest you drop the flag for YUV decoding and just use
decoding buffers instead.

[sugoi1, 2014/07/24 23:16:37]

If it fails for any reason, the caller should fallback to regular RGBA decoding
instead using the YUV path.

+        return outputRawData(m_reader.get(), m_decodingBuffers.get());
+    }
+
     // Initialize the framebuffer if needed.
     ImageFrame& buffer = m_frameBufferCache[0];
     if (buffer.status() == ImageFrame::FrameEmpty) {
         ASSERT(info->output_width == static_cast<JDIMENSION>(m_decodedSize.width()));
         ASSERT(info->output_height == static_cast<JDIMENSION>(m_decodedSize.height()));
 
         if (!buffer.setSize(info->output_width, info->output_height))
             return setFailed();
         buffer.setStatus(ImageFrame::FramePartial);
         // The buffer is transparent outside the decoded area while the image is
@@ skipping 57 matching lines @@
     // has failed.
     if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived())
         setFailed();
     // If we're done decoding the image, we don't need the JPEGImageReader
     // anymore.  (If we failed, |m_reader| has already been cleared.)
     else if (!m_frameBufferCache.isEmpty() && (m_frameBufferCache[0].status() == ImageFrame::FrameComplete))
         m_reader.clear();
 }
 
 }