hide Config in SkImageDecoder -- use SkColorType instead

include/core/SkImageDecoder.h

 
 /*
  * 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.
  */
 
 
 #ifndef SkImageDecoder_DEFINED
@@ skipping 221 matching lines @@
 
         This state is automatically reset at the beginning of decode().
      */
     void cancelDecode() {
         // now the subclass must query shouldCancelDecode() to be informed
         // of the request
         fShouldCancelDecode = true;
     }
 
     /** Passed to the decode method. If kDecodeBounds_Mode is passed, then
-        only the bitmap's width/height/config need be set. If kDecodePixels_Mode
+        only the bitmap's info need be set. If kDecodePixels_Mode
         is passed, then the bitmap must have pixels or a pixelRef.
     */
     enum Mode {
-        kDecodeBounds_Mode, //!< only return width/height/config in bitmap
+        kDecodeBounds_Mode, //!< only return info in bitmap
         kDecodePixels_Mode  //!< return entire bitmap (including pixels)
     };
 
     /** Given a stream, decode it into the specified bitmap.
-        If the decoder can decompress the image, it calls bitmap.setConfig(),
+        If the decoder can decompress the image, it calls bitmap.setInfo(),
         and then if the Mode is kDecodePixels_Mode, call allocPixelRef(),
         which will allocated a pixelRef. To access the pixel memory, the codec
         needs to call lockPixels/unlockPixels on the
         bitmap. It can then set the pixels with the decompressed image.
     *   If the image cannot be decompressed, return false. After the
-    *   decoding, the function converts the decoded config in bitmap
+    *   decoding, the function converts the decoded colortype in bitmap
     *   to pref if possible. Whether a conversion is feasible is
     *   tested by Bitmap::canCopyTo(pref).
 
         If an SkBitmap::Allocator is installed via setAllocator, it will be
         used to allocate the pixel memory. A clever allocator can be used
         to allocate the memory from a cache, volatile memory, or even from
         an existing bitmap's memory.
 
         If a Peeker is installed via setPeeker, it may be used to peek into
         meta data during the decode.
-
-        If a Chooser is installed via setChooser, it may be used to select
-        which image to return from a format that contains multiple images.
     */
-    bool decode(SkStream*, SkBitmap* bitmap, SkBitmap::Config pref, Mode);
+    bool decode(SkStream*, SkBitmap* bitmap, SkColorType pref, Mode);
     bool decode(SkStream* stream, SkBitmap* bitmap, Mode mode) {
-        return this->decode(stream, bitmap, SkBitmap::kNo_Config, mode);
+        return this->decode(stream, bitmap, kUnknown_SkColorType, mode);
     }
 
     /**
      * Given a stream, build an index for doing tile-based decode.
      * The built index will be saved in the decoder, and the image size will
      * be returned in width and height.
      *
      * Return true for success or false on failure.
      */
     bool buildTileIndex(SkStreamRewindable*, int *width, int *height);
 
     /**
      * Decode a rectangle subset in the image.
      * The method can only be called after buildTileIndex().
      *
      * Return true for success.
      * Return false if the index is never built or failing in decoding.
      */
-    bool decodeSubset(SkBitmap* bm, const SkIRect& subset, SkBitmap::Config pref);
+    bool decodeSubset(SkBitmap* bm, const SkIRect& subset, SkColorType pref);
 
     /** Given a stream, this will try to find an appropriate decoder object.
         If none is found, the method returns NULL.
     */
     static SkImageDecoder* Factory(SkStreamRewindable*);
 
     /** Decode the image stored in the specified file, and store the result
         in bitmap. Return true for success or false on failure.
 
-        @param prefConfig If the PrefConfigTable is not set, prefer this config.
+        @param pref If the PrefConfigTable is not set, prefer this colortype.
                           See NOTE ABOUT PREFERRED CONFIGS.
 
         @param format On success, if format is non-null, it is set to the format
                       of the decoded file. On failure it is ignored.
     */
