Extend platform layer so it can pass blend modes to the compositing calls
[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 "BitmapImage.h"
37 #include "BitmapImageSingleFrameSkia.h"
38 #include "Extensions3D.h"
39 #include "GrContext.h"
40 #include "GraphicsContext.h"
41 #include "GraphicsContext3D.h"
42 #include "ImageData.h"
43 #include "JPEGImageEncoder.h"
44 #include "MIMETypeRegistry.h"
45 #include "MemoryInstrumentationSkia.h"
46 #include "PNGImageEncoder.h"
47 #include "PlatformContextSkia.h"
48 #include "SharedGraphicsContext3D.h"
49 #include "SkColorPriv.h"
50 #include "SkGpuDevice.h"
51 #include "SkiaUtils.h"
52 #include "WEBPImageEncoder.h"
53
54 #if USE(ACCELERATED_COMPOSITING)
55 #include "Canvas2DLayerBridge.h"
56 #endif
57
58 #include <wtf/text/Base64.h>
59 #include <wtf/text/WTFString.h>
60
61 using namespace std;
62
63 namespace WebCore {
64
65 // We pass a technically-uninitialized canvas to the platform context here since
66 // the canvas initialization completes in ImageBuffer::ImageBuffer. But
67 // PlatformContext doesn't actually need to use the object, and this makes all
68 // the ownership easier to manage.
69 ImageBufferData::ImageBufferData(const IntSize& size)
70     : m_platformContext(0)  // Canvas is set in ImageBuffer constructor.
71 {
72 }
73
74 static SkCanvas* createAcceleratedCanvas(const IntSize& size, ImageBufferData* data, DeferralMode deferralMode)
75 {
76     RefPtr<GraphicsContext3D> context3D = SharedGraphicsContext3D::get();
77     if (!context3D)
78         return 0;
79     GrContext* gr = context3D->grContext();
80     if (!gr)
81         return 0;
82     gr->resetContext();
83     GrTextureDesc desc;
84     desc.fFlags = kRenderTarget_GrTextureFlagBit;
85     desc.fSampleCnt = 0;
86     desc.fWidth = size.width();
87     desc.fHeight = size.height();
88     desc.fConfig = kSkia8888_GrPixelConfig;
89     SkAutoTUnref<GrTexture> texture(gr->createUncachedTexture(desc, 0, 0));
90     if (!texture.get())
91         return 0;
92     SkCanvas* canvas;
93     SkAutoTUnref<SkDevice> device(new SkGpuDevice(gr, texture.get()));
94 #if USE(ACCELERATED_COMPOSITING)
95     data->m_layerBridge = Canvas2DLayerBridge::create(context3D.release(), size, deferralMode, texture.get()->getTextureHandle());
96     canvas = data->m_layerBridge->skCanvas(device.get());
97 #else
98     canvas = new SkCanvas(device.get());
99 #endif
100     data->m_platformContext.setAccelerated(true);
101     return canvas;
102 }
103
104 static SkCanvas* createNonPlatformCanvas(const IntSize& size)
105 {
106     SkAutoTUnref<SkDevice> device(new SkDevice(SkBitmap::kARGB_8888_Config, size.width(), size.height()));
107     SkPixelRef* pixelRef = device->accessBitmap(false).pixelRef();
108     return pixelRef ? new SkCanvas(device) : 0;
109 }
110
111 PassOwnPtr<ImageBuffer> ImageBuffer::createCompatibleBuffer(const IntSize& size, float resolutionScale, ColorSpace colorSpace, const GraphicsContext* context, bool hasAlpha)
112 {
113     bool success = false;
114     OwnPtr<ImageBuffer> buf = adoptPtr(new ImageBuffer(size, resolutionScale, colorSpace, context, hasAlpha, success));
115     if (!success)
116         return nullptr;
117     return buf.release();
118 }
119
120 ImageBuffer::ImageBuffer(const IntSize& size, float resolutionScale, ColorSpace, const GraphicsContext* compatibleContext, bool hasAlpha, bool& success)
121     : m_data(size)
122     , m_size(size)
123     , m_logicalSize(size)
124     , m_resolutionScale(resolutionScale)
125 {
126     if (!compatibleContext) {
127         success = false;
128         return;
129     }
130
131     SkAutoTUnref<SkDevice> device(compatibleContext->platformContext()->createCompatibleDevice(size, hasAlpha));
132     SkPixelRef* pixelRef = device->accessBitmap(false).pixelRef();
133     if (!pixelRef) {
134         success = false;
135         return;
136     }
137
138     m_data.m_canvas = adoptPtr(new SkCanvas(device));
139     m_data.m_platformContext.setCanvas(m_data.m_canvas.get());
140     m_context = adoptPtr(new GraphicsContext(&m_data.m_platformContext));
141     m_context->platformContext()->setDrawingToImageBuffer(true);
142     m_context->scale(FloatSize(m_resolutionScale, m_resolutionScale));
143
144     success = true;
145 }
146
147 ImageBuffer::ImageBuffer(const IntSize& size, float resolutionScale, ColorSpace, RenderingMode renderingMode, DeferralMode deferralMode, bool& success)
148     : m_data(size)
149     , m_size(size)
150     , m_logicalSize(size)
151     , m_resolutionScale(resolutionScale)
152 {
153     OwnPtr<SkCanvas> canvas;
154
155     if (renderingMode == Accelerated)
156         canvas = adoptPtr(createAcceleratedCanvas(size, &m_data, deferralMode));
157     else if (renderingMode == UnacceleratedNonPlatformBuffer)
158         canvas = adoptPtr(createNonPlatformCanvas(size));
159
160     if (!canvas)
161         canvas = adoptPtr(skia::TryCreateBitmapCanvas(size.width(), size.height(), false));
162
163     if (!canvas) {
164         success = false;
165         return;
166     }
167
168     m_data.m_canvas = canvas.release();
169     m_data.m_platformContext.setCanvas(m_data.m_canvas.get());
170     m_context = adoptPtr(new GraphicsContext(&m_data.m_platformContext));
171     m_context->platformContext()->setDrawingToImageBuffer(true);
172     m_context->scale(FloatSize(m_resolutionScale, m_resolutionScale));
173
174     // Make the background transparent. It would be nice if this wasn't
175     // required, but the canvas is currently filled with the magic transparency
176     // color. Can we have another way to manage this?
177     m_data.m_canvas->drawARGB(0, 0, 0, 0, SkXfermode::kClear_Mode);
178
179     success = true;
180 }
181
182 ImageBuffer::~ImageBuffer()
183 {
184 }
185
186 GraphicsContext* ImageBuffer::context() const
187 {
188 #if USE(ACCELERATED_COMPOSITING)
189     if (m_data.m_layerBridge) {
190         // We're using context acquisition as a signal that someone is about to render into our buffer and we need
191         // to be ready. This isn't logically const-correct, hence the cast.
192         const_cast<Canvas2DLayerBridge*>(m_data.m_layerBridge.get())->contextAcquired();
193     }
194 #endif
195     return m_context.get();
196 }
197
198 PassRefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior, ScaleBehavior) const
199 {
200     // FIXME: Start honoring ScaleBehavior to scale 2x buffers down to 1x.
201     return BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), copyBehavior == CopyBackingStore, m_resolutionScale);
202 }
203
204 PlatformLayer* ImageBuffer::platformLayer() const
205 {
206     return m_data.m_layerBridge ? m_data.m_layerBridge->layer() : 0;
207 }
208
209 bool ImageBuffer::copyToPlatformTexture(GraphicsContext3D& context, Platform3DObject texture, GC3Denum internalFormat, bool premultiplyAlpha, bool flipY)
210 {
211     if (!m_data.m_layerBridge || !platformLayer())
212         return false;
213
214     Platform3DObject sourceTexture = m_data.m_layerBridge->backBufferTexture();
215
216     if (!context.makeContextCurrent())
217         return false;
218
219     Extensions3D* extensions = context.getExtensions();
220     if (!extensions->supports("GL_CHROMIUM_copy_texture") || !extensions->supports("GL_CHROMIUM_flipy"))
221         return false;
222
223     // The canvas is stored in a premultiplied format, so unpremultiply if necessary.
224     context.pixelStorei(Extensions3D::UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, !premultiplyAlpha);
225
226     // The canvas is stored in an inverted position, so the flip semantics are reversed.
227     context.pixelStorei(Extensions3D::UNPACK_FLIP_Y_CHROMIUM, !flipY);
228
229     extensions->copyTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, sourceTexture, texture, 0, internalFormat);
230
231     context.pixelStorei(Extensions3D::UNPACK_FLIP_Y_CHROMIUM, false);
232     context.pixelStorei(Extensions3D::UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM, false);
233     context.flush();
234     return true;
235 }
236
237 void ImageBuffer::clip(GraphicsContext* context, const FloatRect& rect) const
238 {
239     context->platformContext()->beginLayerClippedToImage(rect, this);
240 }
241
242 static bool drawNeedsCopy(GraphicsContext* src, GraphicsContext* dst)
243 {
244     return dst->platformContext()->isDeferred() || src == dst;
245 }
246
247 void ImageBuffer::draw(GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
248     CompositeOperator op, BlendMode, bool useLowQualityScale)
249 {
250     RefPtr<Image> image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), drawNeedsCopy(m_context.get(), context));
251     context->drawImage(image.get(), styleColorSpace, destRect, srcRect, op, DoNotRespectImageOrientation, useLowQualityScale);
252 }
253
254 void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform,
255                               const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
256 {
257     RefPtr<Image> image = BitmapImageSingleFrameSkia::create(*m_data.m_platformContext.bitmap(), drawNeedsCopy(m_context.get(), context));
258     image->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
259 }
260
261 void ImageBuffer::platformTransformColorSpace(const Vector<int>& lookUpTable)
262 {
263     // FIXME: Disable color space conversions on accelerated canvases (for now).
264     if (m_data.m_platformContext.isAccelerated()) 
265         return;
266
267     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
268     if (bitmap.isNull())
269         return;
270
271     ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
272     SkAutoLockPixels bitmapLock(bitmap);
273     for (int y = 0; y < m_size.height(); ++y) {
274         uint32_t* srcRow = bitmap.getAddr32(0, y);
275         for (int x = 0; x < m_size.width(); ++x) {
276             SkColor color = SkPMColorToColor(srcRow[x]);
277             srcRow[x] = SkPreMultiplyARGB(SkColorGetA(color),
278                                           lookUpTable[SkColorGetR(color)],
279                                           lookUpTable[SkColorGetG(color)],
280                                           lookUpTable[SkColorGetB(color)]);
281         }
282     }
283 }
284
285 template <Multiply multiplied>
286 PassRefPtr<Uint8ClampedArray> getImageData(const IntRect& rect, PlatformContextSkia* context,
287                                    const IntSize& size)
288 {
289     float area = 4.0f * rect.width() * rect.height();
290     if (area > static_cast<float>(std::numeric_limits<int>::max()))
291         return 0;
292
293     RefPtr<Uint8ClampedArray> result = Uint8ClampedArray::createUninitialized(rect.width() * rect.height() * 4);
294
295     unsigned char* data = result->data();
296
297     if (rect.x() < 0
298         || rect.y() < 0
299         || rect.maxX() > size.width()
300         || rect.maxY() > size.height())
301         result->zeroFill();
302
303     unsigned destBytesPerRow = 4 * rect.width();
304     SkBitmap destBitmap;
305     destBitmap.setConfig(SkBitmap::kARGB_8888_Config, rect.width(), rect.height(), destBytesPerRow);
306     destBitmap.setPixels(data);
307
308     SkCanvas::Config8888 config8888;
309     if (multiplied == Premultiplied)
310         config8888 = SkCanvas::kRGBA_Premul_Config8888;
311     else
312         config8888 = SkCanvas::kRGBA_Unpremul_Config8888;
313
314     context->readPixels(&destBitmap, rect.x(), rect.y(), config8888);
315     return result.release();
316 }
317
318 PassRefPtr<Uint8ClampedArray> ImageBuffer::getUnmultipliedImageData(const IntRect& rect, CoordinateSystem) const
319 {
320     return getImageData<Unmultiplied>(rect, context()->platformContext(), m_size);
321 }
322
323 PassRefPtr<Uint8ClampedArray> ImageBuffer::getPremultipliedImageData(const IntRect& rect, CoordinateSystem) const
324 {
325     return getImageData<Premultiplied>(rect, context()->platformContext(), m_size);
326 }
327
328 void ImageBuffer::putByteArray(Multiply multiplied, Uint8ClampedArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint, CoordinateSystem)
329 {
330     ASSERT(sourceRect.width() > 0);
331     ASSERT(sourceRect.height() > 0);
332
333     int originX = sourceRect.x();
334     int destX = destPoint.x() + sourceRect.x();
335     ASSERT(destX >= 0);
336     ASSERT(destX < m_size.width());
337     ASSERT(originX >= 0);
338     ASSERT(originX < sourceRect.maxX());
339
340     int endX = destPoint.x() + sourceRect.maxX();
341     ASSERT(endX <= m_size.width());
342
343     int numColumns = endX - destX;
344
345     int originY = sourceRect.y();
346     int destY = destPoint.y() + sourceRect.y();
347     ASSERT(destY >= 0);
348     ASSERT(destY < m_size.height());
349     ASSERT(originY >= 0);
350     ASSERT(originY < sourceRect.maxY());
351
352     int endY = destPoint.y() + sourceRect.maxY();
353     ASSERT(endY <= m_size.height());
354     int numRows = endY - destY;
355
356     unsigned srcBytesPerRow = 4 * sourceSize.width();
357     SkBitmap srcBitmap;
358     srcBitmap.setConfig(SkBitmap::kARGB_8888_Config, numColumns, numRows, srcBytesPerRow);
359     srcBitmap.setPixels(source->data() + originY * srcBytesPerRow + originX * 4);
360
361     SkCanvas::Config8888 config8888;
362     if (multiplied == Premultiplied)
363         config8888 = SkCanvas::kRGBA_Premul_Config8888;
364     else
365         config8888 = SkCanvas::kRGBA_Unpremul_Config8888;
366
367     context()->platformContext()->writePixels(srcBitmap, destX, destY, config8888);
368 }
369
370 template <typename T>
371 static bool encodeImage(T& source, const String& mimeType, const double* quality, Vector<char>* output)
372 {
373     Vector<unsigned char>* encodedImage = reinterpret_cast<Vector<unsigned char>*>(output);
374
375     if (mimeType == "image/jpeg") {
376         int compressionQuality = JPEGImageEncoder::DefaultCompressionQuality;
377         if (quality && *quality >= 0.0 && *quality <= 1.0)
378             compressionQuality = static_cast<int>(*quality * 100 + 0.5);
379         if (!JPEGImageEncoder::encode(source, compressionQuality, encodedImage))
380             return false;
381 #if USE(WEBP)
382     } else if (mimeType == "image/webp") {
383         int compressionQuality = WEBPImageEncoder::DefaultCompressionQuality;
384         if (quality && *quality >= 0.0 && *quality <= 1.0)
385             compressionQuality = static_cast<int>(*quality * 100 + 0.5);
386         if (!WEBPImageEncoder::encode(source, compressionQuality, encodedImage))
387             return false;
388 #endif
389     } else {
390         if (!PNGImageEncoder::encode(source, encodedImage))
391             return false;
392         ASSERT(mimeType == "image/png");
393     }
394
395     return true;
396 }
397
398 String ImageBuffer::toDataURL(const String& mimeType, const double* quality, CoordinateSystem) const
399 {
400     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
401
402     Vector<char> encodedImage;
403     if (!encodeImage(*context()->platformContext()->bitmap(), mimeType, quality, &encodedImage))
404         return "data:,";
405
406     Vector<char> base64Data;
407     base64Encode(encodedImage, base64Data);
408
409     return "data:" + mimeType + ";base64," + base64Data;
410 }
411
412 void ImageBufferData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
413 {
414     MemoryClassInfo info(memoryObjectInfo, this);
415     info.addMember(m_canvas);
416     info.addMember(m_platformContext);
417 #if USE(ACCELERATED_COMPOSITING)
418     info.addMember(m_layerBridge);
419 #endif
420 }
421
422 String ImageDataToDataURL(const ImageData& imageData, const String& mimeType, const double* quality)
423 {
424     ASSERT(MIMETypeRegistry::isSupportedImageMIMETypeForEncoding(mimeType));
425
426     Vector<char> encodedImage;
427     if (!encodeImage(imageData, mimeType, quality, &encodedImage))
428         return "data:,";
429
430     Vector<char> base64Data;
431     base64Encode(encodedImage, base64Data);
432
433     return "data:" + mimeType + ";base64," + base64Data;
434 }
435
436 } // namespace WebCore