Add getYUV8Planes() API to SkCodec

include/codec/SkCodec.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkCodec_DEFINED
 #define SkCodec_DEFINED
 
@@ skipping 260 matching lines @@
     Result getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, const Options*,
                      SkPMColor ctable[], int* ctableCount);
 
     /**
      *  Simplified version of getPixels() that asserts that info is NOT kIndex8_SkColorType and
      *  uses the default Options.
      */
     Result getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes);
 
     /**
+     *  If decoding to YUV is supported, this returns true and populates "sizes" with
+     *  the appropriate sizes of the Y, U, and V planes.
+     */
+    bool getYUV8Sizes(SkISize sizes[3]) const {
+        if (nullptr == sizes) {
+            return false;
+        }
+
+        return this->onGetYUV8Sizes(sizes);
+    }
+
+    /**
+     *  @param sizes      Sizes of each of the Y, U, and V planes
+     *  @param pixels     Memory for each of the Y, U, and V planes
+     *  @param rowBytes   Row bytes for each of the Y, U, and V planes
+     *  @param colorSpace If nullptr, this parameter is ignored.  Otherwise,
+     *                    if the decode is successful, this will bet set to
+     *                    kJPEG_SkYUVColorSpace (JPEG is currently the only
+     *                    format that supports YUV).
+     *
+     *  Returns kSuccess, or another value explaining the type of failure.
+     *  This always attempts to perform a full decode.  If the client only
+     *  wants size, it should call getYUV8Sizes().
+     */
+    Result getYUV8Planes(SkISize sizes[3], void* pixels[3], size_t rowBytes[3],
+            SkYUVColorSpace* colorSpace) {
+        if (nullptr == sizes || nullptr == pixels || nullptr == pixels[0] ||
+                nullptr == pixels[1] || nullptr == pixels[2] || nullptr == rowBytes) {
+            return kInvalidInput;
+        }
+
+        if (!this->rewindIfNeeded()) {
+            return kCouldNotRewind;
+        }
+
+        return this->onGetYUV8Planes(sizes, pixels, rowBytes, colorSpace);
+    }
+
+    /**
      *  Some images may initially report that they have alpha due to the format
      *  of the encoded data, but then never use any colors which have alpha
      *  less than 100%. This function can be called *after* decoding to
      *  determine if such an image truly had alpha. Calling it before decoding
      *  is undefined.
      *  FIXME: see skbug.com/3582.
      */
     bool reallyHasAlpha() const {
         return kOpaque_SkAlphaType != this->getInfo().alphaType() && this->onReallyHasAlpha();
     }
@@ skipping 156 matching lines @@
      *  is located in the encoded data.
      *
      *  This will equal inputScanline, except in the case of strangely
      *  encoded image types (bottom-up bmps, interlaced gifs).
      */
     int outputScanline(int inputScanline) const;
 
 protected:
     SkCodec(const SkImageInfo&, SkStream*);
 
-    virtual SkISize onGetScaledDimensions(float /* desiredScale */) const {
+    virtual SkISize onGetScaledDimensions(float /*desiredScale*/) const {

[msarett, 2015/12/22 21:01:36]

Just changing the comments here to be consistent with the rest of the file.

         // By default, scaling is not supported.
         return this->getInfo().dimensions();
     }
 
     // FIXME: What to do about subsets??
     /**
      *  Subclasses should override if they support dimensions other than the
      *  srcInfo's.
      */
     virtual bool onDimensionsSupported(const SkISize&) {
         return false;
     }
 
     virtual SkEncodedFormat onGetEncodedFormat() const = 0;
 
     /**
      * @param rowsDecoded When the encoded image stream is incomplete, this function
      *                    will return kIncompleteInput and rowsDecoded will be set to
      *                    the number of scanlines that were successfully decoded.
      *                    This will allow getPixels() to fill the uninitialized memory.
      */
     virtual Result onGetPixels(const SkImageInfo& info,
                                void* pixels, size_t rowBytes, const Options&,
                                SkPMColor ctable[], int* ctableCount,
                                int* rowsDecoded) = 0;
 
-    virtual bool onGetValidSubset(SkIRect* /* desiredSubset */) const {
+    virtual bool onGetYUV8Sizes(SkISize* /*sizes*/) const {
+        return false;
+    }
+
+    virtual Result onGetYUV8Planes(SkISize* /*sizes*/, void** /*pixels*/, size_t* /*rowBytes*/,
+            SkYUVColorSpace* /*colorSpace*/) {
+        return kUnimplemented;
+    }
+
+    virtual bool onGetValidSubset(SkIRect* /*desiredSubset*/) const {
         // By default, subsets are not supported.
         return false;
     }
 
     /**
      * This is only called if the image indicates that it is not opaque.
      * By default we will assume that the image is in fact non-opaque.
      * Subclasses may override this function if they intend to verify
      * that the image actually has alpha.
      */
@@ skipping 154 matching lines @@
      *  not affect ownership.
      *
      *  Only valid during scanline decoding.
      */
     virtual SkSampler* getSampler(bool /*createIfNecessary*/) { return nullptr; }
 
     friend class SkSampledCodec;
     friend class SkIcoCodec;
 };
 #endif // SkCodec_DEFINED