Implementors of memoryCost() need to be thread-safe.
[WebKit-https.git] / Source / WebCore / platform / graphics / ImageBuffer.cpp
1 /*
2  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
3  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
4  * Copyright (C) 2016-2017 Apple Inc. 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
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26  */
27
28 #include "config.h"
29 #include "ImageBuffer.h"
30
31 #include "GraphicsContext.h"
32 #include "IntRect.h"
33 #include <wtf/MathExtras.h>
34 #include <wtf/NeverDestroyed.h>
35
36 namespace WebCore {
37
38 static const float MaxClampedLength = 4096;
39 static const float MaxClampedArea = MaxClampedLength * MaxClampedLength;
40
41 std::unique_ptr<ImageBuffer> ImageBuffer::create(const FloatSize& size, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace)
42 {
43     bool success = false;
44     std::unique_ptr<ImageBuffer> buffer(new ImageBuffer(size, resolutionScale, colorSpace, renderingMode, success));
45     if (!success)
46         return nullptr;
47     return buffer;
48 }
49
50 #if USE(DIRECT2D)
51 std::unique_ptr<ImageBuffer> ImageBuffer::create(const FloatSize& size, RenderingMode renderingMode, const GraphicsContext* targetContext, float resolutionScale, ColorSpace colorSpace)
52 {
53     bool success = false;
54     std::unique_ptr<ImageBuffer> buffer(new ImageBuffer(size, resolutionScale, colorSpace, renderingMode, targetContext, success));
55     if (!success)
56         return nullptr;
57     return buffer;
58 }
59 #endif
60
61 bool ImageBuffer::sizeNeedsClamping(const FloatSize& size)
62 {
63     if (size.isEmpty())
64         return false;
65
66     return floorf(size.height()) * floorf(size.width()) > MaxClampedArea;
67 }
68
69 bool ImageBuffer::sizeNeedsClamping(const FloatSize& size, FloatSize& scale)
70 {
71     FloatSize scaledSize(size);
72     scaledSize.scale(scale.width(), scale.height());
73
74     if (!sizeNeedsClamping(scaledSize))
75         return false;
76
77     // The area of scaled size is bigger than the upper limit, adjust the scale to fit.
78     scale.scale(sqrtf(MaxClampedArea / (scaledSize.width() * scaledSize.height())));
79     ASSERT(!sizeNeedsClamping(size, scale));
80     return true;
81 }
82
83 FloatSize ImageBuffer::clampedSize(const FloatSize& size)
84 {
85     return size.shrunkTo(FloatSize(MaxClampedLength, MaxClampedLength));
86 }
87
88 FloatSize ImageBuffer::clampedSize(const FloatSize& size, FloatSize& scale)
89 {
90     if (size.isEmpty())
91         return size;
92
93     FloatSize clampedSize = ImageBuffer::clampedSize(size);
94     scale = FloatSize(clampedSize.width() / size.width(), clampedSize.height() / size.height());
95     ASSERT(!sizeNeedsClamping(clampedSize));
96     ASSERT(!sizeNeedsClamping(size, scale));
97     return clampedSize;
98 }
99
100 FloatRect ImageBuffer::clampedRect(const FloatRect& rect)
101 {
102     return FloatRect(rect.location(), clampedSize(rect.size()));
103 }
104
105 Vector<uint8_t> ImageBuffer::toBGRAData() const
106 {
107 #if USE(CG)
108     if (context().isAcceleratedContext())
109         flushContext();
110     return m_data.toBGRAData(context().isAcceleratedContext(), m_size.width(), m_size.height());
111 #else
112     // FIXME: Implement this for other backends.
113     return { };
114 #endif
115 }
116
117 #if !(USE(CG) || USE(DIRECT2D))
118 FloatSize ImageBuffer::sizeForDestinationSize(FloatSize size) const
119 {
120     return size;
121 }
122
123 void ImageBuffer::transformColorSpace(ColorSpace srcColorSpace, ColorSpace dstColorSpace)
124 {
125     static NeverDestroyed<Vector<int>> deviceRgbLUT;
126     static NeverDestroyed<Vector<int>> linearRgbLUT;
127
128     if (srcColorSpace == dstColorSpace)
129         return;
130
131     // only sRGB <-> linearRGB are supported at the moment
132     if ((srcColorSpace != ColorSpaceLinearRGB && srcColorSpace != ColorSpaceDeviceRGB)
133         || (dstColorSpace != ColorSpaceLinearRGB && dstColorSpace != ColorSpaceDeviceRGB))
134         return;
135
136     if (dstColorSpace == ColorSpaceLinearRGB) {
137         if (linearRgbLUT.get().isEmpty()) {
138             for (unsigned i = 0; i < 256; i++) {
139                 float color = i  / 255.0f;
140                 color = (color <= 0.04045f ? color / 12.92f : pow((color + 0.055f) / 1.055f, 2.4f));
141                 color = std::max(0.0f, color);
142                 color = std::min(1.0f, color);
143                 linearRgbLUT.get().append(static_cast<int>(round(color * 255)));
144             }
145         }
146         platformTransformColorSpace(linearRgbLUT.get());
147     } else if (dstColorSpace == ColorSpaceDeviceRGB) {
148         if (deviceRgbLUT.get().isEmpty()) {
149             for (unsigned i = 0; i < 256; i++) {
150                 float color = i / 255.0f;
151                 color = (powf(color, 1.0f / 2.4f) * 1.055f) - 0.055f;
152                 color = std::max(0.0f, color);
153                 color = std::min(1.0f, color);
154                 deviceRgbLUT.get().append(static_cast<int>(round(color * 255)));
155             }
156         }
157         platformTransformColorSpace(deviceRgbLUT.get());
158     }
159 }
160 #endif // USE(CG)
161
162 inline void ImageBuffer::genericConvertToLuminanceMask()
163 {
164     IntRect luminanceRect(IntPoint(), internalSize());
165     RefPtr<Uint8ClampedArray> srcPixelArray = getUnmultipliedImageData(luminanceRect);
166     
167     unsigned pixelArrayLength = srcPixelArray->length();
168     for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
169         unsigned char a = srcPixelArray->item(pixelOffset + 3);
170         if (!a)
171             continue;
172         unsigned char r = srcPixelArray->item(pixelOffset);
173         unsigned char g = srcPixelArray->item(pixelOffset + 1);
174         unsigned char b = srcPixelArray->item(pixelOffset + 2);
175         
176         double luma = (r * 0.2125 + g * 0.7154 + b * 0.0721) * ((double)a / 255.0);
177         srcPixelArray->set(pixelOffset + 3, luma);
178     }
179     putByteArray(Unmultiplied, srcPixelArray.get(), luminanceRect.size(), luminanceRect, IntPoint());
180 }
181
182 void ImageBuffer::convertToLuminanceMask()
183 {
184     // Add platform specific functions with platformConvertToLuminanceMask here later.
185     genericConvertToLuminanceMask();
186 }
187
188 #if !USE(CAIRO)
189 PlatformLayer* ImageBuffer::platformLayer() const
190 {
191     return 0;
192 }
193
194 bool ImageBuffer::copyToPlatformTexture(GraphicsContext3D&, GC3Denum, Platform3DObject, GC3Denum, bool, bool)
195 {
196     return false;
197 }
198 #endif
199
200 std::unique_ptr<ImageBuffer> ImageBuffer::createCompatibleBuffer(const FloatSize& size, ColorSpace colorSpace, const GraphicsContext& context)
201 {
202     if (size.isEmpty())
203         return nullptr;
204
205     IntSize scaledSize = ImageBuffer::compatibleBufferSize(size, context);
206
207     auto buffer = ImageBuffer::createCompatibleBuffer(scaledSize, 1, colorSpace, context);
208     if (!buffer)
209         return nullptr;
210
211     // Set up a corresponding scale factor on the graphics context.
212     buffer->context().scale(FloatSize(scaledSize.width() / size.width(), scaledSize.height() / size.height()));
213     return buffer;
214 }
215
216 std::unique_ptr<ImageBuffer> ImageBuffer::createCompatibleBuffer(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, const GraphicsContext& context)
217 {
218     return create(size, context.renderingMode(), resolutionScale, colorSpace);
219 }
220
221 IntSize ImageBuffer::compatibleBufferSize(const FloatSize& size, const GraphicsContext& context)
222 {
223     // Enlarge the buffer size if the context's transform is scaling it so we need a higher
224     // resolution than one pixel per unit.
225     return expandedIntSize(size * context.scaleFactor());
226 }
227
228 bool ImageBuffer::isCompatibleWithContext(const GraphicsContext& context) const
229 {
230     return areEssentiallyEqual(context.scaleFactor(), this->context().scaleFactor());
231 }
232
233 #if !USE(IOSURFACE_CANVAS_BACKING_STORE)
234 size_t ImageBuffer::memoryCost() const
235 {
236     // memoryCost() may be invoked concurrently from a GC thread, and we need to be careful about what data we access here and how.
237     // It's safe to access internalSize() because it doesn't do any pointer chasing.
238     return 4 * internalSize().width() * internalSize().height();
239 }
240
241 size_t ImageBuffer::externalMemoryCost() const
242 {
243     return 0;
244 }
245 #endif
246
247 }