FFmpeg
ops_tmpl_int.c
Go to the documentation of this file.
1 /**
2  * Copyright (C) 2025 Niklas Haas
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/avassert.h"
22 #include "libavutil/bswap.h"
23 
24 #include "ops_backend.h"
25 
26 #ifndef BIT_DEPTH
27 # define BIT_DEPTH 8
28 #endif
29 
30 #if BIT_DEPTH == 32
31 # define PIXEL_TYPE SWS_PIXEL_U32
32 # define PIXEL_MAX 0xFFFFFFFFu
33 # define SWAP_BYTES av_bswap32
34 # define pixel_t uint32_t
35 # define inter_t int64_t
36 # define block_t u32block_t
37 # define px u32
38 #elif BIT_DEPTH == 16
39 # define PIXEL_TYPE SWS_PIXEL_U16
40 # define PIXEL_MAX 0xFFFFu
41 # define SWAP_BYTES av_bswap16
42 # define pixel_t uint16_t
43 # define inter_t int64_t
44 # define block_t u16block_t
45 # define px u16
46 #elif BIT_DEPTH == 8
47 # define PIXEL_TYPE SWS_PIXEL_U8
48 # define PIXEL_MAX 0xFFu
49 # define pixel_t uint8_t
50 # define inter_t int32_t
51 # define block_t u8block_t
52 # define px u8
53 #else
54 # error Invalid BIT_DEPTH
55 #endif
56 
57 #define IS_FLOAT 0
58 #define FMT_CHAR u
59 #include "ops_tmpl_common.c"
60 
61 DECL_READ(read_planar, const int elems)
62 {
63  SWS_LOOP
64  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
65  x[i] = in0[i];
66  if (elems > 1)
67  y[i] = in1[i];
68  if (elems > 2)
69  z[i] = in2[i];
70  if (elems > 3)
71  w[i] = in3[i];
72  }
73 
74  CONTINUE(x, y, z, w);
75 }
76 
77 DECL_READ(read_packed, const int elems)
78 {
79  SWS_LOOP
80  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
81  x[i] = in0[elems * i + 0];
82  if (elems > 1)
83  y[i] = in0[elems * i + 1];
84  if (elems > 2)
85  z[i] = in0[elems * i + 2];
86  if (elems > 3)
87  w[i] = in0[elems * i + 3];
88  }
89 
90  CONTINUE(x, y, z, w);
91 }
92 
93 DECL_WRITE(write_planar, const int elems)
94 {
95  SWS_LOOP
96  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
97  out0[i] = x[i];
98  if (elems > 1)
99  out1[i] = y[i];
100  if (elems > 2)
101  out2[i] = z[i];
102  if (elems > 3)
103  out3[i] = w[i];
104  }
105 }
106 
107 DECL_WRITE(write_packed, const int elems)
108 {
109  SWS_LOOP
110  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
111  out0[elems * i + 0] = x[i];
112  if (elems > 1)
113  out0[elems * i + 1] = y[i];
114  if (elems > 2)
115  out0[elems * i + 2] = z[i];
116  if (elems > 3)
117  out0[elems * i + 3] = w[i];
118  }
119 }
120 
121 #define WRAP_READ(FUNC, ELEMS, FRAC, PACKED) \
122 static av_flatten void fn(FUNC##ELEMS)(SwsOpIter *restrict iter, \
123  const SwsOpImpl *restrict impl, \
124  void *restrict x, void *restrict y, \
125  void *restrict z, void *restrict w) \
126 { \
127  CALL_READ(FUNC, ELEMS); \
128  for (int i = 0; i < (PACKED ? 1 : ELEMS); i++) \
129  iter->in[i] += sizeof(block_t) * (PACKED ? ELEMS : 1) >> FRAC; \
130 } \
131  \
132 DECL_ENTRY(FUNC##ELEMS, \
133  .op = SWS_OP_READ, \
134  .rw = { \
135  .elems = ELEMS, \
136  .packed = PACKED, \
137  .frac = FRAC, \
138  }, \
139 );
140 
141 WRAP_READ(read_planar, 1, 0, false)
142 WRAP_READ(read_planar, 2, 0, false)
143 WRAP_READ(read_planar, 3, 0, false)
144 WRAP_READ(read_planar, 4, 0, false)
145 WRAP_READ(read_packed, 2, 0, true)
146 WRAP_READ(read_packed, 3, 0, true)
147 WRAP_READ(read_packed, 4, 0, true)
148 
149 #define WRAP_WRITE(FUNC, ELEMS, FRAC, PACKED) \
150 static av_flatten void fn(FUNC##ELEMS)(SwsOpIter *restrict iter, \
151  const SwsOpImpl *restrict impl, \
152  void *restrict x, void *restrict y, \
153  void *restrict z, void *restrict w) \
154 { \
155  CALL_WRITE(FUNC, ELEMS); \
156  for (int i = 0; i < (PACKED ? 1 : ELEMS); i++) \
157  iter->out[i] += sizeof(block_t) * (PACKED ? ELEMS : 1) >> FRAC; \
158 } \
159  \
160 DECL_ENTRY(FUNC##ELEMS, \
161  .op = SWS_OP_WRITE, \
162  .rw = { \
163  .elems = ELEMS, \
164  .packed = PACKED, \
165  .frac = FRAC, \
166  }, \
167 );
168 
169 WRAP_WRITE(write_planar, 1, 0, false)
170 WRAP_WRITE(write_planar, 2, 0, false)
171 WRAP_WRITE(write_planar, 3, 0, false)
172 WRAP_WRITE(write_planar, 4, 0, false)
173 WRAP_WRITE(write_packed, 2, 0, true)
174 WRAP_WRITE(write_packed, 3, 0, true)
175 WRAP_WRITE(write_packed, 4, 0, true)
176 
177 #if BIT_DEPTH == 8
178 DECL_READ(read_nibbles, const int elems)
179 {
180  SWS_LOOP
181  for (int i = 0; i < SWS_BLOCK_SIZE; i += 2) {
182  const pixel_t val = ((const pixel_t *) in0)[i >> 1];
183  x[i + 0] = val >> 4; /* high nibble */
184  x[i + 1] = val & 0xF; /* low nibble */
185  }
186 
187  CONTINUE(x, y, z, w);
188 }
189 
190 DECL_READ(read_bits, const int elems)
191 {
192  SWS_LOOP
193  for (int i = 0; i < SWS_BLOCK_SIZE; i += 8) {
194  const pixel_t val = ((const pixel_t *) in0)[i >> 3];
195  x[i + 0] = (val >> 7) & 1;
196  x[i + 1] = (val >> 6) & 1;
197  x[i + 2] = (val >> 5) & 1;
198  x[i + 3] = (val >> 4) & 1;
199  x[i + 4] = (val >> 3) & 1;
200  x[i + 5] = (val >> 2) & 1;
201  x[i + 6] = (val >> 1) & 1;
202  x[i + 7] = (val >> 0) & 1;
203  }
204 
205  CONTINUE(x, y, z, w);
206 }
207 
208 WRAP_READ(read_nibbles, 1, 1, false)
209 WRAP_READ(read_bits, 1, 3, false)
210 
211 DECL_WRITE(write_nibbles, const int elems)
212 {
213  SWS_LOOP
214  for (int i = 0; i < SWS_BLOCK_SIZE; i += 2)
215  out0[i >> 1] = x[i] << 4 | x[i + 1];
216 }
217 
218 DECL_WRITE(write_bits, const int elems)
219 {
220  SWS_LOOP
221  for (int i = 0; i < SWS_BLOCK_SIZE; i += 8) {
222  out0[i >> 3] = x[i + 0] << 7 |
223  x[i + 1] << 6 |
224  x[i + 2] << 5 |
225  x[i + 3] << 4 |
226  x[i + 4] << 3 |
227  x[i + 5] << 2 |
228  x[i + 6] << 1 |
229  x[i + 7];
230  }
231 }
232 
233 WRAP_WRITE(write_nibbles, 1, 1, false)
234 WRAP_WRITE(write_bits, 1, 3, false)
235 #endif /* BIT_DEPTH == 8 */
236 
237 #ifdef SWAP_BYTES
238 DECL_PATTERN(swap_bytes)
239 {
240  SWS_LOOP
241  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
242  if (X)
243  x[i] = SWAP_BYTES(x[i]);
244  if (Y)
245  y[i] = SWAP_BYTES(y[i]);
246  if (Z)
247  z[i] = SWAP_BYTES(z[i]);
248  if (W)
249  w[i] = SWAP_BYTES(w[i]);
250  }
251 
252  CONTINUE(x, y, z, w);
253 }
254 
255 WRAP_COMMON_PATTERNS(swap_bytes, .op = SWS_OP_SWAP_BYTES);
256 #endif /* SWAP_BYTES */
257 
258 #if BIT_DEPTH == 8
259 DECL_PATTERN(expand16)
260 {
261  u16block_t x16, y16, z16, w16;
262 
263  SWS_LOOP
264  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
265  if (X)
266  x16[i] = x[i] << 8 | x[i];
267  if (Y)
268  y16[i] = y[i] << 8 | y[i];
269  if (Z)
270  z16[i] = z[i] << 8 | z[i];
271  if (W)
272  w16[i] = w[i] << 8 | w[i];
273  }
274 
275  CONTINUE(x16, y16, z16, w16);
276 }
277 
278 WRAP_COMMON_PATTERNS(expand16,
279  .op = SWS_OP_CONVERT,
280  .convert.to = SWS_PIXEL_U16,
281  .convert.expand = true,
282 );
283 
284 DECL_PATTERN(expand32)
285 {
286  u32block_t x32, y32, z32, w32;
287 
288  SWS_LOOP
289  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
290  x32[i] = (uint32_t)x[i] << 24 | x[i] << 16 | x[i] << 8 | x[i];
291  y32[i] = (uint32_t)y[i] << 24 | y[i] << 16 | y[i] << 8 | y[i];
292  z32[i] = (uint32_t)z[i] << 24 | z[i] << 16 | z[i] << 8 | z[i];
293  w32[i] = (uint32_t)w[i] << 24 | w[i] << 16 | w[i] << 8 | w[i];
294  }
295 
296  CONTINUE(x32, y32, z32, w32);
297 }
298 
299 WRAP_COMMON_PATTERNS(expand32,
300  .op = SWS_OP_CONVERT,
301  .convert.to = SWS_PIXEL_U32,
302  .convert.expand = true,
303 );
304 #endif
305 
306 DECL_FUNC(pack, const int bits0, const int bits1, const int bits2, const int bits3)
307 {
308  SWS_LOOP
309  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
310  x[i] = x[i] << (bits1 + bits2 + bits3);
311  if (bits1)
312  x[i] |= y[i] << (bits2 + bits3);
313  if (bits2)
314  x[i] |= z[i] << bits3;
315  if (bits3)
316  x[i] |= w[i];
317  }
318 
319  CONTINUE(x, y, z, w);
320 }
321 
322 DECL_FUNC(unpack, const int bits0, const int bits1, const int bits2, const int bits3)
323 {
324  SWS_LOOP
325  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
326  const pixel_t val = x[i];
327  x[i] = val >> (bits1 + bits2 + bits3);
328  if (bits1)
329  y[i] = (val >> (bits2 + bits3)) & ((1 << bits1) - 1);
330  if (bits2)
331  z[i] = (val >> bits3) & ((1 << bits2) - 1);
332  if (bits3)
333  w[i] = val & ((1 << bits3) - 1);
334  }
335 
336  CONTINUE(x, y, z, w);
337 }
338 
339 #define WRAP_PACK_UNPACK(X, Y, Z, W) \
340 DECL_IMPL(pack, pack_##X##Y##Z##W, X, Y, Z, W) \
341  \
342 DECL_ENTRY(pack_##X##Y##Z##W, \
343  .op = SWS_OP_PACK, \
344  .pack.pattern = { X, Y, Z, W }, \
345 ); \
346  \
347 DECL_IMPL(unpack, unpack_##X##Y##Z##W, X, Y, Z, W) \
348  \
349 DECL_ENTRY(unpack_##X##Y##Z##W, \
350  .op = SWS_OP_UNPACK, \
351  .pack.pattern = { X, Y, Z, W }, \
352 );
353 
354 WRAP_PACK_UNPACK( 3, 3, 2, 0)
355 WRAP_PACK_UNPACK( 2, 3, 3, 0)
356 WRAP_PACK_UNPACK( 1, 2, 1, 0)
357 WRAP_PACK_UNPACK( 5, 6, 5, 0)
358 WRAP_PACK_UNPACK( 5, 5, 5, 0)
359 WRAP_PACK_UNPACK( 4, 4, 4, 0)
360 WRAP_PACK_UNPACK( 2, 10, 10, 10)
361 WRAP_PACK_UNPACK(10, 10, 10, 2)
362 
363 #if BIT_DEPTH != 8
364 DECL_PATTERN(lshift)
365 {
366  const uint8_t amount = impl->priv.u8[0];
367 
368  SWS_LOOP
369  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
370  x[i] <<= amount;
371  y[i] <<= amount;
372  z[i] <<= amount;
373  w[i] <<= amount;
374  }
375 
376  CONTINUE(x, y, z, w);
377 }
378 
379 DECL_PATTERN(rshift)
380 {
381  const uint8_t amount = impl->priv.u8[0];
382 
383  SWS_LOOP
384  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
385  x[i] >>= amount;
386  y[i] >>= amount;
387  z[i] >>= amount;
388  w[i] >>= amount;
389  }
390 
391  CONTINUE(x, y, z, w);
392 }
393 
394 WRAP_COMMON_PATTERNS(lshift,
395  .op = SWS_OP_LSHIFT,
396  .setup = ff_sws_setup_shift,
397  .flexible = true,
398 );
399 
400 WRAP_COMMON_PATTERNS(rshift,
401  .op = SWS_OP_RSHIFT,
402  .setup = ff_sws_setup_shift,
403  .flexible = true,
404 );
405 #endif /* BIT_DEPTH != 8 */
406 
407 DECL_PATTERN(convert_float)
408 {
409  f32block_t xf, yf, zf, wf;
410 
411  SWS_LOOP
412  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
413  xf[i] = x[i];
414  yf[i] = y[i];
415  zf[i] = z[i];
416  wf[i] = w[i];
417  }
418 
419  CONTINUE(xf, yf, zf, wf);
420 }
421 
422 WRAP_COMMON_PATTERNS(convert_float,
423  .op = SWS_OP_CONVERT,
424  .convert.to = SWS_PIXEL_F32,
425 );
426 
427 /**
428  * Swizzle by directly swapping the order of arguments to the continuation.
429  * Note that this is only safe to do if no arguments are duplicated.
430  */
431 #define DECL_SWIZZLE(X, Y, Z, W) \
432 static void \
433 fn(swizzle_##X##Y##Z##W)(SwsOpIter *restrict iter, \
434  const SwsOpImpl *restrict impl, \
435  void *restrict c0, void *restrict c1, \
436  void *restrict c2, void *restrict c3) \
437 { \
438  CONTINUE(c##X, c##Y, c##Z, c##W); \
439 } \
440  \
441 DECL_ENTRY(swizzle_##X##Y##Z##W, \
442  .op = SWS_OP_SWIZZLE, \
443  .swizzle.in = { X, Y, Z, W }, \
444 );
445 
446 DECL_SWIZZLE(3, 0, 1, 2)
447 DECL_SWIZZLE(3, 0, 2, 1)
448 DECL_SWIZZLE(2, 1, 0, 3)
449 DECL_SWIZZLE(3, 2, 1, 0)
450 DECL_SWIZZLE(3, 1, 0, 2)
451 DECL_SWIZZLE(3, 2, 0, 1)
452 DECL_SWIZZLE(1, 2, 0, 3)
453 DECL_SWIZZLE(1, 0, 2, 3)
454 DECL_SWIZZLE(2, 0, 1, 3)
455 DECL_SWIZZLE(2, 3, 1, 0)
456 DECL_SWIZZLE(2, 1, 3, 0)
457 DECL_SWIZZLE(1, 2, 3, 0)
458 DECL_SWIZZLE(1, 3, 2, 0)
459 DECL_SWIZZLE(0, 2, 1, 3)
460 DECL_SWIZZLE(0, 2, 3, 1)
461 DECL_SWIZZLE(0, 3, 1, 2)
462 DECL_SWIZZLE(3, 1, 2, 0)
463 DECL_SWIZZLE(0, 3, 2, 1)
464 
465 /* Broadcast luma -> rgb (only used for y(a) -> rgb(a)) */
466 #define DECL_EXPAND_LUMA(X, W, T0, T1) \
467 DECL_FUNC(expand_luma_##X##W##_impl, \
468  block_t c0, block_t c1, block_t c2, block_t c3) \
469 { \
470  SWS_LOOP \
471  for (int i = 0; i < SWS_BLOCK_SIZE; i++) \
472  T0[i] = T1[i] = c0[i]; \
473  \
474  CONTINUE(c##X, T0, T1, c##W); \
475 } \
476  \
477 DECL_IMPL(expand_luma_##X##W##_impl, expand_luma_##X##W, x, y, z, w) \
478  \
479 DECL_ENTRY(expand_luma_##X##W, \
480  .op = SWS_OP_SWIZZLE, \
481  .swizzle.in = { X, 0, 0, W }, \
482 );
483 
484 DECL_EXPAND_LUMA(0, 3, c1, c2)
485 DECL_EXPAND_LUMA(3, 0, c1, c2)
486 DECL_EXPAND_LUMA(1, 0, c2, c3)
487 DECL_EXPAND_LUMA(0, 1, c2, c3)
488 
489 static const SwsOpTable fn(op_table_int) = {
490  .block_size = SWS_BLOCK_SIZE,
491  .entries = {
492  &fn(op_read_planar1),
493  &fn(op_read_planar2),
494  &fn(op_read_planar3),
495  &fn(op_read_planar4),
496  &fn(op_read_packed2),
497  &fn(op_read_packed3),
498  &fn(op_read_packed4),
499 
500  &fn(op_write_planar1),
501  &fn(op_write_planar2),
502  &fn(op_write_planar3),
503  &fn(op_write_planar4),
504  &fn(op_write_packed2),
505  &fn(op_write_packed3),
506  &fn(op_write_packed4),
507 
508  &fn(op_filter1_v),
509  &fn(op_filter2_v),
510  &fn(op_filter3_v),
511  &fn(op_filter4_v),
512 
513  &fn(op_filter1_h),
514  &fn(op_filter2_h),
515  &fn(op_filter3_h),
516  &fn(op_filter4_h),
517 
518 #if BIT_DEPTH == 8
519  &fn(op_read_bits1),
520  &fn(op_read_nibbles1),
521  &fn(op_write_bits1),
522  &fn(op_write_nibbles1),
523 
524  &fn(op_pack_1210),
525  &fn(op_pack_2330),
526  &fn(op_pack_3320),
527 
528  &fn(op_unpack_1210),
529  &fn(op_unpack_2330),
530  &fn(op_unpack_3320),
531 
532  REF_COMMON_PATTERNS(expand16),
533  REF_COMMON_PATTERNS(expand32),
534 #elif BIT_DEPTH == 16
535  &fn(op_pack_4440),
536  &fn(op_pack_5550),
537  &fn(op_pack_5650),
538  &fn(op_unpack_4440),
539  &fn(op_unpack_5550),
540  &fn(op_unpack_5650),
541 #elif BIT_DEPTH == 32
542  &fn(op_pack_2101010),
543  &fn(op_pack_1010102),
544  &fn(op_unpack_2101010),
545  &fn(op_unpack_1010102),
546 #endif
547 
548 #ifdef SWAP_BYTES
549  REF_COMMON_PATTERNS(swap_bytes),
550 #endif
551 
552  REF_COMMON_PATTERNS(min),
553  REF_COMMON_PATTERNS(max),
554  REF_COMMON_PATTERNS(scale),
555  REF_COMMON_PATTERNS(convert_float),
556 
557  &fn(op_clear_1110),
558  &fn(op_clear_0111),
559  &fn(op_clear_0011),
560  &fn(op_clear_1011),
561  &fn(op_clear_1001),
562  &fn(op_clear_1100),
563  &fn(op_clear_0101),
564  &fn(op_clear_1010),
565  &fn(op_clear_1000),
566  &fn(op_clear_0100),
567  &fn(op_clear_0010),
568 
569  &fn(op_swizzle_3012),
570  &fn(op_swizzle_3021),
571  &fn(op_swizzle_2103),
572  &fn(op_swizzle_3210),
573  &fn(op_swizzle_3102),
574  &fn(op_swizzle_3201),
575  &fn(op_swizzle_1203),
576  &fn(op_swizzle_1023),
577  &fn(op_swizzle_2013),
578  &fn(op_swizzle_2310),
579  &fn(op_swizzle_2130),
580  &fn(op_swizzle_1230),
581  &fn(op_swizzle_1320),
582  &fn(op_swizzle_0213),
583  &fn(op_swizzle_0231),
584  &fn(op_swizzle_0312),
585  &fn(op_swizzle_3120),
586  &fn(op_swizzle_0321),
587 
588  &fn(op_expand_luma_03),
589  &fn(op_expand_luma_30),
590  &fn(op_expand_luma_10),
591  &fn(op_expand_luma_01),
592 
593 #if BIT_DEPTH != 8
594  REF_COMMON_PATTERNS(lshift),
595  REF_COMMON_PATTERNS(rshift),
596  REF_COMMON_PATTERNS(convert_uint8),
597 #endif /* BIT_DEPTH != 8 */
598 
599 #if BIT_DEPTH != 16
600  REF_COMMON_PATTERNS(convert_uint16),
601 #endif
602 #if BIT_DEPTH != 32
603  REF_COMMON_PATTERNS(convert_uint32),
604 #endif
605 
606  NULL
607  },
608 };
609 
610 #undef PIXEL_TYPE
611 #undef PIXEL_MAX
612 #undef SWAP_BYTES
613 #undef pixel_t
614 #undef inter_t
615 #undef block_t
616 #undef px
617 
618 #undef FMT_CHAR
619 #undef IS_FLOAT
SwsOpTable
Copyright (C) 2025 Niklas Haas.
Definition: ops_chain.h:159
SWS_PIXEL_U16
@ SWS_PIXEL_U16
Definition: ops.h:36
ops_backend.h
SWS_OP_LSHIFT
@ SWS_OP_LSHIFT
Definition: ops.h:58
f32block_t
float f32block_t[SWS_BLOCK_SIZE]
Definition: ops_backend.c:36
ff_sws_setup_shift
int ff_sws_setup_shift(const SwsImplParams *params, SwsImplResult *out)
Definition: ops_chain.c:268
bits3
static const uint8_t bits3[81]
Definition: aactab.c:271
CONTINUE
#define CONTINUE(X, Y, Z, W)
Definition: ops_backend.h:115
max
#define max(a, b)
Definition: cuda_runtime.h:33
SWS_PIXEL_U32
@ SWS_PIXEL_U32
Definition: ops.h:37
c1
static const uint64_t c1
Definition: murmur3.c:52
convert
static void convert(float y, float u, float v, float *b, float *g, float *r)
Definition: exr.c:974
pixel_t
#define pixel_t
Definition: ops_tmpl_int.c:49
SwsOpTable::block_size
int block_size
Definition: ops_chain.h:161
SWS_PIXEL_F32
@ SWS_PIXEL_F32
Definition: ops.h:38
val
static double val(void *priv, double ch)
Definition: aeval.c:77
avassert.h
DECL_SWIZZLE
#define DECL_SWIZZLE(X, Y, Z, W)
Swizzle by directly swapping the order of arguments to the continuation.
Definition: ops_tmpl_int.c:431
W
#define W(a, i, v)
Definition: jpegls.h:119
bits1
static const uint8_t bits1[81]
Definition: aactab.c:225
op
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:76
SWS_LOOP
#define SWS_LOOP
Definition: ops_backend.h:58
u16block_t
uint16_t u16block_t[SWS_BLOCK_SIZE]
Definition: ops_backend.c:34
u32block_t
uint32_t u32block_t[SWS_BLOCK_SIZE]
Definition: ops_backend.c:35
SWS_BLOCK_SIZE
#define SWS_BLOCK_SIZE
Copyright (C) 2025 Niklas Haas.
Definition: ops_backend.c:30
fn
static const SwsOpTable fn(op_table_int)
NULL
#define NULL
Definition: coverity.c:32
DECL_EXPAND_LUMA
#define DECL_EXPAND_LUMA(X, W, T0, T1)
Definition: ops_tmpl_int.c:466
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
SWS_OP_RSHIFT
@ SWS_OP_RSHIFT
Definition: ops.h:59
read_bits
static int read_bits(int bits, int *ppos, unsigned *src)
Definition: fastaudio.c:88
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:622
WRAP_READ
#define WRAP_READ(FUNC, ELEMS, FRAC, PACKED)
Definition: ops_tmpl_int.c:121
Y
#define Y
Definition: boxblur.h:37
unpack
static int unpack(const uint8_t *src, const uint8_t *src_end, uint8_t *dst, int width, int height)
Unpack buffer.
Definition: eatgv.c:73
WRAP_PACK_UNPACK
#define WRAP_PACK_UNPACK(X, Y, Z, W)
Definition: ops_tmpl_int.c:339
DECL_PATTERN
DECL_PATTERN(expand16)
Definition: ops_tmpl_int.c:259
REF_COMMON_PATTERNS
#define REF_COMMON_PATTERNS(NAME)
Definition: ops_backend.h:159
WRAP_WRITE
#define WRAP_WRITE(FUNC, ELEMS, FRAC, PACKED)
Definition: ops_tmpl_int.c:149
bswap.h
bits0
static const uint8_t bits0[]
Definition: mobiclip.c:126
c2
static const uint64_t c2
Definition: murmur3.c:53
SWS_OP_SWAP_BYTES
@ SWS_OP_SWAP_BYTES
Definition: ops.h:52
ops_tmpl_common.c
w
uint8_t w
Definition: llvidencdsp.c:39
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:278
SWS_OP_CONVERT
@ SWS_OP_CONVERT
Definition: ops.h:63
X
@ X
Definition: vf_addroi.c:27
DECL_WRITE
DECL_WRITE(write_planar, const int elems)
Definition: ops_tmpl_int.c:93
WRAP_COMMON_PATTERNS
WRAP_COMMON_PATTERNS(expand16,.op=SWS_OP_CONVERT,.convert.to=SWS_PIXEL_U16,.convert.expand=true,)
bits2
static const uint8_t bits2[81]
Definition: aactab.c:248
DECL_FUNC
DECL_FUNC(pack, const int bits0, const int bits1, const int bits2, const int bits3)
Definition: ops_tmpl_int.c:306
DECL_READ
DECL_READ(read_planar, const int elems)
Definition: ops_tmpl_int.c:61
min
float min
Definition: vorbis_enc_data.h:429
Generated on Thu Apr 16 2026 19:23:46 for FFmpeg by   doxygen 1.8.17