Improve use of NeverDestroyed
[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
35 namespace WebCore {
36
37 static const float MaxClampedLength = 4096;
38 static const float MaxClampedArea = MaxClampedLength * MaxClampedLength;
39
40 std::unique_ptr<ImageBuffer> ImageBuffer::create(const FloatSize& size, RenderingMode renderingMode, float resolutionScale, ColorSpace colorSpace)
41 {
42     bool success = false;
43     std::unique_ptr<ImageBuffer> buffer(new ImageBuffer(size, resolutionScale, colorSpace, renderingMode, success));
44     if (!success)
45         return nullptr;
46     return buffer;
47 }
48
49 #if USE(DIRECT2D)
50 std::unique_ptr<ImageBuffer> ImageBuffer::create(const FloatSize& size, RenderingMode renderingMode, const GraphicsContext* targetContext, float resolutionScale, ColorSpace colorSpace)
51 {
52     bool success = false;
53     std::unique_ptr<ImageBuffer> buffer(new ImageBuffer(size, resolutionScale, colorSpace, renderingMode, targetContext, success));
54     if (!success)
55         return nullptr;
56     return buffer;
57 }
58 #endif
59
60 bool ImageBuffer::sizeNeedsClamping(const FloatSize& size)
61 {
62     if (size.isEmpty())
63         return false;
64
65     return floorf(size.height()) * floorf(size.width()) > MaxClampedArea;
66 }
67
68 bool ImageBuffer::sizeNeedsClamping(const FloatSize& size, FloatSize& scale)
69 {
70     FloatSize scaledSize(size);
71     scaledSize.scale(scale.width(), scale.height());
72
73     if (!sizeNeedsClamping(scaledSize))
74         return false;
75
76     // The area of scaled size is bigger than the upper limit, adjust the scale to fit.
77     scale.scale(sqrtf(MaxClampedArea / (scaledSize.width() * scaledSize.height())));
78     ASSERT(!sizeNeedsClamping(size, scale));
79     return true;
80 }
81
82 FloatSize ImageBuffer::clampedSize(const FloatSize& size)
83 {
84     return size.shrunkTo(FloatSize(MaxClampedLength, MaxClampedLength));
85 }
86
87 FloatSize ImageBuffer::clampedSize(const FloatSize& size, FloatSize& scale)
88 {
89     if (size.isEmpty())
90         return size;
91
92     FloatSize clampedSize = ImageBuffer::clampedSize(size);
93     scale = FloatSize(clampedSize.width() / size.width(), clampedSize.height() / size.height());
94     ASSERT(!sizeNeedsClamping(clampedSize));
95     ASSERT(!sizeNeedsClamping(size, scale));
96     return clampedSize;
97 }
98
99 FloatRect ImageBuffer::clampedRect(const FloatRect& rect)
100 {
101     return FloatRect(rect.location(), clampedSize(rect.size()));
102 }
103
104 Vector<uint8_t> ImageBuffer::toBGRAData() const
105 {
106 #if USE(CG)
107     if (context().isAcceleratedContext())
108         flushContext();
109     return m_data.toBGRAData(context().isAcceleratedContext(), m_size.width(), m_size.height());
110 #else
111     // FIXME: Implement this for other backends.
112     return { };
113 #endif
114 }
115
116 #if !(USE(CG) || USE(DIRECT2D))
117
118 FloatSize ImageBuffer::sizeForDestinationSize(FloatSize size) const
119 {
120     return size;
121 }
122
123 void ImageBuffer::transformColorSpace(ColorSpace srcColorSpace, ColorSpace dstColorSpace)
124 {
125     if (srcColorSpace == dstColorSpace)
126         return;
127
128     // only sRGB <-> linearRGB are supported at the moment
129     if ((srcColorSpace != ColorSpaceLinearRGB && srcColorSpace != ColorSpaceDeviceRGB)
130         || (dstColorSpace != ColorSpaceLinearRGB && dstColorSpace != ColorSpaceDeviceRGB))
131         return;
132
133     if (dstColorSpace == ColorSpaceLinearRGB) {
134         static const std::array<uint8_t, 256> linearRgbLUT = [] {
135             std::array<uint8_t, 256> array;
136             for (unsigned i = 0; i < 256; i++) {
137                 float color = i / 255.0f;
138                 color = (color <= 0.04045f ? color / 12.92f : pow((color + 0.055f) / 1.055f, 2.4f));
139                 color = std::max(0.0f, color);
140                 color = std::min(1.0f, color);
141                 array[i] = static_cast<uint8_t>(round(color * 255));
142             }
143             return array;
144         }();
145         platformTransformColorSpace(linearRgbLUT);
146     } else if (dstColorSpace == ColorSpaceDeviceRGB) {
147         static const std::array<uint8_t, 256> deviceRgbLUT= [] {
148             std::array<uint8_t, 256> array;
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                 array[i] = static_cast<uint8_t>(round(color * 255));
155             }
156             return array;
157         }();
158         platformTransformColorSpace(deviceRgbLUT);
159     }
160 }
161
162 #endif // USE(CG)
163
164 inline void ImageBuffer::genericConvertToLuminanceMask()
165 {
166     IntRect luminanceRect(IntPoint(), internalSize());
167     RefPtr<Uint8ClampedArray> srcPixelArray = getUnmultipliedImageData(luminanceRect);
168     
169     unsigned pixelArrayLength = srcPixelArray->length();
170     for (unsigned pixelOffset = 0; pixelOffset < pixelArrayLength; pixelOffset += 4) {
171         unsigned char a = srcPixelArray->item(pixelOffset + 3);
172         if (!a)
173             continue;
174         unsigned char r = srcPixelArray->item(pixelOffset);
175         unsigned char g = srcPixelArray->item(pixelOffset + 1);
176         unsigned char b = srcPixelArray->item(pixelOffset + 2);
177         
178         double luma = (r * 0.2125 + g * 0.7154 + b * 0.0721) * ((double)a / 255.0);
179         srcPixelArray->set(pixelOffset + 3, luma);
180     }
181     putByteArray(Unmultiplied, srcPixelArray.get(), luminanceRect.size(), luminanceRect, IntPoint());
182 }
183
184 void ImageBuffer::convertToLuminanceMask()
185 {
186     // Add platform specific functions with platformConvertToLuminanceMask here later.
187     genericConvertToLuminanceMask();
188 }
189
190 #if !USE(CAIRO)
191 PlatformLayer* ImageBuffer::platformLayer() const
192 {
193     return 0;
194 }
195
196 bool ImageBuffer::copyToPlatformTexture(GraphicsContext3D&, GC3Denum, Platform3DObject, GC3Denum, bool, bool)
197 {
198     return false;
199 }
200 #endif
201
202 std::unique_ptr<ImageBuffer> ImageBuffer::createCompatibleBuffer(const FloatSize& size, ColorSpace colorSpace, const GraphicsContext& context)
203 {
204     if (size.isEmpty())
205         return nullptr;
206
207     IntSize scaledSize = ImageBuffer::compatibleBufferSize(size, context);
208
209     auto buffer = ImageBuffer::createCompatibleBuffer(scaledSize, 1, colorSpace, context);
210     if (!buffer)
211         return nullptr;
212
213     // Set up a corresponding scale factor on the graphics context.
214     buffer->context().scale(FloatSize(scaledSize.width() / size.width(), scaledSize.height() / size.height()));
215     return buffer;
216 }
217
218 std::unique_ptr<ImageBuffer> ImageBuffer::createCompatibleBuffer(const FloatSize& size, float resolutionScale, ColorSpace colorSpace, const GraphicsContext& context)
219 {
220     return create(size, context.renderingMode(), resolutionScale, colorSpace);
221 }
222
223 IntSize ImageBuffer::compatibleBufferSize(const FloatSize& size, const GraphicsContext& context)
224 {
225     // Enlarge the buffer size if the context's transform is scaling it so we need a higher
226     // resolution than one pixel per unit.
227     return expandedIntSize(size * context.scaleFactor());
228 }
229
230 bool ImageBuffer::isCompatibleWithContext(const GraphicsContext& context) const
231 {
232     return areEssentiallyEqual(context.scaleFactor(), this->context().scaleFactor());
233 }
234
235 #if !USE(IOSURFACE_CANVAS_BACKING_STORE)
236 size_t ImageBuffer::memoryCost() const
237 {
238     // memoryCost() may be invoked concurrently from a GC thread, and we need to be careful about what data we access here and how.
239     // It's safe to access internalSize() because it doesn't do any pointer chasing.
240     return 4 * internalSize().width() * internalSize().height();
241 }
242
243 size_t ImageBuffer::externalMemoryCost() const
244 {
245     return 0;
246 }
247 #endif
248
249 }