#include "config.h"
#include "ImageBuffer.h"
#include "CString.h"
#include "GraphicsContext.h"
#include "ImageData.h"
#include "MIMETypeRegistry.h"
#include "StillImageQt.h"
#include <QBuffer>
#include <QColor>
#include <QImage>
#include <QImageWriter>
#include <QPainter>
#include <QPixmap>
namespace WebCore {
ImageBufferData::ImageBufferData(const IntSize& size)
: m_pixmap(size)
{
m_pixmap.fill(QColor(Qt::transparent));
QPainter* painter = new QPainter(&m_pixmap);
m_painter.set(painter);
QPen pen = painter->pen();
pen.setColor(Qt::black);
pen.setWidth(1);
pen.setCapStyle(Qt::FlatCap);
pen.setJoinStyle(Qt::MiterJoin);
pen.setMiterLimit(10);
painter->setPen(pen);
QBrush brush = painter->brush();
brush.setColor(Qt::black);
painter->setBrush(brush);
painter->setCompositionMode(QPainter::CompositionMode_SourceOver);
}
ImageBuffer::ImageBuffer(const IntSize& size, bool grayScale, bool& success)
: m_data(size)
, m_size(size)
{
m_context.set(new GraphicsContext(m_data.m_painter.get()));
success = true;
}
ImageBuffer::~ImageBuffer()
{
}
GraphicsContext* ImageBuffer::context() const
{
ASSERT(m_data.m_painter->isActive());
return m_context.get();
}
Image* ImageBuffer::image() const
{
if (!m_image) {
ASSERT(context());
m_image = StillImage::create(m_data.m_pixmap);
}
return m_image.get();
}
PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
{
PassRefPtr<ImageData> result = ImageData::create(rect.width(), rect.height());
unsigned char* data = result->data()->data()->data();
if (rect.x() < 0 || rect.y() < 0 || (rect.x() + rect.width()) > m_size.width() || (rect.y() + rect.height()) > m_size.height())
memset(data, 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 > 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;
QImage image = m_data.m_pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
ASSERT(!image.isNull());
unsigned destBytesPerRow = 4 * rect.width();
unsigned char* destRows = data + desty * destBytesPerRow + destx * 4;
for (int y = 0; y < numRows; ++y) {
for (int x = 0; x < numColumns; x++) {
QRgb value = image.pixel(x + originx, y + originy);
int basex = x * 4;
destRows[basex] = qRed(value);
destRows[basex + 1] = qGreen(value);
destRows[basex + 2] = qBlue(value);
destRows[basex + 3] = qAlpha(value);
}
destRows += destBytesPerRow;
}
return result;
}
void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect, const IntPoint& destPoint)
{
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.right();
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.bottom();
ASSERT(endy <= m_size.height());
int numRows = endy - desty;
unsigned srcBytesPerRow = 4 * source->width();
bool isPainting = m_data.m_painter->isActive();
if (isPainting)
m_data.m_painter->end();
QImage image = m_data.m_pixmap.toImage().convertToFormat(QImage::Format_ARGB32);
unsigned char* srcRows = source->data()->data()->data() + originy * srcBytesPerRow + originx * 4;
for (int y = 0; y < numRows; ++y) {
quint32* scanLine = reinterpret_cast<quint32*>(image.scanLine(y + desty));
for (int x = 0; x < numColumns; x++) {
int basex = x * 4;
scanLine[x + destx] = reinterpret_cast<quint32*>(srcRows + basex)[0];
}
srcRows += srcBytesPerRow;
}
m_data.m_pixmap = QPixmap::fromImage(image);
if (isPainting)
m_data.m_painter->begin(&m_data.m_pixmap);
}
String ImageBuffer::toDataURL(const String& mimeType) const
{
ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
if (!mimeType.startsWith("image/"))
return "data:,";
QByteArray data;
QBuffer buffer(&data);
buffer.open(QBuffer::WriteOnly);
if (!m_data.m_pixmap.save(&buffer, mimeType.substring(sizeof "image").utf8().data()))
return "data:,";
buffer.close();
return String::format("data:%s;base64,%s", mimeType.utf8().data(), data.toBase64().data());
}
}