Add SkEncodedFormat, used by SkCodec.

src/ports/SkImageDecoder_WIC.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 "SkTypes.h"
 
@@ skipping 43 matching lines @@
         kDecodeFormat_WICMode,
         kDecodeBounds_WICMode,
         kDecodePixels_WICMode,
     };
 
     /**
      *  Helper function to decode an SkStream.
      *  @param stream SkStream to decode. Must be at the beginning.
      *  @param bm   SkBitmap to decode into. Only used if wicMode is kDecodeBounds_WICMode or
      *      kDecodePixels_WICMode, in which case it must not be NULL.
-     *  @param format Out parameter for the SkImageDecoder::Format of the SkStream. Only used if
+     *  @param format Out parameter for the SkEncodedFormat of the SkStream. Only used if
      *      wicMode is kDecodeFormat_WICMode.
      */
-    bool decodeStream(SkStream* stream, SkBitmap* bm, WICModes wicMode, Format* format) const;
+    bool decodeStream(SkStream* stream, SkBitmap* bm, WICModes wicMode,
+                      SkEncodedFormat* format) const;
 
 protected:
     Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) SK_OVERRIDE;
 };
 
 struct FormatConversion {
-    GUID                    fGuidFormat;
-    SkImageDecoder::Format  fFormat;
+    GUID            fGuidFormat;
+    SkEncodedFormat fFormat;
 };
 
 static const FormatConversion gFormatConversions[] = {
-    { GUID_ContainerFormatBmp, SkImageDecoder::kBMP_Format },
-    { GUID_ContainerFormatGif, SkImageDecoder::kGIF_Format },
-    { GUID_ContainerFormatIco, SkImageDecoder::kICO_Format },
-    { GUID_ContainerFormatJpeg, SkImageDecoder::kJPEG_Format },
-    { GUID_ContainerFormatPng, SkImageDecoder::kPNG_Format },
+    { GUID_ContainerFormatBmp, kBMP_SkEncodedFormat },
+    { GUID_ContainerFormatGif, kGIF_SkEncodedFormat },
+    { GUID_ContainerFormatIco, kICO_SkEncodedFormat },
+    { GUID_ContainerFormatJpeg, kJPEG_SkEncodedFormat },
+    { GUID_ContainerFormatPng, kPNG_SkEncodedFormat },
 };
 
-static SkImageDecoder::Format GuidContainerFormat_to_Format(REFGUID guid) {
+static SkEncodedFormat GuidContainerFormat_to_Format(REFGUID guid) {
     for (size_t i = 0; i < SK_ARRAY_COUNT(gFormatConversions); i++) {
         if (IsEqualGUID(guid, gFormatConversions[i].fGuidFormat)) {
             return gFormatConversions[i].fFormat;
         }
     }
-    return SkImageDecoder::kUnknown_Format;
+    return kUnknown_SkEncodedFormat;
 }
 
 SkImageDecoder::Result SkImageDecoder_WIC::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
     WICModes wicMode;
     switch (mode) {
         case SkImageDecoder::kDecodeBounds_Mode:
             wicMode = kDecodeBounds_WICMode;
             break;
         case SkImageDecoder::kDecodePixels_Mode:
             wicMode = kDecodePixels_WICMode;
             break;
     }
     return this->decodeStream(stream, bm, wicMode, NULL) ? kSuccess : kFailure;
 }
 
 bool SkImageDecoder_WIC::decodeStream(SkStream* stream, SkBitmap* bm, WICModes wicMode,
-                                      Format* format) const {
+                                      SkEncodedFormat* format) const {
     //Initialize COM.
     SkAutoCoInitialize scopedCo;
     if (!scopedCo.succeeded()) {
         return false;
     }
 
     HRESULT hr = S_OK;
 
     //Create Windows Imaging Component ImagingFactory.
     SkTScopedComPtr<IWICImagingFactory> piImagingFactory;
@@ skipping 312 matching lines @@
         hr = piEncoder->Commit();
     }
 
     return SUCCEEDED(hr);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkImageEncoder* sk_imageencoder_wic_factory(SkImageEncoder::Type t) {
     switch (t) {
-        case SkImageEncoder::kBMP_Type:
-        case SkImageEncoder::kICO_Type:
-        case SkImageEncoder::kJPEG_Type:
-        case SkImageEncoder::kPNG_Type:
+        case kBMP_SkEncodedFormat:
+        case kICO_SkEncodedFormat:
+        case kJPEG_SkEncodedFormat:
+        case kPNG_SkEncodedFormat:
             break;
         default:
             return NULL;
     }
     return SkNEW_ARGS(SkImageEncoder_WIC, (t));
 }
 
 static SkImageEncoder_EncodeReg gEReg(sk_imageencoder_wic_factory);
 
-static SkImageDecoder::Format get_format_wic(SkStreamRewindable* stream) {
-    SkImageDecoder::Format format;
+static SkEncodedFormat get_format_wic(SkStreamRewindable* stream) {
+    SkEncodedFormat format;
     SkImageDecoder_WIC codec;
     if (!codec.decodeStream(stream, NULL, SkImageDecoder_WIC::kDecodeFormat_WICMode, &format)) {
-        format = SkImageDecoder::kUnknown_Format;
+        format = kUnknown_SkEncodedFormat;
     }
     return format;
 }
 
 static SkImageDecoder_FormatReg gFormatReg(get_format_wic);