Unreviewed, rolling out r102244.
[WebKit-https.git] / Source / WebCore / platform / graphics / skia / ImageBufferSkia.cpp
1 /*
2  * Copyright (c) 2008, Google Inc. All rights reserved.
3  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
4  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are
8  * met:
9  *
10  *     * Redistributions of source code must retain the above copyright
11  * notice, this list of conditions and the following disclaimer.
12  *     * Redistributions in binary form must reproduce the above
13  * copyright notice, this list of conditions and the following disclaimer
14  * in the documentation and/or other materials provided with the
15  * distribution.
16  *     * Neither the name of Google Inc. nor the names of its
17  * contributors may be used to endorse or promote products derived from
18  * this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #include "config.h"
34 #include "ImageBuffer.h"
35
36 #include "Base64.h"
37 #include "BitmapImage.h"
38 #include "BitmapImageSingleFrameSkia.h"
39 #include "Canvas2DLayerChromium.h"
40 #include "GrContext.h"
41 #include "GraphicsContext.h"
42 #include "ImageData.h"
43 #include "JPEGImageEncoder.h"
44 #include "MIMETypeRegistry.h"
45 #include "PNGImageEncoder.h"
46 #include "PlatformContextSkia.h"
47 #include "SharedGraphicsContext3D.h"
48 #include "SkColorPriv.h"
49 #include "SkGpuDevice.h"
50 #include "SkiaUtils.h"
51 #include "WEBPImageEncoder.h"
52
53 #include <wtf/text/WTFString.h>
54
55 using namespace std;
56
57 namespace WebCore {
58
59 // We pass a technically-uninitialized canvas to the platform context here since
60 // the canvas initialization completes in ImageBuffer::ImageBuffer. But
61 // PlatformContext doesn't actually need to use the object, and this makes all
62 // the ownership easier to manage.
63 ImageBufferData::ImageBufferData(const IntSize& size)
64     : m_platformContext(0)  // Canvas is set in ImageBuffer constructor.
65 {
66 }
67
68 static SkCanvas* createAcceleratedCanvas(const IntSize& size, ImageBufferData* data)
69 {
70     GraphicsContext3D* context3D = SharedGraphicsContext3D::get();
71     if (!context3D)
72         return 0;
73     GrContext* gr = context3D->grContext();
74     if (!gr)
75         return 0;
76     gr->resetContext();
77     GrTextureDesc desc;
78     desc.fFlags = kRenderTarget_GrTextureFlagBit;
79     desc.fAALevel = kNone_GrAALevel;
80     desc.fWidth = size.width();
81     desc.fHeight = size.height();
82     desc.fConfig = kRGBA_8888_GrPixelConfig;
83     SkAutoTUnref<GrTexture> texture(gr->createUncachedTexture(desc, 0, 0));
84     if (!texture.get())
85         return 0;
86     SkCanvas* canvas = new SkCanvas();
87     canvas->setDevice(new SkGpuDevice(gr, texture.get()))->unref();
88     data->m_platformContext.setGraphicsContext3D(context3D);
89 #if USE(ACCELERATED_COMPOSITING)
90     data->m_platformLayer = Canvas2DLayerChromium::create(context3D);
91     data->m_platformLayer->setTextureId(texture.get()->getTextureHandle());
92 #endif
93     return canvas;
94 }
95
96 ImageBuffer::ImageBuffer(const IntSize& size, ColorSpace, RenderingMode renderingMode, bool& success)
97     : m_data(size)
98     , m_size(size)
99 {
100     OwnPtr<SkCanvas> canvas;
101
102     if (renderingMode == Accelerated)
103         canvas = adoptPtr(createAcceleratedCanvas(size, &m_data));
104
105     if (!canvas)
106         canvas = adoptPtr(skia::TryCreateBitmapCanvas(size.width(), size.height(), false));
107
108     if (!canvas) {
109         success = false;
110         return;
111     }
112
113     m_data.m_canvas = canvas.release();
114     m_data.m_platformContext.setCanvas(m_data.m_canvas.get());
115     m_context = adoptPtr(new GraphicsContext(&m_data.m_platformContext));
116     m_context->platformContext()->setDrawingToImageBuffer(true);
117
118     // Make the background transparent. It would be nice if this wasn't
119     // required, but the canvas is currently filled with the magic transparency
120     // color. Can we have another way to manage this?
121     m_data.m_canvas->drawARGB(0, 0, 0, 0, SkXfermode::kClear_Mode);
122
123     success = true;
124 }
125
126 ImageBuffer::~ImageBuffer()
127 {
128 #if USE(ACCELERATED_COMPOSITING)
129     if (m_data.m_platformLayer)
130         m_data.m_platformLayer->setTextureId(0);
131 #endif
132 }
133
134 GraphicsContext* ImageBuffer::context() const
135 {
136     return m_context.get();
137 }
138
139 size_t ImageBuffer::dataSize() const
140 {
141     return m_size.width() * m_size.height() * 4;
142 }
143
144 PassRefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior) const
145 {
146     ASSERT(copyBehavior == CopyBackingStore);
147     return BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), true);
148 }
149
150 PlatformLayer* ImageBuffer::platformLayer() const
151 {
152     return m_data.m_platformLayer.get();
153 }
154
155 void ImageBuffer::clip(GraphicsContext* context, const FloatRect& rect) const
156 {
157     context->platformContext()->beginLayerClippedToImage(rect, this);
158 }
159
160 static bool drawNeedsCopy(GraphicsContext* src, GraphicsContext* dst)
161 {
162     return dst->platformContext()->isDeferred() || src == dst;
163 }
164
165 void ImageBuffer::draw(GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
166                        CompositeOperator op, bool useLowQualityScale)
167 {
168     RefPtr<Image> image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), drawNeedsCopy(m_context.get(), context));
169     context->drawImage(image.get(), styleColorSpace, destRect, srcRect, op, useLowQualityScale);
170 }
171
172 void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform,
173                               const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
174 {
175     RefPtr<Image> image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), drawNeedsCopy(m_context.get(), context));
176     image->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
177 }
178
179 void ImageBuffer::platformTransformColorSpace(const Vector<int>& lookUpTable)
180 {
181     // FIXME: Disable color space conversions on accelerated canvases (for now).
182     if (m_data.m_platformContext.isAccelerated()) 
183         return;
184
185     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
186     if (bitmap.isNull())
187         return;
188
189     ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
190     SkAutoLockPixels bitmapLock(bitmap);
191     for (int y = 0; y < m_size.height(); ++y) {
192         uint32_t* srcRow = bitmap.getAddr32(0, y);
193         for (int x = 0; x < m_size.width(); ++x) {
194             SkColor color = SkPMColorToColor(srcRow[x]);
195             srcRow[x] = SkPreMultiplyARGB(SkColorGetA(color),
196                                           lookUpTable[SkColorGetR(color)],
197                                           lookUpTable[SkColorGetG(color)],
198                                           lookUpTable[SkColorGetB(color)]);
199         }
200     }
201 }
202
203 template <Multiply multiplied>
204 PassRefPtr<ByteArray> getImageData(const IntRect& rect, SkCanvas* canvas,
205                                    const IntSize& size)
206 {
207     float area = 4.0f * rect.width() * rect.height();
208     if (area > static_cast<float>(std::numeric_limits<int>::max()))
209         return 0;
210
211     RefPtr<ByteArray> result = ByteArray::create(rect.width() * rect.height() * 4);
212
213     unsigned char* data = result->data();
214
215     if (rect.x() < 0
216         || rect.y() < 0
217         || rect.maxX() > size.width()
218         || rect.maxY() > size.height())
219         memset(data, 0, result->length());
220
221     int originX = rect.x();
222     int destX = 0;
223     if (originX < 0) {
224         destX = -originX;
225         originX = 0;
226     }
227     int endX = rect.maxX();
228     if (endX > size.width())
229         endX = size.width();
230     int numColumns = endX - originX;
231
232     if (numColumns <= 0)
233         return result.release();
234
235     int originY = rect.y();
236     int destY = 0;
237     if (originY < 0) {
238         destY = -originY;
239         originY = 0;
240     }
241     int endY = rect.maxY();
242     if (endY > size.height())
243         endY = size.height();
244     int numRows = endY - originY;
245
246     if (numRows <= 0)
247         return result.release();
248
249     SkBitmap srcBitmap;
250     if (!canvas->readPixels(SkIRect::MakeXYWH(originX, originY, numColumns, numRows), &srcBitmap))
251         return result.release();
252
253     unsigned destBytesPerRow = 4 * rect.width();
254     unsigned char* destRow = data + destY * destBytesPerRow + destX * 4;
255
256     // Do conversion of byte order and alpha divide (if necessary)
257     for (int y = 0; y < numRows; ++y) {
258         SkPMColor* srcBitmapRow = srcBitmap.getAddr32(0, y);
259         for (int x = 0; x < numColumns; ++x) {
260             SkPMColor srcPMColor = srcBitmapRow[x];
261             unsigned char* destPixel = &destRow[x * 4];
262             if (multiplied == Unmultiplied) {
263                 unsigned char a = SkGetPackedA32(srcPMColor);
264                 destPixel[0] = a ? SkGetPackedR32(srcPMColor) * 255 / a : 0;
265                 destPixel[1] = a ? SkGetPackedG32(srcPMColor) * 255 / a : 0;
266                 destPixel[2] = a ? SkGetPackedB32(srcPMColor) * 255 / a : 0;
267                 destPixel[3] = a;
268             } else {
269                 // Input and output are both pre-multiplied, we just need to re-arrange the
270                 // bytes from the bitmap format to RGBA.
271                 destPixel[0] = SkGetPackedR32(srcPMColor);
272                 destPixel[1] = SkGetPackedG32(srcPMColor);
273                 destPixel[2] = SkGetPackedB32(srcPMColor);
274                 destPixel[3] = SkGetPackedA32(srcPMColor);
275             }
276         }
277         destRow += destBytesPerRow;
278     }
279
280     return result.release();
281 }
282
283 PassRefPtr<ByteArray> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const
284 {
285     return getImageData<Unmultiplied>(rect, context()->platformContext()->canvas(), m_size);
286 }
287
288 PassRefPtr<ByteArray> ImageBuffer::getPremultipliedImageData(const IntRect& rect) const
289 {
290     return getImageData<Premultiplied>(rect, context()->platformContext()->canvas(), m_size);
291 }
292
293 template <Multiply multiplied>
294 void putImageData(ByteArray*& source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint,
295                   SkDevice* dstDevice, const IntSize& size)
296 {
297     ASSERT(sourceRect.width() > 0);
298     ASSERT(sourceRect.height() > 0);
299
300     int originX = sourceRect.x();
301     int destX = destPoint.x() + sourceRect.x();
302     ASSERT(destX >= 0);
303     ASSERT(destX < size.width());
304     ASSERT(originX >= 0);
305     ASSERT(originX < sourceRect.maxX());
306
307     int endX = destPoint.x() + sourceRect.maxX();
308     ASSERT(endX <= size.width());
309
310     int numColumns = endX - destX;
311
312     int originY = sourceRect.y();
313     int destY = destPoint.y() + sourceRect.y();
314     ASSERT(destY >= 0);
315     ASSERT(destY < size.height());
316     ASSERT(originY >= 0);
317     ASSERT(originY < sourceRect.maxY());
318
319     int endY = destPoint.y() + sourceRect.maxY();
320     ASSERT(endY <= size.height());
321     int numRows = endY - destY;
322
323     unsigned srcBytesPerRow = 4 * sourceSize.width();
324
325     SkBitmap deviceBitmap = dstDevice->accessBitmap(true);
326
327     // If the device's bitmap doesn't have pixels we will make a temp and call writePixels on the device.
328     bool temporaryBitmap = !!deviceBitmap.getTexture();
329     SkBitmap destBitmap;
330
331     if (temporaryBitmap) {
332         destBitmap.setConfig(SkBitmap::kARGB_8888_Config, numColumns, numRows, srcBytesPerRow);
333         if (!destBitmap.allocPixels())
334             CRASH();
335     } else
336         deviceBitmap.extractSubset(&destBitmap, SkIRect::MakeXYWH(destX, destY, numColumns, numRows));
337
338     // Whether we made a temporary or not destBitmap is always configured to be written at 0,0
339     SkAutoLockPixels destAutoLock(destBitmap);
340     const unsigned char* srcRow = source->data() + originY * srcBytesPerRow + originX * 4;
341     for (int y = 0; y < numRows; ++y) {
342         SkPMColor* destRow = destBitmap.getAddr32(0, y);
343         for (int x = 0; x < numColumns; ++x) {
344             const unsigned char* srcPixel = &srcRow[x * 4];
345             if (multiplied == Unmultiplied) {
346                 unsigned char alpha = srcPixel[3];
347                 unsigned char r = SkMulDiv255Ceiling(srcPixel[0], alpha);
348                 unsigned char g = SkMulDiv255Ceiling(srcPixel[1], alpha);
349                 unsigned char b = SkMulDiv255Ceiling(srcPixel[2], alpha);
350                 destRow[x] = SkPackARGB32(alpha, r, g, b);
351             } else
352                 destRow[x] = SkPackARGB32NoCheck(srcPixel[3], srcPixel[0], srcPixel[1], srcPixel[2]);
353         }
354         srcRow += srcBytesPerRow;
355     }
356
357     // If we used a temporary then write it to the device
358     if (temporaryBitmap)
359         dstDevice->writePixels(destBitmap, destX, destY);
360 }
361
362 void ImageBuffer::putUnmultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
363 {
364     putImageData<Unmultiplied>(source, sourceSize, sourceRect, destPoint, context()->platformContext()->canvas()->getDevice(), m_size);
365 }
366
367 void ImageBuffer::putPremultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
368 {
369     putImageData<Premultiplied>(source, sourceSize, sourceRect, destPoint, context()->platformContext()->canvas()->getDevice(), m_size);
370 }
371
372 template <typename T>
373 static bool encodeImage(T& source, const String& mimeType, const double* quality, Vector<char>* output)
374 {
375     Vector<unsigned char>* encodedImage = reinterpret_cast<Vector<unsigned char>*>(output);
376
377     if (mimeType == "image/jpeg") {
378         int compressionQuality = JPEGImageEncoder::DefaultCompressionQuality;
379         if (quality && *quality >= 0.0 && *quality <= 1.0)
380             compressionQuality = static_cast<int>(*quality * 100 + 0.5);
381         if (!JPEGImageEncoder::encode(source, compressionQuality, encodedImage))
382             return false;
383 #if USE(WEBP)
384     } else if (mimeType == "image/webp") {
385         int compressionQuality = WEBPImageEncoder::DefaultCompressionQuality;
386         if (quality && *quality >= 0.0 && *quality <= 1.0)
387             compressionQuality = static_cast<int>(*quality * 100 + 0.5);
388         if (!WEBPImageEncoder::encode(source, compressionQuality, encodedImage))
389             return false;
390 #endif
391     } else {
392         if (!PNGImageEncoder::encode(source, encodedImage))
393             return false;
394         ASSERT(mimeType == "image/png");
395     }
396
397     return true;
398 }
399
400 String ImageBuffer::toDataURL(const String& mimeType, const double* quality) const
401 {
402     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
403
404     Vector<char> encodedImage, base64Data;
405     SkDevice* device = context()->platformContext()->canvas()->getDevice();
406     if (!encodeImage(device->accessBitmap(false), mimeType, quality, &encodedImage))
407         return "data:,";
408
409     base64Encode(encodedImage, base64Data);
410     return "data:" + mimeType + ";base64," + base64Data;
411 }
412
413 String ImageDataToDataURL(const ImageData& imageData, const String& mimeType, const double* quality)
414 {
415     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
416
417     Vector<char> encodedImage, base64Data;
418     if (!encodeImage(imageData, mimeType, quality, &encodedImage))
419         return "data:,";
420
421     base64Encode(encodedImage, base64Data);
422     return "data:" + mimeType + ";base64," + base64Data;
423 }
424
425 } // namespace WebCore