2009-02-05 Scott Violet <sky@google.com>
[WebKit-https.git] / WebCore / platform / graphics / skia / ImageBufferSkia.cpp
1 /*
2  * Copyright (c) 2008, Google Inc. All rights reserved.
3  * 
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  * 
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  * 
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "ImageBuffer.h"
33
34 #include "Base64.h"
35 #include "BitmapImage.h"
36 #include "BitmapImageSingleFrameSkia.h"
37 #include "GraphicsContext.h"
38 #include "ImageData.h"
39 #include "NotImplemented.h"
40 #include "PlatformContextSkia.h"
41 #include "PNGImageEncoder.h"
42 #include "SkiaUtils.h"
43
44 using namespace std;
45
46 namespace WebCore {
47
48 // We pass a technically-uninitialized canvas to the platform context here since
49 // the canvas initialization completes in ImageBuffer::ImageBuffer. But
50 // PlatformContext doesn't actually need to use the object, and this makes all
51 // the ownership easier to manage.
52 ImageBufferData::ImageBufferData(const IntSize& size)
53     : m_platformContext(0)  // Canvas is set in ImageBuffer constructor.
54 {
55 }
56
57 ImageBuffer::ImageBuffer(const IntSize& size, bool grayScale, bool& success)
58     : m_data(size)
59     , m_size(size)
60 {
61     if (!m_data.m_canvas.initialize(size.width(), size.height(), false)) {
62         success = false;
63         return;
64     }
65
66     m_data.m_platformContext.setCanvas(&m_data.m_canvas);
67     m_context.set(new GraphicsContext(&m_data.m_platformContext));
68 #if PLATFORM(WIN_OS)
69     m_context->platformContext()->setDrawingToImageBuffer(true);
70 #endif
71
72     // Make the background transparent. It would be nice if this wasn't
73     // required, but the canvas is currently filled with the magic transparency
74     // color. Can we have another way to manage this?
75     m_data.m_canvas.drawARGB(0, 0, 0, 0, SkPorterDuff::kClear_Mode);
76     success = true;
77 }
78
79 ImageBuffer::~ImageBuffer()
80 {
81 }
82
83 GraphicsContext* ImageBuffer::context() const
84 {
85     return m_context.get();
86 }
87
88 Image* ImageBuffer::image() const
89 {
90     if (!m_image) {
91         // This creates a COPY of the image and will cache that copy. This means
92         // that if subsequent operations take place on the context, neither the
93         // currently-returned image, nor the results of future image() calls,
94         // will contain that operation.
95         //
96         // This seems silly, but is the way the CG port works: image() is
97         // intended to be used only when rendering is "complete."
98         m_image = BitmapImageSingleFrameSkia::create(
99             *m_data.m_platformContext.bitmap());
100     }
101     return m_image.get();
102 }
103
104 PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
105 {
106     ASSERT(context());
107
108     RefPtr<ImageData> result = ImageData::create(rect.width(), rect.height());
109     unsigned char* data = result->data()->data();
110
111     if (rect.x() < 0 || rect.y() < 0 ||
112         (rect.x() + rect.width()) > m_size.width() ||
113         (rect.y() + rect.height()) > m_size.height())
114         memset(data, 0, result->data()->length());
115
116     int originX = rect.x();
117     int destX = 0;
118     if (originX < 0) {
119         destX = -originX;
120         originX = 0;
121     }
122     int endX = rect.x() + rect.width();
123     if (endX > m_size.width())
124         endX = m_size.width();
125     int numColumns = endX - originX;
126
127     int originY = rect.y();
128     int destY = 0;
129     if (originY < 0) {
130         destY = -originY;
131         originY = 0;
132     }
133     int endY = rect.y() + rect.height();
134     if (endY > m_size.height())
135         endY = m_size.height();
136     int numRows = endY - originY;
137
138     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
139     ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
140     SkAutoLockPixels bitmapLock(bitmap);
141
142     unsigned destBytesPerRow = 4 * rect.width();
143     unsigned char* destRow = data + destY * destBytesPerRow + destX * 4;
144
145     for (int y = 0; y < numRows; ++y) {
146         uint32_t* srcRow = bitmap.getAddr32(originX, originY + y);
147         for (int x = 0; x < numColumns; ++x) {
148             SkColor color = SkPMColorToColor(srcRow[x]);
149             unsigned char* destPixel = &destRow[x * 4];
150             destPixel[0] = SkColorGetR(color);
151             destPixel[1] = SkColorGetG(color);
152             destPixel[2] = SkColorGetB(color);
153             destPixel[3] = SkColorGetA(color);
154         }
155         destRow += destBytesPerRow;
156     }
157
158     return result;
159 }
160
161 void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect,
162                                const IntPoint& destPoint)
163 {
164     ASSERT(sourceRect.width() > 0);
165     ASSERT(sourceRect.height() > 0);
166
167     int originX = sourceRect.x();
168     int destX = destPoint.x() + sourceRect.x();
169     ASSERT(destX >= 0);
170     ASSERT(destX < m_size.width());
171     ASSERT(originX >= 0);
172     ASSERT(originX < sourceRect.right());
173
174     int endX = destPoint.x() + sourceRect.right();
175     ASSERT(endX <= m_size.width());
176
177     int numColumns = endX - destX;
178
179     int originY = sourceRect.y();
180     int destY = destPoint.y() + sourceRect.y();
181     ASSERT(destY >= 0);
182     ASSERT(destY < m_size.height());
183     ASSERT(originY >= 0);
184     ASSERT(originY < sourceRect.bottom());
185
186     int endY = destPoint.y() + sourceRect.bottom();
187     ASSERT(endY <= m_size.height());
188     int numRows = endY - destY;
189
190     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
191     ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
192     SkAutoLockPixels bitmapLock(bitmap);
193
194     unsigned srcBytesPerRow = 4 * source->width();
195
196     const unsigned char* srcRow = source->data()->data() + originY * srcBytesPerRow + originX * 4;
197
198     for (int y = 0; y < numRows; ++y) {
199         uint32_t* destRow = bitmap.getAddr32(destX, destY + y);
200         for (int x = 0; x < numColumns; ++x) {
201             const unsigned char* srcPixel = &srcRow[x * 4];
202             destRow[x] = SkPreMultiplyARGB(srcPixel[3], srcPixel[0],
203                                            srcPixel[1], srcPixel[2]);
204         }
205         srcRow += srcBytesPerRow;
206     }
207 }
208
209 String ImageBuffer::toDataURL(const String&) const
210 {
211     // Encode the image into a vector.
212     Vector<unsigned char> pngEncodedData;
213     PNGImageEncoder::encode(*context()->platformContext()->bitmap(), &pngEncodedData);
214
215     // Convert it into base64.
216     Vector<char> base64EncodedData;
217     base64Encode(*reinterpret_cast<Vector<char>*>(&pngEncodedData), base64EncodedData);
218     // Append with a \0 so that it's a valid string.
219     base64EncodedData.append('\0');
220
221     // And the resulting string.
222     return String::format("data:image/png;base64,%s", base64EncodedData.data());
223 }
224
225 } // namespace WebCore