new API for retrieving YUV data

include/core/SkPixelRef.h

 /*
  * Copyright 2008 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 SkPixelRef_DEFINED
 #define SkPixelRef_DEFINED
 
@@ skipping 214 matching lines @@
      */
     bool decodeInto(int pow2, SkBitmap* bitmap) {
         SkASSERT(pow2 >= 0);
         return this->onDecodeInto(pow2, bitmap);
     }
 
     /** Are we really wrapping a texture instead of a bitmap?
      */
     virtual GrTexture* getTexture() { return NULL; }
 
+#ifdef SK_SUPPORT_LEGACY_IMAGEGENERATOR_YUV_API
     /**
      *  If any planes or rowBytes is NULL, this should output the sizes and return true
      *  if it can efficiently return YUV planar data. If it cannot, it should return false.
      *
      *  If all planes and rowBytes are not NULL, then it should copy the associated Y,U,V data
      *  into those planes of memory supplied by the caller. It should validate that the sizes
      *  match what it expected. If the sizes do not match, it should return false.
      *
      *  If colorSpace is not NULL, the YUV color space of the data should be stored in the address
      *  it points at.
      */
     bool getYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
                        SkYUVColorSpace* colorSpace) {
         return this->onGetYUV8Planes(sizes, planes, rowBytes, colorSpace);
     }
+#endif
+
+    /**
+     *  If this pixelref supports returning planar YUV data, return true, and return
+     *  the logicalSizes (if not NULL) and the optimalAllocationSizes (if not NULL), where each
+     *  array represents [0]=Y, [1]=U, [2]=V
+     *
+     *  The optimalAllocationSizes may be the same as the logicalSizes, but they may also be larger
+     *  if that will aid the pixelref (for performance).
+     *
+     *  If this returns false, the value of the (optional) sizes parameters is undefined.
+     */
+    bool queryYUV8(SkISize logicalSizes[3], SkISize optimalAllocationSizes[3]) {
+        return this->onQueryYUV8(logicalSizes, optimalAllocationSizes);
+    }
+
+    /**
+     *  If this pixelref supports returning planar YUV data, and can fulfill the requested
+     *  sizes for each plane, return true and write the YUV data into the planes.
+     *
+     *  Calling queryYUV8() will return both the logical sizes (W/H) and the optimal-allocation
+     *  sizes for the 3 planes. For getYUV8(), tt is legal to pass the logical sizes
+     *  (though smaller than those will return false). However, this may
+     *  (depending on the implementation) be slower than passing in the optimal-allocation sizes
+     *  (or larger). The extra space may allow the implementation to run faster at the cost of
+     *  slightly more ram being allocated. There should be no performance penalty for the
+     *  allocationSizes to larger than the values in optimalAllocationSizes, as they are just the
+     *  minimum sizes for best performance.
+     *
+     *  If colorSpace is not NULL, return the corresponding colorSpace for the YUV data.
+     */
+    bool getYUV8(const SkISize allocationSizes[3], void* planes[3], SkYUVColorSpace* colorSpace) {
+        return this->onGetYUV8(allocationSizes, planes, colorSpace);
+    }
 
     bool readPixels(SkBitmap* dst, const SkIRect* subset = NULL);
 
     /**
      *  Makes a deep copy of this PixelRef, respecting the requested config.
      *  @param colorType Desired colortype.
      *  @param profileType Desired colorprofiletype.
      *  @param subset Subset of this PixelRef to copy. Must be fully contained within the bounds of
      *         of this PixelRef.
      *  @return A new SkPixelRef, or NULL if either there is an error (e.g. the destination could
@@ skipping 68 matching lines @@
      *  For pixelrefs that don't have access to their raw pixels, they may be
      *  able to make a copy of them (e.g. if the pixels are on the GPU).
      *
      *  The base class implementation returns false;
      */
     virtual bool onReadPixels(SkBitmap* dst, const SkIRect* subsetOrNull);
 
     // default impl returns NULL.
     virtual SkData* onRefEncodedData();
 
-    // default impl returns false.
+    virtual bool onQueryYUV8(SkISize logicalSizes[3], SkISize optimalAllocationSizes[3]) {
+        return false;
+    }
+
+    virtual bool onGetYUV8(const SkISize sizes[3], void* planes[3], SkYUVColorSpace*) {
+        return false;
+    }
+
+#ifdef SK_SUPPORT_LEGACY_IMAGEGENERATOR_YUV_API
     virtual bool onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
-                                 SkYUVColorSpace* colorSpace);
+                                 SkYUVColorSpace* colorSpace) {
+        return false;
+    }
+#endif
 
     /**
      *  Returns the size (in bytes) of the internally allocated memory.
      *  This should be implemented in all serializable SkPixelRef derived classes.
      *  SkBitmap::fPixelRefOffset + SkBitmap::getSafeSize() should never overflow this value,
      *  otherwise the rendering code may attempt to read memory out of bounds.
      *
      *  @return default impl returns 0.
      */
     virtual size_t getAllocatedSizeInBytes() const;
@@ skipping 51 matching lines @@
     /**
      *  Allocate a new pixelref matching the specified ImageInfo, allocating
      *  the memory for the pixels. If the ImageInfo requires a ColorTable,
      *  the pixelref will ref() the colortable.
      *  On failure return NULL.
      */
     virtual SkPixelRef* create(const SkImageInfo&, size_t rowBytes, SkColorTable*) = 0;
 };
 
 #endif