1 /*
2 * Texture block decompression
3 * Copyright (C) 2009 Benjamin Dobell, Glass Echidna
4 * Copyright (C) 2012 Matthäus G. "Anteru" Chajdas (http://anteru.net)
5 * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
22 * IN THE SOFTWARE.
23 */
24
25 #include <stddef.h>
26 #include <stdint.h>
27
28 #include "libavutil/attributes.h"
29 #include "libavutil/common.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/libm.h"
32
33 #include "texturedsp.h"
34
35 #define RGBA(r, g, b, a) (((uint8_t)(r) << 0) | \
36 ((uint8_t)(g) << 8) | \
37 ((uint8_t)(b) << 16) | \
38 ((unsigned)(uint8_t)(a) << 24))
39
extract_color(uint32_t colors[4],uint16_t color0,uint16_t color1,int dxtn,int alpha)40 static av_always_inline void extract_color(uint32_t colors[4],
41 uint16_t color0,
42 uint16_t color1,
43 int dxtn, int alpha)
44 {
45 int tmp;
46 uint8_t r0, g0, b0, r1, g1, b1;
47 uint8_t a = dxtn ? 0 : 255;
48
49 tmp = (color0 >> 11) * 255 + 16;
50 r0 = (uint8_t) ((tmp / 32 + tmp) / 32);
51 tmp = ((color0 & 0x07E0) >> 5) * 255 + 32;
52 g0 = (uint8_t) ((tmp / 64 + tmp) / 64);
53 tmp = (color0 & 0x001F) * 255 + 16;
54 b0 = (uint8_t) ((tmp / 32 + tmp) / 32);
55
56 tmp = (color1 >> 11) * 255 + 16;
57 r1 = (uint8_t) ((tmp / 32 + tmp) / 32);
58 tmp = ((color1 & 0x07E0) >> 5) * 255 + 32;
59 g1 = (uint8_t) ((tmp / 64 + tmp) / 64);
60 tmp = (color1 & 0x001F) * 255 + 16;
61 b1 = (uint8_t) ((tmp / 32 + tmp) / 32);
62
63 if (dxtn || color0 > color1) {
64 colors[0] = RGBA(r0, g0, b0, a);
65 colors[1] = RGBA(r1, g1, b1, a);
66 colors[2] = RGBA((2 * r0 + r1) / 3,
67 (2 * g0 + g1) / 3,
68 (2 * b0 + b1) / 3,
69 a);
70 colors[3] = RGBA((2 * r1 + r0) / 3,
71 (2 * g1 + g0) / 3,
72 (2 * b1 + b0) / 3,
73 a);
74 } else {
75 colors[0] = RGBA(r0, g0, b0, a);
76 colors[1] = RGBA(r1, g1, b1, a);
77 colors[2] = RGBA((r0 + r1) / 2,
78 (g0 + g1) / 2,
79 (b0 + b1) / 2,
80 a);
81 colors[3] = RGBA(0, 0, 0, alpha);
82 }
83 }
84
dxt1_block_internal(uint8_t * dst,ptrdiff_t stride,const uint8_t * block,uint8_t alpha)85 static inline void dxt1_block_internal(uint8_t *dst, ptrdiff_t stride,
86 const uint8_t *block, uint8_t alpha)
87 {
88 int x, y;
89 uint32_t colors[4];
90 uint16_t color0 = AV_RL16(block + 0);
91 uint16_t color1 = AV_RL16(block + 2);
92 uint32_t code = AV_RL32(block + 4);
93
94 extract_color(colors, color0, color1, 0, alpha);
95
96 for (y = 0; y < 4; y++) {
97 for (x = 0; x < 4; x++) {
98 uint32_t pixel = colors[code & 3];
99 code >>= 2;
100 AV_WL32(dst + x * 4, pixel);
101 }
102 dst += stride;
103 }
104 }
105
106 /**
107 * Decompress one block of a DXT1 texture and store the resulting
108 * RGBA pixels in 'dst'. Alpha component is fully opaque.
109 *
110 * @param dst output buffer.
111 * @param stride scanline in bytes.
112 * @param block block to decompress.
113 * @return how much texture data has been consumed.
114 */
dxt1_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)115 static int dxt1_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
116 {
117 dxt1_block_internal(dst, stride, block, 255);
118
119 return 8;
120 }
121
122 /**
123 * Decompress one block of a DXT1 with 1-bit alpha texture and store
124 * the resulting RGBA pixels in 'dst'. Alpha is either fully opaque or
125 * fully transparent.
126 *
127 * @param dst output buffer.
128 * @param stride scanline in bytes.
129 * @param block block to decompress.
130 * @return how much texture data has been consumed.
131 */
dxt1a_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)132 static int dxt1a_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
133 {
134 dxt1_block_internal(dst, stride, block, 0);
135
136 return 8;
137 }
138
dxt3_block_internal(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)139 static inline void dxt3_block_internal(uint8_t *dst, ptrdiff_t stride,
140 const uint8_t *block)
141 {
142 int x, y;
143 uint32_t colors[4];
144 uint16_t color0 = AV_RL16(block + 8);
145 uint16_t color1 = AV_RL16(block + 10);
146 uint32_t code = AV_RL32(block + 12);
147
148 extract_color(colors, color0, color1, 1, 0);
149
150 for (y = 0; y < 4; y++) {
151 const uint16_t alpha_code = AV_RL16(block + 2 * y);
152 uint8_t alpha_values[4];
153
154 alpha_values[0] = ((alpha_code >> 0) & 0x0F) * 17;
155 alpha_values[1] = ((alpha_code >> 4) & 0x0F) * 17;
156 alpha_values[2] = ((alpha_code >> 8) & 0x0F) * 17;
157 alpha_values[3] = ((alpha_code >> 12) & 0x0F) * 17;
158
159 for (x = 0; x < 4; x++) {
160 uint8_t alpha = alpha_values[x];
161 uint32_t pixel = colors[code & 3] | ((unsigned)alpha << 24);
162 code >>= 2;
163
164 AV_WL32(dst + x * 4, pixel);
165 }
166 dst += stride;
167 }
168 }
169
170 /** Convert a premultiplied alpha pixel to a straight alpha pixel. */
premult2straight(uint8_t * src)171 static av_always_inline void premult2straight(uint8_t *src)
172 {
173 int r = src[0];
174 int g = src[1];
175 int b = src[2];
176 int a = src[3]; /* unchanged */
177
178 src[0] = (uint8_t) r * a / 255;
179 src[1] = (uint8_t) g * a / 255;
180 src[2] = (uint8_t) b * a / 255;
181 }
182
183 /**
184 * Decompress one block of a DXT2 texture and store the resulting
185 * RGBA pixels in 'dst'.
186 *
187 * @param dst output buffer.
188 * @param stride scanline in bytes.
189 * @param block block to decompress.
190 * @return how much texture data has been consumed.
191 */
dxt2_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)192 static int dxt2_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
193 {
194 int x, y;
195
196 dxt3_block_internal(dst, stride, block);
197
198 /* This format is DXT3, but returns premultiplied alpha. It needs to be
199 * converted because it's what lavc outputs (and swscale expects). */
200 for (y = 0; y < 4; y++)
201 for (x = 0; x < 4; x++)
202 premult2straight(dst + x * 4 + y * stride);
203
204 return 16;
205 }
206
207 /**
208 * Decompress one block of a DXT3 texture and store the resulting
209 * RGBA pixels in 'dst'.
210 *
211 * @param dst output buffer.
212 * @param stride scanline in bytes.
213 * @param block block to decompress.
214 * @return how much texture data has been consumed.
215 */
dxt3_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)216 static int dxt3_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
217 {
218 dxt3_block_internal(dst, stride, block);
219
220 return 16;
221 }
222
223 /**
224 * Decompress a BC 16x3 index block stored as
225 * h g f e
226 * d c b a
227 * p o n m
228 * l k j i
229 *
230 * Bits packed as
231 * | h | g | f | e | d | c | b | a | // Entry
232 * |765 432 107 654 321 076 543 210| // Bit
233 * |0000000000111111111112222222222| // Byte
234 *
235 * into 16 8-bit indices.
236 */
decompress_indices(uint8_t * dst,const uint8_t * src)237 static void decompress_indices(uint8_t *dst, const uint8_t *src)
238 {
239 int block, i;
240
241 for (block = 0; block < 2; block++) {
242 int tmp = AV_RL24(src);
243
244 /* Unpack 8x3 bit from last 3 byte block */
245 for (i = 0; i < 8; i++)
246 dst[i] = (tmp >> (i * 3)) & 0x7;
247
248 src += 3;
249 dst += 8;
250 }
251 }
252
dxt5_block_internal(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)253 static inline void dxt5_block_internal(uint8_t *dst, ptrdiff_t stride,
254 const uint8_t *block)
255 {
256 int x, y;
257 uint32_t colors[4];
258 uint8_t alpha_indices[16];
259 uint16_t color0 = AV_RL16(block + 8);
260 uint16_t color1 = AV_RL16(block + 10);
261 uint32_t code = AV_RL32(block + 12);
262 uint8_t alpha0 = *(block);
263 uint8_t alpha1 = *(block + 1);
264
265 decompress_indices(alpha_indices, block + 2);
266
267 extract_color(colors, color0, color1, 1, 0);
268
269 for (y = 0; y < 4; y++) {
270 for (x = 0; x < 4; x++) {
271 int alpha_code = alpha_indices[x + y * 4];
272 uint32_t pixel;
273 uint8_t alpha;
274
275 if (alpha_code == 0) {
276 alpha = alpha0;
277 } else if (alpha_code == 1) {
278 alpha = alpha1;
279 } else {
280 if (alpha0 > alpha1) {
281 alpha = (uint8_t) (((8 - alpha_code) * alpha0 +
282 (alpha_code - 1) * alpha1) / 7);
283 } else {
284 if (alpha_code == 6) {
285 alpha = 0;
286 } else if (alpha_code == 7) {
287 alpha = 255;
288 } else {
289 alpha = (uint8_t) (((6 - alpha_code) * alpha0 +
290 (alpha_code - 1) * alpha1) / 5);
291 }
292 }
293 }
294 pixel = colors[code & 3] | ((unsigned)alpha << 24);
295 code >>= 2;
296 AV_WL32(dst + x * 4, pixel);
297 }
298 dst += stride;
299 }
300 }
301
302 /**
303 * Decompress one block of a DXT4 texture and store the resulting
304 * RGBA pixels in 'dst'.
305 *
306 * @param dst output buffer.
307 * @param stride scanline in bytes.
308 * @param block block to decompress.
309 * @return how much texture data has been consumed.
310 */
dxt4_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)311 static int dxt4_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
312 {
313 int x, y;
314
315 dxt5_block_internal(dst, stride, block);
316
317 /* This format is DXT5, but returns premultiplied alpha. It needs to be
318 * converted because it's what lavc outputs (and swscale expects). */
319 for (y = 0; y < 4; y++)
320 for (x = 0; x < 4; x++)
321 premult2straight(dst + x * 4 + y * stride);
322
323 return 16;
324 }
325
326 /**
327 * Decompress one block of a DXT5 texture and store the resulting
328 * RGBA pixels in 'dst'.
329 *
330 * @param dst output buffer.
331 * @param stride scanline in bytes.
332 * @param block block to decompress.
333 * @return how much texture data has been consumed.
334 */
dxt5_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)335 static int dxt5_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
336 {
337 dxt5_block_internal(dst, stride, block);
338
339 return 16;
340 }
341
342 /**
343 * Convert a YCoCg buffer to RGBA.
344 *
345 * @param src input buffer.
346 * @param scaled variant with scaled chroma components and opaque alpha.
347 */
ycocg2rgba(uint8_t * src,int scaled)348 static av_always_inline void ycocg2rgba(uint8_t *src, int scaled)
349 {
350 int r = src[0];
351 int g = src[1];
352 int b = src[2];
353 int a = src[3];
354
355 int s = scaled ? (b >> 3) + 1 : 1;
356 int y = a;
357 int co = (r - 128) / s;
358 int cg = (g - 128) / s;
359
360 src[0] = av_clip_uint8(y + co - cg);
361 src[1] = av_clip_uint8(y + cg);
362 src[2] = av_clip_uint8(y - co - cg);
363 src[3] = scaled ? 255 : b;
364 }
365
366 /**
367 * Decompress one block of a DXT5 texture with classic YCoCg and store
368 * the resulting RGBA pixels in 'dst'. Alpha component is fully opaque.
369 *
370 * @param dst output buffer.
371 * @param stride scanline in bytes.
372 * @param block block to decompress.
373 * @return how much texture data has been consumed.
374 */
dxt5y_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)375 static int dxt5y_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
376 {
377 int x, y;
378
379 /* This format is basically DXT5, with luma stored in alpha.
380 * Run a normal decompress and then reorder the components. */
381 dxt5_block_internal(dst, stride, block);
382
383 for (y = 0; y < 4; y++)
384 for (x = 0; x < 4; x++)
385 ycocg2rgba(dst + x * 4 + y * stride, 0);
386
387 return 16;
388 }
389
390 /**
391 * Decompress one block of a DXT5 texture with scaled YCoCg and store
392 * the resulting RGBA pixels in 'dst'. Alpha component is fully opaque.
393 *
394 * @param dst output buffer.
395 * @param stride scanline in bytes.
396 * @param block block to decompress.
397 * @return how much texture data has been consumed.
398 */
dxt5ys_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)399 static int dxt5ys_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
400 {
401 int x, y;
402
403 /* This format is basically DXT5, with luma stored in alpha.
404 * Run a normal decompress and then reorder the components. */
405 dxt5_block_internal(dst, stride, block);
406
407 for (y = 0; y < 4; y++)
408 for (x = 0; x < 4; x++)
409 ycocg2rgba(dst + x * 4 + y * stride, 1);
410
411 return 16;
412 }
413
rgtc_block_internal(uint8_t * dst,ptrdiff_t stride,const uint8_t * block,const int * color_tab,int mono,int offset,int pix_size)414 static inline void rgtc_block_internal(uint8_t *dst, ptrdiff_t stride,
415 const uint8_t *block,
416 const int *color_tab, int mono, int offset, int pix_size)
417 {
418 uint8_t indices[16];
419 int x, y;
420
421 decompress_indices(indices, block + 2);
422
423 /* Only one or two channels are stored at most, since it only used to
424 * compress specular (black and white) or normal (red and green) maps.
425 * Although the standard says to zero out unused components, many
426 * implementations fill all of them with the same value. */
427 for (y = 0; y < 4; y++) {
428 for (x = 0; x < 4; x++) {
429 int i = indices[x + y * 4];
430 /* Interval expansion from [-1 1] or [0 1] to [0 255]. */
431 int c = color_tab[i];
432
433 if (mono){
434 dst [x * pix_size + y * stride + offset] = (uint8_t)c;
435 }
436 else{
437 uint32_t pixel = RGBA(c, c, c, 255U);
438 AV_WL32(dst + x * pix_size + y * stride, pixel);
439 }
440 }
441 }
442 }
443
rgtc1_block_internal(uint8_t * dst,ptrdiff_t stride,const uint8_t * block,int sign,int mono,int offset,int pix_size)444 static inline void rgtc1_block_internal(uint8_t *dst, ptrdiff_t stride,
445 const uint8_t *block, int sign, int mono, int offset, int pix_size)
446 {
447 int color_table[8];
448 int r0, r1;
449
450 if (sign) {
451 /* signed data is in [-128 127] so just offset it to unsigned
452 * and it can be treated exactly the same */
453 r0 = ((int8_t) block[0]) + 128;
454 r1 = ((int8_t) block[1]) + 128;
455 } else {
456 r0 = block[0];
457 r1 = block[1];
458 }
459
460 color_table[0] = r0;
461 color_table[1] = r1;
462
463 if (r0 > r1) {
464 /* 6 interpolated color values */
465 color_table[2] = (6 * r0 + 1 * r1) / 7; // bit code 010
466 color_table[3] = (5 * r0 + 2 * r1) / 7; // bit code 011
467 color_table[4] = (4 * r0 + 3 * r1) / 7; // bit code 100
468 color_table[5] = (3 * r0 + 4 * r1) / 7; // bit code 101
469 color_table[6] = (2 * r0 + 5 * r1) / 7; // bit code 110
470 color_table[7] = (1 * r0 + 6 * r1) / 7; // bit code 111
471 } else {
472 /* 4 interpolated color values */
473 color_table[2] = (4 * r0 + 1 * r1) / 5; // bit code 010
474 color_table[3] = (3 * r0 + 2 * r1) / 5; // bit code 011
475 color_table[4] = (2 * r0 + 3 * r1) / 5; // bit code 100
476 color_table[5] = (1 * r0 + 4 * r1) / 5; // bit code 101
477 color_table[6] = 0; /* min range */ // bit code 110
478 color_table[7] = 255; /* max range */ // bit code 111
479 }
480
481 rgtc_block_internal(dst, stride, block, color_table, mono, offset, pix_size);
482 }
483
484 /**
485 * Decompress one block of a RGRC1 texture with signed components
486 * and store the resulting RGBA pixels in 'dst'.
487 *
488 * @param dst output buffer.
489 * @param stride scanline in bytes.
490 * @param block block to decompress.
491 * @return how much texture data has been consumed.
492 */
rgtc1s_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)493 static int rgtc1s_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
494 {
495 rgtc1_block_internal(dst, stride, block, 1, 0, 0, 4);
496
497 return 8;
498 }
499
500 /**
501 * Decompress one block of a RGRC1 texture with unsigned components
502 * and store the resulting RGBA pixels in 'dst'.
503 *
504 * @param dst output buffer.
505 * @param stride scanline in bytes.
506 * @param block block to decompress.
507 * @return how much texture data has been consumed.
508 */
rgtc1u_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)509 static int rgtc1u_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
510 {
511 rgtc1_block_internal(dst, stride, block, 0, 0, 0, 4);
512
513 return 8;
514 }
515
516 /**
517 * Decompress one block of a RGTC1 texture with unsigned components
518 * and overwrite the alpha component in 'dst' (RGBA data).
519 *
520 * @param dst output buffer.
521 * @param stride scanline in bytes.
522 * @param block block to decompress.
523 * @return how much texture data has been consumed.
524 */
rgtc1u_alpha_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)525 static int rgtc1u_alpha_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
526 {
527 rgtc1_block_internal(dst, stride, block, 0, 1, 3, 4);
528
529 return 8;
530 }
531
532 /**
533 * Decompress one block of a RGTC1 texture with unsigned components
534 * to Gray 8.
535 *
536 * @param dst output buffer.
537 * @param stride scanline in bytes.
538 * @param block block to decompress.
539 * @return how much texture data has been consumed.
540 */
rgtc1u_gray_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)541 static int rgtc1u_gray_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
542 {
543 rgtc1_block_internal(dst, stride, block, 0, 1, 0, 1);
544
545 return 8;
546 }
547
rgtc2_block_internal(uint8_t * dst,ptrdiff_t stride,const uint8_t * block,int sign)548 static inline void rgtc2_block_internal(uint8_t *dst, ptrdiff_t stride,
549 const uint8_t *block, int sign)
550 {
551 /* 4x4 block containing 4 component pixels. */
552 uint8_t c0[4 * 4 * 4];
553 uint8_t c1[4 * 4 * 4];
554 int x, y;
555
556 /* Decompress the two channels separately and interleave them afterwards. */
557 rgtc1_block_internal(c0, 16, block, sign, 0, 0, 4);
558 rgtc1_block_internal(c1, 16, block + 8, sign, 0, 0, 4);
559
560 /* B is rebuilt exactly like a normal map. */
561 for (y = 0; y < 4; y++) {
562 for (x = 0; x < 4; x++) {
563 uint8_t *p = dst + x * 4 + y * stride;
564 int r = c0[x * 4 + y * 16];
565 int g = c1[x * 4 + y * 16];
566 int b = 127;
567
568 int d = (255 * 255 - r * r - g * g) / 2;
569 if (d > 0)
570 b = lrint(sqrtf(d));
571
572 p[0] = r;
573 p[1] = g;
574 p[2] = b;
575 p[3] = 255;
576 }
577 }
578 }
579
580 /**
581 * Decompress one block of a RGRC2 texture with signed components
582 * and store the resulting RGBA pixels in 'dst'. Alpha is fully opaque.
583 *
584 * @param dst output buffer.
585 * @param stride scanline in bytes.
586 * @param block block to decompress.
587 * @return how much texture data has been consumed.
588 */
rgtc2s_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)589 static int rgtc2s_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
590 {
591 rgtc2_block_internal(dst, stride, block, 1);
592
593 return 16;
594 }
595
596 /**
597 * Decompress one block of a RGRC2 texture with unsigned components
598 * and store the resulting RGBA pixels in 'dst'. Alpha is fully opaque.
599 *
600 * @param dst output buffer.
601 * @param stride scanline in bytes.
602 * @param block block to decompress.
603 * @return how much texture data has been consumed.
604 */
rgtc2u_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)605 static int rgtc2u_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
606 {
607 rgtc2_block_internal(dst, stride, block, 0);
608
609 return 16;
610 }
611
612 /**
613 * Decompress one block of a 3Dc texture with unsigned components
614 * and store the resulting RGBA pixels in 'dst'. Alpha is fully opaque.
615 *
616 * @param dst output buffer.
617 * @param stride scanline in bytes.
618 * @param block block to decompress.
619 * @return how much texture data has been consumed.
620 */
dxn3dc_block(uint8_t * dst,ptrdiff_t stride,const uint8_t * block)621 static int dxn3dc_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
622 {
623 int x, y;
624 rgtc2_block_internal(dst, stride, block, 0);
625
626 /* This is the 3Dc variant of RGTC2, with swapped R and G. */
627 for (y = 0; y < 4; y++) {
628 for (x = 0; x < 4; x++) {
629 uint8_t *p = dst + x * 4 + y * stride;
630 FFSWAP(uint8_t, p[0], p[1]);
631 }
632 }
633
634 return 16;
635 }
636
ff_texturedsp_init(TextureDSPContext * c)637 av_cold void ff_texturedsp_init(TextureDSPContext *c)
638 {
639 c->dxt1_block = dxt1_block;
640 c->dxt1a_block = dxt1a_block;
641 c->dxt2_block = dxt2_block;
642 c->dxt3_block = dxt3_block;
643 c->dxt4_block = dxt4_block;
644 c->dxt5_block = dxt5_block;
645 c->dxt5y_block = dxt5y_block;
646 c->dxt5ys_block = dxt5ys_block;
647 c->rgtc1s_block = rgtc1s_block;
648 c->rgtc1u_block = rgtc1u_block;
649 c->rgtc1u_gray_block = rgtc1u_gray_block;
650 c->rgtc1u_alpha_block = rgtc1u_alpha_block;
651 c->rgtc2s_block = rgtc2s_block;
652 c->rgtc2u_block = rgtc2u_block;
653 c->dxn3dc_block = dxn3dc_block;
654 }
655