-    static bool DecodeFile(const char file[], SkBitmap* bitmap,
-                           SkBitmap::Config prefConfig, Mode,
+    static bool DecodeFile(const char file[], SkBitmap* bitmap, SkColorType pref, Mode,
                            Format* format = NULL);
     static bool DecodeFile(const char file[], SkBitmap* bitmap) {
-        return DecodeFile(file, bitmap, SkBitmap::kNo_Config,
-                          kDecodePixels_Mode, NULL);
+        return DecodeFile(file, bitmap, kUnknown_SkColorType, kDecodePixels_Mode, NULL);
     }
+
     /** Decode the image stored in the specified memory buffer, and store the
         result in bitmap. Return true for success or false on failure.
 
-        @param prefConfig If the PrefConfigTable is not set, prefer this config.
+        @param pref If the PrefConfigTable is not set, prefer this colortype.
                           See NOTE ABOUT PREFERRED CONFIGS.
 
         @param format On success, if format is non-null, it is set to the format
                        of the decoded buffer. On failure it is ignored.
      */
-    static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap,
-                             SkBitmap::Config prefConfig, Mode,
-                             Format* format = NULL);
+    static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap, SkColorType pref,
+                             Mode, Format* format = NULL);
     static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap){
-        return DecodeMemory(buffer, size, bitmap, SkBitmap::kNo_Config,
-                            kDecodePixels_Mode, NULL);
+        return DecodeMemory(buffer, size, bitmap, kUnknown_SkColorType, kDecodePixels_Mode, NULL);
     }
 
     /**
      *  Struct containing information about a pixel destination.
      */
     struct Target {
         /**
          *  Pre-allocated memory.
          */
         void*  fAddr;
 
         /**
          *  Rowbytes of the allocated memory.
          */
         size_t fRowBytes;
     };
 
     /** Decode the image stored in the specified SkStreamRewindable, and store the result
         in bitmap. Return true for success or false on failure.
 
-        @param prefConfig If the PrefConfigTable is not set, prefer this config.
+        @param pref If the PrefConfigTable is not set, prefer this colortype.
                           See NOTE ABOUT PREFERRED CONFIGS.
 
         @param format On success, if format is non-null, it is set to the format
                       of the decoded stream. On failure it is ignored.
      */
