JPEGImageDecoder RGB565 and downsample support and related Skia imagegenerator changes

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 47 matching lines @@
 #error Blink assumes a little-endian target.
 #endif
 
 #if defined(JCS_ALPHA_EXTENSIONS)
 #define TURBO_JPEG_RGB_SWIZZLE
 #if SK_B32_SHIFT // Output little-endian RGBA pixels (Android).
 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 turboSwizzled(J_COLOR_SPACE colorSpace) { return colorSpace == JCS_EXT_RGBA || colorSpace == JCS_EXT_BGRA || colorSpace == JCS_RGB565; }
 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
 
 namespace {
 
 const int exifMarker = JPEG_APP0 + 1;
 
@@ skipping 386 matching lines @@
                 break;
             case JCS_CMYK:
             case JCS_YCCK:
                 // libjpeg can convert YCCK to CMYK, but neither to RGB, so we
                 // manually convert CMKY to RGB.
                 m_info.out_color_space = JCS_CMYK;
                 break;
             default:
                 return m_decoder->setFailed();
             }
+            if (m_decoder->decodeToRGB565Enabled()) {
+                if (m_info.out_color_space == rgbOutputColorSpace()) {
+                    // the rest would need to be converted manually on write
+#if defined (JCS_ALPHA_EXTENSIONS)
+                    m_info.out_color_space = JCS_RGB565;
+#else
+                    m_info.out_color_space = JCS_RGB;

[scroggo_chromium, 2015/10/19 20:41:36]

Isn't that the same as rgbOutputColorSpace when JCS_ALPHA_EXTENSIONS is not
defined? So isn't this line unnecessary?

[aleksandar.stojiljkovic, 2015/10/20 09:51:12]

Correct, not needed to set to same.

+#endif
+#if USE(QCMSLIB)
+                    // if there is colorprofile, use JCS_RGB as QCMS is not supporting RGB565
+                    // conversion, RGB->RGB565 happens in outputRows<>()
+                    if (!m_decoder->ignoresGammaAndColorProfile())
+                        m_info.out_color_space = JCS_RGB;
+#endif
+                }
+            }
+            // fell through

[scroggo_chromium, 2015/10/19 20:41:36]

nit: Other places in this file say "FALL THROUGH". I think this should be
consistent.

[aleksandar.stojiljkovic, 2015/10/20 09:51:12]

Done.

 
             m_state = JPEG_START_DECOMPRESS;
 
             // We can fill in the size now that the header is available.
             if (!m_decoder->setSize(m_info.image_width, m_info.image_height))
                 return false;
 
             // Calculate and set decoded size.
             m_info.scale_num = m_decoder->desiredScaleNumerator();
             m_info.scale_denom = scaleDenominator;
@@ skipping 53 matching lines @@
                 clearBuffer();
                 return true;
             }
         // FALL THROUGH
 
         case JPEG_START_DECOMPRESS:
             // Set parameters for decompression.
             // FIXME -- Should reset dct_method and dither mode for final pass
             // of progressive JPEG.
             m_info.dct_method = JDCT_ISLOW;
             m_info.dither_mode = JDITHER_FS;

[aleksandar.stojiljkovic, 2015/10/19 18:17:10]

Dither: Floyd-Steinberg set here for all decoding.

             m_info.do_fancy_upsampling = true;
             m_info.do_block_smoothing = true;
             m_info.enable_2pass_quant = false;
             // FIXME: should we just assert these?
             m_info.enable_external_quant = false;
             m_info.enable_1pass_quant = false;
             m_info.quantize_colors = false;
             m_info.colormap = 0;
 
             // Make a one-row-high sample array that will go away when done with
