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