2 * Copyright (C) 2011 LunarG, Inc.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
25 * \file texcompress_etc.c
26 * GL_OES_compressed_ETC1_RGB8_texture support.
27 * Supported ETC2 texture formats are:
28 * GL_COMPRESSED_RGB8_ETC2
29 * GL_COMPRESSED_SRGB8_ETC2
30 * GL_COMPRESSED_RGBA8_ETC2_EAC
31 * GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
32 * GL_COMPRESSED_R11_EAC
33 * GL_COMPRESSED_RG11_EAC
34 * GL_COMPRESSED_SIGNED_R11_EAC
35 * GL_COMPRESSED_SIGNED_RG11_EAC
36 * MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1
37 * MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1
41 #include "texcompress.h"
42 #include "texcompress_etc.h"
45 #include "format_unpack.h"
46 #include "util/format_srgb.h"
51 uint64_t pixel_indices
[2];
52 const int *modifier_tables
[2];
60 uint8_t base_colors
[3][3];
61 uint8_t paint_colors
[4][3];
62 uint8_t base_codeword
;
67 static const int etc2_distance_table
[8] = {
68 3, 6, 11, 16, 23, 32, 41, 64 };
70 static const int etc2_modifier_tables
[16][8] = {
71 { -3, -6, -9, -15, 2, 5, 8, 14},
72 { -3, -7, -10, -13, 2, 6, 9, 12},
73 { -2, -5, -8, -13, 1, 4, 7, 12},
74 { -2, -4, -6, -13, 1, 3, 5, 12},
75 { -3, -6, -8, -12, 2, 5, 7, 11},
76 { -3, -7, -9, -11, 2, 6, 8, 10},
77 { -4, -7, -8, -11, 3, 6, 7, 10},
78 { -3, -5, -8, -11, 2, 4, 7, 10},
79 { -2, -6, -8, -10, 1, 5, 7, 9},
80 { -2, -5, -8, -10, 1, 4, 7, 9},
81 { -2, -4, -8, -10, 1, 3, 7, 9},
82 { -2, -5, -7, -10, 1, 4, 6, 9},
83 { -3, -4, -7, -10, 2, 3, 6, 9},
84 { -1, -2, -3, -10, 0, 1, 2, 9},
85 { -4, -6, -8, -9, 3, 5, 7, 8},
86 { -3, -5, -7, -9, 2, 4, 6, 8},
89 static const int etc2_modifier_tables_non_opaque
[8][4] = {
100 /* define etc1_parse_block and etc. */
101 #define UINT8_TYPE GLubyte
103 #include "texcompress_etc_tmp.h"
108 _mesa_texstore_etc1_rgb8(TEXSTORE_PARAMS
)
110 /* GL_ETC1_RGB8_OES is only valid in glCompressedTexImage2D */
118 * Decode texture data in format `MESA_FORMAT_ETC1_RGB8` to
119 * `MESA_FORMAT_ABGR8888`.
121 * The size of the source data must be a multiple of the ETC1 block size,
122 * which is 8, even if the texture image's dimensions are not aligned to 4.
123 * From the GL_OES_compressed_ETC1_RGB8_texture spec:
124 * The texture is described as a number of 4x4 pixel blocks. If the
125 * texture (or a particular mip-level) is smaller than 4 pixels in
126 * any dimension (such as a 2x2 or a 8x1 texture), the texture is
127 * found in the upper left part of the block(s), and the rest of the
128 * pixels are not used. For instance, a texture of size 4x2 will be
129 * placed in the upper half of a 4x4 block, and the lower half of the
130 * pixels in the block will not be accessed.
132 * \param src_width in pixels
133 * \param src_height in pixels
134 * \param dst_stride in bytes
137 _mesa_etc1_unpack_rgba8888(uint8_t *dst_row
,
139 const uint8_t *src_row
,
144 etc1_unpack_rgba8888(dst_row
, dst_stride
,
146 src_width
, src_height
);
150 etc2_base_color1_t_mode(const uint8_t *in
, GLuint index
)
152 uint8_t R1a
= 0, x
= 0;
153 /* base col 1 = extend_4to8bits( (R1a << 2) | R1b, G1, B1) */
156 R1a
= (in
[0] >> 3) & 0x3;
157 x
= ((R1a
<< 2) | (in
[0] & 0x3));
160 x
= ((in
[1] >> 4) & 0xf);
169 return ((x
<< 4) | (x
& 0xf));
173 etc2_base_color2_t_mode(const uint8_t *in
, GLuint index
)
176 /*extend 4to8bits(R2, G2, B2)*/
179 x
= ((in
[2] >> 4) & 0xf );
185 x
= ((in
[3] >> 4) & 0xf);
191 return ((x
<< 4) | (x
& 0xf));
195 etc2_base_color1_h_mode(const uint8_t *in
, GLuint index
)
198 /* base col 1 = extend 4to8bits(R1, (G1a << 1) | G1b, (B1a << 3) | B1b) */
201 x
= ((in
[0] >> 3) & 0xf);
204 x
= (((in
[0] & 0x7) << 1) | ((in
[1] >> 4) & 0x1));
208 (((in
[1] & 0x3) << 1) | ((in
[2] >> 7) & 0x1)));
214 return ((x
<< 4) | (x
& 0xf));
218 etc2_base_color2_h_mode(const uint8_t *in
, GLuint index
)
221 /* base col 2 = extend 4to8bits(R2, G2, B2) */
224 x
= ((in
[2] >> 3) & 0xf );
227 x
= (((in
[2] & 0x7) << 1) | ((in
[3] >> 7) & 0x1));
230 x
= ((in
[3] >> 3) & 0xf);
236 return ((x
<< 4) | (x
& 0xf));
240 etc2_base_color_o_planar(const uint8_t *in
, GLuint index
)
245 tmp
= ((in
[0] >> 1) & 0x3f); /* RO */
246 return ((tmp
<< 2) | (tmp
>> 4));
248 tmp
= (((in
[0] & 0x1) << 6) | /* GO1 */
249 ((in
[1] >> 1) & 0x3f)); /* GO2 */
250 return ((tmp
<< 1) | (tmp
>> 6));
252 tmp
= (((in
[1] & 0x1) << 5) | /* BO1 */
253 (in
[2] & 0x18) | /* BO2 */
254 (((in
[2] & 0x3) << 1) | ((in
[3] >> 7) & 0x1))); /* BO3 */
255 return ((tmp
<< 2) | (tmp
>> 4));
263 etc2_base_color_h_planar(const uint8_t *in
, GLuint index
)
268 tmp
= (((in
[3] & 0x7c) >> 1) | /* RH1 */
269 (in
[3] & 0x1)); /* RH2 */
270 return ((tmp
<< 2) | (tmp
>> 4));
272 tmp
= (in
[4] >> 1) & 0x7f; /* GH */
273 return ((tmp
<< 1) | (tmp
>> 6));
275 tmp
= (((in
[4] & 0x1) << 5) |
276 ((in
[5] >> 3) & 0x1f)); /* BH */
277 return ((tmp
<< 2) | (tmp
>> 4));
285 etc2_base_color_v_planar(const uint8_t *in
, GLuint index
)
290 tmp
= (((in
[5] & 0x7) << 0x3) |
291 ((in
[6] >> 5) & 0x7)); /* RV */
292 return ((tmp
<< 2) | (tmp
>> 4));
294 tmp
= (((in
[6] & 0x1f) << 2) |
295 ((in
[7] >> 6) & 0x3)); /* GV */
296 return ((tmp
<< 1) | (tmp
>> 6));
298 tmp
= in
[7] & 0x3f; /* BV */
299 return ((tmp
<< 2) | (tmp
>> 4));
307 etc2_get_pixel_index(const struct etc2_block
*block
, int x
, int y
)
309 int bit
= ((3 - y
) + (3 - x
) * 4) * 3;
310 int idx
= (block
->pixel_indices
[1] >> bit
) & 0x7;
315 etc2_clamp(int color
)
317 /* CLAMP(color, 0, 255) */
318 return (uint8_t) CLAMP(color
, 0, 255);
322 etc2_clamp2(int color
)
324 /* CLAMP(color, 0, 2047) */
325 return (GLushort
) CLAMP(color
, 0, 2047);
329 etc2_clamp3(int color
)
331 /* CLAMP(color, -1023, 1023) */
332 return (GLshort
) CLAMP(color
, -1023, 1023);
336 etc2_rgb8_parse_block(struct etc2_block
*block
,
338 GLboolean punchthrough_alpha
)
341 GLboolean diffbit
= false;
342 static const int lookup
[8] = { 0, 1, 2, 3, -4, -3, -2, -1 };
344 const int R_plus_dR
= (src
[0] >> 3) + lookup
[src
[0] & 0x7];
345 const int G_plus_dG
= (src
[1] >> 3) + lookup
[src
[1] & 0x7];
346 const int B_plus_dB
= (src
[2] >> 3) + lookup
[src
[2] & 0x7];
348 /* Reset the mode flags */
349 block
->is_ind_mode
= false;
350 block
->is_diff_mode
= false;
351 block
->is_t_mode
= false;
352 block
->is_h_mode
= false;
353 block
->is_planar_mode
= false;
355 if (punchthrough_alpha
)
356 block
->opaque
= src
[3] & 0x2;
358 diffbit
= src
[3] & 0x2;
360 if (!diffbit
&& !punchthrough_alpha
) {
361 /* individual mode */
362 block
->is_ind_mode
= true;
364 for (i
= 0; i
< 3; i
++) {
365 /* Texture decode algorithm is same for individual mode in etc1
368 block
->base_colors
[0][i
] = etc1_base_color_ind_hi(src
[i
]);
369 block
->base_colors
[1][i
] = etc1_base_color_ind_lo(src
[i
]);
372 else if (R_plus_dR
< 0 || R_plus_dR
> 31){
374 block
->is_t_mode
= true;
376 for(i
= 0; i
< 3; i
++) {
377 block
->base_colors
[0][i
] = etc2_base_color1_t_mode(src
, i
);
378 block
->base_colors
[1][i
] = etc2_base_color2_t_mode(src
, i
);
382 etc2_distance_table
[(((src
[3] >> 2) & 0x3) << 1) |
385 for (i
= 0; i
< 3; i
++) {
386 block
->paint_colors
[0][i
] = etc2_clamp(block
->base_colors
[0][i
]);
387 block
->paint_colors
[1][i
] = etc2_clamp(block
->base_colors
[1][i
] +
389 block
->paint_colors
[2][i
] = etc2_clamp(block
->base_colors
[1][i
]);
390 block
->paint_colors
[3][i
] = etc2_clamp(block
->base_colors
[1][i
] -
394 else if (G_plus_dG
< 0 || G_plus_dG
> 31){
395 int base_color_1_value
, base_color_2_value
;
398 block
->is_h_mode
= true;
400 for(i
= 0; i
< 3; i
++) {
401 block
->base_colors
[0][i
] = etc2_base_color1_h_mode(src
, i
);
402 block
->base_colors
[1][i
] = etc2_base_color2_h_mode(src
, i
);
405 base_color_1_value
= (block
->base_colors
[0][0] << 16) +
406 (block
->base_colors
[0][1] << 8) +
407 block
->base_colors
[0][2];
408 base_color_2_value
= (block
->base_colors
[1][0] << 16) +
409 (block
->base_colors
[1][1] << 8) +
410 block
->base_colors
[1][2];
413 etc2_distance_table
[(src
[3] & 0x4) |
414 ((src
[3] & 0x1) << 1) |
415 (base_color_1_value
>= base_color_2_value
)];
417 for (i
= 0; i
< 3; i
++) {
418 block
->paint_colors
[0][i
] = etc2_clamp(block
->base_colors
[0][i
] +
420 block
->paint_colors
[1][i
] = etc2_clamp(block
->base_colors
[0][i
] -
422 block
->paint_colors
[2][i
] = etc2_clamp(block
->base_colors
[1][i
] +
424 block
->paint_colors
[3][i
] = etc2_clamp(block
->base_colors
[1][i
] -
428 else if (B_plus_dB
< 0 || B_plus_dB
> 31) {
430 block
->is_planar_mode
= true;
432 /* opaque bit must be set in planar mode */
433 block
->opaque
= true;
435 for (i
= 0; i
< 3; i
++) {
436 block
->base_colors
[0][i
] = etc2_base_color_o_planar(src
, i
);
437 block
->base_colors
[1][i
] = etc2_base_color_h_planar(src
, i
);
438 block
->base_colors
[2][i
] = etc2_base_color_v_planar(src
, i
);
441 else if (diffbit
|| punchthrough_alpha
) {
442 /* differential mode */
443 block
->is_diff_mode
= true;
445 for (i
= 0; i
< 3; i
++) {
446 /* Texture decode algorithm is same for differential mode in etc1
449 block
->base_colors
[0][i
] = etc1_base_color_diff_hi(src
[i
]);
450 block
->base_colors
[1][i
] = etc1_base_color_diff_lo(src
[i
]);
454 if (block
->is_ind_mode
|| block
->is_diff_mode
) {
455 int table1_idx
= (src
[3] >> 5) & 0x7;
456 int table2_idx
= (src
[3] >> 2) & 0x7;
458 /* Use same modifier tables as for etc1 textures if opaque bit is set
459 * or if non punchthrough texture format
461 block
->modifier_tables
[0] = (block
->opaque
|| !punchthrough_alpha
) ?
462 etc1_modifier_tables
[table1_idx
] :
463 etc2_modifier_tables_non_opaque
[table1_idx
];
464 block
->modifier_tables
[1] = (block
->opaque
|| !punchthrough_alpha
) ?
465 etc1_modifier_tables
[table2_idx
] :
466 etc2_modifier_tables_non_opaque
[table2_idx
];
468 block
->flipped
= (src
[3] & 0x1);
471 block
->pixel_indices
[0] =
472 (src
[4] << 24) | (src
[5] << 16) | (src
[6] << 8) | src
[7];
476 etc2_rgb8_fetch_texel(const struct etc2_block
*block
,
477 int x
, int y
, uint8_t *dst
,
478 GLboolean punchthrough_alpha
)
480 const uint8_t *base_color
;
481 int modifier
, bit
, idx
, blk
;
483 /* get pixel index */
485 idx
= ((block
->pixel_indices
[0] >> (15 + bit
)) & 0x2) |
486 ((block
->pixel_indices
[0] >> (bit
)) & 0x1);
488 if (block
->is_ind_mode
|| block
->is_diff_mode
) {
489 /* check for punchthrough_alpha format */
490 if (punchthrough_alpha
) {
491 if (!block
->opaque
&& idx
== 2) {
492 dst
[0] = dst
[1] = dst
[2] = dst
[3] = 0;
499 /* Use pixel index and subblock to get the modifier */
500 blk
= (block
->flipped
) ? (y
>= 2) : (x
>= 2);
501 base_color
= block
->base_colors
[blk
];
502 modifier
= block
->modifier_tables
[blk
][idx
];
504 dst
[0] = etc2_clamp(base_color
[0] + modifier
);
505 dst
[1] = etc2_clamp(base_color
[1] + modifier
);
506 dst
[2] = etc2_clamp(base_color
[2] + modifier
);
508 else if (block
->is_t_mode
|| block
->is_h_mode
) {
509 /* check for punchthrough_alpha format */
510 if (punchthrough_alpha
) {
511 if (!block
->opaque
&& idx
== 2) {
512 dst
[0] = dst
[1] = dst
[2] = dst
[3] = 0;
519 /* Use pixel index to pick one of the paint colors */
520 dst
[0] = block
->paint_colors
[idx
][0];
521 dst
[1] = block
->paint_colors
[idx
][1];
522 dst
[2] = block
->paint_colors
[idx
][2];
524 else if (block
->is_planar_mode
) {
525 /* {R(x, y) = clamp255((x × (RH − RO) + y × (RV − RO) + 4 × RO + 2) >> 2)
526 * {G(x, y) = clamp255((x × (GH − GO) + y × (GV − GO) + 4 × GO + 2) >> 2)
527 * {B(x, y) = clamp255((x × (BH − BO) + y × (BV − BO) + 4 × BO + 2) >> 2)
529 int red
, green
, blue
;
530 red
= (x
* (block
->base_colors
[1][0] - block
->base_colors
[0][0]) +
531 y
* (block
->base_colors
[2][0] - block
->base_colors
[0][0]) +
532 4 * block
->base_colors
[0][0] + 2) >> 2;
534 green
= (x
* (block
->base_colors
[1][1] - block
->base_colors
[0][1]) +
535 y
* (block
->base_colors
[2][1] - block
->base_colors
[0][1]) +
536 4 * block
->base_colors
[0][1] + 2) >> 2;
538 blue
= (x
* (block
->base_colors
[1][2] - block
->base_colors
[0][2]) +
539 y
* (block
->base_colors
[2][2] - block
->base_colors
[0][2]) +
540 4 * block
->base_colors
[0][2] + 2) >> 2;
542 dst
[0] = etc2_clamp(red
);
543 dst
[1] = etc2_clamp(green
);
544 dst
[2] = etc2_clamp(blue
);
546 /* check for punchthrough_alpha format */
547 if (punchthrough_alpha
)
553 etc2_alpha8_fetch_texel(const struct etc2_block
*block
,
554 int x
, int y
, uint8_t *dst
)
556 int modifier
, alpha
, idx
;
557 /* get pixel index */
558 idx
= etc2_get_pixel_index(block
, x
, y
);
559 modifier
= etc2_modifier_tables
[block
->table_index
][idx
];
560 alpha
= block
->base_codeword
+ modifier
* block
->multiplier
;
561 dst
[3] = etc2_clamp(alpha
);
565 etc2_r11_fetch_texel(const struct etc2_block
*block
,
566 int x
, int y
, uint8_t *dst
)
570 /* Get pixel index */
571 idx
= etc2_get_pixel_index(block
, x
, y
);
572 modifier
= etc2_modifier_tables
[block
->table_index
][idx
];
574 if (block
->multiplier
!= 0)
575 /* clamp2(base codeword × 8 + 4 + modifier × multiplier × 8) */
576 color
= etc2_clamp2(((block
->base_codeword
<< 3) | 0x4) +
577 ((modifier
* block
->multiplier
) << 3));
579 color
= etc2_clamp2(((block
->base_codeword
<< 3) | 0x4) + modifier
);
581 /* Extend 11 bits color value to 16 bits. OpenGL ES 3.0 specification
582 * allows extending the color value to any number of bits. But, an
583 * implementation is not allowed to truncate the 11-bit value to less than
586 color
= (color
<< 5) | (color
>> 6);
587 ((GLushort
*)dst
)[0] = color
;
591 etc2_signed_r11_fetch_texel(const struct etc2_block
*block
,
592 int x
, int y
, uint8_t *dst
)
596 GLbyte base_codeword
= (GLbyte
) block
->base_codeword
;
598 if (base_codeword
== -128)
599 base_codeword
= -127;
601 /* Get pixel index */
602 idx
= etc2_get_pixel_index(block
, x
, y
);
603 modifier
= etc2_modifier_tables
[block
->table_index
][idx
];
605 if (block
->multiplier
!= 0)
606 /* clamp3(base codeword × 8 + modifier × multiplier × 8) */
607 color
= etc2_clamp3((base_codeword
<< 3) +
608 ((modifier
* block
->multiplier
) << 3));
610 color
= etc2_clamp3((base_codeword
<< 3) + modifier
);
612 /* Extend 11 bits color value to 16 bits. OpenGL ES 3.0 specification
613 * allows extending the color value to any number of bits. But, an
614 * implementation is not allowed to truncate the 11-bit value to less than
615 * 11 bits. A negative 11-bit value must first be made positive before bit
616 * replication, and then made negative again
619 color
= (color
<< 5) | (color
>> 5);
622 color
= (color
<< 5) | (color
>> 5);
625 ((GLshort
*)dst
)[0] = color
;
629 etc2_alpha8_parse_block(struct etc2_block
*block
, const uint8_t *src
)
631 block
->base_codeword
= src
[0];
632 block
->multiplier
= (src
[1] >> 4) & 0xf;
633 block
->table_index
= src
[1] & 0xf;
634 block
->pixel_indices
[1] = (((uint64_t)src
[2] << 40) |
635 ((uint64_t)src
[3] << 32) |
636 ((uint64_t)src
[4] << 24) |
637 ((uint64_t)src
[5] << 16) |
638 ((uint64_t)src
[6] << 8) |
643 etc2_r11_parse_block(struct etc2_block
*block
, const uint8_t *src
)
645 /* Parsing logic remains same as for etc2_alpha8_parse_block */
646 etc2_alpha8_parse_block(block
, src
);
650 etc2_rgba8_parse_block(struct etc2_block
*block
, const uint8_t *src
)
652 /* RGB component is parsed the same way as for MESA_FORMAT_ETC2_RGB8 */
653 etc2_rgb8_parse_block(block
, src
+ 8,
654 false /* punchthrough_alpha */);
655 /* Parse Alpha component */
656 etc2_alpha8_parse_block(block
, src
);
660 etc2_rgba8_fetch_texel(const struct etc2_block
*block
,
661 int x
, int y
, uint8_t *dst
)
663 etc2_rgb8_fetch_texel(block
, x
, y
, dst
,
664 false /* punchthrough_alpha */);
665 etc2_alpha8_fetch_texel(block
, x
, y
, dst
);
669 etc2_unpack_rgb8(uint8_t *dst_row
,
671 const uint8_t *src_row
,
676 const unsigned bw
= 4, bh
= 4, bs
= 8, comps
= 4;
677 struct etc2_block block
;
680 for (y
= 0; y
< height
; y
+= bh
) {
681 const uint8_t *src
= src_row
;
683 * Destination texture may not be a multiple of four texels in
684 * height. Compute a safe height to avoid writing outside the texture.
686 const unsigned h
= MIN2(bh
, height
- y
);
688 for (x
= 0; x
< width
; x
+= bw
) {
690 * Destination texture may not be a multiple of four texels in
691 * width. Compute a safe width to avoid writing outside the texture.
693 const unsigned w
= MIN2(bw
, width
- x
);
695 etc2_rgb8_parse_block(&block
, src
,
696 false /* punchthrough_alpha */);
698 for (j
= 0; j
< h
; j
++) {
699 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+ x
* comps
;
700 for (i
= 0; i
< w
; i
++) {
701 etc2_rgb8_fetch_texel(&block
, i
, j
, dst
,
702 false /* punchthrough_alpha */);
711 src_row
+= src_stride
;
716 etc2_unpack_srgb8(uint8_t *dst_row
,
718 const uint8_t *src_row
,
723 const unsigned bw
= 4, bh
= 4, bs
= 8, comps
= 4;
724 struct etc2_block block
;
728 for (y
= 0; y
< height
; y
+= bh
) {
729 const uint8_t *src
= src_row
;
730 const unsigned h
= MIN2(bh
, height
- y
);
732 for (x
= 0; x
< width
; x
+= bw
) {
733 const unsigned w
= MIN2(bw
, width
- x
);
734 etc2_rgb8_parse_block(&block
, src
,
735 false /* punchthrough_alpha */);
738 for (j
= 0; j
< h
; j
++) {
739 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+ x
* comps
;
740 for (i
= 0; i
< w
; i
++) {
741 etc2_rgb8_fetch_texel(&block
, i
, j
, dst
,
742 false /* punchthrough_alpha */);
743 /* Convert to MESA_FORMAT_B8G8R8A8_SRGB */
755 src_row
+= src_stride
;
760 etc2_unpack_rgba8(uint8_t *dst_row
,
762 const uint8_t *src_row
,
767 /* If internalformat is COMPRESSED_RGBA8_ETC2_EAC, each 4 × 4 block of
768 * RGBA8888 information is compressed to 128 bits. To decode a block, the
769 * two 64-bit integers int64bitAlpha and int64bitColor are calculated.
771 const unsigned bw
= 4, bh
= 4, bs
= 16, comps
= 4;
772 struct etc2_block block
;
775 for (y
= 0; y
< height
; y
+= bh
) {
776 const uint8_t *src
= src_row
;
777 const unsigned h
= MIN2(bh
, height
- y
);
779 for (x
= 0; x
< width
; x
+= bw
) {
780 const unsigned w
= MIN2(bw
, width
- x
);
781 etc2_rgba8_parse_block(&block
, src
);
783 for (j
= 0; j
< h
; j
++) {
784 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+ x
* comps
;
785 for (i
= 0; i
< w
; i
++) {
786 etc2_rgba8_fetch_texel(&block
, i
, j
, dst
);
793 src_row
+= src_stride
;
798 etc2_unpack_srgb8_alpha8(uint8_t *dst_row
,
800 const uint8_t *src_row
,
805 /* If internalformat is COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, each 4 × 4 block
806 * of RGBA8888 information is compressed to 128 bits. To decode a block, the
807 * two 64-bit integers int64bitAlpha and int64bitColor are calculated.
809 const unsigned bw
= 4, bh
= 4, bs
= 16, comps
= 4;
810 struct etc2_block block
;
814 for (y
= 0; y
< height
; y
+= bh
) {
815 const unsigned h
= MIN2(bh
, height
- y
);
816 const uint8_t *src
= src_row
;
818 for (x
= 0; x
< width
; x
+= bw
) {
819 const unsigned w
= MIN2(bw
, width
- x
);
820 etc2_rgba8_parse_block(&block
, src
);
822 for (j
= 0; j
< h
; j
++) {
823 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+ x
* comps
;
824 for (i
= 0; i
< w
; i
++) {
825 etc2_rgba8_fetch_texel(&block
, i
, j
, dst
);
827 /* Convert to MESA_FORMAT_B8G8R8A8_SRGB */
839 src_row
+= src_stride
;
844 etc2_unpack_r11(uint8_t *dst_row
,
846 const uint8_t *src_row
,
851 /* If internalformat is COMPRESSED_R11_EAC, each 4 × 4 block of
852 color information is compressed to 64 bits.
854 const unsigned bw
= 4, bh
= 4, bs
= 8, comps
= 1, comp_size
= 2;
855 struct etc2_block block
;
858 for (y
= 0; y
< height
; y
+= bh
) {
859 const unsigned h
= MIN2(bh
, height
- y
);
860 const uint8_t *src
= src_row
;
862 for (x
= 0; x
< width
; x
+= bw
) {
863 const unsigned w
= MIN2(bw
, width
- x
);
864 etc2_r11_parse_block(&block
, src
);
866 for (j
= 0; j
< h
; j
++) {
867 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+ x
* comps
* comp_size
;
868 for (i
= 0; i
< w
; i
++) {
869 etc2_r11_fetch_texel(&block
, i
, j
, dst
);
870 dst
+= comps
* comp_size
;
876 src_row
+= src_stride
;
881 etc2_unpack_rg11(uint8_t *dst_row
,
883 const uint8_t *src_row
,
888 /* If internalformat is COMPRESSED_RG11_EAC, each 4 × 4 block of
889 RG color information is compressed to 128 bits.
891 const unsigned bw
= 4, bh
= 4, bs
= 16, comps
= 2, comp_size
= 2;
892 struct etc2_block block
;
895 for (y
= 0; y
< height
; y
+= bh
) {
896 const unsigned h
= MIN2(bh
, height
- y
);
897 const uint8_t *src
= src_row
;
899 for (x
= 0; x
< width
; x
+= bw
) {
900 const unsigned w
= MIN2(bw
, width
- x
);
902 etc2_r11_parse_block(&block
, src
);
904 for (j
= 0; j
< h
; j
++) {
905 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+
906 x
* comps
* comp_size
;
907 for (i
= 0; i
< w
; i
++) {
908 etc2_r11_fetch_texel(&block
, i
, j
, dst
);
909 dst
+= comps
* comp_size
;
912 /* green component */
913 etc2_r11_parse_block(&block
, src
+ 8);
915 for (j
= 0; j
< h
; j
++) {
916 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+
917 x
* comps
* comp_size
;
918 for (i
= 0; i
< w
; i
++) {
919 etc2_r11_fetch_texel(&block
, i
, j
, dst
+ comp_size
);
920 dst
+= comps
* comp_size
;
926 src_row
+= src_stride
;
931 etc2_unpack_signed_r11(uint8_t *dst_row
,
933 const uint8_t *src_row
,
938 /* If internalformat is COMPRESSED_SIGNED_R11_EAC, each 4 × 4 block of
939 red color information is compressed to 64 bits.
941 const unsigned bw
= 4, bh
= 4, bs
= 8, comps
= 1, comp_size
= 2;
942 struct etc2_block block
;
945 for (y
= 0; y
< height
; y
+= bh
) {
946 const unsigned h
= MIN2(bh
, height
- y
);
947 const uint8_t *src
= src_row
;
949 for (x
= 0; x
< width
; x
+= bw
) {
950 const unsigned w
= MIN2(bw
, width
- x
);
951 etc2_r11_parse_block(&block
, src
);
953 for (j
= 0; j
< h
; j
++) {
954 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+
955 x
* comps
* comp_size
;
956 for (i
= 0; i
< w
; i
++) {
957 etc2_signed_r11_fetch_texel(&block
, i
, j
, dst
);
958 dst
+= comps
* comp_size
;
964 src_row
+= src_stride
;
969 etc2_unpack_signed_rg11(uint8_t *dst_row
,
971 const uint8_t *src_row
,
976 /* If internalformat is COMPRESSED_SIGNED_RG11_EAC, each 4 × 4 block of
977 RG color information is compressed to 128 bits.
979 const unsigned bw
= 4, bh
= 4, bs
= 16, comps
= 2, comp_size
= 2;
980 struct etc2_block block
;
983 for (y
= 0; y
< height
; y
+= bh
) {
984 const unsigned h
= MIN2(bh
, height
- y
);
985 const uint8_t *src
= src_row
;
987 for (x
= 0; x
< width
; x
+= bw
) {
988 const unsigned w
= MIN2(bw
, width
- x
);
990 etc2_r11_parse_block(&block
, src
);
992 for (j
= 0; j
< h
; j
++) {
993 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+
994 x
* comps
* comp_size
;
995 for (i
= 0; i
< w
; i
++) {
996 etc2_signed_r11_fetch_texel(&block
, i
, j
, dst
);
997 dst
+= comps
* comp_size
;
1000 /* green component */
1001 etc2_r11_parse_block(&block
, src
+ 8);
1003 for (j
= 0; j
< h
; j
++) {
1004 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+
1005 x
* comps
* comp_size
;
1006 for (i
= 0; i
< w
; i
++) {
1007 etc2_signed_r11_fetch_texel(&block
, i
, j
, dst
+ comp_size
);
1008 dst
+= comps
* comp_size
;
1014 src_row
+= src_stride
;
1019 etc2_unpack_rgb8_punchthrough_alpha1(uint8_t *dst_row
,
1020 unsigned dst_stride
,
1021 const uint8_t *src_row
,
1022 unsigned src_stride
,
1026 const unsigned bw
= 4, bh
= 4, bs
= 8, comps
= 4;
1027 struct etc2_block block
;
1028 unsigned x
, y
, i
, j
;
1030 for (y
= 0; y
< height
; y
+= bh
) {
1031 const unsigned h
= MIN2(bh
, height
- y
);
1032 const uint8_t *src
= src_row
;
1034 for (x
= 0; x
< width
; x
+= bw
) {
1035 const unsigned w
= MIN2(bw
, width
- x
);
1036 etc2_rgb8_parse_block(&block
, src
,
1037 true /* punchthrough_alpha */);
1038 for (j
= 0; j
< h
; j
++) {
1039 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+ x
* comps
;
1040 for (i
= 0; i
< w
; i
++) {
1041 etc2_rgb8_fetch_texel(&block
, i
, j
, dst
,
1042 true /* punchthrough_alpha */);
1050 src_row
+= src_stride
;
1055 etc2_unpack_srgb8_punchthrough_alpha1(uint8_t *dst_row
,
1056 unsigned dst_stride
,
1057 const uint8_t *src_row
,
1058 unsigned src_stride
,
1062 const unsigned bw
= 4, bh
= 4, bs
= 8, comps
= 4;
1063 struct etc2_block block
;
1064 unsigned x
, y
, i
, j
;
1067 for (y
= 0; y
< height
; y
+= bh
) {
1068 const unsigned h
= MIN2(bh
, height
- y
);
1069 const uint8_t *src
= src_row
;
1071 for (x
= 0; x
< width
; x
+= bw
) {
1072 const unsigned w
= MIN2(bw
, width
- x
);
1073 etc2_rgb8_parse_block(&block
, src
,
1074 true /* punchthrough_alpha */);
1075 for (j
= 0; j
< h
; j
++) {
1076 uint8_t *dst
= dst_row
+ (y
+ j
) * dst_stride
+ x
* comps
;
1077 for (i
= 0; i
< w
; i
++) {
1078 etc2_rgb8_fetch_texel(&block
, i
, j
, dst
,
1079 true /* punchthrough_alpha */);
1080 /* Convert to MESA_FORMAT_B8G8R8A8_SRGB */
1093 src_row
+= src_stride
;
1097 /* ETC2 texture formats are valid in glCompressedTexImage2D and
1098 * glCompressedTexSubImage2D functions */
1100 _mesa_texstore_etc2_rgb8(TEXSTORE_PARAMS
)
1108 _mesa_texstore_etc2_srgb8(TEXSTORE_PARAMS
)
1116 _mesa_texstore_etc2_rgba8_eac(TEXSTORE_PARAMS
)
1124 _mesa_texstore_etc2_srgb8_alpha8_eac(TEXSTORE_PARAMS
)
1132 _mesa_texstore_etc2_r11_eac(TEXSTORE_PARAMS
)
1140 _mesa_texstore_etc2_signed_r11_eac(TEXSTORE_PARAMS
)
1148 _mesa_texstore_etc2_rg11_eac(TEXSTORE_PARAMS
)
1156 _mesa_texstore_etc2_signed_rg11_eac(TEXSTORE_PARAMS
)
1164 _mesa_texstore_etc2_rgb8_punchthrough_alpha1(TEXSTORE_PARAMS
)
1172 _mesa_texstore_etc2_srgb8_punchthrough_alpha1(TEXSTORE_PARAMS
)
1181 * Decode texture data in any one of following formats:
1182 * `MESA_FORMAT_ETC2_RGB8`
1183 * `MESA_FORMAT_ETC2_SRGB8`
1184 * `MESA_FORMAT_ETC2_RGBA8_EAC`
1185 * `MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC`
1186 * `MESA_FORMAT_ETC2_R11_EAC`
1187 * `MESA_FORMAT_ETC2_RG11_EAC`
1188 * `MESA_FORMAT_ETC2_SIGNED_R11_EAC`
1189 * `MESA_FORMAT_ETC2_SIGNED_RG11_EAC`
1190 * `MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1`
1191 * `MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1`
1193 * The size of the source data must be a multiple of the ETC2 block size
1194 * even if the texture image's dimensions are not aligned to 4.
1196 * \param src_width in pixels
1197 * \param src_height in pixels
1198 * \param dst_stride in bytes
1202 _mesa_unpack_etc2_format(uint8_t *dst_row
,
1203 unsigned dst_stride
,
1204 const uint8_t *src_row
,
1205 unsigned src_stride
,
1207 unsigned src_height
,
1210 if (format
== MESA_FORMAT_ETC2_RGB8
)
1211 etc2_unpack_rgb8(dst_row
, dst_stride
,
1212 src_row
, src_stride
,
1213 src_width
, src_height
);
1214 else if (format
== MESA_FORMAT_ETC2_SRGB8
)
1215 etc2_unpack_srgb8(dst_row
, dst_stride
,
1216 src_row
, src_stride
,
1217 src_width
, src_height
);
1218 else if (format
== MESA_FORMAT_ETC2_RGBA8_EAC
)
1219 etc2_unpack_rgba8(dst_row
, dst_stride
,
1220 src_row
, src_stride
,
1221 src_width
, src_height
);
1222 else if (format
== MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC
)
1223 etc2_unpack_srgb8_alpha8(dst_row
, dst_stride
,
1224 src_row
, src_stride
,
1225 src_width
, src_height
);
1226 else if (format
== MESA_FORMAT_ETC2_R11_EAC
)
1227 etc2_unpack_r11(dst_row
, dst_stride
,
1228 src_row
, src_stride
,
1229 src_width
, src_height
);
1230 else if (format
== MESA_FORMAT_ETC2_RG11_EAC
)
1231 etc2_unpack_rg11(dst_row
, dst_stride
,
1232 src_row
, src_stride
,
1233 src_width
, src_height
);
1234 else if (format
== MESA_FORMAT_ETC2_SIGNED_R11_EAC
)
1235 etc2_unpack_signed_r11(dst_row
, dst_stride
,
1236 src_row
, src_stride
,
1237 src_width
, src_height
);
1238 else if (format
== MESA_FORMAT_ETC2_SIGNED_RG11_EAC
)
1239 etc2_unpack_signed_rg11(dst_row
, dst_stride
,
1240 src_row
, src_stride
,
1241 src_width
, src_height
);
1242 else if (format
== MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1
)
1243 etc2_unpack_rgb8_punchthrough_alpha1(dst_row
, dst_stride
,
1244 src_row
, src_stride
,
1245 src_width
, src_height
);
1246 else if (format
== MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1
)
1247 etc2_unpack_srgb8_punchthrough_alpha1(dst_row
, dst_stride
,
1248 src_row
, src_stride
,
1249 src_width
, src_height
);
1255 fetch_etc1_rgb8(const GLubyte
*map
,
1256 GLint rowStride
, GLint i
, GLint j
,
1259 struct etc1_block block
;
1263 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 8;
1265 etc1_parse_block(&block
, src
);
1266 etc1_fetch_texel(&block
, i
% 4, j
% 4, dst
);
1268 texel
[RCOMP
] = UBYTE_TO_FLOAT(dst
[0]);
1269 texel
[GCOMP
] = UBYTE_TO_FLOAT(dst
[1]);
1270 texel
[BCOMP
] = UBYTE_TO_FLOAT(dst
[2]);
1271 texel
[ACOMP
] = 1.0f
;
1276 fetch_etc2_rgb8(const GLubyte
*map
,
1277 GLint rowStride
, GLint i
, GLint j
, GLfloat
*texel
)
1279 struct etc2_block block
;
1283 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 8;
1285 etc2_rgb8_parse_block(&block
, src
,
1286 false /* punchthrough_alpha */);
1287 etc2_rgb8_fetch_texel(&block
, i
% 4, j
% 4, dst
,
1288 false /* punchthrough_alpha */);
1290 texel
[RCOMP
] = UBYTE_TO_FLOAT(dst
[0]);
1291 texel
[GCOMP
] = UBYTE_TO_FLOAT(dst
[1]);
1292 texel
[BCOMP
] = UBYTE_TO_FLOAT(dst
[2]);
1293 texel
[ACOMP
] = 1.0f
;
1297 fetch_etc2_srgb8(const GLubyte
*map
,
1298 GLint rowStride
, GLint i
, GLint j
, GLfloat
*texel
)
1300 struct etc2_block block
;
1304 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 8;
1306 etc2_rgb8_parse_block(&block
, src
,
1307 false /* punchthrough_alpha */);
1308 etc2_rgb8_fetch_texel(&block
, i
% 4, j
% 4, dst
,
1309 false /* punchthrough_alpha */);
1311 texel
[RCOMP
] = util_format_srgb_8unorm_to_linear_float(dst
[0]);
1312 texel
[GCOMP
] = util_format_srgb_8unorm_to_linear_float(dst
[1]);
1313 texel
[BCOMP
] = util_format_srgb_8unorm_to_linear_float(dst
[2]);
1314 texel
[ACOMP
] = 1.0f
;
1318 fetch_etc2_rgba8_eac(const GLubyte
*map
,
1319 GLint rowStride
, GLint i
, GLint j
, GLfloat
*texel
)
1321 struct etc2_block block
;
1325 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 16;
1327 etc2_rgba8_parse_block(&block
, src
);
1328 etc2_rgba8_fetch_texel(&block
, i
% 4, j
% 4, dst
);
1330 texel
[RCOMP
] = UBYTE_TO_FLOAT(dst
[0]);
1331 texel
[GCOMP
] = UBYTE_TO_FLOAT(dst
[1]);
1332 texel
[BCOMP
] = UBYTE_TO_FLOAT(dst
[2]);
1333 texel
[ACOMP
] = UBYTE_TO_FLOAT(dst
[3]);
1337 fetch_etc2_srgb8_alpha8_eac(const GLubyte
*map
,
1338 GLint rowStride
, GLint i
, GLint j
, GLfloat
*texel
)
1340 struct etc2_block block
;
1344 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 16;
1346 etc2_rgba8_parse_block(&block
, src
);
1347 etc2_rgba8_fetch_texel(&block
, i
% 4, j
% 4, dst
);
1349 texel
[RCOMP
] = util_format_srgb_8unorm_to_linear_float(dst
[0]);
1350 texel
[GCOMP
] = util_format_srgb_8unorm_to_linear_float(dst
[1]);
1351 texel
[BCOMP
] = util_format_srgb_8unorm_to_linear_float(dst
[2]);
1352 texel
[ACOMP
] = UBYTE_TO_FLOAT(dst
[3]);
1356 fetch_etc2_r11_eac(const GLubyte
*map
,
1357 GLint rowStride
, GLint i
, GLint j
, GLfloat
*texel
)
1359 struct etc2_block block
;
1363 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 8;
1365 etc2_r11_parse_block(&block
, src
);
1366 etc2_r11_fetch_texel(&block
, i
% 4, j
% 4, (uint8_t *)&dst
);
1368 texel
[RCOMP
] = USHORT_TO_FLOAT(dst
);
1369 texel
[GCOMP
] = 0.0f
;
1370 texel
[BCOMP
] = 0.0f
;
1371 texel
[ACOMP
] = 1.0f
;
1375 fetch_etc2_rg11_eac(const GLubyte
*map
,
1376 GLint rowStride
, GLint i
, GLint j
, GLfloat
*texel
)
1378 struct etc2_block block
;
1382 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 16;
1385 etc2_r11_parse_block(&block
, src
);
1386 etc2_r11_fetch_texel(&block
, i
% 4, j
% 4, (uint8_t *)dst
);
1388 /* green component */
1389 etc2_r11_parse_block(&block
, src
+ 8);
1390 etc2_r11_fetch_texel(&block
, i
% 4, j
% 4, (uint8_t *)(dst
+ 1));
1392 texel
[RCOMP
] = USHORT_TO_FLOAT(dst
[0]);
1393 texel
[GCOMP
] = USHORT_TO_FLOAT(dst
[1]);
1394 texel
[BCOMP
] = 0.0f
;
1395 texel
[ACOMP
] = 1.0f
;
1399 fetch_etc2_signed_r11_eac(const GLubyte
*map
,
1400 GLint rowStride
, GLint i
, GLint j
, GLfloat
*texel
)
1402 struct etc2_block block
;
1406 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 8;
1408 etc2_r11_parse_block(&block
, src
);
1409 etc2_signed_r11_fetch_texel(&block
, i
% 4, j
% 4, (uint8_t *)&dst
);
1411 texel
[RCOMP
] = SHORT_TO_FLOAT(dst
);
1412 texel
[GCOMP
] = 0.0f
;
1413 texel
[BCOMP
] = 0.0f
;
1414 texel
[ACOMP
] = 1.0f
;
1418 fetch_etc2_signed_rg11_eac(const GLubyte
*map
,
1419 GLint rowStride
, GLint i
, GLint j
, GLfloat
*texel
)
1421 struct etc2_block block
;
1425 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 16;
1428 etc2_r11_parse_block(&block
, src
);
1429 etc2_signed_r11_fetch_texel(&block
, i
% 4, j
% 4, (uint8_t *)dst
);
1431 /* green component */
1432 etc2_r11_parse_block(&block
, src
+ 8);
1433 etc2_signed_r11_fetch_texel(&block
, i
% 4, j
% 4, (uint8_t *)(dst
+ 1));
1435 texel
[RCOMP
] = SHORT_TO_FLOAT(dst
[0]);
1436 texel
[GCOMP
] = SHORT_TO_FLOAT(dst
[1]);
1437 texel
[BCOMP
] = 0.0f
;
1438 texel
[ACOMP
] = 1.0f
;
1442 fetch_etc2_rgb8_punchthrough_alpha1(const GLubyte
*map
,
1443 GLint rowStride
, GLint i
, GLint j
,
1446 struct etc2_block block
;
1450 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 8;
1452 etc2_rgb8_parse_block(&block
, src
,
1453 true /* punchthrough alpha */);
1454 etc2_rgb8_fetch_texel(&block
, i
% 4, j
% 4, dst
,
1455 true /* punchthrough alpha */);
1456 texel
[RCOMP
] = UBYTE_TO_FLOAT(dst
[0]);
1457 texel
[GCOMP
] = UBYTE_TO_FLOAT(dst
[1]);
1458 texel
[BCOMP
] = UBYTE_TO_FLOAT(dst
[2]);
1459 texel
[ACOMP
] = UBYTE_TO_FLOAT(dst
[3]);
1463 fetch_etc2_srgb8_punchthrough_alpha1(const GLubyte
*map
,
1465 GLint i
, GLint j
, GLfloat
*texel
)
1467 struct etc2_block block
;
1471 src
= map
+ (((rowStride
+ 3) / 4) * (j
/ 4) + (i
/ 4)) * 8;
1473 etc2_rgb8_parse_block(&block
, src
,
1474 true /* punchthrough alpha */);
1475 etc2_rgb8_fetch_texel(&block
, i
% 4, j
% 4, dst
,
1476 true /* punchthrough alpha */);
1477 texel
[RCOMP
] = util_format_srgb_8unorm_to_linear_float(dst
[0]);
1478 texel
[GCOMP
] = util_format_srgb_8unorm_to_linear_float(dst
[1]);
1479 texel
[BCOMP
] = util_format_srgb_8unorm_to_linear_float(dst
[2]);
1480 texel
[ACOMP
] = UBYTE_TO_FLOAT(dst
[3]);
1484 compressed_fetch_func
1485 _mesa_get_etc_fetch_func(mesa_format format
)
1488 case MESA_FORMAT_ETC1_RGB8
:
1489 return fetch_etc1_rgb8
;
1490 case MESA_FORMAT_ETC2_RGB8
:
1491 return fetch_etc2_rgb8
;
1492 case MESA_FORMAT_ETC2_SRGB8
:
1493 return fetch_etc2_srgb8
;
1494 case MESA_FORMAT_ETC2_RGBA8_EAC
:
1495 return fetch_etc2_rgba8_eac
;
1496 case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC
:
1497 return fetch_etc2_srgb8_alpha8_eac
;
1498 case MESA_FORMAT_ETC2_R11_EAC
:
1499 return fetch_etc2_r11_eac
;
1500 case MESA_FORMAT_ETC2_RG11_EAC
:
1501 return fetch_etc2_rg11_eac
;
1502 case MESA_FORMAT_ETC2_SIGNED_R11_EAC
:
1503 return fetch_etc2_signed_r11_eac
;
1504 case MESA_FORMAT_ETC2_SIGNED_RG11_EAC
:
1505 return fetch_etc2_signed_rg11_eac
;
1506 case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1
:
1507 return fetch_etc2_rgb8_punchthrough_alpha1
;
1508 case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1
:
1509 return fetch_etc2_srgb8_punchthrough_alpha1
;