Allow decoding JPEG into A8.

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 121 matching lines @@
         */
         virtual int choose() = 0;
 
     private:
         typedef SkRefCnt INHERITED;
     };
 
     Chooser* getChooser() const { return fChooser; }
     Chooser* setChooser(Chooser*);
 
-    /** This optional table describes the caller's preferred config based on
+    /**
+        @Deprecated. Use the struct version instead.
+
+        This optional table describes the caller's preferred config based on
         information about the src data. For this table, the src attributes are
         described in terms of depth (index (8), 16, 32/24) and if there is
         per-pixel alpha. These inputs combine to create an index into the
         pref[] table, which contains the caller's preferred config for that
         input, or kNo_Config if there is no preference.
 
-        To specify no preferrence, call setPrefConfigTable(NULL), which is
+        To specify no preference, call setPrefConfigTable(NULL), which is
         the default.
 
         Note, it is still at the discretion of the codec as to what output
         config is actually returned, as it may not be able to support the
         caller's preference.
 
         Here is how the index into the table is computed from the src:
             depth [8, 16, 32/24] -> 0, 2, 4
             alpha [no, yes] -> 0, 1
         The two index values are OR'd together.
             src: 8-index, no-alpha  -> 0
             src: 8-index, yes-alpha -> 1
             src: 16bit,   no-alpha  -> 2    // e.g. 565
             src: 16bit,   yes-alpha -> 3    // e.g. 1555
             src: 32/24,   no-alpha  -> 4
             src: 32/24,   yes-alpha -> 5
      */
     void setPrefConfigTable(const SkBitmap::Config pref[6]);
 
+    /**
+     *  Optional table describing the caller's preferred config based on
+     *  information about the src data. Each field should be set to the
+     *  preferred config for a src described in the name of the field. The
+     *  src attributes are described in terms of depth (8-index,
+     *  8bit-grayscale, or 8-bits/component) and whether there is per-pixel
+     *  alpha (does not apply to grayscale). If the caller has no preference
+     *  for a particular src type, its slot should be set to kNo_Config.
+     *
+     *  NOTE ABOUT PREFERRED CONFIGS:
+     *  If a config is preferred, either using a pref table or as a parameter
+     *  to some flavor of decode, it is still at the discretion of the codec
+     *  as to what output config is actually returned, as it may not be able
+     *  to support the caller's preference.
+     *
+     *  If a bitmap is decoded into SkBitmap::A8_Config, the resulting bitmap
+     *  will either be a conversion of the grayscale in the case of a
+     *  grayscale source or the alpha channel in the case of a source with
+     *  an alpha channel.
+     */
+    struct PrefConfigTable {
+        SkBitmap::Config fPrefFor_8Index_NoAlpha_src;

[scroggo, 2013/07/11 20:37:29]

New names. Uglier, but also more clear what they stand for.

+        SkBitmap::Config fPrefFor_8Index_YesAlpha_src;
+        SkBitmap::Config fPrefFor_8Gray_src;
+        SkBitmap::Config fPrefFor_8bpc_NoAlpha_src;
+        SkBitmap::Config fPrefFor_8bpc_YesAlpha_src;

[scroggo, 2013/07/11 20:37:29]

The 32/24 duality was because we used the same SrcDepth enum for 24 bit (8 bits
per component RGB) and 32 bit (8 bits per component ARGB). We could split that
up in SrcDepth, but then we have a redundant hasAlpha. 

+    };
+
+    /**
+     *  Set an optional table for specifying the caller's preferred config
+     *  based on information about the src data.
+     *
+     *  The default is no preference, which will assume the config set by
+     *  decode is preferred.
+     */
+    void setPrefConfigTable(const PrefConfigTable&);
+
+    /**
+     *  Do not use a PrefConfigTable to determine the output config. This
+     *  is the default, so there is no need to call unless a PrefConfigTable
+     *  was previously set.
+     */
+    void resetPrefConfigTable() { fUsePrefTable = false; }
+
     SkBitmap::Allocator* getAllocator() const { return fAllocator; }
     SkBitmap::Allocator* setAllocator(SkBitmap::Allocator*);
 
     // sample-size, if set to > 1, tells the decoder to return a smaller than
     // original bitmap, sampling 1 pixel for every size pixels. e.g. if sample
     // size is set to 3, then the returned bitmap will be 1/3 as wide and high,
     // and will contain 1/9 as many pixels as the original.
     // Note: this is a hint, and the codec may choose to ignore this, or only
     // approximate the sample size.
     int getSampleSize() const { return fSampleSize; }
@@ skipping 83 matching lines @@
     }
 
     /** Given a stream, this will try to find an appropriate decoder object.
         If none is found, the method returns NULL.
     */
     static SkImageDecoder* Factory(SkStream*);
 
     /** Decode the image stored in the specified file, and store the result
         in bitmap. Return true for success or false on failure.
 
-        If pref is kNo_Config, then the decoder is free to choose the most natural
-        config given the image data. If pref something other than kNo_Config,
-        the decoder will attempt to decode the image into that format, unless
-        there is a conflict (e.g. the image has per-pixel alpha and the bitmap's
-        config does not support that), in which case the decoder will choose a
-        closest match configuration.
+        @param prefConfig If the PrefConfigTable is not set, prefer this config.
+                          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,
                            Format* format = NULL);
     static bool DecodeFile(const char file[], SkBitmap* bitmap) {
         return DecodeFile(file, bitmap, SkBitmap::kNo_Config,
                           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.
 
-        If pref is kNo_Config, then the decoder is free to choose the most natural
-        config given the image data. If pref something other than kNo_Config,
-        the decoder will attempt to decode the image into that format, unless
-        there is a conflict (e.g. the image has per-pixel alpha and the bitmap's
-        config does not support that), in which case the decoder will choose a
-        closest match configuration.
+        @param prefConfig If the PrefConfigTable is not set, prefer this config.
+                          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){
         return DecodeMemory(buffer, size, bitmap, SkBitmap::kNo_Config,
                             kDecodePixels_Mode, NULL);
@@ skipping 22 matching lines @@
      *      // and could be NULL
      *      success = DecodeMemoryToTarget(src, size, &info, &target);
      *  </code>
      */
     static bool DecodeMemoryToTarget(const void* buffer, size_t size, SkImage::Info* info,
                                      const SkBitmapFactory::Target* target);
 
     /** Decode the image stored in the specified SkStream, and store the result
         in bitmap. Return true for success or false on failure.
 
-        If pref is kNo_Config, then the decoder is free to choose the most
-        natural config given the image data. If pref something other than
-        kNo_Config, the decoder will attempt to decode the image into that
-        format, unless there is a conflict (e.g. the image has per-pixel alpha
-        and the bitmap's config does not support that), in which case the
-        decoder will choose a closest match configuration.
+        @param prefConfig If the PrefConfigTable is not set, prefer this config.
+                          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(SkStream* stream, SkBitmap* bitmap,
                              SkBitmap::Config prefConfig, Mode,
                              Format* format = NULL);
     static bool DecodeStream(SkStream* stream, SkBitmap* bitmap) {
         return DecodeStream(stream, bitmap, SkBitmap::kNo_Config,
                             kDecodePixels_Mode, NULL);
@@ skipping 78 matching lines @@
     // helper function for decoders to handle the (common) case where there is only
     // once choice available in the image file.
     bool chooseFromOneChoice(SkBitmap::Config config, int width, int height) const;
 
     /*  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.
     */
     bool allocPixelRef(SkBitmap*, SkColorTable*) const;
 
+    /**
+     *  The raw data of the src image.
+     */
     enum SrcDepth {
+        // Color-indexed.
         kIndex_SrcDepth,
-        k16Bit_SrcDepth,
-        k32Bit_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 config 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 kNo_Config if there is no preference.
 
         Note: this also takes into account GetDeviceConfig(), so the subclass
         need not call that.
      */
     SkBitmap::Config getPrefConfig(SrcDepth, bool hasAlpha) const;
 
 private:
     Peeker*                 fPeeker;
     Chooser*                fChooser;
     SkBitmap::Allocator*    fAllocator;
     int                     fSampleSize;
     SkBitmap::Config        fDefaultPref;   // use if fUsePrefTable is false
-    SkBitmap::Config        fPrefTable[6];  // use if fUsePrefTable is true
+    PrefConfigTable         fPrefTable;     // use if fUsePrefTable is true
     bool                    fDitherImage;
     bool                    fUsePrefTable;
     mutable bool            fShouldCancelDecode;
     bool                    fPreferQualityOverSpeed;
     bool                    fRequireUnpremultipliedColors;
 };
 
 /** 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
@@ skipping 34 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