Checking for valid colorType, alphaType, colorSpace in SkCodec

src/codec/SkPngCodec.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 "SkBitmap.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 339 matching lines @@
     // implemented to guess sRGB in this case.
     return nullptr;
 }
 
 static int bytes_per_pixel(int bitsPerPixel) {
     // Note that we will have to change this implementation if we start
     // supporting outputs from libpng that are less than 8-bits per component.
     return bitsPerPixel / 8;
 }
 
-static bool png_conversion_possible(const SkImageInfo& dst, const SkImageInfo& src) {
-    // Ensure the alpha type is valid
-    if (!valid_alpha(dst.alphaType(), src.alphaType())) {
-        return false;
-    }
-
-    // Check for supported color types
-    switch (dst.colorType()) {
-        case kRGBA_8888_SkColorType:
-        case kBGRA_8888_SkColorType:
-        case kRGBA_F16_SkColorType:
-            return true;
-        case kRGB_565_SkColorType:
-            return kOpaque_SkAlphaType == src.alphaType();
-        default:
-            return dst.colorType() == src.colorType();
-    }
-}
-
 void SkPngCodec::allocateStorage(const SkImageInfo& dstInfo) {
     switch (fXformMode) {
         case kSwizzleOnly_XformMode:
             fStorage.reset(SkAlign4(fSrcRowBytes));
             fSwizzlerSrcRow = fStorage.get();
             break;
         case kColorOnly_XformMode:
             // Intentional fall through.  A swizzler hasn't been created yet, but one will
             // be created later if we are sampling.  We'll go ahead and allocate
             // enough memory to swizzle if necessary.
@@ skipping 26 matching lines @@
 class SkPngNormalCodec : public SkPngCodec {
 public:
     SkPngNormalCodec(const SkEncodedInfo& encodedInfo, const SkImageInfo& imageInfo,
             SkStream* stream, SkPngChunkReader* chunkReader, png_structp png_ptr,
             png_infop info_ptr, int bitDepth)
         : INHERITED(encodedInfo, imageInfo, stream, chunkReader, png_ptr, info_ptr, bitDepth, 1)
     {}
 
     Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options,
             SkPMColor ctable[], int* ctableCount) override {
-        if (!png_conversion_possible(dstInfo, this->getInfo()) ||
+        if (!conversion_possible(dstInfo, this->getInfo()) ||
             !this->initializeXforms(dstInfo, options, ctable, ctableCount))
         {
             return kInvalidConversion;
         }
 
         this->allocateStorage(dstInfo);
         return kSuccess;
     }
 
     int readRows(const SkImageInfo& dstInfo, void* dst, size_t rowBytes, int count, int startRow)
@@ skipping 46 matching lines @@
             png_infop info_ptr, int bitDepth, int numberPasses)
         : INHERITED(encodedInfo, imageInfo, stream, chunkReader, png_ptr, info_ptr, bitDepth,
                     numberPasses)
         , fCanSkipRewind(false)
     {
         SkASSERT(numberPasses != 1);
     }
 
     Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options,
             SkPMColor ctable[], int* ctableCount) override {
-        if (!png_conversion_possible(dstInfo, this->getInfo()) ||
+        if (!conversion_possible(dstInfo, this->getInfo()) ||
             !this->initializeXforms(dstInfo, options, ctable, ctableCount))
         {
             return kInvalidConversion;
         }
 
         this->allocateStorage(dstInfo);
         fCanSkipRewind = true;
         return SkCodec::kSuccess;
     }
 
@@ skipping 299 matching lines @@
     }
     png_read_update_info(fPng_ptr, fInfo_ptr);
 
     // Reset fSwizzler and fColorXform.  We can't do this in onRewind() because the
     // interlaced scanline decoder may need to rewind.
     fSwizzler.reset(nullptr);
     fColorXform = nullptr;
 
     bool needsColorXform = needs_color_xform(dstInfo, this->getInfo());
     if (needsColorXform) {
-        if (kGray_8_SkColorType == dstInfo.colorType() ||
-            kRGB_565_SkColorType == dstInfo.colorType())
-        {
-            return false;
-        }
-
         fColorXform = SkColorSpaceXform::New(sk_ref_sp(this->getInfo().colorSpace()),
                                              sk_ref_sp(dstInfo.colorSpace()));
 
-        if (!fColorXform && kRGBA_F16_SkColorType == dstInfo.colorType()) {
+        // TODO (msarett): Possibly working toward asserting this?
+        if (!fColorXform) {
             return false;
         }
     }
 
     // If the image is RGBA and we have a color xform, we can skip the swizzler.
     // FIXME (msarett):
     // Support more input types to fColorXform (ex: RGB, Gray) and skip the swizzler more often.
     if (fColorXform && SkEncodedInfo::kRGBA_Color == this->getEncodedInfo().color() &&
         !options.fSubset)
     {
@@ skipping 68 matching lines @@
 
     fPng_ptr = png_ptr;
     fInfo_ptr = info_ptr;
     return true;
 }
 
 SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& dstInfo, void* dst,
                                         size_t rowBytes, const Options& options,
                                         SkPMColor ctable[], int* ctableCount,
                                         int* rowsDecoded) {
-    if (!png_conversion_possible(dstInfo, this->getInfo()) ||
+    if (!conversion_possible(dstInfo, this->getInfo()) ||
         !this->initializeXforms(dstInfo, options, ctable, ctableCount))
     {
         return kInvalidConversion;
     }
 
     if (options.fSubset) {
         return kUnimplemented;
     }
 
     this->allocateStorage(dstInfo);
@@ skipping 20 matching lines @@
     SkCodec* outCodec;
     if (read_header(stream, chunkReader, &outCodec, nullptr, nullptr)) {
         // Codec has taken ownership of the stream.
         SkASSERT(outCodec);
         streamDeleter.release();
         return outCodec;
     }
 
     return nullptr;
 }