Use SkSwizzler to convert from CMYK

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 "SkJpegCodec.h"
 #include "SkJpegDecoderMgr.h"
 #include "SkJpegUtility_codec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkTypes.h"
 
 // stdio is needed for libjpeg-turbo
 #include <stdio.h>
 
 extern "C" {
     #include "jerror.h"
     #include "jpeglib.h"
 }
 
-/*
- * Convert a row of CMYK samples to RGBA in place.
- * Note that this method moves the row pointer.
- * @param width the number of pixels in the row that is being converted
- *              CMYK is stored as four bytes per pixel
- */
-static void convert_CMYK_to_RGBA(uint8_t* row, uint32_t width) {
-    // We will implement a crude conversion from CMYK -> RGB using formulas
-    // from easyrgb.com.
-    //
-    // CMYK -> CMY
-    // C = C * (1 - K) + K
-    // M = M * (1 - K) + K
-    // Y = Y * (1 - K) + K
-    //
-    // libjpeg actually gives us inverted CMYK, so we must subtract the
-    // original terms from 1.
-    // CMYK -> CMY
-    // C = (1 - C) * (1 - (1 - K)) + (1 - K)
-    // M = (1 - M) * (1 - (1 - K)) + (1 - K)
-    // Y = (1 - Y) * (1 - (1 - K)) + (1 - K)
-    //
-    // Simplifying the above expression.
-    // CMYK -> CMY
-    // C = 1 - CK
-    // M = 1 - MK
-    // Y = 1 - YK
-    //
-    // CMY -> RGB
-    // R = (1 - C) * 255
-    // G = (1 - M) * 255
-    // B = (1 - Y) * 255
-    //
-    // Therefore the full conversion is below.  This can be verified at
-    // www.rapidtables.com (assuming inverted CMYK).
-    // CMYK -> RGB
-    // R = C * K * 255
-    // G = M * K * 255
-    // B = Y * K * 255
-    //
-    // As a final note, we have treated the CMYK values as if they were on
-    // a scale from 0-1, when in fact they are 8-bit ints scaling from 0-255.
-    // We must divide each CMYK component by 255 to obtain the true conversion
-    // we should perform.
-    // CMYK -> RGB
-    // R = C * K / 255
-    // G = M * K / 255
-    // B = Y * K / 255
-    for (uint32_t x = 0; x < width; x++, row += 4) {
-#if defined(SK_PMCOLOR_IS_RGBA)
-        row[0] = SkMulDiv255Round(row[0], row[3]);
-        row[1] = SkMulDiv255Round(row[1], row[3]);
-        row[2] = SkMulDiv255Round(row[2], row[3]);
-#else
-        uint8_t tmp = row[0];
-        row[0] = SkMulDiv255Round(row[2], row[3]);
-        row[1] = SkMulDiv255Round(row[1], row[3]);
-        row[2] = SkMulDiv255Round(tmp, row[3]);
-#endif
-        row[3] = 0xFF;
-    }
-}
-
 bool SkJpegCodec::IsJpeg(SkStream* stream) {
     static const uint8_t jpegSig[] = { 0xFF, 0xD8, 0xFF };
     char buffer[sizeof(jpegSig)];
     return stream->read(buffer, sizeof(jpegSig)) == sizeof(jpegSig) &&
             !memcmp(buffer, jpegSig, sizeof(jpegSig));
 }
 
 bool SkJpegCodec::ReadHeader(SkStream* stream, SkCodec** codecOut,
         JpegDecoderMgr** decoderMgrOut) {
 
@@ skipping 157 matching lines @@
     #if defined(SK_PMCOLOR_IS_RGBA)
                 fDecoderMgr->dinfo()->out_color_space = JCS_EXT_RGBA;
     #else
                 fDecoderMgr->dinfo()->out_color_space = JCS_EXT_BGRA;
     #endif
 #endif
             }
             return true;
         case kRGB_565_SkColorType:
             if (isCMYK) {
-                // FIXME (msarett): We need to support 565 here.  It's not hard to do, considering
-                // we already convert CMYK to RGBA, I just need to do it.  I think it might be
-                // best to do this in SkSwizzler and also move convert_CMYK_to_RGBA into SkSwizzler.
-                return false;
+                fDecoderMgr->dinfo()->out_color_space = JCS_CMYK;
             } else {
 #if defined(GOOGLE3)
                 return false;
 #else
                 fDecoderMgr->dinfo()->dither_mode = JDITHER_NONE;
                 fDecoderMgr->dinfo()->out_color_space = JCS_RGB565;
 #endif
             }
             return true;
         case kGray_8_SkColorType:
@@ skipping 78 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) {
+        this->initializeSwizzler(dstInfo, options);
+    }
+
     // Perform the decode a single row at a time
     uint32_t dstHeight = dstInfo.height();
