1 /**************************************************************************
3 * Copyright 2010 VMware, Inc.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
30 * Pixel format accessor functions.
32 * @author Jose Fonseca <jfonseca@vmware.com>
42 util_format_read_4f(enum pipe_format format
,
43 float *dst
, unsigned dst_stride
,
44 const void *src
, unsigned src_stride
,
45 unsigned x
, unsigned y
, unsigned w
, unsigned h
)
47 const struct util_format_description
*format_desc
;
48 const uint8_t *src_row
;
51 format_desc
= util_format_description(format
);
53 assert(x
% format_desc
->block
.width
== 0);
54 assert(y
% format_desc
->block
.height
== 0);
56 src_row
= (const uint8_t *)src
+ y
*src_stride
+ x
*(format_desc
->block
.bits
/8);
59 format_desc
->unpack_float(dst_row
, dst_stride
, src_row
, src_stride
, w
, h
);
64 util_format_write_4f(enum pipe_format format
,
65 const float *src
, unsigned src_stride
,
66 void *dst
, unsigned dst_stride
,
67 unsigned x
, unsigned y
, unsigned w
, unsigned h
)
69 const struct util_format_description
*format_desc
;
73 format_desc
= util_format_description(format
);
75 assert(x
% format_desc
->block
.width
== 0);
76 assert(y
% format_desc
->block
.height
== 0);
78 dst_row
= (uint8_t *)dst
+ y
*dst_stride
+ x
*(format_desc
->block
.bits
/8);
81 format_desc
->pack_float(dst_row
, dst_stride
, src_row
, src_stride
, w
, h
);
86 util_format_read_4ub(enum pipe_format format
, uint8_t *dst
, unsigned dst_stride
, const void *src
, unsigned src_stride
, unsigned x
, unsigned y
, unsigned w
, unsigned h
)
88 const struct util_format_description
*format_desc
;
89 const uint8_t *src_row
;
92 format_desc
= util_format_description(format
);
94 assert(x
% format_desc
->block
.width
== 0);
95 assert(y
% format_desc
->block
.height
== 0);
97 src_row
= (const uint8_t *)src
+ y
*src_stride
+ x
*(format_desc
->block
.bits
/8);
100 format_desc
->unpack_8unorm(dst_row
, dst_stride
, src_row
, src_stride
, w
, h
);
105 util_format_write_4ub(enum pipe_format format
, const uint8_t *src
, unsigned src_stride
, void *dst
, unsigned dst_stride
, unsigned x
, unsigned y
, unsigned w
, unsigned h
)
107 const struct util_format_description
*format_desc
;
109 const uint8_t *src_row
;
111 format_desc
= util_format_description(format
);
113 assert(x
% format_desc
->block
.width
== 0);
114 assert(y
% format_desc
->block
.height
== 0);
116 dst_row
= (uint8_t *)dst
+ y
*dst_stride
+ x
*(format_desc
->block
.bits
/8);
119 format_desc
->pack_8unorm(dst_row
, dst_stride
, src_row
, src_stride
, w
, h
);
123 static INLINE boolean
124 util_format_fits_8unorm(const struct util_format_description
*format_desc
)
128 switch (format_desc
->layout
) {
130 case UTIL_FORMAT_LAYOUT_S3TC
:
131 case UTIL_FORMAT_LAYOUT_RGTC
:
133 * These are straight forward.
138 case UTIL_FORMAT_LAYOUT_PLAIN
:
140 * For these we can find a generic rule.
143 for (chan
= 0; chan
< format_desc
->nr_channels
; ++chan
) {
144 switch (format_desc
->channel
[chan
].type
) {
145 case UTIL_FORMAT_TYPE_VOID
:
147 case UTIL_FORMAT_TYPE_UNSIGNED
:
148 if (!format_desc
->channel
[chan
].normalized
||
149 format_desc
->channel
[chan
].size
> 8) {
160 * Handle all others on a case by case basis.
163 switch (format_desc
->format
) {
164 case PIPE_FORMAT_R1_UNORM
:
165 case PIPE_FORMAT_UYVY
:
166 case PIPE_FORMAT_YUYV
:
167 case PIPE_FORMAT_R8G8_B8G8_UNORM
:
168 case PIPE_FORMAT_G8R8_G8B8_UNORM
:
179 util_format_translate(enum pipe_format dst_format
,
180 void *dst
, unsigned dst_stride
,
181 unsigned dst_x
, unsigned dst_y
,
182 enum pipe_format src_format
,
183 const void *src
, unsigned src_stride
,
184 unsigned src_x
, unsigned src_y
,
185 unsigned width
, unsigned height
)
187 const struct util_format_description
*dst_format_desc
;
188 const struct util_format_description
*src_format_desc
;
190 const uint8_t *src_row
;
195 if (dst_format
== src_format
) {
200 util_copy_rect(dst
, dst_format
, dst_stride
, dst_x
, dst_y
,
201 width
, height
, src
, (int)src_stride
,
206 dst_format_desc
= util_format_description(dst_format
);
207 src_format_desc
= util_format_description(src_format
);
209 assert(dst_x
% dst_format_desc
->block
.width
== 0);
210 assert(dst_y
% dst_format_desc
->block
.height
== 0);
211 assert(src_x
% src_format_desc
->block
.width
== 0);
212 assert(src_y
% src_format_desc
->block
.height
== 0);
214 dst_row
= (uint8_t *)dst
+ dst_y
*dst_stride
+ dst_x
*(dst_format_desc
->block
.bits
/8);
215 src_row
= (const uint8_t *)src
+ src_y
*src_stride
+ src_x
*(src_format_desc
->block
.bits
/8);
218 * This works because all pixel formats have pixel blocks with power of two
222 y_step
= MAX2(dst_format_desc
->block
.height
, src_format_desc
->block
.height
);
223 assert(y_step
% dst_format_desc
->block
.height
== 0);
224 assert(y_step
% src_format_desc
->block
.height
== 0);
226 dst_step
= y_step
/ dst_format_desc
->block
.height
* dst_stride
;
227 src_step
= y_step
/ src_format_desc
->block
.height
* src_stride
;
230 * TODO: double formats will loose precision
231 * TODO: Add a special case for formats that are mere swizzles of each other
234 if (util_format_fits_8unorm(src_format_desc
) ||
235 util_format_fits_8unorm(dst_format_desc
)) {
239 tmp_stride
= width
* 4 * sizeof *tmp_row
;
240 tmp_row
= MALLOC(y_step
* tmp_stride
);
244 while (height
>= y_step
) {
245 src_format_desc
->unpack_8unorm(tmp_row
, tmp_stride
, src_row
, src_stride
, width
, y_step
);
246 dst_format_desc
->pack_8unorm(dst_row
, dst_stride
, tmp_row
, tmp_stride
, width
, y_step
);
254 src_format_desc
->unpack_8unorm(tmp_row
, tmp_stride
, src_row
, src_stride
, width
, height
);
255 dst_format_desc
->pack_8unorm(dst_row
, dst_stride
, tmp_row
, tmp_stride
, width
, height
);
264 tmp_stride
= width
* 4 * sizeof *tmp_row
;
265 tmp_row
= MALLOC(y_step
* tmp_stride
);
269 while (height
>= y_step
) {
270 src_format_desc
->unpack_float(tmp_row
, tmp_stride
, src_row
, src_stride
, width
, y_step
);
271 dst_format_desc
->pack_float(dst_row
, dst_stride
, tmp_row
, tmp_stride
, width
, y_step
);
279 src_format_desc
->unpack_float(tmp_row
, tmp_stride
, src_row
, src_stride
, width
, height
);
280 dst_format_desc
->pack_float(dst_row
, dst_stride
, tmp_row
, tmp_stride
, width
, height
);