← 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/openvg/VGUtils.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/openvg/VGUtils.cpp
 
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
 
 
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
 
 
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
 
 
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
 
 
68
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
 
 
77
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
 
 
87
AffineTransform::operator VGMatrix() const
 
88
{
 
89
    return VGMatrix(*this);
 
90
}
 
91
 
 
92
TransformationMatrix::operator VGMatrix() const
 
93
{
 
94
    return VGMatrix(*this);
 
95
}
 
96
 
 
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
 
 
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
 
 
113
VGRect::operator FloatRect() const
 
114
{
 
115
    return FloatRect(m_data[0], m_data[1], m_data[2], m_data[3]);
 
116
}
 
117
 
 
118
FloatRect::operator VGRect() const
 
119
{
 
120
    return VGRect(*this);
 
121
}
 
122
 
 
123
int VGUtils::bytesForImage(VGImageFormat format, VGint width, VGint height)
 
124
{
 
125
    return width * height * imageFormatBitsPerPixel(format) / 8;
 
126
}
 
127
 
 
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
 
 
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
 
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
 
229
VGImageFormat VGUtils::endianAwareImageFormat(VGImageFormat bigEndianFormat)
 
230
{
 
231
    return bigEndianFormat;
 
232
}
 
233
#endif
 
234
 
 
235
}