add ways to peer into an image to get its pixels

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 58 matching lines @@
     /**
      *  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 draw(SkCanvas*, const SkRect* src, const SkRect& dst, const SkPaint*);
 
     /**
+     *  If the image has direct access to its pixels (i.e. they are in local
+     *  RAM) return true and set bitmap to those pixels. In this case the client
+     *  must still call lockPixels/unlockPixels to access them, and must NOT
+     *  modify the pixels in any way.
+     *
+     *  If this direct exposing of the pixels is not valid, return false and
+     *  bitmap will unmodified.

[scroggo, 2014/02/05 17:16:07]

nit: will be*

+     */
+    bool peekPixels(SkBitmap* bitmap) const;

[bsalomon, 2014/02/05 17:13:37]

Maybe this should return a const pointer, an image info, and a rowbytes? It
seems like SkBitmap's API is a mismatch for what the client is supposed to do
with the result.

[scroggo, 2014/02/05 17:16:43]

+1

[reed1, 2014/02/05 17:47:52]

Interesting. That is precisely what I first typed, but then changed it to
bitmap, so that I could know the lifetime of the client's window into the
pixels. Returning a void* means (which may be ok...)
- the image's pixels must be locked in ram (and decoded)
- they can't be unlocked/moved/purged

If we're fine with these constraints, I can switch back to that Raw version

+
+    /**
+     *  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. Aany pixels in the bitmap that do not

[scroggo, 2014/02/05 17:16:07]

Any*

+     *  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.
+     */
+    bool readPixels(SkBitmap* bitmap, const SkIRect* subset = NULL);

[scroggo, 2014/02/05 17:16:07]

Should this function be const also?

In the case of the GPU, where it *can* support these but it's slow (IIUC), will
it just return false? (Or, if I'm reading the comments correctly, it will return
false for peekPixels but true for readPixels?)

+    
+    /**
      *  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;
 
 protected:
@@ skipping 10 matching lines @@
     const int       fWidth;
     const int       fHeight;
     const uint32_t  fUniqueID;
 
     static uint32_t NextUniqueID();
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif