Make SkJpegCodec compatible with libjpeg

src/codec/SkJpegCodec.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec.h"
 #include "SkMSAN.h"
 #include "SkJpegCodec.h"
@@ skipping 68 matching lines @@
         JpegDecoderMgr* decoderMgr)
     : INHERITED(srcInfo, stream)
     , fDecoderMgr(decoderMgr)
     , fReadyState(decoderMgr->dinfo()->global_state)
 {}
 
 /*
  * Return the row bytes of a particular image type and width
  */
 static size_t get_row_bytes(const j_decompress_ptr dinfo) {
-    size_t colorBytes = (dinfo->out_color_space == JCS_RGB565) ? 2 : dinfo->out_color_components;
+#ifdef TURBO_HAS_565
+    const size_t colorBytes = (dinfo->out_color_space == JCS_RGB565) ? 2 :
+            dinfo->out_color_components;
+#else
+    const size_t colorBytes = dinfo->out_color_components;
+#endif
     return dinfo->output_width * colorBytes;
 
 }
 
 /*
  *  Calculate output dimensions based on the provided factors.
  *
  *  Not to be used on the actual jpeg_decompress_struct used for decoding, since it will
  *  incorrectly modify num_components.
  */
@@ skipping 77 matching lines @@
     // Check if we will decode to CMYK because a conversion to RGBA is not supported
     J_COLOR_SPACE colorSpace = fDecoderMgr->dinfo()->jpeg_color_space;
     bool isCMYK = JCS_CMYK == colorSpace || JCS_YCCK == colorSpace;
 
     // Check for valid color types and set the output color space
     switch (dst.colorType()) {
         case kN32_SkColorType:
             if (isCMYK) {
                 fDecoderMgr->dinfo()->out_color_space = JCS_CMYK;
             } else {
-                // Check the byte ordering of the RGBA color space for the
-                // current platform
-#if defined(SK_PMCOLOR_IS_RGBA)
-                fDecoderMgr->dinfo()->out_color_space = JCS_EXT_RGBA;
+#ifdef LIBJPEG_TURBO_VERSION
+            // Check the byte ordering of the RGBA color space for the
+            // current platform
+    #ifdef SK_PMCOLOR_IS_RGBA
+            fDecoderMgr->dinfo()->out_color_space = JCS_EXT_RGBA;
+    #else
+            fDecoderMgr->dinfo()->out_color_space = JCS_EXT_BGRA;
+    #endif
 #else
-                fDecoderMgr->dinfo()->out_color_space = JCS_EXT_BGRA;
+            fDecoderMgr->dinfo()->out_color_space = JCS_RGB;
 #endif
             }
             return true;
         case kRGB_565_SkColorType:
             if (isCMYK) {
                 fDecoderMgr->dinfo()->out_color_space = JCS_CMYK;
             } else {
+#ifdef TURBO_HAS_565
                 fDecoderMgr->dinfo()->dither_mode = JDITHER_NONE;
                 fDecoderMgr->dinfo()->out_color_space = JCS_RGB565;
+#else
+                fDecoderMgr->dinfo()->out_color_space = JCS_RGB;
+#endif
             }
             return true;
         case kGray_8_SkColorType:
             if (isCMYK) {
                 return false;
             } else {
                 // We will enable decodes to gray even if the image is color because this is
                 // much faster than decoding to color and then converting
                 fDecoderMgr->dinfo()->out_color_space = JCS_GRAYSCALE;
             }
@@ skipping 71 matching lines @@
 
     // Now, given valid output dimensions, we can start the decompress
     if (!jpeg_start_decompress(dinfo)) {
         return fDecoderMgr->returnFailure("startDecompress", kInvalidInput);
     }
 
     // The recommended output buffer height should always be 1 in high quality modes.
     // If it's not, we want to know because it means our strategy is not optimal.
     SkASSERT(1 == dinfo->rec_outbuf_height);
 
-    if (JCS_CMYK == dinfo->out_color_space) {
+    J_COLOR_SPACE colorSpace = dinfo->out_color_space;
+    if (JCS_CMYK == colorSpace || JCS_RGB == colorSpace) {
         this->initializeSwizzler(dstInfo, options);
     }
 
     // Perform the decode a single row at a time
     uint32_t dstHeight = dstInfo.height();
 
     JSAMPLE* dstRow;
     if (fSwizzler) {
         // write data to storage row, then sample using swizzler
         dstRow = fSrcRow;
@@ skipping 42 matching lines @@
                 break;
             case kRGB_565_SkColorType:
                 srcConfig = SkSwizzler::kNoOp16;
                 break;
             default:
                 // This function should only be called if the colorType is supported by jpeg
                 SkASSERT(false);
         }
     }
 
+    if (JCS_RGB == fDecoderMgr->dinfo()->out_color_space) {
+        srcConfig = SkSwizzler::kRGB;
+    }
+
     fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, dstInfo, options));
     fStorage.reset(get_row_bytes(fDecoderMgr->dinfo()));
     fSrcRow = fStorage.get();
 }
 
 SkSampler* SkJpegCodec::getSampler(bool createIfNecessary) {
     if (!createIfNecessary || fSwizzler) {
         SkASSERT(!fSwizzler || (fSrcRow && fStorage.get() == fSrcRow));
         return fSwizzler;
     }
@@ skipping 21 matching lines @@
     fStorage.free();
 
     // Now, given valid output dimensions, we can start the decompress
     if (!jpeg_start_decompress(fDecoderMgr->dinfo())) {
         SkCodecPrintf("start decompress failed\n");
         return kInvalidInput;
     }
 
     // We will need a swizzler if we are performing a subset decode or
     // converting from CMYK.
-    if (options.fSubset || JCS_CMYK == fDecoderMgr->dinfo()->out_color_space) {
+    J_COLOR_SPACE colorSpace = fDecoderMgr->dinfo()->out_color_space;
+    if (options.fSubset || JCS_CMYK == colorSpace || JCS_RGB == colorSpace) {
         this->initializeSwizzler(dstInfo, options);
     }
 
     return kSuccess;
 }
 
 int SkJpegCodec::onGetScanlines(void* dst, int count, size_t dstRowBytes) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         return fDecoderMgr->returnFailure("setjmp", kInvalidInput);
@@ skipping 238 matching lines @@
 
         JDIMENSION linesRead = jpeg_read_raw_data(dinfo, yuv, numRowsPerBlock);
         if (linesRead < remainingRows) {
             // FIXME: Handle incomplete YUV decodes without signalling an error.
             return kInvalidInput;
         }
     }
 
     return kSuccess;
 }