Non DCTSIZE multiple width support for JPEG YUV decoding

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 234 matching lines @@
         ignoreProfile = true;
 
     ASSERT(colorProfile.isEmpty());
     if (!ignoreProfile)
         colorProfile.append(profileData, profileLength);
     free(profile);
 #endif
 }
 #endif
 
-static IntSize computeUVSize(const jpeg_decompress_struct* info)
+static IntSize computeYUVSize(const jpeg_decompress_struct* info, int component, ImageDecoder::SizeType sizeType)
 {
-    int h = info->cur_comp_info[0]->h_samp_factor;
-    int v = info->cur_comp_info[0]->v_samp_factor;
-    return IntSize((info->output_width + h - 1) / h, (info->output_height + v - 1) / v);
+    if (sizeType == ImageDecoder::SizeForMemoryAllocation) {
+        return IntSize(info->cur_comp_info[component]->width_in_blocks * DCTSIZE, info->cur_comp_info[component]->height_in_blocks * DCTSIZE);
+    }
+    return IntSize(info->cur_comp_info[component]->downsampled_width, info->cur_comp_info[component]->downsampled_height);
 }
 
 static yuv_subsampling yuvSubsampling(const jpeg_decompress_struct& info)
 {
     if ((DCTSIZE == 8)
         && (info.num_components == 3)
         && (info.comps_in_scan >= info.num_components)
         && (info.scale_denom <= 8)
         && (info.cur_comp_info[0])
         && (info.cur_comp_info[1])
@@ skipping 198 matching lines @@
                     if (m_info.out_color_space == JCS_EXT_BGRA)
                         m_info.out_color_space = JCS_EXT_RGBA;
 #endif
                 }
                 m_decoder->setHasColorProfile(!!m_transform);
             }
 #endif
             if (overrideColorSpace == JCS_YCbCr) {
                 m_info.out_color_space = JCS_YCbCr;
                 m_info.raw_data_out = TRUE;
+                m_uvSize = computeYUVSize(&m_info, 1, ImageDecoder::SizeForMemoryAllocation); // U size and V size have to be the same if we got here
             }
 
             // Don't allocate a giant and superfluous memory buffer when the
             // image is a sequential JPEG.
             m_info.buffered_image = jpeg_has_multiple_scans(&m_info);
 
             if (onlySize) {
                 // We can stop here. Reduce our buffer length and available data.
                 m_bufferLength -= m_info.src->bytes_in_buffer;
                 m_info.src->bytes_in_buffer = 0;
@@ skipping 101 matching lines @@
             // We can get here if the constructor failed.
             return m_decoder->setFailed();
         }
 
         return true;
     }
 
     jpeg_decompress_struct* info() { return &m_info; }
     JSAMPARRAY samples() const { return m_samples; }
     JPEGImageDecoder* decoder() { return m_decoder; }
+    IntSize uvSize() const { return m_uvSize; }
 #if USE(QCMSLIB)
     qcms_transform* colorTransform() const { return m_transform; }
 
     void clearColorTransform()
     {
         if (m_transform)
             qcms_transform_release(m_transform);
         m_transform = 0;
     }
 
@@ skipping 22 matching lines @@
     JPEGImageDecoder* m_decoder;
     unsigned m_bufferLength;
     int m_bytesToSkip;
 
     jpeg_decompress_struct m_info;
     decoder_error_mgr m_err;
     jstate m_state;
 
     JSAMPARRAY m_samples;
 
+    IntSize m_uvSize;
+
 #if USE(QCMSLIB)
     qcms_transform* m_transform;
 #endif
 };
 
 // Override the standard error method in the IJG JPEG decoder code.
 void error_exit(j_common_ptr cinfo)
 {
     // Return control to the setjmp point.
     decoder_error_mgr *err = reinterpret_cast_ptr<decoder_error_mgr *>(cinfo->err);
@@ skipping 54 matching lines @@
 
     setDecodedSize(width, height);
     return true;
 }
 
 void JPEGImageDecoder::setDecodedSize(unsigned width, unsigned height)
 {
     m_decodedSize = IntSize(width, height);
 }
 
-IntSize JPEGImageDecoder::decodedYUVSize(int component) const
+IntSize JPEGImageDecoder::decodedYUVSize(int component, ImageDecoder::SizeType sizeType) const
 {
-    if (((component == 1) || (component == 2)) && m_reader.get()) { // Asking for U or V
+    if (((component >= 0) && (component <= 2)) && m_reader) {

[Stephen White, 2014/09/09 15:33:51]

Nit: spurious parens (now that these are all &&'s).

Although, maybe these should all be ASSERTs now instead? Is there a 
valid reason to fall back to m_decodedSize?

         const jpeg_decompress_struct* info = m_reader->info();
-        if (info && (info->out_color_space == JCS_YCbCr)) {
-            return computeUVSize(info);
+        if (info->out_color_space == JCS_YCbCr) {
+            return computeYUVSize(info, component, sizeType);
         }
     }
 
     return m_decodedSize;
 }
 
 unsigned JPEGImageDecoder::desiredScaleNumerator() const
 {
     size_t originalBytes = size().width() * size().height() * 4;
     if (originalBytes <= m_maxDecodedBytes) {
@@ skipping 117 matching lines @@
     jpeg_decompress_struct* info = reader->info();
     JSAMPARRAY bufferraw[3];
     JSAMPROW bufferraw2[32];
     bufferraw[0] = &bufferraw2[0]; // Y channel rows (8 or 16)
     bufferraw[1] = &bufferraw2[16]; // U channel rows (8)
     bufferraw[2] = &bufferraw2[24]; // V channel rows (8)
     int yWidth = info->output_width;
     int yHeight = info->output_height;
     int yMaxH = yHeight - 1;
     int v = info->cur_comp_info[0]->v_samp_factor;
-    IntSize uvSize = computeUVSize(info);
+    IntSize uvSize = reader->uvSize();
     int uvMaxH = uvSize.height() - 1;
     JSAMPROW outputY = static_cast<JSAMPROW>(imagePlanes->plane(0));
     JSAMPROW outputU = static_cast<JSAMPROW>(imagePlanes->plane(1));
     JSAMPROW outputV = static_cast<JSAMPROW>(imagePlanes->plane(2));
     size_t rowBytesY = imagePlanes->rowBytes(0);
     size_t rowBytesU = imagePlanes->rowBytes(1);
     size_t rowBytesV = imagePlanes->rowBytes(2);
 
     int yScanlinesToRead = DCTSIZE * v;
     JSAMPROW yLastRow = *samples;
@@ skipping 132 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)) || (hasImagePlanes() && !onlySize))
         m_reader.clear();
 }
 
 }