1 /*
2 * Copyright (C) Research In Motion Limited 2009. All rights reserved.
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public License
15 * along with this library; see the file COPYING.LIB. If not, write to
16 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 */
19
20 #include "config.h"
21 #include "VGUtils.h"
22
23 #include "AffineTransform.h"
24 #include "FloatRect.h"
25 #include "TransformationMatrix.h"
26
27 namespace WebCore {
28
VGMatrix(const VGfloat data[9])29 VGMatrix::VGMatrix(const VGfloat data[9])
30 {
31 m_data[0] = data[0];
32 m_data[1] = data[1];
33 m_data[2] = data[2];
34 m_data[3] = data[3];
35 m_data[4] = data[4];
36 m_data[5] = data[5];
37 m_data[6] = data[6];
38 m_data[7] = data[7];
39 m_data[8] = data[8];
40 }
41
VGMatrix(const AffineTransform & transformation)42 VGMatrix::VGMatrix(const AffineTransform& transformation)
43 {
44 m_data[0] = transformation.a();
45 m_data[1] = transformation.b();
46 m_data[2] = 0;
47 m_data[3] = transformation.c();
48 m_data[4] = transformation.d();
49 m_data[5] = 0;
50 m_data[6] = transformation.e();
51 m_data[7] = transformation.f();
52 m_data[8] = 1;
53 }
54
VGMatrix(const TransformationMatrix & matrix)55 VGMatrix::VGMatrix(const TransformationMatrix& matrix)
56 {
57 m_data[0] = matrix.m11();
58 m_data[1] = matrix.m12();
59 m_data[2] = matrix.m14();
60 m_data[3] = matrix.m21();
61 m_data[4] = matrix.m22();
62 m_data[5] = matrix.m24();
63 m_data[6] = matrix.m41();
64 m_data[7] = matrix.m42();
65 m_data[8] = matrix.m44();
66 }
67
operator AffineTransform() const68 VGMatrix::operator AffineTransform() const
69 {
70 AffineTransform transformation(
71 m_data[0], m_data[1],
72 m_data[3], m_data[4],
73 m_data[6], m_data[7]);
74 return transformation;
75 }
76
operator TransformationMatrix() const77 VGMatrix::operator TransformationMatrix() const
78 {
79 TransformationMatrix matrix(
80 m_data[0], m_data[1], 0, m_data[2],
81 m_data[3], m_data[4], 0, m_data[5],
82 0, 0, 1, 0,
83 m_data[6], m_data[7], 0, m_data[8]);
84 return matrix;
85 }
86
operator VGMatrix() const87 AffineTransform::operator VGMatrix() const
88 {
89 return VGMatrix(*this);
90 }
91
operator VGMatrix() const92 TransformationMatrix::operator VGMatrix() const
93 {
94 return VGMatrix(*this);
95 }
96
VGRect(const VGfloat data[4])97 VGRect::VGRect(const VGfloat data[4])
98 {
99 m_data[0] = data[0];
100 m_data[1] = data[1];
101 m_data[2] = data[2];
102 m_data[3] = data[3];
103 }
104
VGRect(const FloatRect & rect)105 VGRect::VGRect(const FloatRect& rect)
106 {
107 m_data[0] = rect.x();
108 m_data[1] = rect.y();
109 m_data[2] = rect.width();
110 m_data[3] = rect.height();
111 }
112
operator FloatRect() const113 VGRect::operator FloatRect() const
114 {
115 return FloatRect(m_data[0], m_data[1], m_data[2], m_data[3]);
116 }
117
operator VGRect() const118 FloatRect::operator VGRect() const
119 {
120 return VGRect(*this);
121 }
122
bytesForImage(VGImageFormat format,VGint width,VGint height)123 int VGUtils::bytesForImage(VGImageFormat format, VGint width, VGint height)
124 {
125 return width * height * imageFormatBitsPerPixel(format) / 8;
126 }
127
bytesForImageScanline(VGImageFormat format,VGint width)128 int VGUtils::bytesForImageScanline(VGImageFormat format, VGint width)
129 {
130 int bits = width * imageFormatBitsPerPixel(format);
131 if (bits % 8 > 1) // If unaligned, round up to the next byte.
132 bits += 8 - (bits % 8);
133
134 return bits / 8;
135 }
136
imageFormatBitsPerPixel(VGImageFormat format)137 int VGUtils::imageFormatBitsPerPixel(VGImageFormat format)
138 {
139 switch (format) {
140 case VG_sRGBX_8888:
141 case VG_sRGBA_8888:
142 case VG_sRGBA_8888_PRE:
143 case VG_lRGBX_8888:
144 case VG_lRGBA_8888:
145 case VG_lRGBA_8888_PRE:
146 case VG_sXRGB_8888:
147 case VG_sARGB_8888:
148 case VG_sARGB_8888_PRE:
149 case VG_lXRGB_8888:
150 case VG_lARGB_8888:
151 case VG_lARGB_8888_PRE:
152 case VG_sBGRX_8888:
153 case VG_sBGRA_8888:
154 case VG_sBGRA_8888_PRE:
155 case VG_lBGRX_8888:
156 case VG_lBGRA_8888:
157 case VG_lBGRA_8888_PRE:
158 case VG_sXBGR_8888:
159 case VG_sABGR_8888:
160 case VG_sABGR_8888_PRE:
161 case VG_lXBGR_8888:
162 case VG_lABGR_8888:
163 case VG_lABGR_8888_PRE:
164 return 32;
165
166 case VG_sRGB_565:
167 case VG_sRGBA_5551:
168 case VG_sRGBA_4444:
169 case VG_sARGB_1555:
170 case VG_sARGB_4444:
171 case VG_sBGR_565:
172 case VG_sBGRA_5551:
173 case VG_sBGRA_4444:
174 case VG_sABGR_1555:
175 case VG_sABGR_4444:
176 return 16;
177
178 case VG_sL_8:
179 case VG_lL_8:
180 case VG_A_8:
181 return 8;
182
183 case VG_A_4:
184 return 4;
185
186 case VG_BW_1:
187 case VG_A_1:
188 return 1;
189
190 default: // Will only happen when OpenVG extends the enum and we don't.
191 ASSERT(false);
192 return 0;
193 }
194 }
195
196 #ifndef WTF_PLATFORM_BIG_ENDIAN
endianAwareImageFormat(VGImageFormat bigEndianFormat)197 VGImageFormat VGUtils::endianAwareImageFormat(VGImageFormat bigEndianFormat)
198 {
199 switch (bigEndianFormat) {
200 case VG_sRGBX_8888: return VG_sXBGR_8888;
201 case VG_sRGBA_8888: return VG_sABGR_8888;
202 case VG_sRGBA_8888_PRE: return VG_sABGR_8888_PRE;
203 case VG_lRGBX_8888: return VG_lXBGR_8888;
204 case VG_lRGBA_8888: return VG_lABGR_8888;
205 case VG_lRGBA_8888_PRE: return VG_lABGR_8888_PRE;
206 case VG_sXRGB_8888: return VG_sBGRX_8888;
207 case VG_sARGB_8888: return VG_sBGRA_8888;
208 case VG_sARGB_8888_PRE: return VG_sBGRA_8888_PRE;
209 case VG_lXRGB_8888: return VG_lBGRX_8888;
210 case VG_lARGB_8888: return VG_lBGRA_8888;
211 case VG_lARGB_8888_PRE: return VG_lBGRA_8888_PRE;
212 case VG_sBGRX_8888: return VG_sXRGB_8888;
213 case VG_sBGRA_8888: return VG_sARGB_8888;
214 case VG_sBGRA_8888_PRE: return VG_sARGB_8888_PRE;
215 case VG_lBGRX_8888: return VG_lXRGB_8888;
216 case VG_lBGRA_8888: return VG_lARGB_8888;
217 case VG_lBGRA_8888_PRE: return VG_lARGB_8888_PRE;
218 case VG_sXBGR_8888: return VG_sRGBX_8888;
219 case VG_sABGR_8888: return VG_sRGBA_8888;
220 case VG_sABGR_8888_PRE: return VG_sRGBA_8888_PRE;
221 case VG_lXBGR_8888: return VG_lRGBX_8888;
222 case VG_lABGR_8888: return VG_lRGBA_8888;
223 case VG_lABGR_8888_PRE: return VG_lRGBA_8888_PRE;
224 default: ASSERT(false);
225 return (VGImageFormat) 0;
226 }
227 }
228 #else
endianAwareImageFormat(VGImageFormat bigEndianFormat)229 VGImageFormat VGUtils::endianAwareImageFormat(VGImageFormat bigEndianFormat)
230 {
231 return bigEndianFormat;
232 }
233 #endif
234
235 }
236