add readPixels to SkImage

include/core/SkImage.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImage_DEFINED
 #define SkImage_DEFINED
 
@@ skipping 67 matching lines @@
      *  RAM) return the (const) address of those pixels, and if not null, return
      *  the ImageInfo and rowBytes. The returned address is only valid while
      *  the image object is in scope.
      *
      *  On failure, returns NULL and the info and rowBytes parameters are
      *  ignored.
      */
     const void* peekPixels(SkImageInfo* info, size_t* rowBytes) const;
 
     /**
+     *  Copy the pixels from the image into the specified buffer (pixels + rowBytes),
+     *  converting them into the requested format (dstInfo). The image pixels are read
+     *  starting at the specified (srcX,srcY) location.
+     *
+     *  The specified ImageInfo and (srcX,srcY) offset specifies a source rectangle
+     *
+     *      srcR.setXYWH(srcX, srcY, dstInfo.width(), dstInfo.height());
+     *
+     *  srcR is intersected with the bounds of the image. If this intersection is not empty,
+     *  then we have two sets of pixels (of equal size). Replace the dst pixels with the
+     *  corresponding src pixels, performing any colortype/alphatype transformations needed
+     *  (in the case where the src and dst have different colortypes or alphatypes).
+     *
+     *  This call can fail, returning false, for several reasons:
+     *  - If srcR does not intersect the image bounds.
+     *  - If the requested colortype/alphatype cannot be converted from the image's types.
+     */
+    bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
+                    int srcX, int srcY) const;
+
+    /**
      *  Encode the image's pixels and return the result as a new SkData, which
      *  the caller must manage (i.e. call unref() when they are done).
      *
      *  If the image type cannot be encoded, or the requested encoder type is
      *  not supported, this will return NULL.
      */
     SkData* encode(SkImageEncoder::Type t = SkImageEncoder::kPNG_Type,
                    int quality = 80) const;
 
     /**
@@ skipping 29 matching lines @@
     void draw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) const;
 
     /**
      *  Draw the image, cropped to the src rect, to the dst rect of a canvas.
      *  If src is larger than the bounds of the image, the rest of the image is
      *  filled with transparent black pixels.
      *
      *  See SkCanvas::drawBitmapRectToRect for similar behavior.
      */
     void drawRect(SkCanvas*, const SkRect* src, const SkRect& dst, const SkPaint*) const;
-
-    /**
-     *  Return a copy of the image's pixels, limiting them to the subset
-     *  rectangle's intersection wit the image bounds. If subset is NULL, then
-     *  the entire image will be considered.
-     *
-     *  If the bitmap's pixels have already been allocated, then readPixels()
-     *  will succeed only if it can support converting the image's pixels into
-     *  the bitmap's ColorType/AlphaType. Any pixels in the bitmap that do not
-     *  intersect with the image's bounds and the subset (if not null) will be
-     *  left untouched.
-     *
-     *  If the bitmap is initially empty/unallocated, then it will be allocated
-     *  using the default allocator, and the ColorType/AlphaType will be chosen
-     *  to most closely fit the image's configuration.
-     *
-     *  On failure, false will be returned, and bitmap will unmodified.
-     */
-    // On ice for now:
-    // - should it respect the particular colortype/alphatype of the src
-    // - should it have separate entrypoints for preallocated and not bitmaps?
-    // - isn't it enough to allow the caller to draw() the image into a canvas?
-    bool readPixels(SkBitmap* bitmap, const SkIRect* subset = NULL) const;
 };
 
 #endif