util: Split the pack/unpack functions out of the format desc.
[mesa.git] / src / util / format / u_format.c
1 /**************************************************************************
2 *
3 * Copyright 2010 VMware, Inc.
4 * All Rights Reserved.
5 *
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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
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.
25 *
26 **************************************************************************/
27
28 /**
29 * @file
30 * Pixel format accessor functions.
31 *
32 * @author Jose Fonseca <jfonseca@vmware.com>
33 */
34
35 #include "util/format/u_format.h"
36 #include "util/format/u_format_s3tc.h"
37 #include "util/u_math.h"
38
39 #include "pipe/p_defines.h"
40 #include "pipe/p_screen.h"
41
42
43 /**
44 * Copy 2D rect from one place to another.
45 * Position and sizes are in pixels.
46 * src_stride may be negative to do vertical flip of pixels from source.
47 */
48 void
49 util_copy_rect(ubyte * dst,
50 enum pipe_format format,
51 unsigned dst_stride,
52 unsigned dst_x,
53 unsigned dst_y,
54 unsigned width,
55 unsigned height,
56 const ubyte * src,
57 int src_stride,
58 unsigned src_x,
59 unsigned src_y)
60 {
61 unsigned i;
62 int src_stride_pos = src_stride < 0 ? -src_stride : src_stride;
63 int blocksize = util_format_get_blocksize(format);
64 int blockwidth = util_format_get_blockwidth(format);
65 int blockheight = util_format_get_blockheight(format);
66
67 assert(blocksize > 0);
68 assert(blockwidth > 0);
69 assert(blockheight > 0);
70
71 dst_x /= blockwidth;
72 dst_y /= blockheight;
73 width = (width + blockwidth - 1)/blockwidth;
74 height = (height + blockheight - 1)/blockheight;
75 src_x /= blockwidth;
76 src_y /= blockheight;
77
78 dst += dst_x * blocksize;
79 src += src_x * blocksize;
80 dst += dst_y * dst_stride;
81 src += src_y * src_stride_pos;
82 width *= blocksize;
83
84 if (width == dst_stride && width == (unsigned)src_stride)
85 memcpy(dst, src, height * width);
86 else {
87 for (i = 0; i < height; i++) {
88 memcpy(dst, src, width);
89 dst += dst_stride;
90 src += src_stride;
91 }
92 }
93 }
94
95
96 boolean
97 util_format_is_float(enum pipe_format format)
98 {
99 const struct util_format_description *desc = util_format_description(format);
100 int i;
101
102 assert(desc);
103 if (!desc) {
104 return FALSE;
105 }
106
107 i = util_format_get_first_non_void_channel(format);
108 if (i < 0) {
109 return FALSE;
110 }
111
112 return desc->channel[i].type == UTIL_FORMAT_TYPE_FLOAT ? TRUE : FALSE;
113 }
114
115
116 /** Test if the format contains RGB, but not alpha */
117 boolean
118 util_format_has_alpha(enum pipe_format format)
119 {
120 const struct util_format_description *desc =
121 util_format_description(format);
122
123 return (desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
124 desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
125 desc->swizzle[3] != PIPE_SWIZZLE_1;
126 }
127
128
129 boolean
130 util_format_is_luminance(enum pipe_format format)
131 {
132 const struct util_format_description *desc =
133 util_format_description(format);
134
135 if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
136 desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
137 desc->swizzle[0] == PIPE_SWIZZLE_X &&
138 desc->swizzle[1] == PIPE_SWIZZLE_X &&
139 desc->swizzle[2] == PIPE_SWIZZLE_X &&
140 desc->swizzle[3] == PIPE_SWIZZLE_1) {
141 return TRUE;
142 }
143 return FALSE;
144 }
145
146 boolean
147 util_format_is_alpha(enum pipe_format format)
148 {
149 const struct util_format_description *desc =
150 util_format_description(format);
151
152 if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
153 desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
154 desc->swizzle[0] == PIPE_SWIZZLE_0 &&
155 desc->swizzle[1] == PIPE_SWIZZLE_0 &&
156 desc->swizzle[2] == PIPE_SWIZZLE_0 &&
157 desc->swizzle[3] == PIPE_SWIZZLE_X) {
158 return TRUE;
159 }
160 return FALSE;
161 }
162
163 boolean
164 util_format_is_pure_integer(enum pipe_format format)
165 {
166 const struct util_format_description *desc = util_format_description(format);
167 int i;
168
169 /* Find the first non-void channel. */
170 i = util_format_get_first_non_void_channel(format);
171 if (i == -1)
172 return FALSE;
173
174 return desc->channel[i].pure_integer ? TRUE : FALSE;
175 }
176
177 boolean
178 util_format_is_pure_sint(enum pipe_format format)
179 {
180 const struct util_format_description *desc = util_format_description(format);
181 int i;
182
183 i = util_format_get_first_non_void_channel(format);
184 if (i == -1)
185 return FALSE;
186
187 return (desc->channel[i].type == UTIL_FORMAT_TYPE_SIGNED && desc->channel[i].pure_integer) ? TRUE : FALSE;
188 }
189
190 boolean
191 util_format_is_pure_uint(enum pipe_format format)
192 {
193 const struct util_format_description *desc = util_format_description(format);
194 int i;
195
196 i = util_format_get_first_non_void_channel(format);
197 if (i == -1)
198 return FALSE;
199
200 return (desc->channel[i].type == UTIL_FORMAT_TYPE_UNSIGNED && desc->channel[i].pure_integer) ? TRUE : FALSE;
201 }
202
203 /**
204 * Returns true if the format contains normalized signed channels.
205 */
206 boolean
207 util_format_is_snorm(enum pipe_format format)
208 {
209 const struct util_format_description *desc = util_format_description(format);
210
211 return desc->is_snorm;
212 }
213
214 /**
215 * Returns true if the format contains normalized unsigned channels.
216 */
217 boolean
218 util_format_is_unorm(enum pipe_format format)
219 {
220 const struct util_format_description *desc = util_format_description(format);
221
222 return desc->is_unorm;
223 }
224
225 boolean
226 util_format_is_snorm8(enum pipe_format format)
227 {
228 const struct util_format_description *desc = util_format_description(format);
229 int i;
230
231 if (desc->is_mixed)
232 return FALSE;
233
234 i = util_format_get_first_non_void_channel(format);
235 if (i == -1)
236 return FALSE;
237
238 return desc->channel[i].type == UTIL_FORMAT_TYPE_SIGNED &&
239 !desc->channel[i].pure_integer &&
240 desc->channel[i].normalized &&
241 desc->channel[i].size == 8;
242 }
243
244 boolean
245 util_format_is_luminance_alpha(enum pipe_format format)
246 {
247 const struct util_format_description *desc =
248 util_format_description(format);
249
250 if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
251 desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
252 desc->swizzle[0] == PIPE_SWIZZLE_X &&
253 desc->swizzle[1] == PIPE_SWIZZLE_X &&
254 desc->swizzle[2] == PIPE_SWIZZLE_X &&
255 desc->swizzle[3] == PIPE_SWIZZLE_Y) {
256 return TRUE;
257 }
258 return FALSE;
259 }
260
261
262 boolean
263 util_format_is_intensity(enum pipe_format format)
264 {
265 const struct util_format_description *desc =
266 util_format_description(format);
267
268 if ((desc->colorspace == UTIL_FORMAT_COLORSPACE_RGB ||
269 desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) &&
270 desc->swizzle[0] == PIPE_SWIZZLE_X &&
271 desc->swizzle[1] == PIPE_SWIZZLE_X &&
272 desc->swizzle[2] == PIPE_SWIZZLE_X &&
273 desc->swizzle[3] == PIPE_SWIZZLE_X) {
274 return TRUE;
275 }
276 return FALSE;
277 }
278
279 boolean
280 util_format_is_subsampled_422(enum pipe_format format)
281 {
282 const struct util_format_description *desc =
283 util_format_description(format);
284
285 return desc->layout == UTIL_FORMAT_LAYOUT_SUBSAMPLED &&
286 desc->block.width == 2 &&
287 desc->block.height == 1 &&
288 desc->block.bits == 32;
289 }
290
291 /**
292 * Calculates the MRD for the depth format. MRD is used in depth bias
293 * for UNORM and unbound depth buffers. When the depth buffer is floating
294 * point, the depth bias calculation does not use the MRD. However, the
295 * default MRD will be 1.0 / ((1 << 24) - 1).
296 */
297 double
298 util_get_depth_format_mrd(const struct util_format_description *desc)
299 {
300 /*
301 * Depth buffer formats without a depth component OR scenarios
302 * without a bound depth buffer default to D24.
303 */
304 double mrd = 1.0 / ((1 << 24) - 1);
305 unsigned depth_channel;
306
307 assert(desc);
308
309 /*
310 * Some depth formats do not store the depth component in the first
311 * channel, detect the format and adjust the depth channel. Get the
312 * swizzled depth component channel.
313 */
314 depth_channel = desc->swizzle[0];
315
316 if (desc->channel[depth_channel].type == UTIL_FORMAT_TYPE_UNSIGNED &&
317 desc->channel[depth_channel].normalized) {
318 int depth_bits;
319
320 depth_bits = desc->channel[depth_channel].size;
321 mrd = 1.0 / ((1ULL << depth_bits) - 1);
322 }
323
324 return mrd;
325 }
326
327
328 void
329 util_format_read_4(enum pipe_format format,
330 void *dst, unsigned dst_stride,
331 const void *src, unsigned src_stride,
332 unsigned x, unsigned y, unsigned w, unsigned h)
333 {
334 const struct util_format_description *format_desc;
335 const struct util_format_unpack_description *unpack =
336 util_format_unpack_description(format);
337 const uint8_t *src_row;
338
339 format_desc = util_format_description(format);
340
341 assert(x % format_desc->block.width == 0);
342 assert(y % format_desc->block.height == 0);
343
344 src_row = (const uint8_t *)src + y*src_stride + x*(format_desc->block.bits/8);
345
346 unpack->unpack_rgba(dst, dst_stride, src_row, src_stride, w, h);
347 }
348
349
350 void
351 util_format_write_4(enum pipe_format format,
352 const void *src, unsigned src_stride,
353 void *dst, unsigned dst_stride,
354 unsigned x, unsigned y, unsigned w, unsigned h)
355 {
356 const struct util_format_description *format_desc;
357 const struct util_format_pack_description *pack =
358 util_format_pack_description(format);
359 uint8_t *dst_row;
360
361 format_desc = util_format_description(format);
362
363 assert(x % format_desc->block.width == 0);
364 assert(y % format_desc->block.height == 0);
365
366 dst_row = (uint8_t *)dst + y*dst_stride + x*(format_desc->block.bits/8);
367
368 if (util_format_is_pure_uint(format))
369 pack->pack_rgba_uint(dst_row, dst_stride, src, src_stride, w, h);
370 else if (util_format_is_pure_sint(format))
371 pack->pack_rgba_sint(dst_row, dst_stride, src, src_stride, w, h);
372 else
373 pack->pack_rgba_float(dst_row, dst_stride, src, src_stride, w, h);
374 }
375
376
377 void
378 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)
379 {
380 const struct util_format_description *format_desc;
381 const struct util_format_unpack_description *unpack =
382 util_format_unpack_description(format);
383 const uint8_t *src_row;
384 uint8_t *dst_row;
385
386 format_desc = util_format_description(format);
387
388 assert(x % format_desc->block.width == 0);
389 assert(y % format_desc->block.height == 0);
390
391 src_row = (const uint8_t *)src + y*src_stride + x*(format_desc->block.bits/8);
392 dst_row = dst;
393
394 unpack->unpack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, w, h);
395 }
396
397
398 void
399 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)
400 {
401 const struct util_format_description *format_desc;
402 const struct util_format_pack_description *pack =
403 util_format_pack_description(format);
404 uint8_t *dst_row;
405 const uint8_t *src_row;
406
407 format_desc = util_format_description(format);
408
409 assert(x % format_desc->block.width == 0);
410 assert(y % format_desc->block.height == 0);
411
412 dst_row = (uint8_t *)dst + y*dst_stride + x*(format_desc->block.bits/8);
413 src_row = src;
414
415 pack->pack_rgba_8unorm(dst_row, dst_stride, src_row, src_stride, w, h);
416 }
417
418 /**
419 * Check if we can safely memcopy from the source format to the dest format.
420 * This basically covers the cases of a "used" channel copied to a typeless
421 * channel, plus some 1-channel cases.
422 * Examples of compatible copy formats include:
423 * b8g8r8a8_unorm -> b8g8r8x8_unorm
424 * a8r8g8b8_unorm -> x8r8g8b8_unorm
425 * b5g5r5a1_unorm -> b5g5r5x1_unorm
426 * b4g4r4a4_unorm -> b4g4r4x4_unorm
427 * l8_unorm -> r8_unorm
428 * i8_unorm -> l8_unorm
429 * i8_unorm -> a8_unorm
430 * i8_unorm -> r8_unorm
431 * l16_unorm -> r16_unorm
432 * z24_unorm_s8_uint -> z24x8_unorm
433 * s8_uint_z24_unorm -> x8z24_unorm
434 * r8g8b8a8_unorm -> r8g8b8x8_unorm
435 * a8b8g8r8_srgb -> x8b8g8r8_srgb
436 * b8g8r8a8_srgb -> b8g8r8x8_srgb
437 * a8r8g8b8_srgb -> x8r8g8b8_srgb
438 * a8b8g8r8_unorm -> x8b8g8r8_unorm
439 * r10g10b10a2_uscaled -> r10g10b10x2_uscaled
440 * r10sg10sb10sa2u_norm -> r10g10b10x2_snorm
441 */
442 boolean
443 util_is_format_compatible(const struct util_format_description *src_desc,
444 const struct util_format_description *dst_desc)
445 {
446 unsigned chan;
447
448 if (src_desc->format == dst_desc->format) {
449 return TRUE;
450 }
451
452 if (src_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN ||
453 dst_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN) {
454 return FALSE;
455 }
456
457 if (src_desc->block.bits != dst_desc->block.bits ||
458 src_desc->nr_channels != dst_desc->nr_channels ||
459 src_desc->colorspace != dst_desc->colorspace) {
460 return FALSE;
461 }
462
463 for (chan = 0; chan < 4; ++chan) {
464 if (src_desc->channel[chan].size !=
465 dst_desc->channel[chan].size) {
466 return FALSE;
467 }
468 }
469
470 for (chan = 0; chan < 4; ++chan) {
471 enum pipe_swizzle swizzle = dst_desc->swizzle[chan];
472
473 if (swizzle < 4) {
474 if (src_desc->swizzle[chan] != swizzle) {
475 return FALSE;
476 }
477 if ((src_desc->channel[swizzle].type !=
478 dst_desc->channel[swizzle].type) ||
479 (src_desc->channel[swizzle].normalized !=
480 dst_desc->channel[swizzle].normalized)) {
481 return FALSE;
482 }
483 }
484 }
485
486 return TRUE;
487 }
488
489
490 boolean
491 util_format_fits_8unorm(const struct util_format_description *format_desc)
492 {
493 unsigned chan;
494
495 /*
496 * After linearized sRGB values require more than 8bits.
497 */
498
499 if (format_desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB) {
500 return FALSE;
501 }
502
503 switch (format_desc->layout) {
504
505 case UTIL_FORMAT_LAYOUT_S3TC:
506 /*
507 * These are straight forward.
508 */
509 return TRUE;
510 case UTIL_FORMAT_LAYOUT_RGTC:
511 if (format_desc->format == PIPE_FORMAT_RGTC1_SNORM ||
512 format_desc->format == PIPE_FORMAT_RGTC2_SNORM ||
513 format_desc->format == PIPE_FORMAT_LATC1_SNORM ||
514 format_desc->format == PIPE_FORMAT_LATC2_SNORM)
515 return FALSE;
516 return TRUE;
517 case UTIL_FORMAT_LAYOUT_BPTC:
518 if (format_desc->format == PIPE_FORMAT_BPTC_RGBA_UNORM)
519 return TRUE;
520 return FALSE;
521
522 case UTIL_FORMAT_LAYOUT_ETC:
523 if (format_desc->format == PIPE_FORMAT_ETC1_RGB8)
524 return TRUE;
525 return FALSE;
526
527 case UTIL_FORMAT_LAYOUT_PLAIN:
528 /*
529 * For these we can find a generic rule.
530 */
531
532 for (chan = 0; chan < format_desc->nr_channels; ++chan) {
533 switch (format_desc->channel[chan].type) {
534 case UTIL_FORMAT_TYPE_VOID:
535 break;
536 case UTIL_FORMAT_TYPE_UNSIGNED:
537 if (!format_desc->channel[chan].normalized ||
538 format_desc->channel[chan].size > 8) {
539 return FALSE;
540 }
541 break;
542 default:
543 return FALSE;
544 }
545 }
546 return TRUE;
547
548 default:
549 /*
550 * Handle all others on a case by case basis.
551 */
552
553 switch (format_desc->format) {
554 case PIPE_FORMAT_R1_UNORM:
555 case PIPE_FORMAT_UYVY:
556 case PIPE_FORMAT_YUYV:
557 case PIPE_FORMAT_R8G8_B8G8_UNORM:
558 case PIPE_FORMAT_G8R8_G8B8_UNORM:
559 return TRUE;
560
561 default:
562 return FALSE;
563 }
564 }
565 }
566
567
568 boolean
569 util_format_translate(enum pipe_format dst_format,
570 void *dst, unsigned dst_stride,
571 unsigned dst_x, unsigned dst_y,
572 enum pipe_format src_format,
573 const void *src, unsigned src_stride,
574 unsigned src_x, unsigned src_y,
575 unsigned width, unsigned height)
576 {
577 const struct util_format_description *dst_format_desc;
578 const struct util_format_description *src_format_desc;
579 const struct util_format_pack_description *pack =
580 util_format_pack_description(dst_format);
581 const struct util_format_unpack_description *unpack =
582 util_format_unpack_description(src_format);
583 uint8_t *dst_row;
584 const uint8_t *src_row;
585 unsigned x_step, y_step;
586 unsigned dst_step;
587 unsigned src_step;
588
589 dst_format_desc = util_format_description(dst_format);
590 src_format_desc = util_format_description(src_format);
591
592 if (util_is_format_compatible(src_format_desc, dst_format_desc)) {
593 /*
594 * Trivial case.
595 */
596
597 util_copy_rect(dst, dst_format, dst_stride, dst_x, dst_y,
598 width, height, src, (int)src_stride,
599 src_x, src_y);
600 return TRUE;
601 }
602
603 assert(dst_x % dst_format_desc->block.width == 0);
604 assert(dst_y % dst_format_desc->block.height == 0);
605 assert(src_x % src_format_desc->block.width == 0);
606 assert(src_y % src_format_desc->block.height == 0);
607
608 dst_row = (uint8_t *)dst + dst_y*dst_stride + dst_x*(dst_format_desc->block.bits/8);
609 src_row = (const uint8_t *)src + src_y*src_stride + src_x*(src_format_desc->block.bits/8);
610
611 /*
612 * This works because all pixel formats have pixel blocks with power of two
613 * sizes.
614 */
615
616 y_step = MAX2(dst_format_desc->block.height, src_format_desc->block.height);
617 x_step = MAX2(dst_format_desc->block.width, src_format_desc->block.width);
618 assert(y_step % dst_format_desc->block.height == 0);
619 assert(y_step % src_format_desc->block.height == 0);
620
621 dst_step = y_step / dst_format_desc->block.height * dst_stride;
622 src_step = y_step / src_format_desc->block.height * src_stride;
623
624 /*
625 * TODO: double formats will loose precision
626 * TODO: Add a special case for formats that are mere swizzles of each other
627 */
628
629 if (src_format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS ||
630 dst_format_desc->colorspace == UTIL_FORMAT_COLORSPACE_ZS) {
631 float *tmp_z = NULL;
632 uint8_t *tmp_s = NULL;
633
634 assert(x_step == 1);
635 assert(y_step == 1);
636
637 if (unpack->unpack_z_float && pack->pack_z_float) {
638 tmp_z = malloc(width * sizeof *tmp_z);
639 }
640
641 if (unpack->unpack_s_8uint && pack->pack_s_8uint) {
642 tmp_s = malloc(width * sizeof *tmp_s);
643 }
644
645 while (height--) {
646 if (tmp_z) {
647 util_format_unpack_z_float(src_format, tmp_z, src_row, width);
648 util_format_pack_z_float(dst_format, dst_row, tmp_z, width);
649 }
650
651 if (tmp_s) {
652 util_format_unpack_s_8uint(src_format, tmp_s, src_row, width);
653 util_format_pack_s_8uint(dst_format, dst_row, tmp_s, width);
654 }
655
656 dst_row += dst_step;
657 src_row += src_step;
658 }
659
660 free(tmp_s);
661
662 free(tmp_z);
663
664 return TRUE;
665 }
666
667 if (util_format_fits_8unorm(src_format_desc) ||
668 util_format_fits_8unorm(dst_format_desc)) {
669 unsigned tmp_stride;
670 uint8_t *tmp_row;
671
672 if (!unpack->unpack_rgba_8unorm ||
673 !pack->pack_rgba_8unorm) {
674 return FALSE;
675 }
676
677 tmp_stride = MAX2(width, x_step) * 4 * sizeof *tmp_row;
678 tmp_row = malloc(y_step * tmp_stride);
679 if (!tmp_row)
680 return FALSE;
681
682 while (height >= y_step) {
683 unpack->unpack_rgba_8unorm(tmp_row, tmp_stride, src_row, src_stride, width, y_step);
684 pack->pack_rgba_8unorm(dst_row, dst_stride, tmp_row, tmp_stride, width, y_step);
685
686 dst_row += dst_step;
687 src_row += src_step;
688 height -= y_step;
689 }
690
691 if (height) {
692 unpack->unpack_rgba_8unorm(tmp_row, tmp_stride, src_row, src_stride, width, height);
693 pack->pack_rgba_8unorm(dst_row, dst_stride, tmp_row, tmp_stride, width, height);
694 }
695
696 free(tmp_row);
697 }
698 else if (util_format_is_pure_sint(src_format) ||
699 util_format_is_pure_sint(dst_format)) {
700 unsigned tmp_stride;
701 int *tmp_row;
702
703 if (util_format_is_pure_sint(src_format) !=
704 util_format_is_pure_sint(dst_format)) {
705 return FALSE;
706 }
707
708 tmp_stride = MAX2(width, x_step) * 4 * sizeof *tmp_row;
709 tmp_row = malloc(y_step * tmp_stride);
710 if (!tmp_row)
711 return FALSE;
712
713 while (height >= y_step) {
714 unpack->unpack_rgba(tmp_row, tmp_stride, src_row, src_stride, width, y_step);
715 pack->pack_rgba_sint(dst_row, dst_stride, tmp_row, tmp_stride, width, y_step);
716
717 dst_row += dst_step;
718 src_row += src_step;
719 height -= y_step;
720 }
721
722 if (height) {
723 unpack->unpack_rgba(tmp_row, tmp_stride, src_row, src_stride, width, height);
724 pack->pack_rgba_sint(dst_row, dst_stride, tmp_row, tmp_stride, width, height);
725 }
726
727 free(tmp_row);
728 }
729 else if (util_format_is_pure_uint(src_format) ||
730 util_format_is_pure_uint(dst_format)) {
731 unsigned tmp_stride;
732 unsigned int *tmp_row;
733
734 if (!unpack->unpack_rgba ||
735 !pack->pack_rgba_uint) {
736 return FALSE;
737 }
738
739 tmp_stride = MAX2(width, x_step) * 4 * sizeof *tmp_row;
740 tmp_row = malloc(y_step * tmp_stride);
741 if (!tmp_row)
742 return FALSE;
743
744 while (height >= y_step) {
745 unpack->unpack_rgba(tmp_row, tmp_stride, src_row, src_stride, width, y_step);
746 pack->pack_rgba_uint(dst_row, dst_stride, tmp_row, tmp_stride, width, y_step);
747
748 dst_row += dst_step;
749 src_row += src_step;
750 height -= y_step;
751 }
752
753 if (height) {
754 unpack->unpack_rgba(tmp_row, tmp_stride, src_row, src_stride, width, height);
755 pack->pack_rgba_uint(dst_row, dst_stride, tmp_row, tmp_stride, width, height);
756 }
757
758 free(tmp_row);
759 }
760 else {
761 unsigned tmp_stride;
762 float *tmp_row;
763
764 if (!unpack->unpack_rgba ||
765 !pack->pack_rgba_float) {
766 return FALSE;
767 }
768
769 tmp_stride = MAX2(width, x_step) * 4 * sizeof *tmp_row;
770 tmp_row = malloc(y_step * tmp_stride);
771 if (!tmp_row)
772 return FALSE;
773
774 while (height >= y_step) {
775 unpack->unpack_rgba(tmp_row, tmp_stride, src_row, src_stride, width, y_step);
776 pack->pack_rgba_float(dst_row, dst_stride, tmp_row, tmp_stride, width, y_step);
777
778 dst_row += dst_step;
779 src_row += src_step;
780 height -= y_step;
781 }
782
783 if (height) {
784 unpack->unpack_rgba(tmp_row, tmp_stride, src_row, src_stride, width, height);
785 pack->pack_rgba_float(dst_row, dst_stride, tmp_row, tmp_stride, width, height);
786 }
787
788 free(tmp_row);
789 }
790 return TRUE;
791 }
792
793 boolean
794 util_format_translate_3d(enum pipe_format dst_format,
795 void *dst, unsigned dst_stride,
796 unsigned dst_slice_stride,
797 unsigned dst_x, unsigned dst_y,
798 unsigned dst_z,
799 enum pipe_format src_format,
800 const void *src, unsigned src_stride,
801 unsigned src_slice_stride,
802 unsigned src_x, unsigned src_y,
803 unsigned src_z, unsigned width,
804 unsigned height, unsigned depth)
805 {
806 uint8_t *dst_layer;
807 const uint8_t *src_layer;
808 unsigned z;
809 dst_layer = dst;
810 src_layer = src;
811 dst_layer += dst_z * dst_slice_stride;
812 src_layer += src_z * src_slice_stride;
813 for (z = 0; z < depth; ++z) {
814 if (!util_format_translate(dst_format, dst_layer, dst_stride,
815 dst_x, dst_y,
816 src_format, src_layer, src_stride,
817 src_x, src_y,
818 width, height))
819 return FALSE;
820
821 dst_layer += dst_slice_stride;
822 src_layer += src_slice_stride;
823 }
824 return TRUE;
825 }
826
827 void util_format_compose_swizzles(const unsigned char swz1[4],
828 const unsigned char swz2[4],
829 unsigned char dst[4])
830 {
831 unsigned i;
832
833 for (i = 0; i < 4; i++) {
834 dst[i] = swz2[i] <= PIPE_SWIZZLE_W ?
835 swz1[swz2[i]] : swz2[i];
836 }
837 }
838
839 void util_format_apply_color_swizzle(union pipe_color_union *dst,
840 const union pipe_color_union *src,
841 const unsigned char swz[4],
842 const boolean is_integer)
843 {
844 unsigned c;
845
846 if (is_integer) {
847 for (c = 0; c < 4; ++c) {
848 switch (swz[c]) {
849 case PIPE_SWIZZLE_X: dst->ui[c] = src->ui[0]; break;
850 case PIPE_SWIZZLE_Y: dst->ui[c] = src->ui[1]; break;
851 case PIPE_SWIZZLE_Z: dst->ui[c] = src->ui[2]; break;
852 case PIPE_SWIZZLE_W: dst->ui[c] = src->ui[3]; break;
853 default:
854 dst->ui[c] = (swz[c] == PIPE_SWIZZLE_1) ? 1 : 0;
855 break;
856 }
857 }
858 } else {
859 for (c = 0; c < 4; ++c) {
860 switch (swz[c]) {
861 case PIPE_SWIZZLE_X: dst->f[c] = src->f[0]; break;
862 case PIPE_SWIZZLE_Y: dst->f[c] = src->f[1]; break;
863 case PIPE_SWIZZLE_Z: dst->f[c] = src->f[2]; break;
864 case PIPE_SWIZZLE_W: dst->f[c] = src->f[3]; break;
865 default:
866 dst->f[c] = (swz[c] == PIPE_SWIZZLE_1) ? 1.0f : 0.0f;
867 break;
868 }
869 }
870 }
871 }
872
873 void pipe_swizzle_4f(float *dst, const float *src,
874 const unsigned char swz[4])
875 {
876 unsigned i;
877
878 for (i = 0; i < 4; i++) {
879 if (swz[i] <= PIPE_SWIZZLE_W)
880 dst[i] = src[swz[i]];
881 else if (swz[i] == PIPE_SWIZZLE_0)
882 dst[i] = 0;
883 else if (swz[i] == PIPE_SWIZZLE_1)
884 dst[i] = 1;
885 }
886 }
887
888 void util_format_unswizzle_4f(float *dst, const float *src,
889 const unsigned char swz[4])
890 {
891 unsigned i;
892
893 for (i = 0; i < 4; i++) {
894 switch (swz[i]) {
895 case PIPE_SWIZZLE_X:
896 dst[0] = src[i];
897 break;
898 case PIPE_SWIZZLE_Y:
899 dst[1] = src[i];
900 break;
901 case PIPE_SWIZZLE_Z:
902 dst[2] = src[i];
903 break;
904 case PIPE_SWIZZLE_W:
905 dst[3] = src[i];
906 break;
907 }
908 }
909 }
910
911 enum pipe_format
912 util_format_snorm8_to_sint8(enum pipe_format format)
913 {
914 switch (format) {
915 case PIPE_FORMAT_R8_SNORM:
916 return PIPE_FORMAT_R8_SINT;
917 case PIPE_FORMAT_R8G8_SNORM:
918 return PIPE_FORMAT_R8G8_SINT;
919 case PIPE_FORMAT_R8G8B8_SNORM:
920 return PIPE_FORMAT_R8G8B8_SINT;
921 case PIPE_FORMAT_R8G8B8A8_SNORM:
922 return PIPE_FORMAT_R8G8B8A8_SINT;
923
924 case PIPE_FORMAT_A8_SNORM:
925 return PIPE_FORMAT_A8_SINT;
926 case PIPE_FORMAT_L8_SNORM:
927 return PIPE_FORMAT_L8_SINT;
928 case PIPE_FORMAT_L8A8_SNORM:
929 return PIPE_FORMAT_L8A8_SINT;
930 case PIPE_FORMAT_I8_SNORM:
931 return PIPE_FORMAT_I8_SINT;
932
933 case PIPE_FORMAT_R8G8B8X8_SNORM:
934 return PIPE_FORMAT_R8G8B8X8_SINT;
935 case PIPE_FORMAT_R8A8_SNORM:
936 return PIPE_FORMAT_R8A8_SINT;
937 case PIPE_FORMAT_G8R8_SNORM:
938 return PIPE_FORMAT_G8R8_SINT;
939 case PIPE_FORMAT_A8B8G8R8_SNORM:
940 return PIPE_FORMAT_A8B8G8R8_SINT;
941 case PIPE_FORMAT_X8B8G8R8_SNORM:
942 return PIPE_FORMAT_X8B8G8R8_SINT;
943
944 default:
945 return format;
946 }
947 }