String ImageBuffer::toDataURL(const String& mimeType, const double* quality) const
{
SkDevice* device = context()->platformContext()->canvas()->getDevice();
SkBitmap bitmap = device->accessBitmap(false);
// if we can't see the pixels directly, call readPixels() to get a copy.
// this could happen if the device is backed by a GPU.
bitmap.lockPixels(); // balanced by our destructor, or explicitly if getPixels() fails
if (!bitmap.getPixels()) {
bitmap.unlockPixels();
SkIRect bounds = SkIRect::MakeWH(device->width(), device->height());
if (!device->readPixels(bounds, &bitmap))
return "data:,";
}
return ImageToDataURL(bitmap, mimeType, quality);
}
PassRefPtr<ByteArray> getImageData(const IntRect& rect, SkDevice& srcDevice,
const IntSize& size)
{
RefPtr<ByteArray> result = ByteArray::create(rect.width() * rect.height() * 4);
SkBitmap::Config srcConfig = srcDevice.accessBitmap(false).config();
if (srcConfig == SkBitmap::kNo_Config) {
// This is an empty SkBitmap that could not be configured.
ASSERT(!size.width() || !size.height());
return result.release();
}
unsigned char* data = result->data();
if (rect.x() < 0
|| rect.y() < 0
|| rect.maxX() > size.width()
|| rect.maxY() > size.height())
memset(data, 0, result->length());
int originX = rect.x();
int destX = 0;
if (originX < 0) {
destX = -originX;
originX = 0;
}
int endX = rect.maxX();
if (endX > size.width())
endX = size.width();
int numColumns = endX - originX;
if (numColumns <= 0)
return result.release();
int originY = rect.y();
int destY = 0;
if (originY < 0) {
destY = -originY;
originY = 0;
}
int endY = rect.maxY();
if (endY > size.height())
endY = size.height();
int numRows = endY - originY;
if (numRows <= 0)
return result.release();
ASSERT(srcConfig == SkBitmap::kARGB_8888_Config);
unsigned destBytesPerRow = 4 * rect.width();
SkBitmap srcBitmap;
srcDevice.readPixels(SkIRect::MakeXYWH(originX, originY, numColumns, numRows), &srcBitmap);
unsigned char* destRow = data + destY * destBytesPerRow + destX * 4;
// Do conversion of byte order and alpha divide (if necessary)
for (int y = 0; y < numRows; ++y) {
SkPMColor* srcBitmapRow = srcBitmap.getAddr32(0, y);
for (int x = 0; x < numColumns; ++x) {
SkPMColor srcPMColor = srcBitmapRow[x];
unsigned char* destPixel = &destRow[x * 4];
if (multiplied == Unmultiplied) {
unsigned char a = SkGetPackedA32(srcPMColor);
destPixel[0] = a ? SkGetPackedR32(srcPMColor) * 255 / a : 0;
destPixel[1] = a ? SkGetPackedG32(srcPMColor) * 255 / a : 0;
destPixel[2] = a ? SkGetPackedB32(srcPMColor) * 255 / a : 0;
destPixel[3] = a;
} else {
// Input and output are both pre-multiplied, we just need to re-arrange the
// bytes from the bitmap format to RGBA.
destPixel[0] = SkGetPackedR32(srcPMColor);
destPixel[1] = SkGetPackedG32(srcPMColor);
destPixel[2] = SkGetPackedB32(srcPMColor);
destPixel[3] = SkGetPackedA32(srcPMColor);
}
}
destRow += destBytesPerRow;
}
return result.release();
}