-    JSAMPLE* dstRow = (JSAMPLE*) dst;
+
+    JSAMPLE* dstRow;
+    if (fSwizzler) {
+        // write data to storage row, then sample using swizzler
+        dstRow = fSrcRow;
+    } else {
+        // write data directly to dst
+        dstRow = (JSAMPLE*) dst;
+    }
+
     for (uint32_t y = 0; y < dstHeight; y++) {
         // Read rows of the image
         uint32_t lines = jpeg_read_scanlines(dinfo, &dstRow, 1);
 
         // If we cannot read enough rows, assume the input is incomplete
         if (lines != 1) {
             *rowsDecoded = y;
 
             return fDecoderMgr->returnFailure("Incomplete image data", kIncompleteInput);
         }
 
-        // Convert to RGBA if necessary
-        if (JCS_CMYK == dinfo->out_color_space) {
-            convert_CMYK_to_RGBA(dstRow, dstInfo.width());
+        if (fSwizzler) {
+            // use swizzler to sample row
+            fSwizzler->swizzle(dst, dstRow);
+            dst = SkTAddOffset<JSAMPLE>(dst, dstRowBytes);
+        } else {
+            dstRow = SkTAddOffset<JSAMPLE>(dstRow, dstRowBytes);
         }
-
-        // Move to the next row
-        dstRow = SkTAddOffset<JSAMPLE>(dstRow, dstRowBytes);
     }
 
     return kSuccess;
 }
 
 void SkJpegCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options& options) {
     SkSwizzler::SrcConfig srcConfig = SkSwizzler::kUnknown;
-    switch (dstInfo.colorType()) {
-        case kGray_8_SkColorType:
-            srcConfig = SkSwizzler::kGray;
-            break;
-        case kRGBA_8888_SkColorType:
-            srcConfig = SkSwizzler::kRGBX;
-            break;
-        case kBGRA_8888_SkColorType:
-            srcConfig = SkSwizzler::kBGRX;
-            break;
-        case kRGB_565_SkColorType:
-            srcConfig = SkSwizzler::kRGB_565;
-            break;
-        default:
-            // This function should only be called if the colorType is supported by jpeg
+    if (JCS_CMYK == fDecoderMgr->dinfo()->out_color_space) {
+        srcConfig = SkSwizzler::kCMYK;
+    } else {
+        switch (dstInfo.colorType()) {
+            case kGray_8_SkColorType:
+                srcConfig = SkSwizzler::kGray;
+                break;
+            case kRGBA_8888_SkColorType:
+                srcConfig = SkSwizzler::kRGBX;
+                break;
+            case kBGRA_8888_SkColorType:
+                srcConfig = SkSwizzler::kBGRX;
+                break;
+            case kRGB_565_SkColorType:
+                srcConfig = SkSwizzler::kRGB_565;
+                break;
+            default:
+                // This function should only be called if the colorType is supported by jpeg
 #if defined(GOOGLE3)
-            SK_CRASH();
+                SK_CRASH();
 #else
-            SkASSERT(false);
+                SkASSERT(false);
 #endif
+        }
     }
 
     fSwizzler.reset(SkSwizzler::CreateSwizzler(srcConfig, nullptr, dstInfo, options));
     fStorage.reset(get_row_bytes(fDecoderMgr->dinfo()));
     fSrcRow = static_cast<uint8_t*>(fStorage.get());
 }
 
 SkSampler* SkJpegCodec::getSampler(bool createIfNecessary) {
     if (!createIfNecessary || fSwizzler) {
         SkASSERT(!fSwizzler || (fSrcRow && static_cast<uint8_t*>(fStorage.get()) == fSrcRow));
@@ skipping 21 matching lines @@
     fSwizzler.reset(nullptr);
     fSrcRow = nullptr;
     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
-    if (options.fSubset) {
+    // 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) {
         this->initializeSwizzler(dstInfo, options);
     }
 
     return kSuccess;
 }
 
 int SkJpegCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         return fDecoderMgr->returnFailure("setjmp", kInvalidInput);
     }
     // Read rows one at a time
     JSAMPLE* dstRow;
     if (fSwizzler) {
         // write data to storage row, then sample using swizzler
         dstRow = fSrcRow;
     } else {
         // write data directly to dst
         dstRow = (JSAMPLE*) dst;
     }
 
     for (int y = 0; y < count; y++) {
         // Read row of the image
         uint32_t rowsDecoded = jpeg_read_scanlines(fDecoderMgr->dinfo(), &dstRow, 1);
         if (rowsDecoded != 1) {
             fDecoderMgr->dinfo()->output_scanline = this->dstInfo().height();
             return y;
         }
 
-        // Convert to RGBA if necessary
-        if (JCS_CMYK == fDecoderMgr->dinfo()->out_color_space) {
-            convert_CMYK_to_RGBA(dstRow, fDecoderMgr->dinfo()->output_width);
-        }
-
-        if(fSwizzler) {
+        if (fSwizzler) {
             // use swizzler to sample row
             fSwizzler->swizzle(dst, dstRow);
             dst = SkTAddOffset<JSAMPLE>(dst, rowBytes);
         } else {
             dstRow = SkTAddOffset<JSAMPLE>(dstRow, rowBytes);
         }
     }
     return count;
 }
 
@@ skipping 12 matching lines @@
 #endif
 
 bool SkJpegCodec::onSkipScanlines(int count) {
     // Set the jump location for libjpeg errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         return fDecoderMgr->returnFalse("setjmp");
     }
 
     return (uint32_t) count == jpeg_skip_scanlines(fDecoderMgr->dinfo(), count);
 }