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;
+        int width, bpp;
 

[Noel Gordon, 2016/03/01 02:27:49]

abbrv: what is bpp?

[msarett, 2016/03/01 18:00:38]

bytesPer(Pixel/YSample/USample/VSample).

I've rewritten this in an attempt to make it more clear.

-        if (m_info.out_color_space == JCS_YCbCr)
-            width = computeYUVSize(&m_info, 0, ImageDecoder::SizeForMemoryAllocation).width();
-        else
+        if (m_info.out_color_space == JCS_YCbCr) {
+            width = computeYUVWidthBytes(&m_info, 0);
+            bpp = 1;

[Noel Gordon, 2016/03/01 02:27:49]

We seem to be allocating less memory for the YCbCr samples buffer now.  Given
the changes to outputRawData(), hard for me to tell if these changes are sound
memory-wise.  How is this tested?  I ask because I'm pretty sure there are no
layout tests for JPEG with various YUV orderings (4:4:4, 4:2:2, 4:2:0 etc).

[msarett, 2016/03/01 18:00:38]

The jpeg library requires that the memory widths and heights for the Y, U, and V
planes are multiples of DCTSIZE (8).

That is why we computeYUVWidthBytes() instead of width, to make sure all of the
rows are padded appropriately.

Luckily, libjpeg/libjpeg-turbo wants a 2D array (JSAMPLE**) for its input
planes.  So, for the unnecessary rows at the bottom, we can pass the same
pointer to a single extra memory buffer.

Cases that I think are interesting to test (due to my implementation changes)
are dimensions that are multiples of 8 and dimensions that are not multiples of
8.  I have added a test to JpegImageDecoderTest to make sure we cover these two
cases.

I'm not extremely familiar with LayoutTests/visual correctness tests for jpeg
decodes in chromium, so I'll defer to your judgment.  But looking over the set
of images in src/third_party/WebKit/LayoutTests/fast/images/resources/, I feel
comfortable that this will be well tested.

+        } else {
             width = m_info.output_width;
+            bpp = 4;
+        }
 
-        return (*m_info.mem->alloc_sarray)(reinterpret_cast_ptr<j_common_ptr>(&m_info), JPOOL_IMAGE, width * 4, 1);
+        return (*m_info.mem->alloc_sarray)(reinterpret_cast_ptr<j_common_ptr>(&m_info), JPOOL_IMAGE, width * bpp, 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;
     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) {
                 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) {
                 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