Perform color correction on png decodes

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 460 matching lines @@
         // Try the next scale
         num -= 1;
         calc_output_dimensions(&dinfo, num, denom);
     }
 
     fDecoderMgr->dinfo()->scale_num = num;
     fDecoderMgr->dinfo()->scale_denom = denom;
     return true;
 }
 
-static bool needs_color_xform(const SkImageInfo& dstInfo, const SkImageInfo& srcInfo) {
-    return (kRGBA_F16_SkColorType == dstInfo.colorType()) ||
-           (dstInfo.colorSpace() && !SkColorSpace::Equals(srcInfo.colorSpace(),
-                                                          dstInfo.colorSpace()));
-}
-
 int SkJpegCodec::readRows(const SkImageInfo& dstInfo, void* dst, size_t rowBytes, int count) {
     // Set the jump location for libjpeg-turbo errors
     if (setjmp(fDecoderMgr->getJmpBuf())) {
         return 0;
     }
 
     // When fSwizzleSrcRow is non-null, it means that we need to swizzle.  In this case,
     // we will always decode into fSwizzlerSrcRow before swizzling into the next buffer.
     // We can never swizzle "in place" because the swizzler may perform sampling and/or
     // subsetting.
@@ skipping 25 matching lines @@
         sk_msan_mark_initialized(decodeDst, decodeDst + srcRowBytes, "skbug.com/4550");
         if (0 == lines) {
             return y;
         }
 
         if (fSwizzler) {
             fSwizzler->swizzle(swizzleDst, decodeDst);
         }
 
         if (fColorXform) {
-            int width = dstInfo.width();
-            switch (dstInfo.colorType()) {
-                case kRGBA_8888_SkColorType:
-                    fColorXform->applyToRGBA((uint32_t*) dst, swizzleDst, width);
-                    break;
-                case kBGRA_8888_SkColorType:
-                    fColorXform->applyToBGRA((uint32_t*) dst, swizzleDst, width);
-                    break;
-                case kRGBA_F16_SkColorType:
-                    fColorXform->applyToF16((uint64_t*) dst, swizzleDst, width);
-                    break;
-                default:
-                    SkASSERT(false);
-                    break;
-            }
-
+            fColorXform->apply(dst, swizzleDst, dstInfo.width(), dstInfo.colorType(),
+                               kOpaque_SkAlphaType);
             dst = SkTAddOffset<void>(dst, rowBytes);
         }
 
         decodeDst = SkTAddOffset<JSAMPLE>(decodeDst, decodeDstRowBytes);
         swizzleDst = SkTAddOffset<uint32_t>(swizzleDst, swizzleDstRowBytes);
     }
 
     return count;
 }
 
@@ skipping 54 matching lines @@
 void SkJpegCodec::allocateStorage(const SkImageInfo& dstInfo) {
     size_t swizzleBytes = 0;
     if (fSwizzler) {
         swizzleBytes = get_row_bytes(fDecoderMgr->dinfo());
         SkASSERT(!fColorXform || SkIsAlign4(swizzleBytes));
     }
 
     size_t xformBytes = 0;
     if (kRGBA_F16_SkColorType == dstInfo.colorType()) {
         SkASSERT(fColorXform);
-        xformBytes = dstInfo.width() * sizeof(SkColorSpaceXform::RGBA32);
+        xformBytes = dstInfo.width() * sizeof(uint32_t);
     }
 
     size_t totalBytes = swizzleBytes + xformBytes;
     if (totalBytes > 0) {
         fStorage.reset(totalBytes);
         fSwizzleSrcRow = (swizzleBytes > 0) ? fStorage.get() : nullptr;
         fColorXformSrcRow = (xformBytes > 0) ?
                 SkTAddOffset<uint32_t>(fStorage.get(), swizzleBytes) : nullptr;
     }
 }
@@ skipping 364 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;
 }