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(block_t, 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(block_t, 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 DECL_IMPL(FUNC##ELEMS) \
123 { \
124  CALL_READ(FUNC, ELEMS); \
125  for (int i = 0; i < (PACKED ? 1 : ELEMS); i++) \
126  iter->in[i] += sizeof(block_t) * (PACKED ? ELEMS : 1) >> FRAC; \
127 } \
128  \
129 DECL_ENTRY(FUNC##ELEMS, \
130  .op = SWS_OP_READ, \
131  .rw = { \
132  .elems = ELEMS, \
133  .packed = PACKED, \
134  .frac = FRAC, \
135  }, \
136 );
137 
138 WRAP_READ(read_planar, 1, 0, false)
139 WRAP_READ(read_planar, 2, 0, false)
140 WRAP_READ(read_planar, 3, 0, false)
141 WRAP_READ(read_planar, 4, 0, false)
142 WRAP_READ(read_packed, 2, 0, true)
143 WRAP_READ(read_packed, 3, 0, true)
144 WRAP_READ(read_packed, 4, 0, true)
145 
146 #define WRAP_WRITE(FUNC, ELEMS, FRAC, PACKED) \
147 DECL_IMPL(FUNC##ELEMS) \
148 { \
149  CALL_WRITE(FUNC, ELEMS); \
150  for (int i = 0; i < (PACKED ? 1 : ELEMS); i++) \
151  iter->out[i] += sizeof(block_t) * (PACKED ? ELEMS : 1) >> FRAC; \
152 } \
153  \
154 DECL_ENTRY(FUNC##ELEMS, \
155  .op = SWS_OP_WRITE, \
156  .rw = { \
157  .elems = ELEMS, \
158  .packed = PACKED, \
159  .frac = FRAC, \
160  }, \
161 );
162 
163 WRAP_WRITE(write_planar, 1, 0, false)
164 WRAP_WRITE(write_planar, 2, 0, false)
165 WRAP_WRITE(write_planar, 3, 0, false)
166 WRAP_WRITE(write_planar, 4, 0, false)
167 WRAP_WRITE(write_packed, 2, 0, true)
168 WRAP_WRITE(write_packed, 3, 0, true)
169 WRAP_WRITE(write_packed, 4, 0, true)
170 
171 #if BIT_DEPTH == 8
172 DECL_READ(read_nibbles, const int elems)
173 {
174  SWS_LOOP
175  for (int i = 0; i < SWS_BLOCK_SIZE; i += 2) {
176  const pixel_t val = ((const pixel_t *) in0)[i >> 1];
177  x[i + 0] = val >> 4; /* high nibble */
178  x[i + 1] = val & 0xF; /* low nibble */
179  }
180 
181  CONTINUE(block_t, x, y, z, w);
182 }
183 
184 DECL_READ(read_bits, const int elems)
185 {
186  SWS_LOOP
187  for (int i = 0; i < SWS_BLOCK_SIZE; i += 8) {
188  const pixel_t val = ((const pixel_t *) in0)[i >> 3];
189  x[i + 0] = (val >> 7) & 1;
190  x[i + 1] = (val >> 6) & 1;
191  x[i + 2] = (val >> 5) & 1;
192  x[i + 3] = (val >> 4) & 1;
193  x[i + 4] = (val >> 3) & 1;
194  x[i + 5] = (val >> 2) & 1;
195  x[i + 6] = (val >> 1) & 1;
196  x[i + 7] = (val >> 0) & 1;
197  }
198 
199  CONTINUE(block_t, x, y, z, w);
200 }
201 
202 WRAP_READ(read_nibbles, 1, 1, false)
203 WRAP_READ(read_bits, 1, 3, false)
204 
205 DECL_WRITE(write_nibbles, const int elems)
206 {
207  SWS_LOOP
208  for (int i = 0; i < SWS_BLOCK_SIZE; i += 2)
209  out0[i >> 1] = x[i] << 4 | x[i + 1];
210 }
211 
212 DECL_WRITE(write_bits, const int elems)
213 {
214  SWS_LOOP
215  for (int i = 0; i < SWS_BLOCK_SIZE; i += 8) {
216  out0[i >> 3] = x[i + 0] << 7 |
217  x[i + 1] << 6 |
218  x[i + 2] << 5 |
219  x[i + 3] << 4 |
220  x[i + 4] << 3 |
221  x[i + 5] << 2 |
222  x[i + 6] << 1 |
223  x[i + 7];
224  }
225 }
226 
227 WRAP_WRITE(write_nibbles, 1, 1, false)
228 WRAP_WRITE(write_bits, 1, 3, false)
229 #endif /* BIT_DEPTH == 8 */
230 
231 #ifdef SWAP_BYTES
232 DECL_PATTERN(swap_bytes)
233 {
234  SWS_LOOP
235  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
236  if (X)
237  x[i] = SWAP_BYTES(x[i]);
238  if (Y)
239  y[i] = SWAP_BYTES(y[i]);
240  if (Z)
241  z[i] = SWAP_BYTES(z[i]);
242  if (W)
243  w[i] = SWAP_BYTES(w[i]);
244  }
245 
246  CONTINUE(block_t, x, y, z, w);
247 }
248 
249 WRAP_COMMON_PATTERNS(swap_bytes, .op = SWS_OP_SWAP_BYTES);
250 #endif /* SWAP_BYTES */
251 
252 #if BIT_DEPTH == 8
253 DECL_PATTERN(expand16)
254 {
255  u16block_t x16, y16, z16, w16;
256 
257  SWS_LOOP
258  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
259  if (X)
260  x16[i] = x[i] << 8 | x[i];
261  if (Y)
262  y16[i] = y[i] << 8 | y[i];
263  if (Z)
264  z16[i] = z[i] << 8 | z[i];
265  if (W)
266  w16[i] = w[i] << 8 | w[i];
267  }
268 
269  CONTINUE(u16block_t, x16, y16, z16, w16);
270 }
271 
272 WRAP_COMMON_PATTERNS(expand16,
273  .op = SWS_OP_CONVERT,
274  .convert.to = SWS_PIXEL_U16,
275  .convert.expand = true,
276 );
277 
278 DECL_PATTERN(expand32)
279 {
280  u32block_t x32, y32, z32, w32;
281 
282  SWS_LOOP
283  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
284  x32[i] = (uint32_t)x[i] << 24 | x[i] << 16 | x[i] << 8 | x[i];
285  y32[i] = (uint32_t)y[i] << 24 | y[i] << 16 | y[i] << 8 | y[i];
286  z32[i] = (uint32_t)z[i] << 24 | z[i] << 16 | z[i] << 8 | z[i];
287  w32[i] = (uint32_t)w[i] << 24 | w[i] << 16 | w[i] << 8 | w[i];
288  }
289 
290  CONTINUE(u32block_t, x32, y32, z32, w32);
291 }
292 
293 WRAP_COMMON_PATTERNS(expand32,
294  .op = SWS_OP_CONVERT,
295  .convert.to = SWS_PIXEL_U32,
296  .convert.expand = true,
297 );
298 #endif
299 
300 #define WRAP_PACK_UNPACK(X, Y, Z, W) \
301 inline DECL_IMPL(pack_##X##Y##Z##W) \
302 { \
303  SWS_LOOP \
304  for (int i = 0; i < SWS_BLOCK_SIZE; i++) { \
305  x[i] = x[i] << (Y+Z+W); \
306  if (Y) \
307  x[i] |= y[i] << (Z+W); \
308  if (Z) \
309  x[i] |= z[i] << W; \
310  if (W) \
311  x[i] |= w[i]; \
312  } \
313  \
314  CONTINUE(block_t, x, y, z, w); \
315 } \
316  \
317 DECL_ENTRY(pack_##X##Y##Z##W, \
318  .op = SWS_OP_PACK, \
319  .pack.pattern = { X, Y, Z, W }, \
320 ); \
321  \
322 inline DECL_IMPL(unpack_##X##Y##Z##W) \
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 >> (Y+Z+W); \
328  if (Y) \
329  y[i] = (val >> (Z+W)) & ((1 << Y) - 1); \
330  if (Z) \
331  z[i] = (val >> W) & ((1 << Z) - 1); \
332  if (W) \
333  w[i] = val & ((1 << W) - 1); \
334  } \
335  \
336  CONTINUE(block_t, x, y, z, w); \
337 } \
338  \
339 DECL_ENTRY(unpack_##X##Y##Z##W, \
340  .op = SWS_OP_UNPACK, \
341  .pack.pattern = { X, Y, Z, W }, \
342 );
343 
344 WRAP_PACK_UNPACK( 3, 3, 2, 0)
345 WRAP_PACK_UNPACK( 2, 3, 3, 0)
346 WRAP_PACK_UNPACK( 1, 2, 1, 0)
347 WRAP_PACK_UNPACK( 5, 6, 5, 0)
348 WRAP_PACK_UNPACK( 5, 5, 5, 0)
349 WRAP_PACK_UNPACK( 4, 4, 4, 0)
350 WRAP_PACK_UNPACK( 2, 10, 10, 10)
351 WRAP_PACK_UNPACK(10, 10, 10, 2)
352 
353 #if BIT_DEPTH != 8
354 DECL_PATTERN(lshift)
355 {
356  const uint8_t amount = impl->priv.u8[0];
357 
358  SWS_LOOP
359  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
360  x[i] <<= amount;
361  y[i] <<= amount;
362  z[i] <<= amount;
363  w[i] <<= amount;
364  }
365 
366  CONTINUE(block_t, x, y, z, w);
367 }
368 
369 DECL_PATTERN(rshift)
370 {
371  const uint8_t amount = impl->priv.u8[0];
372 
373  SWS_LOOP
374  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
375  x[i] >>= amount;
376  y[i] >>= amount;
377  z[i] >>= amount;
378  w[i] >>= amount;
379  }
380 
381  CONTINUE(block_t, x, y, z, w);
382 }
383 
384 WRAP_COMMON_PATTERNS(lshift,
385  .op = SWS_OP_LSHIFT,
386  .setup = ff_sws_setup_shift,
387  .flexible = true,
388 );
389 
390 WRAP_COMMON_PATTERNS(rshift,
391  .op = SWS_OP_RSHIFT,
392  .setup = ff_sws_setup_shift,
393  .flexible = true,
394 );
395 #endif /* BIT_DEPTH != 8 */
396 
397 DECL_PATTERN(convert_float)
398 {
399  f32block_t xf, yf, zf, wf;
400 
401  SWS_LOOP
402  for (int i = 0; i < SWS_BLOCK_SIZE; i++) {
403  xf[i] = x[i];
404  yf[i] = y[i];
405  zf[i] = z[i];
406  wf[i] = w[i];
407  }
408 
409  CONTINUE(f32block_t, xf, yf, zf, wf);
410 }
411 
412 WRAP_COMMON_PATTERNS(convert_float,
413  .op = SWS_OP_CONVERT,
414  .convert.to = SWS_PIXEL_F32,
415 );
416 
417 /**
418  * Swizzle by directly swapping the order of arguments to the continuation.
419  * Note that this is only safe to do if no arguments are duplicated.
420  */
421 #define DECL_SWIZZLE(X, Y, Z, W) \
422 static SWS_FUNC void \
423 fn(swizzle_##X##Y##Z##W)(SwsOpIter *restrict iter, \
424  const SwsOpImpl *restrict impl, \
425  block_t c0, block_t c1, block_t c2, block_t c3) \
426 { \
427  CONTINUE(block_t, c##X, c##Y, c##Z, c##W); \
428 } \
429  \
430 DECL_ENTRY(swizzle_##X##Y##Z##W, \
431  .op = SWS_OP_SWIZZLE, \
432  .swizzle.in = { X, Y, Z, W }, \
433 );
434 
435 DECL_SWIZZLE(3, 0, 1, 2)
436 DECL_SWIZZLE(3, 0, 2, 1)
437 DECL_SWIZZLE(2, 1, 0, 3)
438 DECL_SWIZZLE(3, 2, 1, 0)
439 DECL_SWIZZLE(3, 1, 0, 2)
440 DECL_SWIZZLE(3, 2, 0, 1)
441 DECL_SWIZZLE(1, 2, 0, 3)
442 DECL_SWIZZLE(1, 0, 2, 3)
443 DECL_SWIZZLE(2, 0, 1, 3)
444 DECL_SWIZZLE(2, 3, 1, 0)
445 DECL_SWIZZLE(2, 1, 3, 0)
446 DECL_SWIZZLE(1, 2, 3, 0)
447 DECL_SWIZZLE(1, 3, 2, 0)
448 DECL_SWIZZLE(0, 2, 1, 3)
449 DECL_SWIZZLE(0, 2, 3, 1)
450 DECL_SWIZZLE(0, 3, 1, 2)
451 DECL_SWIZZLE(3, 1, 2, 0)
452 DECL_SWIZZLE(0, 3, 2, 1)
453 
454 /* Broadcast luma -> rgb (only used for y(a) -> rgb(a)) */
455 #define DECL_EXPAND_LUMA(X, W, T0, T1) \
456 static SWS_FUNC void \
457 fn(expand_luma_##X##W)(SwsOpIter *restrict iter, \
458  const SwsOpImpl *restrict impl, \
459  block_t c0, block_t c1, block_t c2, block_t c3) \
460 { \
461  SWS_LOOP \
462  for (int i = 0; i < SWS_BLOCK_SIZE; i++) \
463  T0[i] = T1[i] = c0[i]; \
464  \
465  CONTINUE(block_t, c##X, T0, T1, c##W); \
466 } \
467  \
468 DECL_ENTRY(expand_luma_##X##W, \
469  .op = SWS_OP_SWIZZLE, \
470  .swizzle.in = { X, 0, 0, W }, \
471 );
472 
473 DECL_EXPAND_LUMA(0, 3, c1, c2)
474 DECL_EXPAND_LUMA(3, 0, c1, c2)
475 DECL_EXPAND_LUMA(1, 0, c2, c3)
476 DECL_EXPAND_LUMA(0, 1, c2, c3)
477 
478 static const SwsOpTable fn(op_table_int) = {
479  .block_size = SWS_BLOCK_SIZE,
480  .entries = {
481  &fn(op_read_planar1),
482  &fn(op_read_planar2),
483  &fn(op_read_planar3),
484  &fn(op_read_planar4),
485  &fn(op_read_packed2),
486  &fn(op_read_packed3),
487  &fn(op_read_packed4),
488 
489  &fn(op_write_planar1),
490  &fn(op_write_planar2),
491  &fn(op_write_planar3),
492  &fn(op_write_planar4),
493  &fn(op_write_packed2),
494  &fn(op_write_packed3),
495  &fn(op_write_packed4),
496 
497  &fn(op_filter1_v),
498  &fn(op_filter2_v),
499  &fn(op_filter3_v),
500  &fn(op_filter4_v),
501 
502  &fn(op_filter1_h),
503  &fn(op_filter2_h),
504  &fn(op_filter3_h),
505  &fn(op_filter4_h),
506 
507 #if BIT_DEPTH == 8
508  &fn(op_read_bits1),
509  &fn(op_read_nibbles1),
510  &fn(op_write_bits1),
511  &fn(op_write_nibbles1),
512 
513  &fn(op_pack_1210),
514  &fn(op_pack_2330),
515  &fn(op_pack_3320),
516 
517  &fn(op_unpack_1210),
518  &fn(op_unpack_2330),
519  &fn(op_unpack_3320),
520 
521  REF_COMMON_PATTERNS(expand16),
522  REF_COMMON_PATTERNS(expand32),
523 #elif BIT_DEPTH == 16
524  &fn(op_pack_4440),
525  &fn(op_pack_5550),
526  &fn(op_pack_5650),
527  &fn(op_unpack_4440),
528  &fn(op_unpack_5550),
529  &fn(op_unpack_5650),
530 #elif BIT_DEPTH == 32
531  &fn(op_pack_2101010),
532  &fn(op_pack_1010102),
533  &fn(op_unpack_2101010),
534  &fn(op_unpack_1010102),
535 #endif
536 
537 #ifdef SWAP_BYTES
538  REF_COMMON_PATTERNS(swap_bytes),
539 #endif
540 
541  REF_COMMON_PATTERNS(min),
542  REF_COMMON_PATTERNS(max),
543  REF_COMMON_PATTERNS(scale),
544  REF_COMMON_PATTERNS(convert_float),
545 
546  &fn(op_clear_1110),
547  &fn(op_clear_0111),
548  &fn(op_clear_0011),
549  &fn(op_clear_1011),
550  &fn(op_clear_1001),
551  &fn(op_clear_1100),
552  &fn(op_clear_0101),
553  &fn(op_clear_1010),
554  &fn(op_clear_1000),
555  &fn(op_clear_0100),
556  &fn(op_clear_0010),
557 
558  &fn(op_swizzle_3012),
559  &fn(op_swizzle_3021),
560  &fn(op_swizzle_2103),
561  &fn(op_swizzle_3210),
562  &fn(op_swizzle_3102),
563  &fn(op_swizzle_3201),
564  &fn(op_swizzle_1203),
565  &fn(op_swizzle_1023),
566  &fn(op_swizzle_2013),
567  &fn(op_swizzle_2310),
568  &fn(op_swizzle_2130),
569  &fn(op_swizzle_1230),
570  &fn(op_swizzle_1320),
571  &fn(op_swizzle_0213),
572  &fn(op_swizzle_0231),
573  &fn(op_swizzle_0312),
574  &fn(op_swizzle_3120),
575  &fn(op_swizzle_0321),
576 
577  &fn(op_expand_luma_03),
578  &fn(op_expand_luma_30),
579  &fn(op_expand_luma_10),
580  &fn(op_expand_luma_01),
581 
582 #if BIT_DEPTH != 8
583  REF_COMMON_PATTERNS(lshift),
584  REF_COMMON_PATTERNS(rshift),
585  REF_COMMON_PATTERNS(convert_uint8),
586 #endif /* BIT_DEPTH != 8 */
587 
588 #if BIT_DEPTH != 16
589  REF_COMMON_PATTERNS(convert_uint16),
590 #endif
591 #if BIT_DEPTH != 32
592  REF_COMMON_PATTERNS(convert_uint32),
593 #endif
594 
595  NULL
596  },
597 };
598 
599 #undef PIXEL_TYPE
600 #undef PIXEL_MAX
601 #undef SWAP_BYTES
602 #undef pixel_t
603 #undef inter_t
604 #undef block_t
605 #undef px
606 
607 #undef FMT_CHAR
608 #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
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:421
W
#define W(a, i, v)
Definition: jpegls.h:119
CONTINUE
#define CONTINUE(TYPE,...)
Definition: ops_backend.h:115
X
@ X
Definition: vf_addroi.c:27
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:60
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:455
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
WRAP_PACK_UNPACK
#define WRAP_PACK_UNPACK(X, Y, Z, W)
Definition: ops_tmpl_int.c:300
block_t
#define block_t
Definition: ops_tmpl_int.c:51
DECL_PATTERN
DECL_PATTERN(expand16)
Definition: ops_tmpl_int.c:253
REF_COMMON_PATTERNS
#define REF_COMMON_PATTERNS(NAME)
Definition: ops_backend.h:161
WRAP_WRITE
#define WRAP_WRITE(FUNC, ELEMS, FRAC, PACKED)
Definition: ops_tmpl_int.c:146
bswap.h
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
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,)
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 9 2026 19:30:57 for FFmpeg by   doxygen 1.8.17