void Gradient::fill(GraphicsContext* context, const FloatRect& rect)
{
SkRect r;
SkPaint paint;
// we don't care about the mode, so try to use the existing one
SkShader::TileMode mode = m_gradient ? m_gradient->m_tileMode :
SkShader::kClamp_TileMode;
paint.setAntiAlias(true);
paint.setShader(this->getShader(mode));
android_gc2canvas(context)->drawRect(*android_setrect(&r, rect), paint);
}
bool CanvasTexture::uploadImageBuffer(ImageBuffer* imageBuffer)
{
m_hasValidTexture = false;
SurfaceTextureClient* anw = nativeWindow();
if (!anw)
return false;
// Size mismatch, early abort (will fall back to software)
if (imageBuffer->size() != m_size)
return false;
GraphicsContext* gc = imageBuffer ? imageBuffer->context() : 0;
if (!gc)
return false;
const SkBitmap& bitmap = android_gc2canvas(gc)->getDevice()->accessBitmap(false);
if (!GLUtils::updateSharedSurfaceTextureWithBitmap(anw, bitmap))
return false;
m_hasValidTexture = true;
return true;
}
String ImageBuffer::toDataURL(const String&, const double*) const
{
ASSERT(context() && context()->platformContext());
// Request for canvas bitmap; conversion required.
if (context()->platformContext()->isRecording())
context()->platformContext()->convertToNonRecording();
// Encode the image into a vector.
SkDynamicMemoryWStream pngStream;
const SkBitmap& dst = android_gc2canvas(context())->getDevice()->accessBitmap(true);
SkImageEncoder::EncodeStream(&pngStream, dst, SkImageEncoder::kPNG_Type, 100);
// Convert it into base64.
Vector<char> pngEncodedData;
pngEncodedData.append(pngStream.getStream(), pngStream.getOffset());
Vector<char> base64EncodedData;
base64Encode(pngEncodedData, base64EncodedData);
// Append with a \0 so that it's a valid string.
base64EncodedData.append('\0');
// And the resulting string.
return String::format("data:image/png;base64,%s", base64EncodedData.data());
}
void ImageBuffer::putUnmultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
{
ASSERT(context() && context()->platformContext());
// Request for canvas bitmap; conversion required.
if (context()->platformContext()->isRecording())
context()->platformContext()->convertToNonRecording();
GraphicsContext* gc = this->context();
if (!gc) {
return;
}
const SkBitmap& dst = android_gc2canvas(gc)->getDevice()->accessBitmap(true);
SkAutoLockPixels alp(dst);
if (!dst.getPixels()) {
return;
}
#if ENABLE(ACCELERATED_2D_CANVAS)
context()->syncSoftwareCanvas();
#endif
ASSERT(sourceRect.width() > 0);
ASSERT(sourceRect.height() > 0);
int originx = sourceRect.x();
int destx = destPoint.x() + sourceRect.x();
ASSERT(destx >= 0);
ASSERT(destx < m_size.width());
ASSERT(originx >= 0);
ASSERT(originx <= sourceRect.right());
int endx = destPoint.x() + sourceRect.maxX();
ASSERT(endx <= m_size.width());
int numColumns = endx - destx;
int originy = sourceRect.y();
int desty = destPoint.y() + sourceRect.y();
ASSERT(desty >= 0);
ASSERT(desty < m_size.height());
ASSERT(originy >= 0);
ASSERT(originy <= sourceRect.bottom());
int endy = destPoint.y() + sourceRect.maxY();
ASSERT(endy <= m_size.height());
int numRows = endy - desty;
unsigned srcBytesPerRow = 4 * sourceSize.width();
unsigned dstPixelsPerRow = dst.rowBytesAsPixels();
unsigned char* srcRows = source->data() + originy * srcBytesPerRow + originx * 4;
SkPMColor* dstRows = dst.getAddr32(destx, desty);
for (int y = 0; y < numRows; ++y) {
for (int x = 0; x < numColumns; x++) {
int basex = x * 4;
dstRows[x] = SkPackARGB32(srcRows[basex + 3],
srcRows[basex + 0],
srcRows[basex + 1],
srcRows[basex + 2]);
}
dstRows += dstPixelsPerRow;
srcRows += srcBytesPerRow;
}
}
PassRefPtr<ByteArray> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const
{
ASSERT(context() && context()->platformContext());
// Request for canvas bitmap; conversion required.
if (context()->platformContext()->isRecording())
context()->platformContext()->convertToNonRecording();
GraphicsContext* gc = this->context();
if (!gc) {
return 0;
}
const SkBitmap& src = android_gc2canvas(gc)->getDevice()->accessBitmap(false);
SkAutoLockPixels alp(src);
if (!src.getPixels()) {
return 0;
}
#if ENABLE(ACCELERATED_2D_CANVAS)
context()->syncSoftwareCanvas();
#endif
RefPtr<ByteArray> result = ByteArray::create(rect.width() * rect.height() * 4);
unsigned char* data = result->data();
if (rect.x() < 0 || rect.y() < 0 || rect.maxX() > m_size.width() || rect.maxY() > m_size.height())
memset(data, 0, result->length());
int originx = rect.x();
int destx = 0;
if (originx < 0) {
destx = -originx;
originx = 0;
}
int endx = rect.x() + rect.width();
if (endx > m_size.width())
endx = m_size.width();
int numColumns = endx - originx;
int originy = rect.y();
int desty = 0;
if (originy < 0) {
desty = -originy;
originy = 0;
}
int endy = rect.y() + rect.height();
if (endy > m_size.height())
endy = m_size.height();
int numRows = endy - originy;
unsigned srcPixelsPerRow = src.rowBytesAsPixels();
unsigned destBytesPerRow = 4 * rect.width();
const SkPMColor* srcRows = src.getAddr32(originx, originy);
unsigned char* destRows = data + desty * destBytesPerRow + destx * 4;
for (int y = 0; y < numRows; ++y) {
for (int x = 0; x < numColumns; x++) {
// ugh, it appears they want unpremultiplied pixels
SkColor c = SkUnPreMultiply::PMColorToColor(srcRows[x]);
int basex = x * 4;
destRows[basex + 0] = SkColorGetR(c);
destRows[basex + 1] = SkColorGetG(c);
destRows[basex + 2] = SkColorGetB(c);
destRows[basex + 3] = SkColorGetA(c);
}
srcRows += srcPixelsPerRow;
destRows += destBytesPerRow;
}
return result.release();
}
