add ways to peer into an image to get its pixels

src/image/SkImage.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkImagePriv.h"
@@ skipping 21 matching lines @@
 void SkImage::draw(SkCanvas* canvas, SkScalar x, SkScalar y,
                    const SkPaint* paint) {
     as_IB(this)->onDraw(canvas, x, y, paint);
 }
 
 void SkImage::draw(SkCanvas* canvas, const SkRect* src, const SkRect& dst,
                    const SkPaint* paint) {
     as_IB(this)->onDrawRectToRect(canvas, src, dst, paint);
 }
 
+const void* SkImage::peekPixels(SkImageInfo* info, size_t* rowBytes) const {
+    SkImageInfo infoStorage;
+    size_t rowBytesStorage;
+    if (NULL == info) {
+        info = &infoStorage;
+    }
+    if (NULL == rowBytes) {
+        rowBytes = &rowBytesStorage;
+    }
+    return as_IB(this)->onPeekPixels(info, rowBytes);
+}
+
+bool SkImage::readPixels(SkBitmap* bitmap, const SkIRect* subset) const {
+    if (NULL == bitmap) {
+        return false;
+    }
+    
+    SkIRect bounds = SkIRect::MakeWH(this->width(), this->height());
+
+    // trim against the bitmap, if its already been allocated
+    if (bitmap->pixelRef()) {
+        bounds.fRight = SkMin32(bounds.fRight, bitmap->width());

[bsalomon, 2014/02/05 21:36:20]

does this mean that for a preallocated bitmap the upper left of the bmp is
mapped to the upper left of the image? It seems more intuitive to me to map it
to the upper left of the image subset. Or to just require that the bitmap's w/h
match the subset's w/h. Or to make the prealloc case have a different (public)
entry that isn't over-specified.

+        bounds.fBottom = SkMin32(bounds.fBottom, bitmap->height());
+        if (bounds.isEmpty()) {
+            return false;
+        }
+    }
+
+    if (subset && !bounds.intersect(*subset)) {
+        // perhaps we could return true + empty-bitmap?
+        return false;
+    }
+    return as_IB(this)->onReadPixels(bitmap, bounds);
+}
+
 GrTexture* SkImage::getTexture() {
     return as_IB(this)->onGetTexture();
 }
 
 SkData* SkImage::encode(SkImageEncoder::Type type, int quality) const {
     SkBitmap bm;
     if (as_IB(this)->getROPixels(&bm)) {
         return SkImageEncoder::EncodeData(bm, type, quality);
     }
     return NULL;
 }
+
+///////////////////////////////////////////////////////////////////////////////
+
+static bool canvas_supports(const SkImageInfo& info) {
+    switch (info.fColorType) {
+        case kPMColor_SkColorType:
+            return kUnpremul_SkAlphaType != info.fAlphaType;
+        case kRGB_565_SkColorType:
+            return true;
+        case kAlpha_8_SkColorType:
+            return true;
+        default:
+            break;
+    }
+    return false;
+}
+
+bool SkImage_Base::onReadPixels(SkBitmap* bitmap, const SkIRect& subset) const {
+    SkImageInfo info;
+
+    if (bitmap->pixelRef()) {
+        if (!bitmap->asImageInfo(&info)) {
+            return false;
+        }
+        if (canvas_supports(info)) {

[scroggo, 2014/02/05 21:55:28]

Should this be

if(!canvas_supports(info))

?

+            return false;
+        }
+    } else {
+        SkImageInfo info = SkImageInfo::MakeN32Premul(subset.width(),

[scroggo, 2014/02/05 21:55:28]

Are we okay with the side effect that readPixels returns premultiplied even if
the original SkImage was unpremultiplied?

That is, if the destination bitmap had no existing pixel ref. In that case, we
behave differently.

+                                                      subset.height());
+        SkBitmap tmp;
+        if (!tmp.allocPixels(info)) {
+            return false;
+        }
+        *bitmap = tmp;
+    }
+
+    SkRect srcR, dstR;
+    srcR.set(subset);
+    dstR = srcR;
+    dstR.offset(-dstR.left(), -dstR.top());
+    
+    SkCanvas canvas(*bitmap);
+
+    SkPaint paint;
+    paint.setXfermodeMode(SkXfermode::kClear_Mode);
+    canvas.drawRect(dstR, paint);
+
+    const_cast<SkImage_Base*>(this)->onDrawRectToRect(&canvas, &srcR, dstR, NULL);
+    return true;
+}
+