SkBitmap bitmap;
- bitmap.setInfo(SkImageInfo::MakeN32Premul(kWindowSize, kWindowSize));
+ bitmap.allocPixels(SkImageInfo::MakeN32Premul(kWindowSize, kWindowSize));
for (int i = 0; i < loops; i++) {
for (int x = 0; x < kNumStepsX; ++x) {
for (int y = 0; y < kNumStepsY; ++y) {
- canvas->readPixels(&bitmap, x * offX, y * offY);
+ canvas->readPixels(bitmap.info(), bitmap.getPixels(), bitmap.rowBytes(),
+ x * offX, y * offY);
}
}
}
SkBitmap bmp;
bmp.allocN32Pixels(size.width(), size.height());
- canvas->readPixels(&bmp, 0, 0);
+ canvas->readPixels(bmp, 0, 0);
SkImageInfo info = SkImageInfo::Make(bmp.width(), bmp.height(), fColorType, fAlphaType);
if (!canvas) {
return false;
}
- bmp->setInfo(canvas->imageInfo());
- if (!canvas->readPixels(bmp, 0, 0)) {
+ bmp->allocPixels(canvas->imageInfo());
+ if (!canvas->readPixels(*bmp, 0, 0)) {
SkDebugf("Can't read canvas pixels.\n");
return false;
}
canvas->getGrContext()->dumpGpuStats(log);
}
dst->allocPixels(info);
- canvas->readPixels(dst, 0, 0);
+ canvas->readPixels(*dst, 0, 0);
if (FLAGS_abandonGpuContext) {
factory.abandonContexts();
} else if (FLAGS_releaseAndAbandonGpuContext) {
if (fColorSpin) {
SkBitmap pixels;
pixels.allocPixels(canvas->imageInfo());
- canvas->readPixels(&pixels, 0, 0);
+ canvas->readPixels(pixels, 0, 0);
for (int y = 0; y < pixels.height(); y++) {
for (int x = 0; x < pixels.width(); x++) {
uint32_t pixel = *pixels.getAddr32(x, y);
SkScalar pathX = bounds.fLeft - 2;
SkScalar pathY = bounds.fTop - 2;
SkMatrix cMatrix = canvas->getTotalMatrix();
- if (!canvas->readPixels(&offscreen, SkScalarRoundToInt(pathX + cMatrix.getTranslateX()),
+ if (!canvas->readPixels(offscreen, SkScalarRoundToInt(pathX + cMatrix.getTranslateX()),
SkScalarRoundToInt(pathY + cMatrix.getTranslateY()))) {
return;
}
*/
bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
int srcX, int srcY);
+ bool readPixels(const SkPixmap&, int srcX, int srcY);
+ bool readPixels(const SkBitmap&, int srcX, int srcY);
+#ifdef SK_SUPPORT_LEGACY_CANVAS_READPIXELS
/**
* Helper for calling readPixels(info, ...). This call will check if bitmap has been allocated.
* If not, it will attempt to call allocPixels(). If this fails, it will return false. If not,
* it calls through to readPixels(info, ...) and returns its result.
*/
bool readPixels(SkBitmap* bitmap, int srcX, int srcY);
-
/**
* Helper for allocating pixels and then calling readPixels(info, ...). The bitmap is resized
* to the intersection of srcRect and the base-layer bounds. On success, pixels will be
* set to empty.
*/
bool readPixels(const SkIRect& srcRect, SkBitmap* bitmap);
+#endif
/**
* This method affects the pixels in the base-layer, and operates in pixel coordinates,
# Staging flags for API changes
# Temporarily Disable analytic AA for Google3
"SK_NO_ANALYTIC_AA",
+ "SK_SUPPORT_LEGACY_CANVAS_READPIXELS",
]
################################################################################
static SkBitmap capture_bitmap(SkCanvas* canvas) {
SkBitmap bm;
if (bm.tryAllocPixels(canvas->imageInfo())) {
- canvas->readPixels(&bm, 0, 0);
+ canvas->readPixels(bm, 0, 0);
}
return bm;
}
return fMCRec->fTopLayer->fDevice;
}
+#ifdef SK_SUPPORT_LEGACY_CANVAS_READPIXELS
bool SkCanvas::readPixels(SkBitmap* bitmap, int x, int y) {
bool weAllocated = false;
if (nullptr == bitmap->pixelRef()) {
}
return true;
}
+#endif
bool SkCanvas::readPixels(const SkImageInfo& dstInfo, void* dstP, size_t rowBytes, int x, int y) {
SkBaseDevice* device = this->getDevice();
return device->readPixels(dstInfo, dstP, rowBytes, x, y);
}
+bool SkCanvas::readPixels(const SkPixmap& pm, int x, int y) {
+ return pm.addr() && this->readPixels(pm.info(), pm.writable_addr(), pm.rowBytes(), x, y);
+}
+
+bool SkCanvas::readPixels(const SkBitmap& bm, int x, int y) {
+ SkPixmap pm;
+ return bm.peekPixels(&pm) && this->readPixels(pm, x, y);
+}
+
bool SkCanvas::writePixels(const SkBitmap& bitmap, int x, int y) {
SkAutoPixmapUnlock unlocker;
if (bitmap.requestLock(&unlocker)) {
static void readback(SkCanvas* canvas, int* result, int resultCount) {
SkBitmap readback;
readback.allocN32Pixels(resultCount, 30);
-
- SkIRect readBackRect = { 0, 0, resultCount, 30 };
-
- canvas->readPixels(readBackRect, &readback);
+ canvas->readPixels(readback, 0, 0);
readback.lockPixels();
SkPMColor* pixels = (SkPMColor*) readback.getAddr32(0, 15);
int y = SkScalarRoundToInt(r.top());
// check that the pixel in question starts as transparent (by the surface)
- if (canvas->readPixels(&output, x, y)) {
+ if (canvas->readPixels(output, x, y)) {
REPORTER_ASSERT(reporter, 0 == pixel[0]);
} else {
REPORTER_ASSERT_MESSAGE(reporter, false, "readPixels failed");
canvas->drawRect(r, paint);
// Now check that it is BLACK
- if (canvas->readPixels(&output, x, y)) {
+ if (canvas->readPixels(output, x, y)) {
// don't know what swizzling PMColor did, but white should always
// appear the same.
REPORTER_ASSERT(reporter, 0xFFFFFFFF == pixel[0]);
destinationCanvas->clear(SK_ColorTRANSPARENT);
destinationCanvas->drawPaint(paint);
- SkIRect rect = info.bounds();
-
SkBitmap bmOrig;
- sourceSurface->getCanvas()->readPixels(rect, &bmOrig);
+ bmOrig.allocN32Pixels(info.width(), info.height());
+ sourceSurface->getCanvas()->readPixels(bmOrig, 0, 0);
SkBitmap bm;
- destinationCanvas->readPixels(rect, &bm);
+ bm.allocN32Pixels(info.width(), info.height());
+ destinationCanvas->readPixels(bm, 0, 0);
test_bitmap_equality(reporter, bmOrig, bm);
destinationCanvas->drawPaint(paintTranslated);
SkBitmap bmt;
- destinationCanvas->readPixels(rect, &bmt);
+ bmt.allocN32Pixels(info.width(), info.height());
+ destinationCanvas->readPixels(bmt, 0, 0);
// Test correctness
{
readBmp1.eraseColor(0);
readBmp2.eraseColor(0);
- canvas->readPixels(&readBmp1, 0, 0);
+ canvas->readPixels(readBmp1, 0, 0);
sk_tool_utils::write_pixels(canvas, readBmp1, 0, 0, gUnpremul[upmaIdx].fColorType,
kUnpremul_SkAlphaType);
- canvas->readPixels(&readBmp2, 0, 0);
+ canvas->readPixels(readBmp2, 0, 0);
bool success = true;
for (int y = 0; y < 256 && success; ++y) {
enum BitmapInit {
kFirstBitmapInit = 0,
- kNoPixels_BitmapInit = kFirstBitmapInit,
- kTight_BitmapInit,
+ kTight_BitmapInit = kFirstBitmapInit,
kRowBytes_BitmapInit,
kRowBytesOdd_BitmapInit,
SkAlphaType at) {
SkImageInfo info = SkImageInfo::Make(rect.width(), rect.height(), ct, at);
size_t rowBytes = 0;
- bool alloc = true;
switch (init) {
- case kNoPixels_BitmapInit:
- alloc = false;
case kTight_BitmapInit:
break;
case kRowBytes_BitmapInit:
SkASSERT(0);
break;
}
-
- if (alloc) {
- bitmap->allocPixels(info, rowBytes);
- } else {
- bitmap->setInfo(info, rowBytes);
- }
+ bitmap->allocPixels(info, rowBytes);
}
static const struct {
fill_dst_bmp_with_init_data(&bmp);
}
uint32_t idBefore = surface->generationID();
- bool success = canvas->readPixels(&bmp, srcRect.fLeft, srcRect.fTop);
+ bool success = canvas->readPixels(bmp, srcRect.fLeft, srcRect.fTop);
uint32_t idAfter = surface->generationID();
// we expect to succeed when the read isn't fully clipped
REPORTER_ASSERT(reporter, bmp.isNull());
}
}
+#ifdef SK_SUPPORT_LEGACY_CANVAS_READPIXELS
// check the old webkit version of readPixels that clips the
// bitmap size
SkBitmap wkbmp;
} else {
REPORTER_ASSERT(reporter, !success);
}
+#endif
}
}
}
for (int i = 0; i < 100; ++i) {
canvas->drawBitmap(src, 0, 0);
- canvas->readPixels(size, &readback);
+ canvas->readPixels(readback, 0, 0);
// "modify" the src texture
src.notifyPixelsChanged();
// At some point this will be unsupported, as we won't allow accessBitmap() to magically call
// readPixels for the client.
SkBitmap secretDevBitmap;
- if (!canvas->readPixels(canvasInfo.bounds(), &secretDevBitmap)) {
+ secretDevBitmap.allocN32Pixels(canvasInfo.width(), canvasInfo.height());
+ if (!canvas->readPixels(secretDevBitmap, 0, 0)) {
return false;
}
SkBitmap* Request::getBitmapFromCanvas(SkCanvas* canvas) {
SkBitmap* bmp = new SkBitmap();
- bmp->setInfo(canvas->imageInfo());
- if (!canvas->readPixels(bmp, 0, 0)) {
+ if (!bmp->tryAllocPixels(canvas->imageInfo()) || !canvas->readPixels(*bmp, 0, 0)) {
fprintf(stderr, "Can't read pixels\n");
+ delete bmp;
return nullptr;
}
return bmp;
// Save a proof (if one was requested).
if (!FLAGS_png.isEmpty()) {
SkBitmap bmp;
- bmp.setInfo(info);
- if (!surface->getCanvas()->readPixels(&bmp, 0, 0)) {
+ bmp.allocPixels(info);
+ if (!surface->getCanvas()->readPixels(bmp, 0, 0)) {
exitf(ExitErr::kUnavailable, "failed to read canvas pixels for png");
}
const SkString &dirname = SkOSPath::Dirname(FLAGS_png[0]),