avformat/mxfdec: fix sorting of index segments
[ffmpeg.git] / libavcodec / texturedsp.c
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
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
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  */
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  */
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
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. */
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  */
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  */
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  */
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
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  */
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  */
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  */
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  */
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  */
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
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
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  */
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  */
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  */
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  */
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
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  */
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  */
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  */
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
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 }