Updates to skimage tool to use it for testing.

src/ports/SkImageDecoder_CG.cpp

 
 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorPriv.h"
 
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkMovie.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkCGUtils.h"
 
 #ifdef SK_BUILD_FOR_MAC
 #include <ApplicationServices/ApplicationServices.h>
 #endif
 
 #ifdef SK_BUILD_FOR_IOS
 #include <CoreGraphics/CoreGraphics.h>
 #include <ImageIO/ImageIO.h>
 #include <MobileCoreServices/MobileCoreServices.h>
 #endif
 
+struct FormatConversion {
+    CFStringRef             fUTType;
+    SkImageDecoder::Format  fFormat;
+};
+
+// Array of the types supported by the decoder.
+static const FormatConversion gFormatConversions[] = {
+    { kUTTypeBMP, SkImageDecoder::kBMP_Format },
+    { kUTTypeGIF, SkImageDecoder::kGIF_Format },
+    { kUTTypeICO, SkImageDecoder::kICO_Format },
+    { kUTTypeJPEG, SkImageDecoder::kJPEG_Format },
+    // Also include JPEG2000
+    { kUTTypeJPEG2000, SkImageDecoder::kJPEG_Format },
+    { kUTTypePNG, SkImageDecoder::kPNG_Format },
+};
+
+static SkImageDecoder::Format UTType_to_Format(const CFStringRef uttype) {
+    for (size_t i = 0; i < SK_ARRAY_COUNT(gFormatConversions); i++) {
+        if (CFStringCompare(uttype, gFormatConversions[i].fUTType, 0) == kCFCompareEqualTo) {
+            return gFormatConversions[i].fFormat;
+        }
+    }
+    return SkImageDecoder::kUnknown_Format;
+}
+
 static void malloc_release_proc(void* info, const void* data, size_t size) {
     sk_free(info);
 }
 
 static CGDataProviderRef SkStreamToDataProvider(SkStream* stream) {
     // TODO: use callbacks, so we don't have to load all the data into RAM
     size_t len = stream->getLength();
     void* data = sk_malloc_throw(len);
     stream->read(data, len);
 
     return CGDataProviderCreateWithData(data, data, len, malloc_release_proc);
 }
 
 static CGImageSourceRef SkStreamToCGImageSource(SkStream* stream) {
     CGDataProviderRef data = SkStreamToDataProvider(stream);
     CGImageSourceRef imageSrc = CGImageSourceCreateWithDataProvider(data, 0);
     CGDataProviderRelease(data);
     return imageSrc;
 }
 
 class SkImageDecoder_CG : public SkImageDecoder {
+public:
+    virtual Format getFormat() const SK_OVERRIDE { return kMultiple_Formats; }
+    Format onGetFormat(SkStream* stream) const SK_OVERRIDE;
+
 protected:
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode);
 };
 
+SkImageDecoder::Format SkImageDecoder_CG::onGetFormat(SkStream *stream) const {
+    CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
+
+    if (NULL == imageSrc) {
+        return kUnknown_Format;
+    }
+
+    SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
+    const CFStringRef name = CGImageSourceGetType(imageSrc);
+    return UTType_to_Format(name);

[epoger, 2013/04/23 16:03:41]

Oh.  I guess this is why the SkImageDecoder subclasses can't just return a
boolean indicating whether they support the format or not... this "meta-decoder"
can support several.

Although, practically speaking, why would the caller care WHICH format the
CG_Decoder finds in the stream?  I think all the caller cares about is whether
CG_Decoder can decode an image from the stream or not, right?

[scroggo, 2013/04/23 20:55:18]

In general, you are correct. The typical client will not care about the Format
of the data. In skimage, I actually do care about the Format, because I want to
test the encoder to verify that we can encode back into that Format. (Ideally
I'd like to then compare that image(re-encoded) to the original, but I don't
think that will work without doing a fuzzy compare.) Do you think that's a good
strategy for skimage? If so, I need to get the data somehow.

+}
+
 #define BITMAP_INFO (kCGBitmapByteOrder32Big | kCGImageAlphaPremultipliedLast)
 
 bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
     CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
 
     if (NULL == imageSrc) {
         return false;
     }
     SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
 
@@ skipping 175 matching lines @@
         case SkImageEncoder::kJPEG_Type:
         case SkImageEncoder::kPNG_Type:
             break;
         default:
             return NULL;
     }
     return SkNEW_ARGS(SkImageEncoder_CG, (t));
 }
 
 static SkTRegistry<SkImageEncoder*, SkImageEncoder::Type> gEReg(sk_imageencoder_cg_factory);