1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifndef __com_sun_star_rendering_XIntegerBitmapColorSpace_idl__
#define __com_sun_star_rendering_XIntegerBitmapColorSpace_idl__
#include <com/sun/star/rendering/XColorSpace.idl>
module com { module sun { module star { module rendering {
/** A color space for integer bitmap formats<p>
This interface encapsulates all information specific to a certain
integer bitmap color space, like for example 1555 ARGB. Note that
the individual elements of the integer color representation
sequence need not correspond to the color space's components -
instead, the color components might be packed back-to-back into
those bytes, as they appear in the raw bitmap data.<p>
*/
interface XIntegerBitmapColorSpace : XColorSpace
{
/** Query number of bits used per bitmap pixel.<p>
This method yields the total number of bits used for a color
value. At the associated XIntegerBitmap, the
<member>XIntegerBitmap::setPixel()</member> method will expect
a sequence of ceil(BitsPerPixel/8) bytes, and the
<member>XIntegerReadOnlyBitmap::getPixel()</member> will
return that number of bytes. Similarly, the color conversion
expect input data in multiples of ceil(BitsPerPixel/8), and
also return converted data in chunks of this.<p>
*/
long getBitsPerPixel();
/** Query the number of bits used for each component.<p>
This method returns a sequence of integers, each denoting the
number of bits occupied by the respective component. The sum
of all component bits must be less or equal than the value
returned from <member>getBitsPerPixel()</member>. If the sum is
less, excess bits are always kept in the most significant bits
of a pixel. Color components will appear in the byte sequences
returned from the XIntegerBitmap methods in the
order defined here, with the first element starting from the
least significant bits of the pixel, etc.<p>
@example For the typical 32 bit RGBA color data, the four
values would all contain the value eight. For a 16 bit 1555
ARGB format, with mask values 0x8000 for alpha, 0x7C for red,
0x3E for green and 0x1F for blue, the values would be 5, 5, 5,
1, in that order.
*/
sequence<long> getComponentBitCounts();
/** Query whether color data bytes need to be swapped.<p>
@return <TRUE/>, This method returns the endianness of the color
data. The value is one of the Endianness
constants. If color data is represented using more than one
byte, the actual channel positions are specified using bit
positions. Therefore, depending on the architecture, the
actual color data bytes might need to get swapped, for the
bits to align properly.<p>
@example with a 16 bit 565 RGB format, written on a big endian
architecture, a destination machine using little endian CPU
will need to swap the bytes, in order to keep the green
channel bits together.
*/
byte getEndianness();
/** Convert integer bitmap color to generic IEEE double device
color of another color space.<p>
Color values are properly rounded and clipped, to be valid in
the target color space.<p>
@param deviceColor Sequence of device color components. Is
permitted to contain more than one device color element,
therefore, batch conversion of multiple color values is
possible.<p>
@return the corresponding sequence of device colors in the
target color space
@throws a
com::sun::star::lang::IllegalArgumentException,
if the input sequence does not match the device color format.
*/
sequence<ColorComponent> convertFromIntegerColorSpace( [in] sequence<byte> deviceColor, [in] XColorSpace targetColorSpace )
raises (com::sun::star::lang::IllegalArgumentException);
/** Convert integer bitmap color to integer bitmap color of
another integer bitmap color space.<p>
Color values are properly rounded and clipped, to be valid in
the target color space.<p>
@param deviceColor Sequence of device color components. Is
permitted to contain more than one device color element,
therefore, batch conversion of multiple color values is
possible.<p>
@return the corresponding sequence of device colors in the
target color space
@throws a
com::sun::star::lang::IllegalArgumentException,
if the input sequence does not match the device color format.
*/
sequence<byte> convertToIntegerColorSpace( [in] sequence<byte> deviceColor, [in] XIntegerBitmapColorSpace targetColorSpace )
raises (com::sun::star::lang::IllegalArgumentException);
/** Convert color value in this color space to sRGB color values.<p>
Any information not representable in the RGBColor
struct is discarded during the conversion. This includes alpha
information. Color values are properly rounded and clipped,
to be valid in the target color space.<p>
@param deviceColor Sequence of device color components. Is
permitted to contain more than one device color element,
therefore, batch conversion of multiple color values is
possible.
@return the corresponding sequence of sRGB colors.
@see XIntegerBitmapColorSpace::convertIntegerToARGB()
@throws a
com::sun::star::lang::IllegalArgumentException,
if the input sequence does not match the device color format.
*/
sequence<RGBColor> convertIntegerToRGB( [in] sequence<byte> deviceColor )
raises (com::sun::star::lang::IllegalArgumentException);
/** Convert color value in this color space to sRGB color values,
with linear alpha.<p>
If the given input color does not carry alpha information, an
alpha value of 1.0 (fully opaque) is assumed. Color values
are properly rounded and clipped, to be valid in the target
color space.<p>
@param deviceColor Sequence of device color components. Is
permitted to contain more than one device color element,
therefore, batch conversion of multiple color values is
possible.
@return the corresponding sequence of sRGB colors.
@throws a
com::sun::star::lang::IllegalArgumentException,
if the input sequence does not match the device color format.
*/
sequence<ARGBColor> convertIntegerToARGB( [in] sequence<byte> deviceColor )
raises (com::sun::star::lang::IllegalArgumentException);
/** Convert color value in this color space to premultiplied sRGB
color values, with linear alpha.<p>
If the given input color does not carry alpha information, an
alpha value of 1.0 (fully opaque) is assumed. Color values
are properly rounded and clipped, to be valid in the target
color space. The resulting individual RGB color values are
premultiplied by the alpha value (e.g. if alpha is 0.5, each
color value has only half of the original intensity).<p>
@param deviceColor Sequence of device color components. Is
permitted to contain more than one device color element,
therefore, batch conversion of multiple color values is
possible.
@return the corresponding sequence of sRGB colors.
@throws a
com::sun::star::lang::IllegalArgumentException,
if the input sequence does not match the device color format.
*/
sequence<ARGBColor> convertIntegerToPARGB( [in] sequence<byte> deviceColor )
raises (com::sun::star::lang::IllegalArgumentException);
/** Convert sRGB color to an integer representation in this color
space.<p>
If this color space conveys alpha information, it is assumed
be fully opaque for the given RGB color value. Color values
are properly rounded and clipped, to be valid in the target
color space.<p>
@param deviceColor Sequence of sRGB color components. Is
permitted to contain more than one color element, therefore,
batch conversion of multiple color values is possible.
@return the corresponding sequence of device colors.
@throws a
com::sun::star::lang::IllegalArgumentException,
if the input sequence does not match the device color format.
*/
sequence<byte> convertIntegerFromRGB( [in] sequence<RGBColor> rgbColor )
raises (com::sun::star::lang::IllegalArgumentException);
/** Convert sRGB color with linear alpha into this color space.<p>
If this color space does not convey alpha information, the
specified alpha value is silently ignored. Color values are
properly rounded and clipped, to be valid in the target color
space.<p>
@param deviceColor Sequence of sRGB color components. Is
permitted to contain more than one color element, therefore,
batch conversion of multiple color values is possible.
@return the corresponding sequence of device colors.
@throws a
com::sun::star::lang::IllegalArgumentException,
if the input sequence does not match the device color format.
*/
sequence<byte> convertIntegerFromARGB( [in] sequence<ARGBColor> rgbColor )
raises (com::sun::star::lang::IllegalArgumentException);
/** Convert premultiplied sRGB color with linear alpha into this
color space.<p>
If this color space does not convey alpha information, the
specified alpha value is silently ignored. Color values are
properly rounded and clipped, to be valid in the target color
space.<p>
@param deviceColor Sequence of sRGB color components. Is
permitted to contain more than one color element, therefore,
batch conversion of multiple color values is possible. The
individual RGB color values are assumed to be premultiplied by
the alpha value already.
@return the corresponding sequence of device colors.
@throws a
com::sun::star::lang::IllegalArgumentException,
if the input sequence does not match the device color format.
*/
sequence<byte> convertIntegerFromPARGB( [in] sequence<ARGBColor> rgbColor )
raises (com::sun::star::lang::IllegalArgumentException);
};
}; }; }; };
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
