Updates to skimage tool to use it for testing.

include/images/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
 #define SkImageDecoder_DEFINED
 
 #include "SkBitmap.h"
 #include "SkBitmapFactory.h"
 #include "SkImage.h"
 #include "SkRect.h"
 #include "SkRefCnt.h"
 
 class SkStream;
 
 /** \class SkImageDecoder
 
     Base class for decoding compressed images into a SkBitmap
 */
 class SkImageDecoder {
 public:
     virtual ~SkImageDecoder();
 
-    // Should be consistent with sFormatName
     enum Format {
         kUnknown_Format,
         kBMP_Format,
         kGIF_Format,
         kICO_Format,
         kJPEG_Format,
         kPNG_Format,
         kWBMP_Format,
         kWEBP_Format,
 
-        kLastKnownFormat = kWEBP_Format
+        kLastKnownFormat = kWEBP_Format,
+        kMultiple_Formats,

[scroggo, 2013/04/22 22:10:16]

Does this seem like the right place for kMultiple_Formats?

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

This seems problematic to me.  Maybe, instead, there could be a bool
decodesFormat(Format f) method that tells the caller whether a particular format
is supported?  The caller can loop through and try several if he wants to...

Otherwise, return an array of formats that are supported.

[scroggo, 2013/04/24 18:00:05]

That seems reasonable to me. For now though, I'll leave getFormat the way it is
and look into deprecation in a further CL.

     };
 
     /** Return the format of image this decoder can decode. If this decoder can decode multiple
-        formats, kUnknown_Format will be returned.
+        formats, returns kMultiple_Formats.
     */
     virtual Format getFormat() const;
 
+    /** If this decoder can determine the format of stream, return its format. Otherwise return
+        kUnknown_Format.

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

Please indicate what state the SkStream will be left in (fully rewound? unknown
state?)

[scroggo, 2013/04/24 18:00:05]

Done.

+    */
+    Format getFormat(SkStream*) const;
+
     /** Return a readable string of the value returned by getFormat().
     */
     const char* getFormatName() const;

[scroggo, 2013/04/22 22:10:16]

Derek, does Android call this? (I assume I have access now so I can check?)

I'm tempted to deprecate it in favor of a function which takes an
SkImageDecoder::Format instead.

[djsollen, 2013/04/23 16:40:46]

It is only used in a debug statement in the BitmapRegionDecoder.cpp

 
     /** Returns true if the decoder should try to dither the resulting image.
         The default setting is true.
     */
     bool getDitherImage() const { return fDitherImage; }
 
     /** Set to true if the the decoder should try to dither the resulting image.
         The default setting is true.
     */
     void setDitherImage(bool dither) { fDitherImage = dither; }
@@ skipping 261 matching lines @@
     static SkBitmap::Config GetDeviceConfig();
     /** Set the default config for the running device.
         Currently this used as a suggestion to image decoders that need to guess
         what config they should decode into.
         Default is kNo_Config.
         This can be queried with GetDeviceConfig()
     */
     static void SetDeviceConfig(SkBitmap::Config);
 
 protected:
+    // Override this in subclass to read a stream and determine its format.
+    // No need to rewind the stream, which will be handled in getFormat.
+    virtual Format onGetFormat(SkStream*) const;
+
     // 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(SkStream*, int *width, int *height) {
         return false;
     }
 
     // If the decoder wants to support tiled based decoding,
@@ skipping 67 matching lines @@
     Chooser*                fChooser;
     SkBitmap::Allocator*    fAllocator;
     int                     fSampleSize;
     SkBitmap::Config        fDefaultPref;   // use if fUsePrefTable is false
     SkBitmap::Config        fPrefTable[6];  // use if fUsePrefTable is true
     bool                    fDitherImage;
     bool                    fUsePrefTable;
     mutable bool            fShouldCancelDecode;
     bool                    fPreferQualityOverSpeed;
 
-    /** Contains the image format name.
-     *  This should be consistent with Format.
-     *
-     *  The format name gives a more meaningful error message than enum.
-     */
-    static const char* sFormatName[];
-
     // illegal
     SkImageDecoder(const SkImageDecoder&);
     SkImageDecoder& operator=(const SkImageDecoder&);
 };
 
 /** Calling newDecoder with a stream returns a new matching imagedecoder
     instance, or NULL if none can be found. The caller must manage its ownership
     of the stream as usual, calling unref() when it is done, as the returned
     decoder may have called ref() (and if so, the decoder is responsible for
     balancing its ownership when it is destroyed).
@@ skipping 32 matching lines @@
 // not all of these will be available
 DECLARE_DECODER_CREATOR(BMPImageDecoder);
 DECLARE_DECODER_CREATOR(GIFImageDecoder);
 DECLARE_DECODER_CREATOR(ICOImageDecoder);
 DECLARE_DECODER_CREATOR(JPEGImageDecoder);
 DECLARE_DECODER_CREATOR(PNGImageDecoder);
 DECLARE_DECODER_CREATOR(WBMPImageDecoder);
 DECLARE_DECODER_CREATOR(WEBPImageDecoder);
 
 #endif