ImageBufferCairo.cpp [plain text]
#include "config.h"
#include "ImageBuffer.h"
#include "Base64.h"
#include "BitmapImage.h"
#include "Color.h"
#include "GraphicsContext.h"
#include "ImageData.h"
#include "MIMETypeRegistry.h"
#include "Pattern.h"
#include "PlatformString.h"
#include <cairo.h>
#include <wtf/Vector.h>
#include <math.h>
using namespace std;
static inline cairo_surface_t* copySurface(cairo_surface_t* surface)
{
cairo_format_t format = cairo_image_surface_get_format(surface);
int width = cairo_image_surface_get_width(surface);
int height = cairo_image_surface_get_height(surface);
cairo_surface_t* newsurface = cairo_image_surface_create(format, width, height);
cairo_t* cr = cairo_create(newsurface);
cairo_set_source_surface(cr, surface, 0, 0);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_paint(cr);
cairo_destroy(cr);
return newsurface;
}
namespace WebCore {
ImageBufferData::ImageBufferData(const IntSize& size)
: m_surface(0)
{
}
ImageBuffer::ImageBuffer(const IntSize& size, ImageColorSpace imageColorSpace, bool& success)
: m_data(size)
, m_size(size)
{
success = false; m_data.m_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
size.width(),
size.height());
if (cairo_surface_status(m_data.m_surface) != CAIRO_STATUS_SUCCESS)
return;
cairo_t* cr = cairo_create(m_data.m_surface);
m_context.set(new GraphicsContext(cr));
cairo_destroy(cr); success = true;
}
ImageBuffer::~ImageBuffer()
{
cairo_surface_destroy(m_data.m_surface);
}
GraphicsContext* ImageBuffer::context() const
{
return m_context.get();
}
Image* ImageBuffer::image() const
{
if (!m_image) {
ASSERT(context());
cairo_surface_t* newsurface = copySurface(m_data.m_surface);
m_image = BitmapImage::create(newsurface);
}
return m_image.get();
}
void ImageBuffer::platformTransformColorSpace(const Vector<int>& lookUpTable)
{
ASSERT(cairo_surface_get_type(m_data.m_surface) == CAIRO_SURFACE_TYPE_IMAGE);
unsigned char* dataSrc = cairo_image_surface_get_data(m_data.m_surface);
int stride = cairo_image_surface_get_stride(m_data.m_surface);
for (int y = 0; y < m_size.height(); ++y) {
unsigned* row = reinterpret_cast<unsigned*>(dataSrc + stride * y);
for (int x = 0; x < m_size.width(); x++) {
unsigned* pixel = row + x;
Color pixelColor = colorFromPremultipliedARGB(*pixel);
pixelColor = Color(lookUpTable[pixelColor.red()],
lookUpTable[pixelColor.green()],
lookUpTable[pixelColor.blue()],
pixelColor.alpha());
*pixel = premultipliedARGBFromColor(pixelColor);
}
}
cairo_surface_mark_dirty_rectangle (m_data.m_surface, 0, 0, m_size.width(), m_size.height());
}
template <Multiply multiplied>
PassRefPtr<ImageData> getImageData(const IntRect& rect, const ImageBufferData& data, const IntSize& size)
{
ASSERT(cairo_surface_get_type(data.m_surface) == CAIRO_SURFACE_TYPE_IMAGE);
PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height());
unsigned char* dataSrc = cairo_image_surface_get_data(data.m_surface);
unsigned char* dataDst = result->data()->data()->data();
if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > size.width() || (rect.y() + rect.height()) > size.height())
memset(dataDst, 0, result->data()->length());
int originx = rect.x();
int destx = 0;
if (originx < 0) {
destx = -originx;
originx = 0;
}
int endx = rect.x() + rect.width();
if (endx > size.width())
endx = 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 > size.height())
endy = size.height();
int numRows = endy - originy;
int stride = cairo_image_surface_get_stride(data.m_surface);
unsigned destBytesPerRow = 4 * rect.width();
unsigned char* destRows = dataDst + desty * destBytesPerRow + destx * 4;
for (int y = 0; y < numRows; ++y) {
unsigned* row = reinterpret_cast<unsigned*>(dataSrc + stride * (y + originy));
for (int x = 0; x < numColumns; x++) {
int basex = x * 4;
unsigned* pixel = row + x + originx;
Color pixelColor;
if (multiplied == Unmultiplied)
pixelColor = colorFromPremultipliedARGB(*pixel);
else
pixelColor = Color(*pixel);
destRows[basex] = pixelColor.red();
destRows[basex + 1] = pixelColor.green();
destRows[basex + 2] = pixelColor.blue();
destRows[basex + 3] = pixelColor.alpha();
}
destRows += destBytesPerRow;
}
return result;
}
PassRefPtr<ImageData> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const
{
return getImageData<Unmultiplied>(rect, m_data, m_size);
}
PassRefPtr<ImageData> ImageBuffer::getPremultipliedImageData(const IntRect& rect) const
{
return getImageData<Premultiplied>(rect, m_data, m_size);
}
template <Multiply multiplied>
void putImageData(ImageData*& source, const IntRect& sourceRect, const IntPoint& destPoint, ImageBufferData& data, const IntSize& size)
{
ASSERT(cairo_surface_get_type(data.m_surface) == CAIRO_SURFACE_TYPE_IMAGE);
unsigned char* dataDst = cairo_image_surface_get_data(data.m_surface);
ASSERT(sourceRect.width() > 0);
ASSERT(sourceRect.height() > 0);
int originx = sourceRect.x();
int destx = destPoint.x() + sourceRect.x();
ASSERT(destx >= 0);
ASSERT(destx < size.width());
ASSERT(originx >= 0);
ASSERT(originx <= sourceRect.right());
int endx = destPoint.x() + sourceRect.right();
ASSERT(endx <= size.width());
int numColumns = endx - destx;
int originy = sourceRect.y();
int desty = destPoint.y() + sourceRect.y();
ASSERT(desty >= 0);
ASSERT(desty < size.height());
ASSERT(originy >= 0);
ASSERT(originy <= sourceRect.bottom());
int endy = destPoint.y() + sourceRect.bottom();
ASSERT(endy <= size.height());
int numRows = endy - desty;
unsigned srcBytesPerRow = 4 * source->width();
int stride = cairo_image_surface_get_stride(data.m_surface);
unsigned char* srcRows = source->data()->data()->data() + originy * srcBytesPerRow + originx * 4;
for (int y = 0; y < numRows; ++y) {
unsigned* row = reinterpret_cast<unsigned*>(dataDst + stride * (y + desty));
for (int x = 0; x < numColumns; x++) {
int basex = x * 4;
unsigned* pixel = row + x + destx;
Color pixelColor(srcRows[basex],
srcRows[basex + 1],
srcRows[basex + 2],
srcRows[basex + 3]);
if (multiplied == Unmultiplied)
*pixel = premultipliedARGBFromColor(pixelColor);
else
*pixel = pixelColor.rgb();
}
srcRows += srcBytesPerRow;
}
cairo_surface_mark_dirty_rectangle (data.m_surface,
destx, desty,
numColumns, numRows);
}
void ImageBuffer::putUnmultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
{
putImageData<Unmultiplied>(source, sourceRect, destPoint, m_data, m_size);
}
void ImageBuffer::putPremultipliedImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
{
putImageData<Premultiplied>(source, sourceRect, destPoint, m_data, m_size);
}
static cairo_status_t writeFunction(void* closure, const unsigned char* data, unsigned int length)
{
Vector<char>* in = reinterpret_cast<Vector<char>*>(closure);
in->append(data, length);
return CAIRO_STATUS_SUCCESS;
}
String ImageBuffer::toDataURL(const String& mimeType) const
{
cairo_surface_t* image = cairo_get_target(context()->platformContext());
if (!image)
return "data:,";
String actualMimeType("image/png");
if (MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType))
actualMimeType = mimeType;
Vector<char> in;
cairo_surface_write_to_png_stream(image, writeFunction, &in);
Vector<char> out;
base64Encode(in, out);
return "data:" + actualMimeType + ";base64," + String(out.data(), out.size());
}
}