Add SkEncodedFormat, used by SkCodec.

src/images/SkImageDecoder.cpp

 /*
  * Copyright 2006 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 "SkImageDecoder.h"
 #include "SkBitmap.h"
@@ skipping 27 matching lines @@
     other->setPeeker(fPeeker);
     other->setAllocator(fAllocator);
     other->setSampleSize(fSampleSize);
     other->setPreserveSrcDepth(fPreserveSrcDepth);
     other->setDitherImage(fDitherImage);
     other->setSkipWritingZeroes(fSkipWritingZeroes);
     other->setPreferQualityOverSpeed(fPreferQualityOverSpeed);
     other->setRequireUnpremultipliedColors(fRequireUnpremultipliedColors);
 }
 
-SkImageDecoder::Format SkImageDecoder::getFormat() const {
-    return kUnknown_Format;
+SkEncodedFormat SkImageDecoder::getFormat() const {
+    return kUnknown_SkEncodedFormat;
 }
 
 const char* SkImageDecoder::getFormatName() const {
     return GetFormatName(this->getFormat());
 }
 
-const char* SkImageDecoder::GetFormatName(Format format) {
+const char* SkImageDecoder::GetFormatName(SkEncodedFormat format) {
     switch (format) {
-        case kUnknown_Format:
-            return "Unknown Format";
-        case kBMP_Format:
+        case kUnknown_SkEncodedFormat:
+            return "Unknown SkEncodedFormat";
+        case kBMP_SkEncodedFormat:
             return "BMP";
-        case kGIF_Format:
+        case kGIF_SkEncodedFormat:
             return "GIF";
-        case kICO_Format:
+        case kICO_SkEncodedFormat:
             return "ICO";
-        case kPKM_Format:
+        case kPKM_SkEncodedFormat:
             return "PKM";
-        case kKTX_Format:
+        case kKTX_SkEncodedFormat:
             return "KTX";
-        case kASTC_Format:
+        case kASTC_SkEncodedFormat:
             return "ASTC";
-        case kJPEG_Format:
+        case kJPEG_SkEncodedFormat:
             return "JPEG";
-        case kPNG_Format:
+        case kPNG_SkEncodedFormat:
             return "PNG";
-        case kWBMP_Format:
+        case kWBMP_SkEncodedFormat:
             return "WBMP";
-        case kWEBP_Format:
+        case kWEBP_SkEncodedFormat:
             return "WEBP";
         default:
             SkDEBUGFAIL("Invalid format type!");
     }
     return "Unknown Format";
 }
 
 SkImageDecoder::Peeker* SkImageDecoder::setPeeker(Peeker* peeker) {
     SkRefCnt_SafeAssign(fPeeker, peeker);
     return peeker;
@@ skipping 119 matching lines @@
     SkCanvas canvas(*dst);
     canvas.drawSprite(*src, (srcX - dstX) / sampleSize,
                             (srcY - dstY) / sampleSize,
                             &paint);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkImageDecoder::DecodeFile(const char file[], SkBitmap* bm, SkColorType pref,  Mode mode,
-                                Format* format) {
+                                SkEncodedFormat* format) {
     SkASSERT(file);
     SkASSERT(bm);
 
     SkAutoTDelete<SkStreamRewindable> stream(SkStream::NewFromFile(file));
     if (stream.get()) {
         if (SkImageDecoder::DecodeStream(stream, bm, pref, mode, format)) {
             if (SkPixelRef* pr = bm->pixelRef()) {
                 pr->setURI(file);
             }
             return true;
         }
     }
     return false;
 }
 
 bool SkImageDecoder::DecodeMemory(const void* buffer, size_t size, SkBitmap* bm, SkColorType pref,
-                                  Mode mode, Format* format) {
+                                  Mode mode, SkEncodedFormat* format) {
     if (0 == size) {
         return false;
     }
     SkASSERT(buffer);
 
     SkMemoryStream  stream(buffer, size);
     return SkImageDecoder::DecodeStream(&stream, bm, pref, mode, format);
 }
 
 bool SkImageDecoder::DecodeStream(SkStreamRewindable* stream, SkBitmap* bm, SkColorType pref,
-                                  Mode mode, Format* format) {
+                                  Mode mode, SkEncodedFormat* format) {
     SkASSERT(stream);
     SkASSERT(bm);
 
     bool success = false;
     SkImageDecoder* codec = SkImageDecoder::Factory(stream);
 
     if (codec) {
         success = codec->decode(stream, bm, pref, mode) != kFailure;
         if (success && format) {
             *format = codec->getFormat();
-            if (kUnknown_Format == *format) {
+            if (kUnknown_SkEncodedFormat == *format) {
                 if (stream->rewind()) {
                     *format = GetStreamFormat(stream);
                 }
             }
         }
         delete codec;
     }
     return success;
 }
 
 bool SkImageDecoder::decodeYUV8Planes(SkStream* stream, SkISize componentSizes[3], void* planes[3],
                                       size_t rowBytes[3], SkYUVColorSpace* colorSpace) {
     // we reset this to false before calling onDecodeYUV8Planes
     fShouldCancelDecode = false;
 
     return this->onDecodeYUV8Planes(stream, componentSizes, planes, rowBytes, colorSpace);
 }