Use isAcceleratedContext() on the GraphicsContext instead of flags in ImageBuffer
[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
52 #include <wtf/text/WTFString.h>
53
54 using namespace std;
55
56 namespace WebCore {
57
58 // We pass a technically-uninitialized canvas to the platform context here since
59 // the canvas initialization completes in ImageBuffer::ImageBuffer. But
60 // PlatformContext doesn't actually need to use the object, and this makes all
61 // the ownership easier to manage.
62 ImageBufferData::ImageBufferData(const IntSize& size)
63     : m_platformContext(0)  // Canvas is set in ImageBuffer constructor.
64 {
65 }
66
67 ImageBuffer::ImageBuffer(const IntSize& size, ColorSpace, RenderingMode renderingMode, bool& success)
68     : m_data(size)
69     , m_size(size)
70 {
71     OwnPtr<SkCanvas> canvas = adoptPtr(skia::TryCreateBitmapCanvas(size.width(), size.height(), false));
72     if (!canvas) {
73         success = false;
74         return;
75     }
76
77     m_data.m_canvas = canvas.release();
78     m_data.m_platformContext.setCanvas(m_data.m_canvas.get());
79     m_context = adoptPtr(new GraphicsContext(&m_data.m_platformContext));
80     m_context->platformContext()->setDrawingToImageBuffer(true);
81
82     // Make the background transparent. It would be nice if this wasn't
83     // required, but the canvas is currently filled with the magic transparency
84     // color. Can we have another way to manage this?
85     m_data.m_canvas->drawARGB(0, 0, 0, 0, SkXfermode::kClear_Mode);
86     if (renderingMode == Accelerated) {
87         GraphicsContext3D* context3D = SharedGraphicsContext3D::create(0);
88         if (context3D) {
89             context3D->makeContextCurrent();
90             GrContext* gr = context3D->grContext();
91             if (gr) {
92                 gr->resetContext();
93                 GrTextureDesc desc;
94                 desc.fFlags = kRenderTarget_GrTextureFlagBit;
95                 desc.fAALevel = kNone_GrAALevel;
96                 desc.fWidth = size.width();
97                 desc.fHeight = size.height();
98                 desc.fFormat = kRGBA_8888_GrPixelConfig;
99                 SkAutoTUnref<GrTexture> texture(gr->createUncachedTexture(desc, 0, 0));
100                 if (texture.get()) {
101                     m_data.m_canvas->setDevice(new SkGpuDevice(gr, texture.get()))->unref();
102                     m_context->platformContext()->setGraphicsContext3D(context3D);
103                     m_context->setIsAcceleratedContext(true);
104 #if USE(ACCELERATED_COMPOSITING)
105                     m_data.m_platformLayer = Canvas2DLayerChromium::create(context3D);
106                     m_data.m_platformLayer->setTextureId(texture.get()->getTextureHandle());
107 #endif
108                 }
109             }
110         }
111     }
112
113     success = true;
114 }
115
116 ImageBuffer::~ImageBuffer()
117 {
118 #if USE(ACCELERATED_COMPOSITING)
119     if (m_data.m_platformLayer)
120         m_data.m_platformLayer->setTextureId(0);
121 #endif
122     if (m_context && m_context->platformContext()) {
123         // This is so that the SkGpuDevice destructor has the correct context.
124         m_context->platformContext()->makeGrContextCurrent();
125     }
126 }
127
128 GraphicsContext* ImageBuffer::context() const
129 {
130     return m_context.get();
131 }
132
133 size_t ImageBuffer::dataSize() const
134 {
135     return m_size.width() * m_size.height() * 4;
136 }
137
138 PassRefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior) const
139 {
140     ASSERT(copyBehavior == CopyBackingStore);
141     m_context->platformContext()->makeGrContextCurrent();
142     return BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), true);
143 }
144
145 PlatformLayer* ImageBuffer::platformLayer() const
146 {
147     return m_data.m_platformLayer.get();
148 }
149
150 void ImageBuffer::clip(GraphicsContext* context, const FloatRect& rect) const
151 {
152     context->platformContext()->beginLayerClippedToImage(rect, this);
153 }
154
155 void ImageBuffer::draw(GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
156                        CompositeOperator op, bool useLowQualityScale)
157 {
158     // Set both graphics contexts current. This looks a little weird, but is
159     // necessary since we may be drawing from an accelerated to
160     // non-accelerated context (e.g., printing), or vice versa. Note that it
161     // only works because the context is actually the same underlying context
162     // (or null), since we use one context for accelerated drawing. If that
163     // assumption changes, we'll have to revisit this code.
164     context->platformContext()->makeGrContextCurrent();
165     m_context->platformContext()->makeGrContextCurrent();
166     RefPtr<Image> image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), context == m_context);
167     context->drawImage(image.get(), styleColorSpace, destRect, srcRect, op, useLowQualityScale);
168 }
169
170 void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform,
171                               const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
172 {
173     context->platformContext()->makeGrContextCurrent();
174     RefPtr<Image> image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), context == m_context);
175     image->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
176 }
177
178 void ImageBuffer::platformTransformColorSpace(const Vector<int>& lookUpTable)
179 {
180     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
181     if (bitmap.isNull())
182         return;
183
184     ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
185     SkAutoLockPixels bitmapLock(bitmap);
186     for (int y = 0; y < m_size.height(); ++y) {
187         uint32_t* srcRow = bitmap.getAddr32(0, y);
188         for (int x = 0; x < m_size.width(); ++x) {
189             SkColor color = SkPMColorToColor(srcRow[x]);
190             srcRow[x] = SkPreMultiplyARGB(SkColorGetA(color),
191                                           lookUpTable[SkColorGetR(color)],
192                                           lookUpTable[SkColorGetG(color)],
193                                           lookUpTable[SkColorGetB(color)]);
194         }
195     }
196 }
197
198 template <Multiply multiplied>
199 PassRefPtr<ByteArray> getImageData(const IntRect& rect, SkDevice& srcDevice,
200                                    const IntSize& size)
201 {
202     float area = 4.0f * rect.width() * rect.height();
203     if (area > static_cast<float>(std::numeric_limits<int>::max()))
204         return 0;
205
206     RefPtr<ByteArray> result = ByteArray::create(rect.width() * rect.height() * 4);
207
208     SkBitmap::Config srcConfig = srcDevice.accessBitmap(false).config();
209
210     if (srcConfig == SkBitmap::kNo_Config) {
211         // This is an empty SkBitmap that could not be configured.
212         ASSERT(!size.width() || !size.height());
213         return result.release();
214     }
215
216     unsigned char* data = result->data();
217
218     if (rect.x() < 0
219         || rect.y() < 0
220         || rect.maxX() > size.width()
221         || rect.maxY() > size.height())
222         memset(data, 0, result->length());
223
224     int originX = rect.x();
225     int destX = 0;
226     if (originX < 0) {
227         destX = -originX;
228         originX = 0;
229     }
230     int endX = rect.maxX();
231     if (endX > size.width())
232         endX = size.width();
233     int numColumns = endX - originX;
234
235     if (numColumns <= 0)
236         return result.release();
237
238     int originY = rect.y();
239     int destY = 0;
240     if (originY < 0) {
241         destY = -originY;
242         originY = 0;
243     }
244     int endY = rect.maxY();
245     if (endY > size.height())
246         endY = size.height();
247     int numRows = endY - originY;
248
249     if (numRows <= 0)
250         return result.release();
251
252     ASSERT(srcConfig == SkBitmap::kARGB_8888_Config);
253
254     unsigned destBytesPerRow = 4 * rect.width();
255
256     SkBitmap srcBitmap;
257     srcDevice.readPixels(SkIRect::MakeXYWH(originX, originY, numColumns, numRows), &srcBitmap);
258
259     unsigned char* destRow = data + destY * destBytesPerRow + destX * 4;
260
261     // Do conversion of byte order and alpha divide (if necessary)
262     for (int y = 0; y < numRows; ++y) {
263         SkPMColor* srcBitmapRow = srcBitmap.getAddr32(0, y);
264         for (int x = 0; x < numColumns; ++x) {
265             SkPMColor srcPMColor = srcBitmapRow[x];
266             unsigned char* destPixel = &destRow[x * 4];
267             if (multiplied == Unmultiplied) {
268                 unsigned char a = SkGetPackedA32(srcPMColor);
269                 destPixel[0] = a ? SkGetPackedR32(srcPMColor) * 255 / a : 0;
270                 destPixel[1] = a ? SkGetPackedG32(srcPMColor) * 255 / a : 0;
271                 destPixel[2] = a ? SkGetPackedB32(srcPMColor) * 255 / a : 0;
272                 destPixel[3] = a;
273             } else {
274                 // Input and output are both pre-multiplied, we just need to re-arrange the
275                 // bytes from the bitmap format to RGBA.
276                 destPixel[0] = SkGetPackedR32(srcPMColor);
277                 destPixel[1] = SkGetPackedG32(srcPMColor);
278                 destPixel[2] = SkGetPackedB32(srcPMColor);
279                 destPixel[3] = SkGetPackedA32(srcPMColor);
280             }
281         }
282         destRow += destBytesPerRow;
283     }
284
285     return result.release();
286 }
287
288 PassRefPtr<ByteArray> ImageBuffer::getUnmultipliedImageData(const IntRect& rect) const
289 {
290     m_context->platformContext()->makeGrContextCurrent();
291     return getImageData<Unmultiplied>(rect, *context()->platformContext()->canvas()->getDevice(), m_size);
292 }
293
294 PassRefPtr<ByteArray> ImageBuffer::getPremultipliedImageData(const IntRect& rect) const
295 {
296     m_context->platformContext()->makeGrContextCurrent();
297     return getImageData<Premultiplied>(rect, *context()->platformContext()->canvas()->getDevice(), m_size);
298 }
299
300 template <Multiply multiplied>
301 void putImageData(ByteArray*& source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint,
302                   SkDevice* dstDevice, const IntSize& size)
303 {
304     ASSERT(sourceRect.width() > 0);
305     ASSERT(sourceRect.height() > 0);
306
307     int originX = sourceRect.x();
308     int destX = destPoint.x() + sourceRect.x();
309     ASSERT(destX >= 0);
310     ASSERT(destX < size.width());
311     ASSERT(originX >= 0);
312     ASSERT(originX < sourceRect.maxX());
313
314     int endX = destPoint.x() + sourceRect.maxX();
315     ASSERT(endX <= size.width());
316
317     int numColumns = endX - destX;
318
319     int originY = sourceRect.y();
320     int destY = destPoint.y() + sourceRect.y();
321     ASSERT(destY >= 0);
322     ASSERT(destY < size.height());
323     ASSERT(originY >= 0);
324     ASSERT(originY < sourceRect.maxY());
325
326     int endY = destPoint.y() + sourceRect.maxY();
327     ASSERT(endY <= size.height());
328     int numRows = endY - destY;
329
330     unsigned srcBytesPerRow = 4 * sourceSize.width();
331
332     SkBitmap deviceBitmap = dstDevice->accessBitmap(true);
333
334     // If the device's bitmap doesn't have pixels we will make a temp and call writePixels on the device.
335     bool temporaryBitmap = !!deviceBitmap.getTexture();
336     SkBitmap destBitmap;
337
338     if (temporaryBitmap) {
339         destBitmap.setConfig(SkBitmap::kARGB_8888_Config, numColumns, numRows, srcBytesPerRow);
340         if (!destBitmap.allocPixels())
341             CRASH();
342     } else
343         deviceBitmap.extractSubset(&destBitmap, SkIRect::MakeXYWH(destX, destY, numColumns, numRows));
344
345     // Whether we made a temporary or not destBitmap is always configured to be written at 0,0
346     SkAutoLockPixels destAutoLock(destBitmap);
347     const unsigned char* srcRow = source->data() + originY * srcBytesPerRow + originX * 4;
348     for (int y = 0; y < numRows; ++y) {
349         SkPMColor* destRow = destBitmap.getAddr32(0, y);
350         for (int x = 0; x < numColumns; ++x) {
351             const unsigned char* srcPixel = &srcRow[x * 4];
352             if (multiplied == Unmultiplied) {
353                 unsigned char alpha = srcPixel[3];
354                 unsigned char r = SkMulDiv255Ceiling(srcPixel[0], alpha);
355                 unsigned char g = SkMulDiv255Ceiling(srcPixel[1], alpha);
356                 unsigned char b = SkMulDiv255Ceiling(srcPixel[2], alpha);
357                 destRow[x] = SkPackARGB32(alpha, r, g, b);
358             } else
359                 destRow[x] = SkPackARGB32NoCheck(srcPixel[3], srcPixel[0], srcPixel[1], srcPixel[2]);
360         }
361         srcRow += srcBytesPerRow;
362     }
363
364     // If we used a temporary then write it to the device
365     if (temporaryBitmap)
366         dstDevice->writePixels(destBitmap, destX, destY);
367 }
368
369 void ImageBuffer::putUnmultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
370 {
371     m_context->platformContext()->makeGrContextCurrent();
372     putImageData<Unmultiplied>(source, sourceSize, sourceRect, destPoint, context()->platformContext()->canvas()->getDevice(), m_size);
373 }
374
375 void ImageBuffer::putPremultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
376 {
377     m_context->platformContext()->makeGrContextCurrent();
378     putImageData<Premultiplied>(source, sourceSize, sourceRect, destPoint, context()->platformContext()->canvas()->getDevice(), m_size);
379 }
380
381 template <typename T>
382 static String ImageToDataURL(T& source, const String& mimeType, const double* quality)
383 {
384     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
385
386     Vector<unsigned char> encodedImage;
387     if (mimeType == "image/jpeg") {
388         int compressionQuality = JPEGImageEncoder::DefaultCompressionQuality;
389         if (quality && *quality >= 0.0 && *quality <= 1.0)
390             compressionQuality = static_cast<int>(*quality * 100 + 0.5);
391         if (!JPEGImageEncoder::encode(source, compressionQuality, &encodedImage))
392             return "data:,";
393     } else {
394         if (!PNGImageEncoder::encode(source, &encodedImage))
395             return "data:,";
396         ASSERT(mimeType == "image/png");
397     }
398
399     Vector<char> base64Data;
400     base64Encode(*reinterpret_cast<Vector<char>*>(&encodedImage), base64Data);
401
402     return "data:" + mimeType + ";base64," + base64Data;
403 }
404
405 String ImageBuffer::toDataURL(const String& mimeType, const double* quality) const
406 {
407     m_context->platformContext()->makeGrContextCurrent();
408     SkDevice* device = context()->platformContext()->canvas()->getDevice();
409     return ImageToDataURL(device->accessBitmap(false), mimeType, quality);
410 }
411
412 String ImageDataToDataURL(const ImageData& source, const String& mimeType, const double* quality)
413 {
414     return ImageToDataURL(source, mimeType, quality);
415 }
416
417 } // namespace WebCore