-    static bool DecodeStream(SkStreamRewindable* stream, SkBitmap* bitmap,
-                             SkBitmap::Config prefConfig, Mode,
+    static bool DecodeStream(SkStreamRewindable* stream, SkBitmap* bitmap, SkColorType pref, Mode,
                              Format* format = NULL);
     static bool DecodeStream(SkStreamRewindable* stream, SkBitmap* bitmap) {
-        return DecodeStream(stream, bitmap, SkBitmap::kNo_Config,
-                            kDecodePixels_Mode, NULL);
+        return DecodeStream(stream, bitmap, kUnknown_SkColorType, kDecodePixels_Mode, NULL);
     }
 
+#ifdef SK_SUPPORT_LEGACY_IMAGEDECODER_CONFIG
+    bool decode(SkStream*, SkBitmap* bitmap, SkBitmap::Config pref, Mode mode) {
+        return this->decode(stream, bitmap, SkBitmapConfigToColorType(pref), mode);
+    }
+    bool decodeSubset(SkBitmap* bm, const SkIRect& subset, SkBitmap::Config pref) {
+        return this->decodeSubset(bm, subset, SkBitmapConfigToColorType(pref));
+    }
+    static bool DecodeFile(const char file[], SkBitmap* bitmap, SkBitmapConfig pref, Mode mode,
+                           Format* format = NULL) {
+        return DecodeFile(file, bitmap, SkBitmapConfigToColorType(pref), mode, format);
+    }
+    static bool DecodeMemory(const void* buffer, size_t size, SkBitmap* bitmap,
+                             SkBitmap::Config pref, Mode mode, Format* format = NULL) {
+        return DecodeMemory(buffer, size, bitmap, SkBitmapConfigToColorType(pref), mode, format);
+    }
+    static bool DecodeStream(SkStreamRewindable* stream, SkBitmap* bitmap, SkBitmap::Config pref,
+                             Mode mode, Format* format = NULL) {
+        return DecodeStream(stream, bitmap, SkBitmapConfigToColorType(pref), mode, format);
+    }
+#endif
+
 protected:
     // must be overridden in subclasses. This guy is called by decode(...)
     virtual bool onDecode(SkStream*, SkBitmap* bitmap, Mode) = 0;
 
     // If the decoder wants to support tiled based decoding,
     // this method must be overridden. This guy is called by buildTileIndex(...)
     virtual bool onBuildTileIndex(SkStreamRewindable*, int *width, int *height) {
         return false;
     }
 
@@ skipping 21 matching lines @@
     bool cropBitmap(SkBitmap *dst, SkBitmap *src, int sampleSize,
                     int dstX, int dstY, int width, int height,
                     int srcX, int srcY);
 
     /**
      *  Copy all fields on this decoder to the other decoder. Used by subclasses
      *  to decode a subimage using a different decoder, but with the same settings.
      */
     void copyFieldsToOther(SkImageDecoder* other);
 
-    /**
-     *  Return the default preference being used by the current or latest call to
-     *  decode.
-     */
-    SkBitmap::Config getDefaultPref() { return fDefaultPref; }
-
     /** Can be queried from within onDecode, to see if the user (possibly in
         a different thread) has requested the decode to cancel. If this returns
         true, your onDecode() should stop and return false.
         Each subclass needs to decide how often it can query this, to balance
         responsiveness with performance.
 
         Calling this outside of onDecode() may return undefined values.
      */
 
 public:
     bool shouldCancelDecode() const { return fShouldCancelDecode; }
 
 protected:
     SkImageDecoder();
 
+    /**
+     *  Return the default preference being used by the current or latest call to decode.
+     */
+    SkColorType getDefaultPref() { return fDefaultPref; }
+    
 #ifdef SK_SUPPORT_LEGACY_IMAGEDECODER_CHOOSER
     // helper function for decoders to handle the (common) case where there is only
     // once choice available in the image file.
     bool chooseFromOneChoice(SkColorType, int width, int height) const;
 #endif
 
-    /*  Helper for subclasses. Call this to allocate the pixel memory given the bitmap's
-        width/height/rowbytes/config. Returns true on success. This method handles checking
-        for an optional Allocator.
+    /*  Helper for subclasses. Call this to allocate the pixel memory given the bitmap's info.
+        Returns true on success. This method handles checking for an optional Allocator.
     */
     bool allocPixelRef(SkBitmap*, SkColorTable*) const;
 
     /**
      *  The raw data of the src image.
      */
     enum SrcDepth {
         // Color-indexed.
         kIndex_SrcDepth,
         // Grayscale in 8 bits.
         k8BitGray_SrcDepth,
         // 8 bits per component. Used for 24 bit if there is no alpha.
         k32Bit_SrcDepth,
     };
     /** The subclass, inside onDecode(), calls this to determine the colorType of
         the returned bitmap. SrcDepth and hasAlpha reflect the raw data of the
         src image. This routine returns the caller's preference given
         srcDepth and hasAlpha, or kUnknown_SkColorType if there is no preference.
      */
     SkColorType getPrefColorType(SrcDepth, bool hasAlpha) const;
 
 private:
     Peeker*                 fPeeker;
 #ifdef SK_SUPPORT_LEGACY_IMAGEDECODER_CHOOSER
     Chooser*                fChooser;
 #endif
     SkBitmap::Allocator*    fAllocator;
     int                     fSampleSize;
-    SkBitmap::Config        fDefaultPref;   // use if fUsePrefTable is false
+    SkColorType             fDefaultPref;   // use if fUsePrefTable is false
     PrefConfigTable         fPrefTable;     // use if fUsePrefTable is true
     bool                    fDitherImage;
     bool                    fUsePrefTable;
     bool                    fSkipWritingZeroes;
     mutable bool            fShouldCancelDecode;
     bool                    fPreferQualityOverSpeed;
     bool                    fRequireUnpremultipliedColors;
 };
 
 /** Calling newDecoder with a stream returns a new matching imagedecoder
@@ skipping 43 matching lines @@
 DECLARE_DECODER_CREATOR(WEBPImageDecoder);
 DECLARE_DECODER_CREATOR(PKMImageDecoder);
 DECLARE_DECODER_CREATOR(KTXImageDecoder);
 
 // Typedefs to make registering decoder and formatter callbacks easier.
 // These have to be defined outside SkImageDecoder. :(
 typedef SkTRegistry<SkImageDecoder*(*)(SkStreamRewindable*)>        SkImageDecoder_DecodeReg;
 typedef SkTRegistry<SkImageDecoder::Format(*)(SkStreamRewindable*)> SkImageDecoder_FormatReg;
 
 #endif