projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
mesa: Import libtxc_dxtn sources
[mesa.git] / src / mesa / main / texcompress_etc.c
1 /*
2 * Copyright (C) 2011 LunarG, Inc.
3 *
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:
10 *
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
13 * Software.
14 *
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.
22 */
23
24 /**
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
38 */
39
40 #include <stdbool.h>
41 #include "texcompress.h"
42 #include "texcompress_etc.h"
43 #include "texstore.h"
44 #include "macros.h"
45 #include "format_unpack.h"
46 #include "util/format_srgb.h"
47
48
49 struct etc2_block {
50 int distance;
51 uint64_t pixel_indices[2];
52 const int *modifier_tables[2];
53 bool flipped;
54 bool opaque;
55 bool is_ind_mode;
56 bool is_diff_mode;
57 bool is_t_mode;
58 bool is_h_mode;
59 bool is_planar_mode;
60 uint8_t base_colors[3][3];
61 uint8_t paint_colors[4][3];
62 uint8_t base_codeword;
63 uint8_t multiplier;
64 uint8_t table_index;
65 };
66
67 static const int etc2_distance_table[8] = {
68 3, 6, 11, 16, 23, 32, 41, 64 };
69
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},
87 };
88
89 static const int etc2_modifier_tables_non_opaque[8][4] = {
90 { 0, 8, 0, -8},
91 { 0, 17, 0, -17},
92 { 0, 29, 0, -29},
93 { 0, 42, 0, -42},
94 { 0, 60, 0, -60},
95 { 0, 80, 0, -80},
96 { 0, 106, 0, -106},
97 { 0, 183, 0, -183}
98 };
99
100 /* define etc1_parse_block and etc. */
101 #define UINT8_TYPE GLubyte
102 #define TAG(x) x
103 #include "texcompress_etc_tmp.h"
104 #undef TAG
105 #undef UINT8_TYPE
106
107 GLboolean
108 _mesa_texstore_etc1_rgb8(TEXSTORE_PARAMS)
109 {
110 /* GL_ETC1_RGB8_OES is only valid in glCompressedTexImage2D */
111 assert(0);
112
113 return GL_FALSE;
114 }
115
116
117 /**
118 * Decode texture data in format `MESA_FORMAT_ETC1_RGB8` to
119 * `MESA_FORMAT_ABGR8888`.
120 *
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.
131 *
132 * \param src_width in pixels
133 * \param src_height in pixels
134 * \param dst_stride in bytes
135 */
136 void
137 _mesa_etc1_unpack_rgba8888(uint8_t *dst_row,
138 unsigned dst_stride,
139 const uint8_t *src_row,
140 unsigned src_stride,
141 unsigned src_width,
142 unsigned src_height)
143 {
144 etc1_unpack_rgba8888(dst_row, dst_stride,
145 src_row, src_stride,
146 src_width, src_height);
147 }
148
149 static uint8_t
150 etc2_base_color1_t_mode(const uint8_t *in, GLuint index)
151 {
152 uint8_t R1a = 0, x = 0;
153 /* base col 1 = extend_4to8bits( (R1a << 2) | R1b, G1, B1) */
154 switch(index) {
155 case 0:
156 R1a = (in[0] >> 3) & 0x3;
157 x = ((R1a << 2) | (in[0] & 0x3));
158 break;
159 case 1:
160 x = ((in[1] >> 4) & 0xf);
161 break;
162 case 2:
163 x = (in[1] & 0xf);
164 break;
165 default:
166 /* invalid index */
167 break;
168 }
169 return ((x << 4) | (x & 0xf));
170 }
171
172 static uint8_t
173 etc2_base_color2_t_mode(const uint8_t *in, GLuint index)
174 {
175 uint8_t x = 0;
176 /*extend 4to8bits(R2, G2, B2)*/
177 switch(index) {
178 case 0:
179 x = ((in[2] >> 4) & 0xf );
180 break;
181 case 1:
182 x = (in[2] & 0xf);
183 break;
184 case 2:
185 x = ((in[3] >> 4) & 0xf);
186 break;
187 default:
188 /* invalid index */
189 break;
190 }
191 return ((x << 4) | (x & 0xf));
192 }
193
194 static uint8_t
195 etc2_base_color1_h_mode(const uint8_t *in, GLuint index)
196 {
197 uint8_t x = 0;
198 /* base col 1 = extend 4to8bits(R1, (G1a << 1) | G1b, (B1a << 3) | B1b) */
199 switch(index) {
200 case 0:
201 x = ((in[0] >> 3) & 0xf);
202 break;
203 case 1:
204 x = (((in[0] & 0x7) << 1) | ((in[1] >> 4) & 0x1));
205 break;
206 case 2:
207 x = ((in[1] & 0x8) |
208 (((in[1] & 0x3) << 1) | ((in[2] >> 7) & 0x1)));
209 break;
210 default:
211 /* invalid index */
212 break;
213 }
214 return ((x << 4) | (x & 0xf));
215 }
216
217 static uint8_t
218 etc2_base_color2_h_mode(const uint8_t *in, GLuint index)
219 {
220 uint8_t x = 0;
221 /* base col 2 = extend 4to8bits(R2, G2, B2) */
222 switch(index) {
223 case 0:
224 x = ((in[2] >> 3) & 0xf );
225 break;
226 case 1:
227 x = (((in[2] & 0x7) << 1) | ((in[3] >> 7) & 0x1));
228 break;
229 case 2:
230 x = ((in[3] >> 3) & 0xf);
231 break;
232 default:
233 /* invalid index */
234 break;
235 }
236 return ((x << 4) | (x & 0xf));
237 }
238
239 static uint8_t
240 etc2_base_color_o_planar(const uint8_t *in, GLuint index)
241 {
242 GLuint tmp;
243 switch(index) {
244 case 0:
245 tmp = ((in[0] >> 1) & 0x3f); /* RO */
246 return ((tmp << 2) | (tmp >> 4));
247 case 1:
248 tmp = (((in[0] & 0x1) << 6) | /* GO1 */
249 ((in[1] >> 1) & 0x3f)); /* GO2 */
250 return ((tmp << 1) | (tmp >> 6));
251 case 2:
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));
256 default:
257 /* invalid index */
258 return 0;
259 }
260 }
261
262 static uint8_t
263 etc2_base_color_h_planar(const uint8_t *in, GLuint index)
264 {
265 GLuint tmp;
266 switch(index) {
267 case 0:
268 tmp = (((in[3] & 0x7c) >> 1) | /* RH1 */
269 (in[3] & 0x1)); /* RH2 */
270 return ((tmp << 2) | (tmp >> 4));
271 case 1:
272 tmp = (in[4] >> 1) & 0x7f; /* GH */
273 return ((tmp << 1) | (tmp >> 6));
274 case 2:
275 tmp = (((in[4] & 0x1) << 5) |
276 ((in[5] >> 3) & 0x1f)); /* BH */
277 return ((tmp << 2) | (tmp >> 4));
278 default:
279 /* invalid index */
280 return 0;
281 }
282 }
283
284 static uint8_t
285 etc2_base_color_v_planar(const uint8_t *in, GLuint index)
286 {
287 GLuint tmp;
288 switch(index) {
289 case 0:
290 tmp = (((in[5] & 0x7) << 0x3) |
291 ((in[6] >> 5) & 0x7)); /* RV */
292 return ((tmp << 2) | (tmp >> 4));
293 case 1:
294 tmp = (((in[6] & 0x1f) << 2) |
295 ((in[7] >> 6) & 0x3)); /* GV */
296 return ((tmp << 1) | (tmp >> 6));
297 case 2:
298 tmp = in[7] & 0x3f; /* BV */
299 return ((tmp << 2) | (tmp >> 4));
300 default:
301 /* invalid index */
302 return 0;
303 }
304 }
305
306 static GLint
307 etc2_get_pixel_index(const struct etc2_block *block, int x, int y)
308 {
309 int bit = ((3 - y) + (3 - x) * 4) * 3;
310 int idx = (block->pixel_indices[1] >> bit) & 0x7;
311 return idx;
312 }
313
314 static uint8_t
315 etc2_clamp(int color)
316 {
317 /* CLAMP(color, 0, 255) */
318 return (uint8_t) CLAMP(color, 0, 255);
319 }
320
321 static GLushort
322 etc2_clamp2(int color)
323 {
324 /* CLAMP(color, 0, 2047) */
325 return (GLushort) CLAMP(color, 0, 2047);
326 }
327
328 static GLshort
329 etc2_clamp3(int color)
330 {
331 /* CLAMP(color, -1023, 1023) */
332 return (GLshort) CLAMP(color, -1023, 1023);
333 }
334
335 static void
336 etc2_rgb8_parse_block(struct etc2_block *block,
337 const uint8_t *src,
338 GLboolean punchthrough_alpha)
339 {
340 unsigned i;
341 GLboolean diffbit = false;
342 static const int lookup[8] = { 0, 1, 2, 3, -4, -3, -2, -1 };
343
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];
347
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;
354
355 if (punchthrough_alpha)
356 block->opaque = src[3] & 0x2;
357 else
358 diffbit = src[3] & 0x2;
359
360 if (!diffbit && !punchthrough_alpha) {
361 /* individual mode */
362 block->is_ind_mode = true;
363
364 for (i = 0; i < 3; i++) {
365 /* Texture decode algorithm is same for individual mode in etc1
366 * & etc2.
367 */
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]);
370 }
371 }
372 else if (R_plus_dR < 0 || R_plus_dR > 31){
373 /* T mode */
374 block->is_t_mode = true;
375
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);
379 }
380 /* pick distance */
381 block->distance =
382 etc2_distance_table[(((src[3] >> 2) & 0x3) << 1) |
383 (src[3] & 0x1)];
384
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] +
388 block->distance);
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] -
391 block->distance);
392 }
393 }
394 else if (G_plus_dG < 0 || G_plus_dG > 31){
395 int base_color_1_value, base_color_2_value;
396
397 /* H mode */
398 block->is_h_mode = true;
399
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);
403 }
404
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];
411 /* pick distance */
412 block->distance =
413 etc2_distance_table[(src[3] & 0x4) |
414 ((src[3] & 0x1) << 1) |
415 (base_color_1_value >= base_color_2_value)];
416
417 for (i = 0; i < 3; i++) {
418 block->paint_colors[0][i] = etc2_clamp(block->base_colors[0][i] +
419 block->distance);
420 block->paint_colors[1][i] = etc2_clamp(block->base_colors[0][i] -
421 block->distance);
422 block->paint_colors[2][i] = etc2_clamp(block->base_colors[1][i] +
423 block->distance);
424 block->paint_colors[3][i] = etc2_clamp(block->base_colors[1][i] -
425 block->distance);
426 }
427 }
428 else if (B_plus_dB < 0 || B_plus_dB > 31) {
429 /* Planar mode */
430 block->is_planar_mode = true;
431
432 /* opaque bit must be set in planar mode */
433 block->opaque = true;
434
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);
439 }
440 }
441 else if (diffbit || punchthrough_alpha) {
442 /* differential mode */
443 block->is_diff_mode = true;
444
445 for (i = 0; i < 3; i++) {
446 /* Texture decode algorithm is same for differential mode in etc1
447 * & etc2.
448 */
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]);
451 }
452 }
453
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;
457
458 /* Use same modifier tables as for etc1 textures if opaque bit is set
459 * or if non punchthrough texture format
460 */
461 block->modifier_tables[0] = (!punchthrough_alpha || block->opaque) ?
462 etc1_modifier_tables[table1_idx] :
463 etc2_modifier_tables_non_opaque[table1_idx];
464 block->modifier_tables[1] = (!punchthrough_alpha || block->opaque) ?
465 etc1_modifier_tables[table2_idx] :
466 etc2_modifier_tables_non_opaque[table2_idx];
467
468 block->flipped = (src[3] & 0x1);
469 }
470
471 block->pixel_indices[0] =
472 (src[4] << 24) | (src[5] << 16) | (src[6] << 8) | src[7];
473 }
474
475 static void
476 etc2_rgb8_fetch_texel(const struct etc2_block *block,
477 int x, int y, uint8_t *dst,
478 GLboolean punchthrough_alpha)
479 {
480 const uint8_t *base_color;
481 int modifier, bit, idx, blk;
482
483 /* get pixel index */
484 bit = y + x * 4;
485 idx = ((block->pixel_indices[0] >> (15 + bit)) & 0x2) |
486 ((block->pixel_indices[0] >> (bit)) & 0x1);
487
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;
493 return;
494 }
495 else
496 dst[3] = 255;
497 }
498
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];
503
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);
507 }
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;
513 return;
514 }
515 else
516 dst[3] = 255;
517 }
518
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];
523 }
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)
528 */
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;
533
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;
537
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;
541
542 dst[0] = etc2_clamp(red);
543 dst[1] = etc2_clamp(green);
544 dst[2] = etc2_clamp(blue);
545
546 /* check for punchthrough_alpha format */
547 if (punchthrough_alpha)
548 dst[3] = 255;
549 }
550 }
551
552 static void
553 etc2_alpha8_fetch_texel(const struct etc2_block *block,
554 int x, int y, uint8_t *dst)
555 {
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);
562 }
563
564 static void
565 etc2_r11_fetch_texel(const struct etc2_block *block,
566 int x, int y, uint8_t *dst)
567 {
568 GLint modifier, idx;
569 GLshort color;
570 /* Get pixel index */
571 idx = etc2_get_pixel_index(block, x, y);
572 modifier = etc2_modifier_tables[block->table_index][idx];
573
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));
578 else
579 color = etc2_clamp2(((block->base_codeword << 3) | 0x4) + modifier);
580
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
584 * 11 bits."
585 */
586 color = (color << 5) | (color >> 6);
587 ((GLushort *)dst)[0] = color;
588 }
589
590 static void
591 etc2_signed_r11_fetch_texel(const struct etc2_block *block,
592 int x, int y, uint8_t *dst)
593 {
594 GLint modifier, idx;
595 GLshort color;
596 GLbyte base_codeword = (GLbyte) block->base_codeword;
597
598 if (base_codeword == -128)
599 base_codeword = -127;
600
601 /* Get pixel index */
602 idx = etc2_get_pixel_index(block, x, y);
603 modifier = etc2_modifier_tables[block->table_index][idx];
604
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));
609 else
610 color = etc2_clamp3((base_codeword << 3) + modifier);
611
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
617 */
618 if (color >= 0)
619 color = (color << 5) | (color >> 5);
620 else {
621 color = -color;
622 color = (color << 5) | (color >> 5);
623 color = -color;
624 }
625 ((GLshort *)dst)[0] = color;
626 }
627
628 static void
629 etc2_alpha8_parse_block(struct etc2_block *block, const uint8_t *src)
630 {
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) |
639 ((uint64_t)src[7]));
640 }
641
642 static void
643 etc2_r11_parse_block(struct etc2_block *block, const uint8_t *src)
644 {
645 /* Parsing logic remains same as for etc2_alpha8_parse_block */
646 etc2_alpha8_parse_block(block, src);
647 }
648
649 static void
650 etc2_rgba8_parse_block(struct etc2_block *block, const uint8_t *src)
651 {
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);
657 }
658
659 static void
660 etc2_rgba8_fetch_texel(const struct etc2_block *block,
661 int x, int y, uint8_t *dst)
662 {
663 etc2_rgb8_fetch_texel(block, x, y, dst,
664 false /* punchthrough_alpha */);
665 etc2_alpha8_fetch_texel(block, x, y, dst);
666 }
667
668 static void
669 etc2_unpack_rgb8(uint8_t *dst_row,
670 unsigned dst_stride,
671 const uint8_t *src_row,
672 unsigned src_stride,
673 unsigned width,
674 unsigned height)
675 {
676 const unsigned bw = 4, bh = 4, bs = 8, comps = 4;
677 struct etc2_block block;
678 unsigned x, y, i, j;
679
680 for (y = 0; y < height; y += bh) {
681 const uint8_t *src = src_row;
682 /*
683 * Destination texture may not be a multiple of four texels in
684 * height. Compute a safe height to avoid writing outside the texture.
685 */
686 const unsigned h = MIN2(bh, height - y);
687
688 for (x = 0; x < width; x+= bw) {
689 /*
690 * Destination texture may not be a multiple of four texels in
691 * width. Compute a safe width to avoid writing outside the texture.
692 */
693 const unsigned w = MIN2(bw, width - x);
694
695 etc2_rgb8_parse_block(&block, src,
696 false /* punchthrough_alpha */);
697
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 */);
703 dst[3] = 255;
704 dst += comps;
705 }
706 }
707
708 src += bs;
709 }
710
711 src_row += src_stride;
712 }
713 }
714
715 static void
716 etc2_unpack_srgb8(uint8_t *dst_row,
717 unsigned dst_stride,
718 const uint8_t *src_row,
719 unsigned src_stride,
720 unsigned width,
721 unsigned height)
722 {
723 const unsigned bw = 4, bh = 4, bs = 8, comps = 4;
724 struct etc2_block block;
725 unsigned x, y, i, j;
726 uint8_t tmp;
727
728 for (y = 0; y < height; y += bh) {
729 const uint8_t *src = src_row;
730 const unsigned h = MIN2(bh, height - y);
731
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 */);
736
737
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 */
744 tmp = dst[0];
745 dst[0] = dst[2];
746 dst[2] = tmp;
747 dst[3] = 255;
748
749 dst += comps;
750 }
751 }
752 src += bs;
753 }
754
755 src_row += src_stride;
756 }
757 }
758
759 static void
760 etc2_unpack_rgba8(uint8_t *dst_row,
761 unsigned dst_stride,
762 const uint8_t *src_row,
763 unsigned src_stride,
764 unsigned width,
765 unsigned height)
766 {
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.
770 */
771 const unsigned bw = 4, bh = 4, bs = 16, comps = 4;
772 struct etc2_block block;
773 unsigned x, y, i, j;
774
775 for (y = 0; y < height; y += bh) {
776 const uint8_t *src = src_row;
777 const unsigned h = MIN2(bh, height - y);
778
779 for (x = 0; x < width; x+= bw) {
780 const unsigned w = MIN2(bw, width - x);
781 etc2_rgba8_parse_block(&block, src);
782
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);
787 dst += comps;
788 }
789 }
790 src += bs;
791 }
792
793 src_row += src_stride;
794 }
795 }
796
797 static void
798 etc2_unpack_srgb8_alpha8(uint8_t *dst_row,
799 unsigned dst_stride,
800 const uint8_t *src_row,
801 unsigned src_stride,
802 unsigned width,
803 unsigned height)
804 {
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.
808 */
809 const unsigned bw = 4, bh = 4, bs = 16, comps = 4;
810 struct etc2_block block;
811 unsigned x, y, i, j;
812 uint8_t tmp;
813
814 for (y = 0; y < height; y += bh) {
815 const unsigned h = MIN2(bh, height - y);
816 const uint8_t *src = src_row;
817
818 for (x = 0; x < width; x+= bw) {
819 const unsigned w = MIN2(bw, width - x);
820 etc2_rgba8_parse_block(&block, src);
821
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);
826
827 /* Convert to MESA_FORMAT_B8G8R8A8_SRGB */
828 tmp = dst[0];
829 dst[0] = dst[2];
830 dst[2] = tmp;
831 dst[3] = dst[3];
832
833 dst += comps;
834 }
835 }
836 src += bs;
837 }
838
839 src_row += src_stride;
840 }
841 }
842
843 static void
844 etc2_unpack_r11(uint8_t *dst_row,
845 unsigned dst_stride,
846 const uint8_t *src_row,
847 unsigned src_stride,
848 unsigned width,
849 unsigned height)
850 {
851 /* If internalformat is COMPRESSED_R11_EAC, each 4 × 4 block of
852 color information is compressed to 64 bits.
853 */
854 const unsigned bw = 4, bh = 4, bs = 8, comps = 1, comp_size = 2;
855 struct etc2_block block;
856 unsigned x, y, i, j;
857
858 for (y = 0; y < height; y += bh) {
859 const unsigned h = MIN2(bh, height - y);
860 const uint8_t *src = src_row;
861
862 for (x = 0; x < width; x+= bw) {
863 const unsigned w = MIN2(bw, width - x);
864 etc2_r11_parse_block(&block, src);
865
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;
871 }
872 }
873 src += bs;
874 }
875
876 src_row += src_stride;
877 }
878 }
879
880 static void
881 etc2_unpack_rg11(uint8_t *dst_row,
882 unsigned dst_stride,
883 const uint8_t *src_row,
884 unsigned src_stride,
885 unsigned width,
886 unsigned height)
887 {
888 /* If internalformat is COMPRESSED_RG11_EAC, each 4 × 4 block of
889 RG color information is compressed to 128 bits.
890 */
891 const unsigned bw = 4, bh = 4, bs = 16, comps = 2, comp_size = 2;
892 struct etc2_block block;
893 unsigned x, y, i, j;
894
895 for (y = 0; y < height; y += bh) {
896 const unsigned h = MIN2(bh, height - y);
897 const uint8_t *src = src_row;
898
899 for (x = 0; x < width; x+= bw) {
900 const unsigned w = MIN2(bw, width - x);
901 /* red component */
902 etc2_r11_parse_block(&block, src);
903
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;
910 }
911 }
912 /* green component */
913 etc2_r11_parse_block(&block, src + 8);
914
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;
921 }
922 }
923 src += bs;
924 }
925
926 src_row += src_stride;
927 }
928 }
929
930 static void
931 etc2_unpack_signed_r11(uint8_t *dst_row,
932 unsigned dst_stride,
933 const uint8_t *src_row,
934 unsigned src_stride,
935 unsigned width,
936 unsigned height)
937 {
938 /* If internalformat is COMPRESSED_SIGNED_R11_EAC, each 4 × 4 block of
939 red color information is compressed to 64 bits.
940 */
941 const unsigned bw = 4, bh = 4, bs = 8, comps = 1, comp_size = 2;
942 struct etc2_block block;
943 unsigned x, y, i, j;
944
945 for (y = 0; y < height; y += bh) {
946 const unsigned h = MIN2(bh, height - y);
947 const uint8_t *src = src_row;
948
949 for (x = 0; x < width; x+= bw) {
950 const unsigned w = MIN2(bw, width - x);
951 etc2_r11_parse_block(&block, src);
952
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;
959 }
960 }
961 src += bs;
962 }
963
964 src_row += src_stride;
965 }
966 }
967
968 static void
969 etc2_unpack_signed_rg11(uint8_t *dst_row,
970 unsigned dst_stride,
971 const uint8_t *src_row,
972 unsigned src_stride,
973 unsigned width,
974 unsigned height)
975 {
976 /* If internalformat is COMPRESSED_SIGNED_RG11_EAC, each 4 × 4 block of
977 RG color information is compressed to 128 bits.
978 */
979 const unsigned bw = 4, bh = 4, bs = 16, comps = 2, comp_size = 2;
980 struct etc2_block block;
981 unsigned x, y, i, j;
982
983 for (y = 0; y < height; y += bh) {
984 const unsigned h = MIN2(bh, height - y);
985 const uint8_t *src = src_row;
986
987 for (x = 0; x < width; x+= bw) {
988 const unsigned w = MIN2(bw, width - x);
989 /* red component */
990 etc2_r11_parse_block(&block, src);
991
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;
998 }
999 }
1000 /* green component */
1001 etc2_r11_parse_block(&block, src + 8);
1002
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;
1009 }
1010 }
1011 src += bs;
1012 }
1013
1014 src_row += src_stride;
1015 }
1016 }
1017
1018 static void
1019 etc2_unpack_rgb8_punchthrough_alpha1(uint8_t *dst_row,
1020 unsigned dst_stride,
1021 const uint8_t *src_row,
1022 unsigned src_stride,
1023 unsigned width,
1024 unsigned height)
1025 {
1026 const unsigned bw = 4, bh = 4, bs = 8, comps = 4;
1027 struct etc2_block block;
1028 unsigned x, y, i, j;
1029
1030 for (y = 0; y < height; y += bh) {
1031 const unsigned h = MIN2(bh, height - y);
1032 const uint8_t *src = src_row;
1033
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 */);
1043 dst += comps;
1044 }
1045 }
1046
1047 src += bs;
1048 }
1049
1050 src_row += src_stride;
1051 }
1052 }
1053
1054 static void
1055 etc2_unpack_srgb8_punchthrough_alpha1(uint8_t *dst_row,
1056 unsigned dst_stride,
1057 const uint8_t *src_row,
1058 unsigned src_stride,
1059 unsigned width,
1060 unsigned height)
1061 {
1062 const unsigned bw = 4, bh = 4, bs = 8, comps = 4;
1063 struct etc2_block block;
1064 unsigned x, y, i, j;
1065 uint8_t tmp;
1066
1067 for (y = 0; y < height; y += bh) {
1068 const unsigned h = MIN2(bh, height - y);
1069 const uint8_t *src = src_row;
1070
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 */
1081 tmp = dst[0];
1082 dst[0] = dst[2];
1083 dst[2] = tmp;
1084 dst[3] = dst[3];
1085
1086 dst += comps;
1087 }
1088 }
1089
1090 src += bs;
1091 }
1092
1093 src_row += src_stride;
1094 }
1095 }
1096
1097 /* ETC2 texture formats are valid in glCompressedTexImage2D and
1098 * glCompressedTexSubImage2D functions */
1099 GLboolean
1100 _mesa_texstore_etc2_rgb8(TEXSTORE_PARAMS)
1101 {
1102 assert(0);
1103
1104 return GL_FALSE;
1105 }
1106
1107 GLboolean
1108 _mesa_texstore_etc2_srgb8(TEXSTORE_PARAMS)
1109 {
1110 assert(0);
1111
1112 return GL_FALSE;
1113 }
1114
1115 GLboolean
1116 _mesa_texstore_etc2_rgba8_eac(TEXSTORE_PARAMS)
1117 {
1118 assert(0);
1119
1120 return GL_FALSE;
1121 }
1122
1123 GLboolean
1124 _mesa_texstore_etc2_srgb8_alpha8_eac(TEXSTORE_PARAMS)
1125 {
1126 assert(0);
1127
1128 return GL_FALSE;
1129 }
1130
1131 GLboolean
1132 _mesa_texstore_etc2_r11_eac(TEXSTORE_PARAMS)
1133 {
1134 assert(0);
1135
1136 return GL_FALSE;
1137 }
1138
1139 GLboolean
1140 _mesa_texstore_etc2_signed_r11_eac(TEXSTORE_PARAMS)
1141 {
1142 assert(0);
1143
1144 return GL_FALSE;
1145 }
1146
1147 GLboolean
1148 _mesa_texstore_etc2_rg11_eac(TEXSTORE_PARAMS)
1149 {
1150 assert(0);
1151
1152 return GL_FALSE;
1153 }
1154
1155 GLboolean
1156 _mesa_texstore_etc2_signed_rg11_eac(TEXSTORE_PARAMS)
1157 {
1158 assert(0);
1159
1160 return GL_FALSE;
1161 }
1162
1163 GLboolean
1164 _mesa_texstore_etc2_rgb8_punchthrough_alpha1(TEXSTORE_PARAMS)
1165 {
1166 assert(0);
1167
1168 return GL_FALSE;
1169 }
1170
1171 GLboolean
1172 _mesa_texstore_etc2_srgb8_punchthrough_alpha1(TEXSTORE_PARAMS)
1173 {
1174 assert(0);
1175
1176 return GL_FALSE;
1177 }
1178
1179
1180 /**
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`
1192 *
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.
1195 *
1196 * \param src_width in pixels
1197 * \param src_height in pixels
1198 * \param dst_stride in bytes
1199 */
1200
1201 void
1202 _mesa_unpack_etc2_format(uint8_t *dst_row,
1203 unsigned dst_stride,
1204 const uint8_t *src_row,
1205 unsigned src_stride,
1206 unsigned src_width,
1207 unsigned src_height,
1208 mesa_format format)
1209 {
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);
1250 }
1251
1252
1253
1254 static void
1255 fetch_etc1_rgb8(const GLubyte *map,
1256 GLint rowStride, GLint i, GLint j,
1257 GLfloat *texel)
1258 {
1259 struct etc1_block block;
1260 GLubyte dst[3];
1261 const GLubyte *src;
1262
1263 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 8;
1264
1265 etc1_parse_block(&block, src);
1266 etc1_fetch_texel(&block, i % 4, j % 4, dst);
1267
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;
1272 }
1273
1274
1275 static void
1276 fetch_etc2_rgb8(const GLubyte *map,
1277 GLint rowStride, GLint i, GLint j, GLfloat *texel)
1278 {
1279 struct etc2_block block;
1280 uint8_t dst[3];
1281 const uint8_t *src;
1282
1283 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 8;
1284
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 */);
1289
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;
1294 }
1295
1296 static void
1297 fetch_etc2_srgb8(const GLubyte *map,
1298 GLint rowStride, GLint i, GLint j, GLfloat *texel)
1299 {
1300 struct etc2_block block;
1301 uint8_t dst[3];
1302 const uint8_t *src;
1303
1304 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 8;
1305
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 */);
1310
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;
1315 }
1316
1317 static void
1318 fetch_etc2_rgba8_eac(const GLubyte *map,
1319 GLint rowStride, GLint i, GLint j, GLfloat *texel)
1320 {
1321 struct etc2_block block;
1322 uint8_t dst[4];
1323 const uint8_t *src;
1324
1325 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 16;
1326
1327 etc2_rgba8_parse_block(&block, src);
1328 etc2_rgba8_fetch_texel(&block, i % 4, j % 4, dst);
1329
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]);
1334 }
1335
1336 static void
1337 fetch_etc2_srgb8_alpha8_eac(const GLubyte *map,
1338 GLint rowStride, GLint i, GLint j, GLfloat *texel)
1339 {
1340 struct etc2_block block;
1341 uint8_t dst[4];
1342 const uint8_t *src;
1343
1344 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 16;
1345
1346 etc2_rgba8_parse_block(&block, src);
1347 etc2_rgba8_fetch_texel(&block, i % 4, j % 4, dst);
1348
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]);
1353 }
1354
1355 static void
1356 fetch_etc2_r11_eac(const GLubyte *map,
1357 GLint rowStride, GLint i, GLint j, GLfloat *texel)
1358 {
1359 struct etc2_block block;
1360 GLushort dst;
1361 const uint8_t *src;
1362
1363 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 8;
1364
1365 etc2_r11_parse_block(&block, src);
1366 etc2_r11_fetch_texel(&block, i % 4, j % 4, (uint8_t *)&dst);
1367
1368 texel[RCOMP] = USHORT_TO_FLOAT(dst);
1369 texel[GCOMP] = 0.0f;
1370 texel[BCOMP] = 0.0f;
1371 texel[ACOMP] = 1.0f;
1372 }
1373
1374 static void
1375 fetch_etc2_rg11_eac(const GLubyte *map,
1376 GLint rowStride, GLint i, GLint j, GLfloat *texel)
1377 {
1378 struct etc2_block block;
1379 GLushort dst[2];
1380 const uint8_t *src;
1381
1382 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 16;
1383
1384 /* red component */
1385 etc2_r11_parse_block(&block, src);
1386 etc2_r11_fetch_texel(&block, i % 4, j % 4, (uint8_t *)dst);
1387
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));
1391
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;
1396 }
1397
1398 static void
1399 fetch_etc2_signed_r11_eac(const GLubyte *map,
1400 GLint rowStride, GLint i, GLint j, GLfloat *texel)
1401 {
1402 struct etc2_block block;
1403 GLushort dst;
1404 const uint8_t *src;
1405
1406 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 8;
1407
1408 etc2_r11_parse_block(&block, src);
1409 etc2_signed_r11_fetch_texel(&block, i % 4, j % 4, (uint8_t *)&dst);
1410
1411 texel[RCOMP] = SHORT_TO_FLOAT(dst);
1412 texel[GCOMP] = 0.0f;
1413 texel[BCOMP] = 0.0f;
1414 texel[ACOMP] = 1.0f;
1415 }
1416
1417 static void
1418 fetch_etc2_signed_rg11_eac(const GLubyte *map,
1419 GLint rowStride, GLint i, GLint j, GLfloat *texel)
1420 {
1421 struct etc2_block block;
1422 GLushort dst[2];
1423 const uint8_t *src;
1424
1425 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 16;
1426
1427 /* red component */
1428 etc2_r11_parse_block(&block, src);
1429 etc2_signed_r11_fetch_texel(&block, i % 4, j % 4, (uint8_t *)dst);
1430
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));
1434
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;
1439 }
1440
1441 static void
1442 fetch_etc2_rgb8_punchthrough_alpha1(const GLubyte *map,
1443 GLint rowStride, GLint i, GLint j,
1444 GLfloat *texel)
1445 {
1446 struct etc2_block block;
1447 uint8_t dst[4];
1448 const uint8_t *src;
1449
1450 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 8;
1451
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]);
1460 }
1461
1462 static void
1463 fetch_etc2_srgb8_punchthrough_alpha1(const GLubyte *map,
1464 GLint rowStride,
1465 GLint i, GLint j, GLfloat *texel)
1466 {
1467 struct etc2_block block;
1468 uint8_t dst[4];
1469 const uint8_t *src;
1470
1471 src = map + (((rowStride + 3) / 4) * (j / 4) + (i / 4)) * 8;
1472
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]);
1481 }
1482
1483
1484 compressed_fetch_func
1485 _mesa_get_etc_fetch_func(mesa_format format)
1486 {
1487 switch (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;
1510 default:
1511 return NULL;
1512 }
1513 }