Swizzler changes Index8 and 565

dm/DMSrcSink.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 "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCommonFlags.h"
@@ skipping 34 matching lines @@
     return gm->getISize();
 }
 
 Name GMSrc::name() const {
     SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
     return gm->getName();
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
-CodecSrc::CodecSrc(Path path, Mode mode) : fPath(path), fMode(mode) {}
+CodecSrc::CodecSrc(Path path, Mode mode, DstColorType dstColorType)
+    : fPath(path)
+    , fMode(mode)
+    , fDstColorType(dstColorType)
+{}
 
 Error CodecSrc::draw(SkCanvas* canvas) const {
     SkImageInfo canvasInfo;
     if (NULL == canvas->peekPixels(&canvasInfo, NULL)) {
         // TODO: Once we implement GPU paths (e.g. JPEG YUV), we should use a deferred decode to
         // let the GPU handle it.
         return Error::Nonfatal("No need to test decoding to non-raster backend.");
     }
 
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     if (!encoded) {
         return SkStringPrintf("Couldn't read %s.", fPath.c_str());
     }
 
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
     if (!codec) {
         return SkStringPrintf("Couldn't decode %s.", fPath.c_str());
     }
 
-    SkImageInfo decodeInfo = codec->getInfo().makeColorType(canvasInfo.colorType());
+    // Choose the color type to decode to
+    SkImageInfo decodeInfo;
+    SkColorType canvasColorType = canvasInfo.colorType();
+    switch (fDstColorType) {
+        case kGetFromCanvas_DstColorType:
+            decodeInfo = codec->getInfo().makeColorType(canvasColorType);
+            break;
+        case kIndex8_Always_DstColorType:
+            if (kRGB_565_SkColorType == canvasColorType) {
+                return Error::Nonfatal("Do not test decoding to kIndex8 when the canvas is 565.");
+            } else if (kIndex_8_SkColorType != codec->getInfo().colorType()) {

[scroggo, 2015/04/07 21:15:34]

nit: This may be a matter of preference, but I don't think there's any need for
the "else" here. If the first case was true, we would have returned, so it's not
functionally related, but the two checks also seem to be independent.

[msarett, 2015/04/08 13:59:10]

Done.

+                return Error::Nonfatal("Do not test decoding to kIndex8 when the image is not "
+                        "natively kIndex8.");
+            }
+            decodeInfo = codec->getInfo();

[scroggo, 2015/04/07 21:15:34]

nit: You could move this into the declaration of decodeInfo, and in the first
case say:

decodeInfo = decodeInfo.makeColorType(canvasColorType);

[msarett, 2015/04/08 13:59:10]

Done.

+            break;
+        case kGrayscale_Always_DstColorType:
+            if (kRGB_565_SkColorType == canvasColorType) {
+                return Error::Nonfatal("Do not test decoding to kGray when the canvas is 565.");
+            } else if (kGray_8_SkColorType != codec->getInfo().colorType()) {
+                return Error::Nonfatal("Do not test decoding to kGray when the image is not "
+                        "natively kGray.");
+            }
+            decodeInfo = codec->getInfo();
+            break;
+    }
+
+    // Construct a color table for the decode if necessary
+    SkAutoTUnref<SkColorTable> colorTable(NULL);
+    SkPMColor* colorPtr = NULL;
+    int* colorCountPtr = NULL;
+    int maxColors = 256;
+    if (kIndex_8_SkColorType == decodeInfo.colorType()) {
+        SkPMColor colors[maxColors];
+        colorTable.reset(SkNEW_ARGS(SkColorTable, (colors, maxColors)));
+        colorPtr = const_cast<SkPMColor*>(colorTable->readColors());
+        colorCountPtr = &maxColors;
+    }
+
+    // FIXME: Currently we cannot draw unpremultiplied sources.
     if (decodeInfo.alphaType() == kUnpremul_SkAlphaType) {
-        // FIXME: Currently we cannot draw unpremultiplied sources.
         decodeInfo = decodeInfo.makeAlphaType(kPremul_SkAlphaType);
     }
 
     SkBitmap bitmap;
-    if (!bitmap.tryAllocPixels(decodeInfo)) {
+    if (!bitmap.tryAllocPixels(decodeInfo, NULL, colorTable.get())) {
         return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
                               decodeInfo.width(), decodeInfo.height());
     }
 
     switch (fMode) {
         case kNormal_Mode:
-            switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes())) {
+            switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(), NULL,
+                    colorPtr, colorCountPtr)) {
                 case SkImageGenerator::kSuccess:
                     // We consider incomplete to be valid, since we should still decode what is
                     // available.
                 case SkImageGenerator::kIncompleteInput:
                     break;
                 case SkImageGenerator::kInvalidConversion:
                     return Error::Nonfatal("Incompatible colortype conversion");
                 default:
                     // Everything else is considered a failure.
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
@@ skipping 565 matching lines @@
             canvas->drawPicture(pic);
             return "";
         }
         SkISize size() const override { return fSrc.size(); }
         Name name() const override { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(src);
     return fSink->draw(proxy, bitmap, stream, log);
 }
 
 }  // namespace DM