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