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 346 matching lines @@
             return;
 
         // Otherwise, empty the buffer, and leave the position the same, so fillBuffer continues
         // reading from the same position in the new SharedBuffer.
         m_nextReadPosition -= m_info.src->bytes_in_buffer;
         clearBuffer();
     }
 
     bool decode(bool onlySize)
     {
+        if ((m_state == JPEG_DECOMPRESS_SEQUENTIAL || m_state == JPEG_DECOMPRESS_PROGRESSIVE)
+            && m_decoder->hasFramebufferChanged()) {
+            // when previous attempts to decode failed with not all data available,
+            // decoder continues. Once that all data is available (and there is no alpha)
+            // and client calls decode to rgb565 or downsampling, it is needed to restart decompression
+            // FIXME restart decompression without reading header
+            clearBuffer();
+            m_state = JPEG_HEADER;
+        }
+
         // We need to do the setjmp here. Otherwise bad things will happen
         if (setjmp(m_err.setjmp_buffer))
             return m_decoder->setFailed();
 
         J_COLOR_SPACE overrideColorSpace = JCS_UNKNOWN;
         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.
@@ skipping 20 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;
+#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
+                }
+            }
+            // FALL THROUGH
 
             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 96 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) {
+
                 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_decodeColor(ImageFrame::RGBA8888)
+    , m_originalMaxDecodedBytes(maxDecodedBytes)
 {
 }
 
 JPEGImageDecoder::~JPEGImageDecoder()
 {
 }
 
 bool JPEGImageDecoder::setSize(unsigned width, unsigned height)
 {
     if (!ImageDecoder::setSize(width, height))
@@ skipping 21 matching lines @@
 {
     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);
 }
 
 unsigned JPEGImageDecoder::desiredScaleNumerator() const
 {
-    size_t originalBytes = size().width() * size().height() * 4;
+    size_t originalBytes = size().width() * size().height()
+        * (decodeToRGB565Enabled() ? 2 : 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::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;
 }
 
+void JPEGImageDecoder::getAvailableDecodeAndScale(ImageFrame::ColorType* outType, float* scale, float* lowerScale)
+{
+    if (outType) {
+        if (*outType != ImageFrame::RGBA8888 && *outType != ImageFrame::RGB565)
+            *outType = ImageFrame::RGBA8888;
+    }
+    if (scale) {
+        unsigned upper = static_cast<unsigned>(ceil(*scale * scaleDenominator));
+        upper = (upper > scaleDenominator) ? scaleDenominator : upper;
+        unsigned lower = upper - 1;
+        *scale = static_cast<float>(upper) / static_cast<float>(scaleDenominator);
+
+        if (lowerScale)
+            *lowerScale = static_cast<float>(lower) / static_cast<float>(scaleDenominator);
+        return;
+    }
+    if (lowerScale)
+        *lowerScale = 1.0f;
+}
+
+bool JPEGImageDecoder::activateDecodeAndScale(ImageFrame::ColorType outColor, size_t maxDecodedBytes)
+{
+    ASSERT(m_decodeColor == ImageFrame::RGBA8888);
+    if (outColor == ImageFrame::RGB565) {
+        m_decodeColor = ImageFrame::RGB565;
+    } else {
+        if (outColor != ImageFrame::RGBA8888) {
+            return false;
+        }
+        m_decodeColor = ImageFrame::RGBA8888;
+    }
+    m_originalMaxDecodedBytes = m_maxDecodedBytes;
+    m_maxDecodedBytes = maxDecodedBytes;
+    return true;
+}
+
+void JPEGImageDecoder::disableDecodeAndScale()
+{
+    m_decodeColor = ImageFrame::RGBA8888;
+    m_maxDecodedBytes = m_originalMaxDecodedBytes;
+}
+
+bool JPEGImageDecoder::hasFramebufferChanged() const
+{
+    // for decoding that doesn't restart (e.g. when previous decodings didn't have
+    // all of the data, and meanwhile decoding to different output size was requested
+    if (m_frameBufferCache.isEmpty() || hasImagePlanes()) {
+        return false;
+    }
+    const ImageFrame& buffer = m_frameBufferCache[0];
+    // size is important here, not the decoded color - so use the current one
+    // when checking size change
+    if (buffer.status() != ImageFrame::FrameEmpty && !buffer.hasSize(m_decodedSize, m_decodeColor))
+        return true;
+    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().
-        buffer.setHasAlpha(true);
+        // For RGB565 this would just fail, having bitmap opaque during decoding
+        // but, since RGB565 is used only for fully loaded content, this is not a problem
+        if (!decodeToRGB565Enabled())
+            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();
 }
 
 }