← Back to branch summary

~ubuntu-branches/ubuntu/raring/qtwebkit-source/raring-proposed

« back to all changes in this revision

Viewing changes to Source/WebCore/platform/graphics/skia/ImageBufferSkia.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2013-02-18 14:24:18 UTC
  • Revision ID: package-import@ubuntu.com-20130218142418-eon0jmjg3nj438uy
Tags: upstream-2.3
Import upstream version 2.3

Show diffs side-by-side

added added

removed removed

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