Modify YUV codecs to match Skia's API change

third_party/WebKit/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>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 215 matching lines @@
         ignoreProfile = true;
 
     ASSERT(colorProfile.isEmpty());
     if (!ignoreProfile)
         colorProfile.append(profileData, profileLength);
     free(profile);
 #endif
 }
 #endif
 
-static IntSize computeYUVSize(const jpeg_decompress_struct* info, int component, ImageDecoder::SizeType sizeType)
+static IntSize computeYUVSize(const jpeg_decompress_struct* info, int component)
 {
-    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 size_t computeYUVWidthBytes(const jpeg_decompress_struct* info, int component)
+{
+    return info->cur_comp_info[component]->width_in_blocks * DCTSIZE;
+}
+
 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])
         && (info.cur_comp_info[2])
         && (info.cur_comp_info[1]->h_samp_factor == 1)
@@ skipping 233 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
+                m_uvSize = computeYUVSize(&m_info, 1); // 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 (m_info.buffered_image) {
                 m_err.pub.emit_message = emit_message;
                 m_err.num_corrupt_warnings = 0;
             }
 
@@ skipping 159 matching lines @@
 #endif
 
 private:
     JSAMPARRAY allocateSampleArray()
     {
         // Some output color spaces don't need the sample array: don't allocate in that case.
 #if defined(TURBO_JPEG_RGB_SWIZZLE)
         if (turboSwizzled(m_info.out_color_space))
             return nullptr;
 #endif
-        int width;
 
-        if (m_info.out_color_space == JCS_YCbCr)
-            width = computeYUVSize(&m_info, 0, ImageDecoder::SizeForMemoryAllocation).width();
-        else
-            width = m_info.output_width;
+        if (m_info.out_color_space != JCS_YCbCr)
+            return (*m_info.mem->alloc_sarray)(reinterpret_cast_ptr<j_common_ptr>(&m_info), JPOOL_IMAGE, 4 * m_info.output_width, 1);
 
-        return (*m_info.mem->alloc_sarray)(reinterpret_cast_ptr<j_common_ptr>(&m_info), JPOOL_IMAGE, width * 4, 1);
+        // Compute the width of the Y plane in bytes.  This may be larger than the output
+        // width, since the jpeg library requires that the allocated width be a multiple of
+        // DCTSIZE.  Note that this buffer will be used as garbage memory for rows that
+        // extend below the actual height of the image.  We can reuse the same memory for
+        // the U and V planes, since we are guaranteed that the Y plane width is at least
+        // as large as the U and V plane widths.
+        int widthBytes = computeYUVWidthBytes(&m_info, 0);
+        return (*m_info.mem->alloc_sarray)(reinterpret_cast_ptr<j_common_ptr>(&m_info), JPOOL_IMAGE, widthBytes, 1);
     }
 
     void updateRestartPosition()
     {
         if (m_lastSetByte != m_info.src->next_input_byte) {
             // next_input_byte was updated by jpeg, meaning that it found a restart position.
             m_restartPosition = m_nextReadPosition - m_info.src->bytes_in_buffer;
         }
     }
 
@@ skipping 100 matching lines @@
 {
     if (m_reader)
         m_reader->setData(data);
 }
 
 void JPEGImageDecoder::setDecodedSize(unsigned width, unsigned height)
 {
     m_decodedSize = IntSize(width, height);
 }
 
-IntSize JPEGImageDecoder::decodedYUVSize(int component, ImageDecoder::SizeType sizeType) const
+IntSize JPEGImageDecoder::decodedYUVSize(int component) const
 {
     ASSERT((component >= 0) && (component <= 2) && m_reader);
     const jpeg_decompress_struct* info = m_reader->info();
 
     ASSERT(info->out_color_space == JCS_YCbCr);
-    return computeYUVSize(info, component, sizeType);
+    return computeYUVSize(info, component);
+}
+
+size_t JPEGImageDecoder::decodedYUVWidthBytes(int component) const
+{
+    ASSERT((component >= 0) && (component <= 2) && m_reader);
+    const jpeg_decompress_struct* info = m_reader->info();
+
+    ASSERT(info->out_color_space == JCS_YCbCr);
+    return computeYUVWidthBytes(info, component);
 }
 
 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.
@@ skipping 84 matching lines @@
 static bool outputRawData(JPEGImageReader* reader, ImagePlanes* imagePlanes)
 {
     JSAMPARRAY samples = reader->samples();
     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 = reader->uvSize();
-    int uvMaxH = uvSize.height() - 1;
+    int uvHeight = uvSize.height();
     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);
 
     // Request 8 or 16 scanlines: returns 0 or more scanlines.
     int yScanlinesToRead = DCTSIZE * v;
-    JSAMPROW yLastRow = *samples;
-    JSAMPROW uLastRow = yLastRow + rowBytesY;
-    JSAMPROW vLastRow = uLastRow + rowBytesY;
-    JSAMPROW dummyRow = vLastRow + rowBytesY;
-
+    JSAMPROW dummyRow = *samples;
     while (info->output_scanline < info->output_height) {
         // Assign 8 or 16 rows of memory to read the Y channel.
-        bool hasYLastRow = false;
         for (int i = 0; i < yScanlinesToRead; ++i) {
             int scanline = info->output_scanline + i;
-            if (scanline < yMaxH) {
+            if (scanline < yHeight) {
                 bufferraw2[i] = &outputY[scanline * rowBytesY];
-            } else if (scanline == yMaxH) {
-                bufferraw2[i] = yLastRow;
-                hasYLastRow = true;
             } else {
                 bufferraw2[i] = dummyRow;
             }
         }
 
         // Assign 8 rows of memory to read the U and V channels.
-        bool hasUVLastRow = false;
         int scaledScanline = info->output_scanline / v;
         for (int i = 0; i < 8; ++i) {
             int scanline = scaledScanline + i;
-            if (scanline < uvMaxH) {
+            if (scanline < uvHeight) {
                 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, yScanlinesToRead);
         if (!scanlinesRead)
             return false;
-
-        if (hasYLastRow)
-            memcpy(&outputY[yMaxH * rowBytesY], yLastRow, yWidth);
-
-        if (hasUVLastRow) {
-            memcpy(&outputU[uvMaxH * rowBytesU], uLastRow, uvSize.width());
-            memcpy(&outputV[uvMaxH * rowBytesV], vLastRow, uvSize.width());
-        }
     }
 
     info->output_scanline = std::min(info->output_scanline, info->output_height);
     return true;
 }
 
 bool JPEGImageDecoder::outputScanlines()
 {
     if (hasImagePlanes())
         return outputRawData(m_reader.get(), m_imagePlanes.get());
@@ skipping 80 matching lines @@
     // has failed.
     if (!m_reader->decode(onlySize) && isAllDataReceived())
         setFailed();
 
     // If decoding is done or failed, we don't need the JPEGImageReader anymore.
     if (isComplete(this, onlySize) || failed())
         m_reader.clear();
 }
 
 } // namespace blink