@@ skipping 22 matching lines @@
                     return false; // I/O suspension.
 
                 // If we've completed image output...
                 ASSERT(m_info.output_scanline == m_info.output_height);
                 m_state = JPEG_DONE;
             }
         // FALL THROUGH
 
         case JPEG_DECOMPRESS_PROGRESSIVE:
             if (m_state == JPEG_DECOMPRESS_PROGRESSIVE) {
+

[scroggo_chromium, 2015/10/19 20:41:36]

Why the extra line here?

                 int status = 0;
                 do {
                     decoder_error_mgr* err = reinterpret_cast_ptr<decoder_error_mgr*>(m_info.err);
                     if (err->num_corrupt_warnings)
                         break;
                     status = jpeg_consume_input(&m_info);
                 } while ((status != JPEG_SUSPENDED) && (status != JPEG_REACHED_EOI));
 
                 for (;;) {
                     if (!m_info.output_scanline) {
@@ skipping 172 matching lines @@
 
 void term_source(j_decompress_ptr jd)
 {
     decoder_source_mgr* src = reinterpret_cast_ptr<decoder_source_mgr*>(jd->src);
     src->decoder->decoder()->complete();
 }
 
 JPEGImageDecoder::JPEGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption colorOptions, size_t maxDecodedBytes)
     : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes)
     , m_hasColorProfile(false)
+    , m_decodeToRGB565(false)
 {
 }
 
 JPEGImageDecoder::~JPEGImageDecoder()
 {
 }
 
 bool JPEGImageDecoder::setSize(unsigned width, unsigned height)
 {
     if (!ImageDecoder::setSize(width, height))
@@ skipping 41 matching lines @@
     return scaleNumerator;
 }
 
 bool JPEGImageDecoder::canDecodeToYUV()
 {
     // Calling isSizeAvailable() ensures the reader is created and the output
     // color space is set.
     return isSizeAvailable() && m_reader->info()->out_color_space == JCS_YCbCr;
 }
 
+bool JPEGImageDecoder::canDecodeToRGB565()
+{
+    // Calling isSizeAvailable() ensures the reader is created and the output

[scroggo_chromium, 2015/10/19 20:41:36]

I do not follow how this comment applies.

[aleksandar.stojiljkovic, 2015/10/20 09:51:12]

Didn't do cleanup after copy paste.
Also decoding works without #if defined(JCS_ALPHA_EXTENSIONS). I'm
over-complicating it, here and bellow. 
Done.

+    // color space is set.
+#if defined(JCS_ALPHA_EXTENSIONS)
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool JPEGImageDecoder::setDecodeRGB565Enabled(const bool enable)
+{
+#if defined(JCS_ALPHA_EXTENSIONS)
+    m_decodeToRGB565 = enable;

[scroggo_chromium, 2015/10/19 20:41:36]

Should m_decodeToRGB565 only be defined if JCS_ALPHA_EXTENSIONS is defined?
Otherwise it seems like we do not need it.

[aleksandar.stojiljkovic, 2015/10/20 09:51:12]

Done.

+    return true;
+#else
+    if (!enable)

[scroggo_chromium, 2015/10/19 20:41:36]

Can this just be:

  return !enable

and then drop the extra return at the end?

[aleksandar.stojiljkovic, 2015/10/20 09:51:12]

Done.

+        return true;
+#endif
+    return false;
+}
+
+
 bool JPEGImageDecoder::decodeToYUV()
 {
     if (!hasImagePlanes())
         return false;
     PlatformInstrumentation::willDecodeImage("JPEG");
     decode(false);
     PlatformInstrumentation::didDecodeImage();
     return !failed();
 }
 
 void JPEGImageDecoder::setImagePlanes(PassOwnPtr<ImagePlanes> imagePlanes)
 {
     m_imagePlanes = imagePlanes;
 }
 
-template <J_COLOR_SPACE colorSpace> void setPixel(ImageFrame& buffer, ImageFrame::PixelData* pixel, JSAMPARRAY samples, int column)
+template <J_COLOR_SPACE colorSpace, class T> void setPixel(ImageFrame& buffer, T* pixel, JSAMPARRAY samples, int column)
 {
     ASSERT_NOT_REACHED();
 }
 
-template <> void setPixel<JCS_RGB>(ImageFrame& buffer, ImageFrame::PixelData* pixel, JSAMPARRAY samples, int column)
+template <> void setPixel<JCS_RGB, ImageFrame::PixelData>(ImageFrame& buffer, ImageFrame::PixelData* pixel, JSAMPARRAY samples, int column)
 {
     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)
+template <> void setPixel<JCS_CMYK, ImageFrame::PixelData>(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)
+template <> void setPixel<JCS_RGB, ImageFrame::PixelData16>(ImageFrame& buffer, ImageFrame::PixelData16* pixel, JSAMPARRAY samples, int column)
+{
+    JSAMPLE* jsample = *samples + column * 3;
+    buffer.setRGB565(pixel, jsample[0], jsample[1], jsample[2]);
+}
+
+template <> void setPixel<JCS_CMYK, ImageFrame::PixelData16>(ImageFrame& buffer, ImageFrame::PixelData16* 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.setRGB565(pixel, jsample[0] * k / 255, jsample[1] * k / 255, jsample[2] * k / 255);
+}
+
+template <J_COLOR_SPACE colorSpace, class T> 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);
+        T* pixel = buffer.getAddrT<T>(0, y);
         for (int x = 0; x < width; ++pixel, ++x)
-            setPixel<colorSpace>(buffer, pixel, samples, x);
+            setPixel<colorSpace, T>(buffer, pixel, samples, x);
     }
 
     buffer.setPixelsChanged(true);
     return true;
 }
 
 static bool outputRawData(JPEGImageReader* reader, ImagePlanes* imagePlanes)
 {
     JSAMPARRAY samples = reader->samples();
     jpeg_decompress_struct* info = reader->info();
@@ skipping 81 matching lines @@
         return false;
 
     jpeg_decompress_struct* info = m_reader->info();
 
     // 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))
+        if (!buffer.setSize(info->output_width, info->output_height, decodeToRGB565Enabled()
+            ? ImageFrame::RGB565 : ImageFrame::RGBA8888))
             return setFailed();
         buffer.setStatus(ImageFrame::FramePartial);
         // The buffer is transparent outside the decoded area while the image is
         // loading. The image will be marked fully opaque in complete().
+        // for RGB565 this would just fail, having bitmap opaque during decoding

[scroggo_chromium, 2015/10/19 20:41:36]

So doesn't this need to say something like if (!565)?

[aleksandar.stojiljkovic, 2015/10/20 09:51:12]

Done.

         buffer.setHasAlpha(true);
 
         // For JPEGs, the frame always fills the entire image.
         buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
     }
 
 #if defined(TURBO_JPEG_RGB_SWIZZLE)
     if (turboSwizzled(info->out_color_space)) {
         while (info->output_scanline < info->output_height) {
-            unsigned char* row = reinterpret_cast_ptr<unsigned char*>(buffer.getAddr(0, info->output_scanline));
-            if (jpeg_read_scanlines(info, &row, 1) != 1)
+            unsigned char* row = decodeToRGB565Enabled()
+                ? reinterpret_cast_ptr<unsigned char*>(buffer.getAddrT<ImageFrame::PixelData16>(0, info->output_scanline))
+                : reinterpret_cast_ptr<unsigned char*>(buffer.getAddr(0, info->output_scanline));
+            if (jpeg_read_scanlines(info, &row, 1) != 1) {
                 return false;
+            }
 #if USE(QCMSLIB)
             if (qcms_transform* transform = m_reader->colorTransform())
                 qcms_transform_data_type(transform, row, row, info->output_width, rgbOutputColorSpace() == JCS_EXT_BGRA ? QCMS_OUTPUT_BGRX : QCMS_OUTPUT_RGBX);
 #endif
         }
         buffer.setPixelsChanged(true);
         return true;
     }
 #endif
 
     switch (info->out_color_space) {
     case JCS_RGB:
-        return outputRows<JCS_RGB>(m_reader.get(), buffer);
+        if (decodeToRGB565Enabled())
+            return outputRows<JCS_RGB, ImageFrame::PixelData16>(m_reader.get(), buffer);
+        return outputRows<JCS_RGB, ImageFrame::PixelData>(m_reader.get(), buffer);
     case JCS_CMYK:
-        return outputRows<JCS_CMYK>(m_reader.get(), buffer);
+        if (decodeToRGB565Enabled())
+            return outputRows<JCS_CMYK, ImageFrame::PixelData16>(m_reader.get(), buffer);
+        return outputRows<JCS_CMYK, ImageFrame::PixelData>(m_reader.get(), buffer);
     default:
         ASSERT_NOT_REACHED();
     }
 
     return setFailed();
 }
 
 void JPEGImageDecoder::complete()
 {
     if (m_frameBufferCache.isEmpty())
@@ skipping 26 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();
 }
 
 }