<rdar://problem/10912680> Pixel access canvas APIs do not operate at backing store...
[WebKit-https.git] / Source / WebCore / platform / graphics / wince / ImageBufferWinCE.cpp
1 /*
2  * Copyright (C) 2009 Torch Mobile, Inc. All rights reserved.
3  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
4  *
5  *  This library is free software; you can redistribute it and/or
6  *  modify it under the terms of the GNU Library General Public
7  *  License as published by the Free Software Foundation; either
8  *  version 2 of the License, or (at your option) any later version.
9  *
10  *  This library is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  Library General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Library General Public License
16  *  along with this library; see the file COPYING.LIB.  If not, write to
17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  *  Boston, MA 02110-1301, USA.
19  */
20
21 #include "config.h"
22 #include "ImageBuffer.h"
23
24 #include "Base64.h"
25 #include "GraphicsContext.h"
26 #include "Image.h"
27 #include "ImageData.h"
28 #include "NotImplemented.h"
29 #include "SharedBitmap.h"
30 #include <wtf/UnusedParam.h>
31
32 namespace WebCore {
33
34 class BufferedImage: public Image {
35
36 public:
37     BufferedImage(const ImageBufferData* data)
38         : m_data(data)
39     {
40     }
41
42     virtual IntSize size() const { return IntSize(m_data->m_bitmap->width(), m_data->m_bitmap->height()); }
43     virtual void destroyDecodedData(bool destroyAll = true) {}
44     virtual unsigned decodedSize() const { return 0; }
45     virtual void draw(GraphicsContext*, const FloatRect& dstRect, const FloatRect& srcRect, ColorSpace styleColorSpace, CompositeOperator);
46     virtual void drawPattern(GraphicsContext*, const FloatRect& srcRect, const AffineTransform& patternTransform,
47                              const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator, const FloatRect& destRect);
48
49     const ImageBufferData* m_data;
50 };
51
52 void BufferedImage::draw(GraphicsContext* ctxt, const FloatRect& dstRect, const FloatRect& srcRect, ColorSpace styleColorSpace, CompositeOperator compositeOp)
53 {
54     IntRect intDstRect = enclosingIntRect(dstRect);
55     IntRect intSrcRect(srcRect);
56     m_data->m_bitmap->draw(ctxt, intDstRect, intSrcRect, styleColorSpace, compositeOp);
57 }
58
59 void BufferedImage::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRectIn, const AffineTransform& patternTransform,
60                              const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
61 {
62     m_data->m_bitmap->drawPattern(ctxt, tileRectIn, patternTransform, phase, styleColorSpace, op, destRect, size());
63 }
64
65 ImageBufferData::ImageBufferData(const IntSize& size)
66     : m_bitmap(SharedBitmap::create(size, BitmapInfo::BitCount32, false))
67 {
68     // http://www.w3.org/TR/2009/WD-html5-20090212/the-canvas-element.html#canvaspixelarray
69     // "When the canvas is initialized it must be set to fully transparent black."
70     m_bitmap->resetPixels(true);
71     m_bitmap->setHasAlpha(true);
72 }
73
74 ImageBuffer::ImageBuffer(const IntSize& size, float resolutionScale, ColorSpace colorSpace, RenderingMode, DeferralMode, bool& success)
75     : m_data(size)
76     , m_size(size)
77     , m_logicalSize(size)
78 {
79     // FIXME: Respect resoutionScale to support high-DPI canvas.
80     UNUSED_PARAM(resolutionScale);
81     // FIXME: colorSpace is not used
82     UNUSED_PARAM(colorSpace);
83
84     m_context = adoptPtr(new GraphicsContext(0));
85     m_context->setBitmap(m_data.m_bitmap);
86     success = true;
87 }
88
89 ImageBuffer::~ImageBuffer()
90 {
91 }
92
93 GraphicsContext* ImageBuffer::context() const
94 {
95     return m_context.get();
96 }
97
98 PassRefPtr<Image> ImageBuffer::copyImage(BackingStoreCopy copyBehavior) const
99 {
100     ASSERT(copyBehavior == CopyBackingStore);
101     return adoptRef(new BufferedImage(&m_data));
102 }
103
104 void ImageBuffer::clip(GraphicsContext*, const FloatRect&) const
105 {
106     notImplemented();
107 }
108
109 void ImageBuffer::draw(GraphicsContext* context, ColorSpace styleColorSpace, const FloatRect& destRect, const FloatRect& srcRect,
110                        CompositeOperator op , bool useLowQualityScale)
111 {
112     RefPtr<Image> imageCopy = copyImage(CopyBackingStore);
113     context->drawImage(imageCopy.get(), styleColorSpace, destRect, srcRect, op, DoNotRespectImageOrientation, useLowQualityScale);
114 }
115
116 void ImageBuffer::drawPattern(GraphicsContext* context, const FloatRect& srcRect, const AffineTransform& patternTransform,
117                               const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect)
118 {
119     RefPtr<Image> imageCopy = copyImage(CopyBackingStore);
120     imageCopy->drawPattern(context, srcRect, patternTransform, phase, styleColorSpace, op, destRect);
121 }
122
123 template <bool premultiplied>
124 static PassRefPtr<ByteArray> getImageData(const IntRect& rect, const SharedBitmap* bitmap)
125 {
126     RefPtr<ByteArray> imageData = ByteArray::create(rect.width() * rect.height() * 4);
127
128     const unsigned char* src = static_cast<const unsigned char*>(bitmap->bytes());
129     if (!src)
130         return imageData.release();
131
132     IntRect sourceRect(0, 0, bitmap->width(), bitmap->height());
133     sourceRect.intersect(rect);
134     if (sourceRect.isEmpty())
135         return imageData.release();
136
137     unsigned char* dst = imageData->data();
138     memset(dst, 0, imageData->length());
139     src += (sourceRect.y() * bitmap->width() + sourceRect.x()) * 4;
140     dst += ((sourceRect.y() - rect.y()) * rect.width() + sourceRect.x() - rect.x()) * 4;
141     int bytesToCopy = sourceRect.width() * 4;
142     int srcSkip = (bitmap->width() - sourceRect.width()) * 4;
143     int dstSkip = (rect.width() - sourceRect.width()) * 4;
144     const unsigned char* dstEnd = dst + sourceRect.height() * rect.width() * 4;
145     while (dst < dstEnd) {
146         const unsigned char* dstRowEnd = dst + bytesToCopy;
147         while (dst < dstRowEnd) {
148             // Convert ARGB little endian to RGBA big endian
149             int blue = *src++;
150             int green = *src++;
151             int red = *src++;
152             int alpha = *src++;
153             if (premultiplied) {
154                 *dst++ = static_cast<unsigned char>((red * alpha + 254) / 255);
155                 *dst++ = static_cast<unsigned char>((green * alpha + 254) / 255);
156                 *dst++ = static_cast<unsigned char>((blue * alpha + 254) / 255);
157                 *dst++ = static_cast<unsigned char>(alpha);
158             } else {
159                 *dst++ = static_cast<unsigned char>(red);
160                 *dst++ = static_cast<unsigned char>(green);
161                 *dst++ = static_cast<unsigned char>(blue);
162                 *dst++ = static_cast<unsigned char>(alpha);
163                 ++src;
164             }
165         }
166         src += srcSkip;
167         dst += dstSkip;
168     }
169
170     return imageData.release();
171 }
172
173 PassRefPtr<ByteArray> ImageBuffer::getUnmultipliedImageData(const IntRect& rect, CoordinateSystem) const
174 {
175     return getImageData<false>(rect, m_data.m_bitmap.get());
176 }
177
178 PassRefPtr<ByteArray> ImageBuffer::getPremultipliedImageData(const IntRect& rect, CoordinateSystem) const
179 {
180     return getImageData<true>(rect, m_data.m_bitmap.get());
181 }
182
183 void ImageBuffer::putByteArray(Multiply multiplied, ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint, CoordinateSystem)
184 {
185     SharedBitmap* bitmap = m_data.m_bitmap.get();
186     unsigned char* dst = (unsigned char*)bitmap->bytes();
187     if (!dst)
188         return;
189
190     IntRect destRect(destPoint, sourceRect.size());
191     destRect.intersect(IntRect(0, 0, bitmap->width(), bitmap->height()));
192
193     if (destRect.isEmpty())
194         return;
195
196     const unsigned char* src = source->data();
197     dst += (destRect.y() * bitmap->width() + destRect.x()) * 4;
198     src += (sourceRect.y() * sourceSize.width() + sourceRect.x()) * 4;
199     int bytesToCopy = destRect.width() * 4;
200     int dstSkip = (bitmap->width() - destRect.width()) * 4;
201     int srcSkip = (sourceSize.width() - destRect.width()) * 4;
202     const unsigned char* dstEnd = dst + destRect.height() * bitmap->width() * 4;
203     while (dst < dstEnd) {
204         const unsigned char* dstRowEnd = dst + bytesToCopy;
205         while (dst < dstRowEnd) {
206             // Convert RGBA big endian to ARGB little endian
207             int red = *src++;
208             int green = *src++;
209             int blue = *src++;
210             int alpha = *src++;
211             if (multiplied == Premultiplied) {
212                 *dst++ = static_cast<unsigned char>(blue * 255 / alpha);
213                 *dst++ = static_cast<unsigned char>(green * 255 / alpha);
214                 *dst++ = static_cast<unsigned char>(red * 255 / alpha);
215                 *dst++ = static_cast<unsigned char>(alpha);
216             } else {
217                 *dst++ = static_cast<unsigned char>(blue);
218                 *dst++ = static_cast<unsigned char>(green);
219                 *dst++ = static_cast<unsigned char>(red);
220                 *dst++ = static_cast<unsigned char>(alpha);
221             }
222         }
223         src += srcSkip;
224         dst += dstSkip;
225     }
226 }
227
228 void ImageBuffer::platformTransformColorSpace(const Vector<int>& lookUpTable)
229 {
230     UNUSED_PARAM(lookUpTable);
231     notImplemented();
232 }
233
234 String ImageBuffer::toDataURL(const String& mimeType, const double*, CoordinateSystem) const
235 {
236     if (!m_data.m_bitmap->bytes())
237         return "data:,";
238
239     notImplemented();
240     return String();
241 }
242
243 } // namespace WebCore