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:
+    SkImageDecoder_CG()
+    : fFormat(kUnknown_Format) {}
+
+    virtual Format getFormat() const SK_OVERRIDE { return fFormat; }
+
 protected:
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode);
+
+private:
+    Format fFormat;
 };
 
 #define BITMAP_INFO (kCGBitmapByteOrder32Big | kCGImageAlphaPremultipliedLast)
 
 bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
     CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
 
     if (NULL == imageSrc) {
         return false;
     }
@@ skipping 37 matching lines @@
         case kCGImageAlphaNoneSkipLast:
         case kCGImageAlphaNoneSkipFirst:
             SkASSERT(SkBitmap::ComputeIsOpaque(*bm));
             bm->setIsOpaque(true);
             break;
         default:
             // we don't know if we're opaque or not, so compute it.
             bm->computeAndSetOpaquePredicate();
     }
     bm->unlockPixels();
+
+    const CFStringRef name = CGImageSourceGetType(imageSrc);
+    fFormat = UTType_to_Format(name);
+
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 extern SkImageDecoder* image_decoder_from_stream(SkStream*);
 
 SkImageDecoder* SkImageDecoder::Factory(SkStream* stream) {
     SkImageDecoder* decoder = image_decoder_from_stream(stream);
     if (NULL == decoder) {
@@ skipping 120 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);