Add config option to skimage.

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"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkRandom.h"
 #include "SkStream.h"
 #include "SkTArray.h"
 #include "SkTemplates.h"
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
+DEFINE_string(config, "None", "Preferred config to decode into. [None|8888|565|A8]");
 DEFINE_string(createExpectationsPath, "", "Path to write JSON expectations.");
 DEFINE_string(mismatchPath, "", "Folder to write mismatched images to.");
 DEFINE_string2(readPath, r, "", "Folder(s) and files to decode images. Required.");
 DEFINE_string(readExpectationsPath, "", "Path to read JSON expectations from.");
 DEFINE_bool(reencode, true, "Reencode the images to test encoding.");
 DEFINE_bool(testSubsetDecoding, true, "Test decoding subsets of images.");
 DEFINE_string2(writePath, w, "",  "Write rendered images into this directory.");
 
 struct Format {
     SkImageEncoder::Type    fType;
@@ skipping 56 matching lines @@
 // Store the names of the filenames to report later which ones failed, succeeded, and were
 // invalid.
 static SkTArray<SkString, false> gInvalidStreams;
 static SkTArray<SkString, false> gMissingCodecs;
 static SkTArray<SkString, false> gDecodeFailures;
 static SkTArray<SkString, false> gEncodeFailures;
 static SkTArray<SkString, false> gSuccessfulDecodes;
 static SkTArray<SkString, false> gSuccessfulSubsetDecodes;
 static SkTArray<SkString, false> gFailedSubsetDecodes;
 
+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);
 }
 
 /**
  *  Return a random SkIRect inside the range specified.
@@ skipping 198 matching lines @@
     }
 
     SkAutoTDelete<SkImageDecoder> ad(codec);
 
     stream.rewind();
 
     // Create a string representing just the filename itself, for use in json expectations.
     SkString basename = SkOSPath::SkBasename(srcPath);
     const char* filename = basename.c_str();
 
-    if (!codec->decode(&stream, &bitmap, SkBitmap::kARGB_8888_Config,
+    if (!codec->decode(&stream, &bitmap, gPrefConfig,
                        SkImageDecoder::kDecodePixels_Mode)) {
         if (expect_to_fail(filename)) {
             gSuccessfulDecodes.push_back().appendf(
                 "failed to decode %s, which is a known failure.", srcPath);
         } else {
             gDecodeFailures.push_back().set(srcPath);
         }
         return;
     }
 
@@ skipping 47 matching lines @@
         if (codec->buildTileIndex(&stream, &width, &height) && width > 1 && height > 1) {
             SkASSERT(bitmap.width() == width && bitmap.height() == height);
             // Call decodeSubset multiple times:
             SkRandom rand(0);
             for (int i = 0; i < 5; i++) {
                 SkBitmap bitmapFromDecodeSubset;
                 // FIXME: Come up with a more representative set of rectangles.
                 SkIRect rect = generate_random_rect(&rand, width, height);
                 SkString subsetDim = SkStringPrintf("[%d,%d,%d,%d]", rect.fLeft, rect.fTop,
                                                     rect.fRight, rect.fBottom);
-                if (codec->decodeSubset(&bitmapFromDecodeSubset, rect, SkBitmap::kNo_Config)) {
+                if (codec->decodeSubset(&bitmapFromDecodeSubset, rect, gPrefConfig)) {
                     SkString subsetName = SkStringPrintf("%s_%s", filename, subsetDim.c_str());
                     if (compare_to_expectations_if_necessary(bitmapFromDecodeSubset,
                                                              subsetName.c_str(),
                                                              &gFailedSubsetDecodes)) {
                         gSuccessfulSubsetDecodes.push_back().printf("Decoded subset %s from %s",
                                                               subsetDim.c_str(), srcPath);
                     } else if (!FLAGS_mismatchPath.isEmpty()) {
                         write_subset(FLAGS_mismatchPath[0], filename, subsetDim.c_str(),
                                      &bitmapFromDecodeSubset, rect, bitmap);
                     }
@@ skipping 61 matching lines @@
             if(file.write(data->data(), data->size())) {
                 gSuccessfulDecodes.push_back().appendf("\twrote %s", outPath.c_str());
             } else {
                 gEncodeFailures.push_back().printf("Failed to write %s", outPath.c_str());
             }
         }
         // Ensure that the reencoded data can still be decoded.
         SkMemoryStream memStream(data);
         SkBitmap redecodedBitmap;
         SkImageDecoder::Format formatOnSecondDecode;
-        if (SkImageDecoder::DecodeStream(&memStream, &redecodedBitmap, SkBitmap::kNo_Config,
+        if (SkImageDecoder::DecodeStream(&memStream, &redecodedBitmap, gPrefConfig,
                                           SkImageDecoder::kDecodePixels_Mode,
                                           &formatOnSecondDecode)) {
             SkASSERT(format_to_type(formatOnSecondDecode) == type);
         } else {
             gDecodeFailures.push_back().printf("Failed to redecode %s after reencoding to '%s'",
                                                srcPath, suffix_for_type(type));
         }
     }
 }
 
@@ skipping 63 matching lines @@
     SkString* outDirPtr;
 
     if (FLAGS_writePath.count() == 1) {
         outDir.set(FLAGS_writePath[0]);
         append_path_separator_if_necessary(&outDir);
         outDirPtr = &outDir;
     } else {
         outDirPtr = NULL;
     }
 
+    if (FLAGS_config.count() == 1) {
+        // Only consider the first config specified on the command line.
+        const char* config = FLAGS_config[0];
+        if (0 == strcmp(config, "8888")) {
+            gPrefConfig = SkBitmap::kARGB_8888_Config;
+        } else if (0 == strcmp(config, "565")) {
+            gPrefConfig = SkBitmap::kRGB_565_Config;
+        } else if (0 == strcmp(config, "A8")) {
+            gPrefConfig = SkBitmap::kA8_Config;
+        } else if (0 != strcmp(config, "None")) {
+            SkDebugf("Invalid preferred config\n");
+            return -1;
+        }
+    }
+
     for (int i = 0; i < FLAGS_readPath.count(); i++) {
         const char* readPath = FLAGS_readPath[i];
         if (strlen(readPath) < 1) {
             break;
         }
         if (sk_isdir(readPath)) {
             const char* dir = readPath;
             SkOSFile::Iter iter(dir);
             SkString filename;
             while (iter.next(&filename)) {
@@ skipping 33 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