FFmpeg
texturedsp.c
Go to the documentation of this file.
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. */
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 
638 {
639  c->dxt1_block = dxt1_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;
654 }
int(* dxt5_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:51
const char * g
Definition: vf_curves.c:115
Texture block (4x4) module.
#define RGBA(r, g, b, a)
Definition: texturedsp.c:35
int(* rgtc1u_alpha_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:57
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
static void rgtc2_block_internal(uint8_t *dst, ptrdiff_t stride, const uint8_t *block, int sign)
Definition: texturedsp.c:548
#define src
Definition: vp8dsp.c:254
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
static void dxt3_block_internal(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.c:139
Macro definitions for various function/variable attributes.
static int dxt4_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a DXT4 texture and store the resulting RGBA pixels in &#39;dst&#39;.
Definition: texturedsp.c:311
static void rgtc1_block_internal(uint8_t *dst, ptrdiff_t stride, const uint8_t *block, int sign, int mono, int offset, int pix_size)
Definition: texturedsp.c:444
static av_always_inline void ycocg2rgba(uint8_t *src, int scaled)
Convert a YCoCg buffer to RGBA.
Definition: texturedsp.c:348
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
static int dxt3_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a DXT3 texture and store the resulting RGBA pixels in &#39;dst&#39;.
Definition: texturedsp.c:216
int(* dxt5y_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:52
int(* dxt3_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:49
static const uint64_t c1
Definition: murmur3.c:49
int(* rgtc2s_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:58
#define U(x)
Definition: vp56_arith.h:37
int(* dxt5ys_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:53
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int(* rgtc1u_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:55
static const ColorEntry color_table[]
Definition: xpmdec.c:50
const char * r
Definition: vf_curves.c:114
static int rgtc2u_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a RGRC2 texture with unsigned components and store the resulting RGBA pixels ...
Definition: texturedsp.c:605
static int rgtc1u_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a RGRC1 texture with unsigned components and store the resulting RGBA pixels ...
Definition: texturedsp.c:509
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_RL24
Definition: bytestream.h:87
static int rgtc1u_alpha_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a RGTC1 texture with unsigned components and overwrite the alpha component in...
Definition: texturedsp.c:525
static void dxt1_block_internal(uint8_t *dst, ptrdiff_t stride, const uint8_t *block, uint8_t alpha)
Definition: texturedsp.c:85
av_cold void ff_texturedsp_init(TextureDSPContext *c)
Definition: texturedsp.c:637
#define b
Definition: input.c:41
int(* dxt1a_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:47
static int rgtc1u_gray_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a RGTC1 texture with unsigned components to Gray 8.
Definition: texturedsp.c:541
static int dxt5y_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a DXT5 texture with classic YCoCg and store the resulting RGBA pixels in &#39;dst...
Definition: texturedsp.c:375
static av_always_inline void premult2straight(uint8_t *src)
Convert a premultiplied alpha pixel to a straight alpha pixel.
Definition: texturedsp.c:171
static av_always_inline void extract_color(uint32_t colors[4], uint16_t color0, uint16_t color1, int dxtn, int alpha)
Definition: texturedsp.c:40
static int dxt5ys_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a DXT5 texture with scaled YCoCg and store the resulting RGBA pixels in &#39;dst&#39;...
Definition: texturedsp.c:399
#define s(width, name)
Definition: cbs_vp9.c:257
int(* dxt2_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:48
static void dxt5_block_internal(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.c:253
static const int16_t alpha[]
Definition: ilbcdata.h:55
static int rgtc2s_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a RGRC2 texture with signed components and store the resulting RGBA pixels in...
Definition: texturedsp.c:589
int(* dxt1_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:46
Replacements for frequently missing libm functions.
int(* dxt4_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:50
uint8_t pixel
Definition: tiny_ssim.c:42
static int dxt2_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a DXT2 texture and store the resulting RGBA pixels in &#39;dst&#39;.
Definition: texturedsp.c:192
int(* rgtc1s_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:54
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static int dxt5_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a DXT5 texture and store the resulting RGBA pixels in &#39;dst&#39;.
Definition: texturedsp.c:335
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
common internal and external API header
static void rgtc_block_internal(uint8_t *dst, ptrdiff_t stride, const uint8_t *block, const int *color_tab, int mono, int offset, int pix_size)
Definition: texturedsp.c:414
int(* rgtc2u_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:59
#define lrint
Definition: tablegen.h:53
#define av_always_inline
Definition: attributes.h:39
#define FFSWAP(type, a, b)
Definition: common.h:99
static int dxn3dc_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a 3Dc texture with unsigned components and store the resulting RGBA pixels in...
Definition: texturedsp.c:621
#define stride
int(* rgtc1u_gray_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:56
static int rgtc1s_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a RGRC1 texture with signed components and store the resulting RGBA pixels in...
Definition: texturedsp.c:493
static int dxt1a_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a DXT1 with 1-bit alpha texture and store the resulting RGBA pixels in &#39;dst&#39;...
Definition: texturedsp.c:132
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
int(* dxn3dc_block)(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Definition: texturedsp.h:60
static void decompress_indices(uint8_t *dst, const uint8_t *src)
Decompress a BC 16x3 index block stored as h g f e d c b a p o n m l k j i.
Definition: texturedsp.c:237
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
static int dxt1_block(uint8_t *dst, ptrdiff_t stride, const uint8_t *block)
Decompress one block of a DXT1 texture and store the resulting RGBA pixels in &#39;dst&#39;.
Definition: texturedsp.c:115
static uint8_t tmp[11]
Definition: aes_ctr.c:26