Fixes for decoding to A8.

tools/skimage_main.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm_expectations.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 93 matching lines @@
 static SkTArray<SkString, false> gMissingExpectations;
 static SkTArray<SkString, false> gMissingSubsetExpectations;
 
 static SkBitmap::Config gPrefConfig(SkBitmap::kNo_Config);
 
 // Expections read from a file specified by readExpectationsPath. The expectations must have been
 // previously written using createExpectationsPath.
 SkAutoTUnref<skiagm::JsonExpectationsSource> gJsonExpectations;
 
 static bool write_bitmap(const char outName[], const SkBitmap& bm) {
-    return SkImageEncoder::EncodeFile(outName, bm, SkImageEncoder::kPNG_Type, 100);
+    const SkBitmap* bmPtr;
+    SkBitmap bm8888;
+    if (bm.config() == SkBitmap::kA8_Config) {
+        // Copy A8 into ARGB_8888, since our image encoders do not currently
+        // support A8.

[djsollen, 2013/10/03 16:54:28]

is that a feature that we should support?

[scroggo, 2013/10/03 16:58:52]

Possibly, although I'd set it at a low priority. Not sure if anyone wants the
feature.

[reed1, 2013/10/04 08:56:27]

Perhaps the code at this level shouldn't know if its supported or not. Why don't
the encoders report (a) what they do support, or (b) failure if they didn't
support a given config. That way this tool could "try" A8, and if it failed,
fallback to 32bit.

[scroggo, 2013/10/04 19:45:53]

They do report failure. I have a CL at https://codereview.chromium.org/25964003
that uses a fallback.

+        if (!bm.copyTo(&bm8888, SkBitmap::kARGB_8888_Config)) {
+            return false;
+        }
+        bmPtr = &bm8888;
+    } else {
+        bmPtr = &bm;
+    }
+    return SkImageEncoder::EncodeFile(outName, *bmPtr, SkImageEncoder::kPNG_Type, 100);
 }
 
 /**
  *  Return a random SkIRect inside the range specified.
  *  @param rand Random number generator.
  *  @param maxX Exclusive maximum x-coordinate. SkIRect's fLeft and fRight will be
  *      in the range [0, maxX)
  *  @param maxY Exclusive maximum y-coordinate. SkIRect's fTop and fBottom will be
  *      in the range [0, maxY)
  *  @return SkIRect Non-empty, non-degenerate rectangle.
@@ skipping 363 matching lines @@
                                      &bitmapFromDecodeSubset, rect, bitmap);
                     }
                 } else {
                     gFailedSubsetDecodes.push_back().printf("Failed to decode region %s from %s",
                                                             subsetDim.c_str(), srcPath);
                 }
             }
         }
     }
 
-    if (FLAGS_reencode) {
+    // Do not attempt to re-encode A8, since our image encoders do not support encoding to A8.
+    if (FLAGS_reencode && bitmap.config() != SkBitmap::kA8_Config) {
         // Encode to the format the file was originally in, or PNG if the encoder for the same
         // format is unavailable.
         SkImageDecoder::Format format = codec->getFormat();
         if (SkImageDecoder::kUnknown_Format == format) {
             if (stream.rewind()) {
                 format = SkImageDecoder::GetStreamFormat(&stream);
             }
             if (SkImageDecoder::kUnknown_Format == format) {
                 const char* dot = strrchr(srcPath, '.');
                 if (NULL != dot) {
@@ skipping 190 matching lines @@
     }
 
     return failed ? -1 : 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif