JPEG YUV Decoding

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
 #define SkImageDecoder_DEFINED
 
 #include "SkBitmap.h"
 #include "SkImage.h"
 #include "SkRect.h"
 #include "SkRefCnt.h"
 #include "SkTRegistry.h"
 #include "SkTypes.h"
 
 class SkStream;
 class SkStreamRewindable;
 
+/** \class SkImagePlanes
+
+    SkImagePlanes can be used to decode color components into provided buffers
+    instead of using an SkBitmap.
+*/
+class SkImagePlanes : public SkRefCnt {
+public:
+    SkImagePlanes();
+    SkImagePlanes(void* planes[3], size_t rowBytes[3]);
+
+    void* plane(int);
+    size_t rowBytes(int) const;
+
+private:
+    void* m_planes[3];
+    size_t m_rowBytes[3];
+};
+
 /** \class SkImageDecoder
 
     Base class for decoding compressed images into a SkBitmap
 */
 class SkImageDecoder : SkNoncopyable {
 public:
     virtual ~SkImageDecoder();
 
     enum Format {
         kUnknown_Format,
         kBMP_Format,
         kGIF_Format,
         kICO_Format,
         kJPEG_Format,
         kPNG_Format,
         kWBMP_Format,
         kWEBP_Format,
         kPKM_Format,
         kKTX_Format,
         kASTC_Format,
 
         kLastKnownFormat = kKTX_Format,
     };
 
     /** Return the format of image this decoder can decode. If this decoder can decode multiple
         formats, kUnknown_Format will be returned.
     */
     virtual Format getFormat() const;
 
+    /** Returns the sizes of each component of the image
+        @param sizes On success, returns the sizes of each component of the image.
+    */
+    bool getYUVComponentSizes(SkStream* stream, SkISize sizes[3]);
+
+    /** Decodes the YUV planes into the provided planes
+        Returns whether the decoding to YUV was successful.
+    */
+    bool decodeToYUV(SkStream* stream, SkISize componentSizes[3], void* planes[3],
+                     size_t rowBytes[3]);
+
     /** Return the format of the SkStreamRewindable or kUnknown_Format if it cannot be determined.
         Rewinds the stream before returning.
     */
     static Format GetStreamFormat(SkStreamRewindable*);
 
     /** Return a readable string of the Format provided.
     */
     static const char* GetFormatName(Format);
 
     /** Return a readable string of the value returned by getFormat().
@@ skipping 272 matching lines @@
     virtual bool onBuildTileIndex(SkStreamRewindable*, int *width, int *height) {
         return false;
     }
 
     // If the decoder wants to support tiled based decoding,
     // this method must be overridden. This guy is called by decodeRegion(...)
     virtual bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) {
         return false;
     }
 
+    /** If imagePlanes is NULL, decodes the header and computes componentSizes
+        for memory allocation.
+        Otherwise, decodes the YUV planes into the provided image planes and
+        updates componentSizes to the final image size.
+        Returns whether the decoding was successful.
+    */
+    virtual bool onDecodeToYUV(SkStream* stream, SkISize componentSizes[3],
+                               SkImagePlanes* imagePlanes) {

[reed1, 2014/10/13 13:15:35]

I thnk passing the planes and sizes arrays is better than creating s small
object to hold them. i.e. not sure we need SkImagePlanes object.

[sugoi1, 2014/10/14 15:07:36]

Done. This was added only to mimic what is used in Blink, but since skia's
decoder is much simpler, it's not required.

+        return false;
+    }
+
     /*
      * Crop a rectangle from the src Bitmap to the dest Bitmap. src and dst are
      * both sampled by sampleSize from an original Bitmap.
      *
      * @param dst the destination bitmap.
      * @param src the source bitmap that is sampled by sampleSize from the
      *            original bitmap.
      * @param sampleSize the sample size that src is sampled from the original bitmap.
      * @param (dstX, dstY) the upper-left point of the dest bitmap in terms of
      *                     the coordinate in the original bitmap.
@@ skipping 125 matching lines @@
 DECLARE_DECODER_CREATOR(PKMImageDecoder);
 DECLARE_DECODER_CREATOR(KTXImageDecoder);
 DECLARE_DECODER_CREATOR(ASTCImageDecoder);
 
 // 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