9f3e9d9eb14da3c3cf83775c034660e2db634fa3
[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 "BitmapImage.h"
35 #include "BitmapImageSingleFrameSkia.h"
36 #include "GraphicsContext.h"
37 #include "ImageData.h"
38 #include "NotImplemented.h"
39 #include "PlatformContextSkia.h"
40 #include "SkiaUtils.h"
41
42 using namespace std;
43
44 namespace WebCore {
45
46 // We pass a technically-uninitialized canvas to the platform context here since
47 // the canvas initialization completes in ImageBuffer::ImageBuffer. But
48 // PlatformContext doesn't actually need to use the object, and this makes all
49 // the ownership easier to manage.
50 ImageBufferData::ImageBufferData(const IntSize& size)
51     : m_platformContext(0)  // Canvas is set in ImageBuffer constructor.
52 {
53 }
54
55 ImageBuffer::ImageBuffer(const IntSize& size, bool grayScale, bool& success)
56     : m_data(size)
57     , m_size(size)
58 {
59     if (!m_data.m_canvas.initialize(size.width(), size.height(), false)) {
60         success = false;
61         return;
62     }
63
64     m_data.m_platformContext.setCanvas(&m_data.m_canvas);
65     m_context.set(new GraphicsContext(&m_data.m_platformContext));
66 #if PLATFORM(WIN_OS)
67     m_context->platformContext()->setDrawingToImageBuffer(true);
68 #endif
69
70     // Make the background transparent. It would be nice if this wasn't
71     // required, but the canvas is currently filled with the magic transparency
72     // color. Can we have another way to manage this?
73     m_data.m_canvas.drawARGB(0, 0, 0, 0, SkPorterDuff::kClear_Mode);
74     success = true;
75 }
76
77 ImageBuffer::~ImageBuffer()
78 {
79 }
80
81 GraphicsContext* ImageBuffer::context() const
82 {
83     return m_context.get();
84 }
85
86 Image* ImageBuffer::image() const
87 {
88     if (!m_image) {
89         // This creates a COPY of the image and will cache that copy. This means
90         // that if subsequent operations take place on the context, neither the
91         // currently-returned image, nor the results of future image() calls,
92         // will contain that operation.
93         //
94         // This seems silly, but is the way the CG port works: image() is
95         // intended to be used only when rendering is "complete."
96         m_image = BitmapImageSingleFrameSkia::create(
97             *m_data.m_platformContext.bitmap());
98     }
99     return m_image.get();
100 }
101
102 PassRefPtr<ImageData> ImageBuffer::getImageData(const IntRect& rect) const
103 {
104     ASSERT(context());
105
106     RefPtr<ImageData> result = ImageData::create(rect.width(), rect.height());
107     unsigned char* data = result->data()->data();
108
109     if (rect.x() < 0 || rect.y() < 0 ||
110         (rect.x() + rect.width()) > m_size.width() ||
111         (rect.y() + rect.height()) > m_size.height())
112         memset(data, 0, result->data()->length());
113
114     int originX = rect.x();
115     int destX = 0;
116     if (originX < 0) {
117         destX = -originX;
118         originX = 0;
119     }
120     int endX = rect.x() + rect.width();
121     if (endX > m_size.width())
122         endX = m_size.width();
123     int numColumns = endX - originX;
124
125     int originY = rect.y();
126     int destY = 0;
127     if (originY < 0) {
128         destY = -originY;
129         originY = 0;
130     }
131     int endY = rect.y() + rect.height();
132     if (endY > m_size.height())
133         endY = m_size.height();
134     int numRows = endY - originY;
135
136     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
137     ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
138     SkAutoLockPixels bitmapLock(bitmap);
139
140     unsigned destBytesPerRow = 4 * rect.width();
141     unsigned char* destRow = data + destY * destBytesPerRow + destX * 4;
142
143     for (int y = 0; y < numRows; ++y) {
144         uint32_t* srcRow = bitmap.getAddr32(originX, originY + y);
145         for (int x = 0; x < numColumns; ++x) {
146             SkColor color = SkPMColorToColor(srcRow[x]);
147             unsigned char* destPixel = &destRow[x * 4];
148             destPixel[0] = SkColorGetR(color);
149             destPixel[1] = SkColorGetG(color);
150             destPixel[2] = SkColorGetB(color);
151             destPixel[3] = SkColorGetA(color);
152         }
153         destRow += destBytesPerRow;
154     }
155
156     return result;
157 }
158
159 void ImageBuffer::putImageData(ImageData* source, const IntRect& sourceRect,
160                                const IntPoint& destPoint)
161 {
162     ASSERT(sourceRect.width() > 0);
163     ASSERT(sourceRect.height() > 0);
164
165     int originX = sourceRect.x();
166     int destX = destPoint.x() + sourceRect.x();
167     ASSERT(destX >= 0);
168     ASSERT(destX < m_size.width());
169     ASSERT(originX >= 0);
170     ASSERT(originX < sourceRect.right());
171
172     int endX = destPoint.x() + sourceRect.right();
173     ASSERT(endX <= m_size.width());
174
175     int numColumns = endX - destX;
176
177     int originY = sourceRect.y();
178     int destY = destPoint.y() + sourceRect.y();
179     ASSERT(destY >= 0);
180     ASSERT(destY < m_size.height());
181     ASSERT(originY >= 0);
182     ASSERT(originY < sourceRect.bottom());
183
184     int endY = destPoint.y() + sourceRect.bottom();
185     ASSERT(endY <= m_size.height());
186     int numRows = endY - destY;
187
188     const SkBitmap& bitmap = *context()->platformContext()->bitmap();
189     ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
190     SkAutoLockPixels bitmapLock(bitmap);
191
192     unsigned srcBytesPerRow = 4 * source->width();
193
194     const unsigned char* srcRow = source->data()->data() + originY * srcBytesPerRow + originX * 4;
195
196     for (int y = 0; y < numRows; ++y) {
197         uint32_t* destRow = bitmap.getAddr32(destX, destY + y);
198         for (int x = 0; x < numColumns; ++x) {
199             const unsigned char* srcPixel = &srcRow[x * 4];
200             destRow[x] = SkPreMultiplyARGB(srcPixel[3], srcPixel[0],
201                                            srcPixel[1], srcPixel[2]);
202         }
203         srcRow += srcBytesPerRow;
204     }
205 }
206
207 String ImageBuffer::toDataURL(const String&) const
208 {
209     notImplemented();
210     return String();
211 }
212
213 } // namespace WebCore