FFmpeg
Loading...
Searching...
No Matches
uops.h
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#ifndef SWSCALE_UOPS_H
22#define SWSCALE_UOPS_H
23
24#include <assert.h>
25#include <stdbool.h>
26#include <stdint.h>
27
28/***************************************************************************
29 * Note: This header must be usable at build time, to generate asm sources *
30 ***************************************************************************/
31
33#include "rational64.h"
34
35typedef struct SwsContext SwsContext;
37typedef struct SwsLut3D SwsLut3D;
38typedef struct SwsOpList SwsOpList;
39
48
50
52{
53 switch (type) {
54 case SWS_PIXEL_U8: return sizeof(uint8_t);
55 case SWS_PIXEL_U16: return sizeof(uint16_t);
56 case SWS_PIXEL_U32: return sizeof(uint32_t);
57 case SWS_PIXEL_F32: return sizeof(float);
58 case SWS_PIXEL_NONE: break;
59 case SWS_PIXEL_TYPE_NB: break;
60 }
61 return 0;
62}
63
65{
66 switch (type) {
67 case SWS_PIXEL_U8:
68 case SWS_PIXEL_U16:
69 case SWS_PIXEL_U32:
70 return true;
71 case SWS_PIXEL_F32:
72 return false;
73 case SWS_PIXEL_NONE:
74 case SWS_PIXEL_TYPE_NB: break;
75 }
76 return false;
77}
78
79typedef union SwsPixel {
80 char data[4];
81
82 uint8_t u8;
83 uint16_t u16;
84 uint32_t u32;
85 float f32;
86} SwsPixel;
87
88/* Ensures (SwsPixel) {0} is properly initialized to all zeros */
89static_assert(sizeof(SwsPixel) == sizeof(char[4]), "SwsPixel size mismatch");
90
92{
93 switch (type) {
94 case SWS_PIXEL_U8: return (SwsPixel) { .u8 = val.num / val.den };
95 case SWS_PIXEL_U16: return (SwsPixel) { .u16 = val.num / val.den };
96 case SWS_PIXEL_U32: return (SwsPixel) { .u32 = val.num / val.den };
97 case SWS_PIXEL_F32: return (SwsPixel) { .f32 = (float) val.num / (float) val.den };
98 case SWS_PIXEL_NONE:
99 case SWS_PIXEL_TYPE_NB: break;
100 }
101 return (SwsPixel) {0};
102}
103
104/* Expand pixel value to 32-bits by repeating as necessary */
106{
107 switch (type) {
108 case SWS_PIXEL_U8: val.u32 = val.u8 * 0x01010101u; break;
109 case SWS_PIXEL_U16: val.u32 = val.u16 * 0x00010001u; break;
110 default: break;
111 }
112 return val;
113}
114
116{
117 switch (ff_sws_pixel_type_size(type)) {
118 case 1: return val.u8 == UINT8_MAX;
119 case 2: return val.u16 == UINT16_MAX;
120 case 4: return val.u32 == UINT32_MAX;
121 default: break;
122 }
123 return false;
124}
125
126/**
127 * Bit-mask of components. Exact meaning depends on the usage context.
128 */
129typedef uint8_t SwsCompMask;
130enum {
133#define SWS_COMP(X) (1 << (X))
134#define SWS_COMP_TEST(mask, X) (!!((mask) & SWS_COMP(X)))
135#define SWS_COMP_INV(mask) ((mask) ^ SWS_COMP_ALL)
136#define SWS_COMP_ELEMS(N) ((1 << (N)) - 1)
137#define SWS_COMP_COUNT(mask) (av_popcount((mask) & SWS_COMP_ALL))
138#define SWS_COMP_MASK(X, Y, Z, W) \
139 (((X) ? SWS_COMP(0) : 0) | \
140 ((Y) ? SWS_COMP(1) : 0) | \
141 ((Z) ? SWS_COMP(2) : 0) | \
142 ((W) ? SWS_COMP(3) : 0))
143};
144
145
146#define ff_sws_comp_mask_str(mask) ff_sws_comp_mask_print(mask, (char[5]){0})
147static inline char *ff_sws_comp_mask_print(SwsCompMask mask, char buf[5])
148{
149 char *ptr = buf;
150 for (int c = 0; c < 4; c++) {
151 if (SWS_COMP_TEST(mask, c))
152 *ptr++ = "xyzw"[c];
153 }
154 *ptr = '\0';
155 return buf;
156}
157
158typedef uint32_t SwsUOpFlags;
159typedef enum SwsUOpFlagBits {
161 SWS_UOP_FLAG_FMA = (1 << 0), /* platform supports FMA ops */
162 SWS_UOP_FLAG_PSHUFB = (1 << 1), /* platform supports pshufb equivalent */
163 SWS_UOP_FLAG_EXPAND_BIT = (1 << 2), /* backend implements SWS_UOP_EXPAND_BIT */
164 SWS_UOP_FLAG_READ_PALETTE = (1 << 3), /* backend implements SWS_UOP_READ_PALETTE */
165 SWS_UOP_FLAG_ADD = (1 << 4), /* backend implements SWS_UOP_ADD */
166 SWS_UOP_FLAG_PUNNING = (1 << 5), /* allow type punning float data as int */
168
169typedef enum SwsUOpType {
171
172 /* Read/write uops; mask = components to read/write */
173 SWS_UOP_READ_PLANAR, /* simple planar byte-aligned read */
174 SWS_UOP_READ_PLANAR_FH, /* planar read with horizontal filter */
175 SWS_UOP_READ_PLANAR_FV, /* planar read with vertical filter */
177 SWS_UOP_READ_PACKED, /* simple packed byte-aligned read */
178 SWS_UOP_READ_NIBBLE, /* fractional read (4 bits) from single plane */
179 SWS_UOP_READ_BIT, /* fractional read (1 bit) from single plane */
180 SWS_UOP_READ_PALETTE, /* indexed read from palette in plane 1 */
181
182 SWS_UOP_WRITE_PLANAR, /* simple planar byte-aligned write */
183 SWS_UOP_WRITE_PACKED, /* simple packed byte-aligned write */
184 SWS_UOP_WRITE_NIBBLE, /* fractional write (4 bits) to single plane */
185 SWS_UOP_WRITE_BIT, /* fractional write (1 bit) to single plane */
186
187 /* Packed shuffle / gather uops */
188 SWS_UOP_RW_SHUFFLE, /* in-place (packed) indexed shuffle/gather */
189
190 /* Data rearrangement uops; mask = needed or trivial components */
191 SWS_UOP_PERMUTE, /* permute pointers (no duplicates) */
192 SWS_UOP_COPY, /* permute data (may contain duplicates) */
193
194 /* Data conversion / manipulation uops; mask = affected components */
195 SWS_UOP_SWAP_BYTES, /* swap byte order in components */
196 SWS_UOP_EXPAND_BIT, /* expand low-order bit to all bits in type */
197 SWS_UOP_EXPAND_PAIR, /* expand bytes in pairs (16 bit) */
198 SWS_UOP_EXPAND_QUAD, /* expand bytes in quads (32 bit) */
199 SWS_UOP_TO_U8, /* cast pixel values to SWS_PIXEL_U8 */
200 SWS_UOP_TO_U16, /* cast pixel values to SWS_PIXEL_U16 */
201 SWS_UOP_TO_U32, /* cast pixel values to SWS_PIXEL_U32 */
202 SWS_UOP_TO_F32, /* cast pixel values to SWS_PIXEL_F32 */
203
204 /* Arithmetic uops */
205 SWS_UOP_SCALE, /* multiply masked components by scalar */
206 SWS_UOP_ADD, /* add vec4 to masked components */
207 SWS_UOP_MIN, /* min(x, vec4) on masked components */
208 SWS_UOP_MAX, /* max(x, vec4) on masked components */
209
210 /* Identical to corresponding SwsOpType */
211 SWS_UOP_UNPACK, /* mask = nonzero components in pack pattern */
212 SWS_UOP_PACK, /* mask = nonzero components in pack pattern */
213 SWS_UOP_LSHIFT, /* mask = components to shift */
214 SWS_UOP_RSHIFT, /* mask = components to shift */
215 SWS_UOP_CLEAR, /* mask = components to clear */
216 SWS_UOP_LINEAR, /* mask = non-trivial output rows */
217 SWS_UOP_LINEAR_FMA, /* with SWS_UOP_FLAG_FMA */
218 SWS_UOP_DITHER, /* mask = components to dither */
219 SWS_UOP_LUT_3D, /* mask = needed output components */
220
221 /* Platform-specific uops would go here */
223} SwsUOpType;
224
225typedef struct SwsShuffleUOp {
226 uint8_t clear_value; /* value to clear elements with negative indices to */
227 uint8_t read_size; /* input bytes per iteration */
228 uint8_t write_size; /* output bytes per iteration */
230
231typedef struct SwsShuffleMask {
232 int8_t mask[16]; /* shuffle index mask, or -1 to clear bytes (to `clear_value`) */
233 uint8_t pixels; /* number of pixels per iteration */
235
236typedef struct SwsFilterUOp {
237 SwsPixelType type; /* pixel type to store result as */
239
240typedef struct SwsShiftUOp {
241 uint8_t amount;
243
244typedef struct SwsMoveUOp {
245 /* The worst case number of moves (for two independent cycles) */
246 #define SWS_UOP_MOVE_MAX 6
248
249 /* This may involve a temporary register (index -1) */
250 int8_t dst[SWS_UOP_MOVE_MAX]; /* destination register index */
251 int8_t src[SWS_UOP_MOVE_MAX]; /* source register index */
252} SwsMoveUOp;
253
254typedef struct SwsPackUOp {
255 uint8_t pattern[4]; /* bit depth pattern, from MSB to LSB */
256} SwsPackUOp;
257
258/**
259 * The clear values (SwsUOp.data.vec4) are always expanded to repeating 32-bit
260 * patterns, so they remain valid if the uop is executed as a smaller type.
261 */
262typedef struct SwsClearUOp {
263 SwsCompMask one; /* mask of coefficients equal to all 1s */
264 SwsCompMask zero; /* mask of coefficients equal to all 0s */
266
267typedef struct SwsLinearUOp {
268 uint32_t one; /* mask of coefficients equal to one */
269 uint32_t zero; /* mask of coefficients equal to zero */
270
271 /* for SWS_UOP_LINEAR_FMA only */
272 uint32_t exact; /* mask of coefficients whose product is exact */
274
275#define SWS_MASK(I, J) (1 << (5 * (I) + (J)))
276#define SWS_MASK_OFF(I) SWS_MASK(I, 4)
277#define SWS_MASK_ROW(I) (0x1F << (5 * (I)))
278#define SWS_MASK_COL(J) (0x8421 << J)
279#define SWS_MASK_DIAG4 (0x41041)
280
281typedef struct SwsDitherUOp {
282 uint8_t y_offset[4];
283 uint8_t size_log2;
285
286typedef struct SwsLut3DUOp {
289
290/**
291 * Computes (1 << size_log2) + MAX(y_offset). The dither matrix attached to
292 * the SwsUOp is always pre-padded to this number of lines.
293 */
295
296typedef union SwsUOpParams {
297 SwsShuffleUOp shuffle; /* for SWS_UOP_RW_SHUFFLE */
298 SwsFilterUOp filter; /* for SWS_UOP_READ_*_FV/FH */
300 SwsMoveUOp move; /* for SWS_UOP_PERMUTE and SWS_UOP_COPY */
307
308typedef struct SwsUOp {
309 /* These fields uniquely identify the uop implementation */
314
315 /* Constant data for this uop; not part of the unique identifier */
316 union {
317 SwsFilterWeights *kernel; /* refstruct */
318 SwsPixel *ptr; /* refstruct */
321 SwsPixel mat4x5[4][5]; /* row major */
322 SwsShuffleMask shuffle; /* for SWS_UOP_RW_SHUFFLE */
323 const SwsLut3D *lut3d; /* for SWS_UOP_LUT_3D; refstruct */
324 void *opaque; /* reserved for internal use */
326} SwsUOp;
327
328/**
329 * Compare two SwsUOps for equality (excluding constant data).
330 */
331int ff_sws_uop_cmp(const SwsUOp *a, const SwsUOp *b);
332
333static inline int ff_sws_uop_cmp_v(const void *a, const void *b)
334{
335 return ff_sws_uop_cmp(a, b);
336}
337
338/**
339 * Generate a unique name for a SwsUOp.
340 */
341#define SWS_UOP_NAME_MAX 64
342void ff_sws_uop_name(const SwsUOp *op, char buf[SWS_UOP_NAME_MAX]);
343
344typedef struct SwsUOpList {
347
348 /* Additional metadata for implementations */
349 SwsCompMask planes_in; /* mask of planes read from */
350 SwsCompMask planes_out; /* mask of planes written to */
351 int pixel_size_max; /* size of largest pixel type seen in any uop */
352} SwsUOpList;
353
356void ff_sws_uop_list_remove_at(SwsUOpList *uops, int index, int count);
357
358/* Takes over ownership of `uop` and sets it to {0}, even on failure. */
360
361/**
362 * Called internally by ff_sws_ops_translate().
363 */
365
366/**
367 * Print the micro-ops of a compiled list at the given log level.
368 */
369void ff_sws_uop_list_print(void *log_ctx, int log_level, const SwsUOpList *uops);
370
371/**
372 * Translate a list of operations down to micro-ops, which can be further
373 * optimized and then directly executed by backends.
374 *
375 * Return 0 or a negative error code.
376 */
379
380/**
381 * Compute a shuffle mask for `pshufb`-style ASM functions, by repeating
382 * the shuffle pattern for as many groups as will fit.
383 *
384 * @param uop An operation of type SWS_UOP_RW_SHUFFLE.
385 * @param shuffle The output shuffle index mask (or -1 to clear bytes).
386 * @param size The maximum size (in bytes) of the output shuffle mask.
387 *
388 * @return the number of groups on success, or a negative error code.
389 *
390 * @note The shuffle mask is already pre-expanded to fill up to 16 bytes,
391 * so this is only needed for larger shuffle instructions (e.g. vpermb).
392 */
393int ff_sws_shuffle_mask(const SwsUOp *uop, int8_t shuffle[], int size);
394
395#endif
static double val(void *priv, double ch)
Definition aeval.c:77
static AVFormatContext * ctx
#define flags(name, subs,...)
Definition cbs_h264.c:74
static uint64_t shuffle(uint64_t in, const uint8_t *shuffle, int shuffle_len)
Definition des.c:179
int index
Definition gxfenc.c:90
int a
#define b
Definition input.c:43
enum MPFType type
Definition jpegmpfenc.c:55
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
Macro definitions for various function/variable attributes.
#define av_const
Definition attributes.h:111
static const uint16_t mask[17]
Definition lzw.c:38
const char data[16]
Definition mxf.c:149
64-bit extension of AVRational.
64-bit Rational number (pair of numerator and denominator).
Definition rational64.h:52
The clear values (SwsUOp.data.vec4) are always expanded to repeating 32-bit patterns,...
Definition uops.h:262
SwsCompMask one
Definition uops.h:263
SwsCompMask zero
Definition uops.h:264
Main external API structure.
Definition swscale.h:227
uint8_t size_log2
Definition uops.h:283
uint8_t y_offset[4]
Definition uops.h:282
SwsPixelType type
Definition uops.h:237
Represents a computed filter kernel.
Definition filters.h:91
uint32_t zero
Definition uops.h:269
uint32_t one
Definition uops.h:268
uint32_t exact
Definition uops.h:272
int dynamic
Definition uops.h:287
int8_t src[SWS_UOP_MOVE_MAX]
Definition uops.h:251
int num_moves
Definition uops.h:247
int8_t dst[SWS_UOP_MOVE_MAX]
Definition uops.h:250
Helper struct for representing a list of operations.
Definition ops.h:318
uint8_t pattern[4]
Definition uops.h:255
uint8_t amount
Definition uops.h:241
int8_t mask[16]
Definition uops.h:232
uint8_t pixels
Definition uops.h:233
uint8_t write_size
Definition uops.h:228
uint8_t read_size
Definition uops.h:227
uint8_t clear_value
Definition uops.h:226
SwsUOp * ops
Definition uops.h:345
int pixel_size_max
Definition uops.h:351
int num_ops
Definition uops.h:346
SwsCompMask planes_in
Definition uops.h:349
SwsCompMask planes_out
Definition uops.h:350
Definition uops.h:308
SwsPixel scalar
Definition uops.h:319
SwsCompMask mask
Definition uops.h:312
SwsUOpType uop
Definition uops.h:311
SwsUOpParams par
Definition uops.h:313
const SwsLut3D * lut3d
Definition uops.h:323
SwsFilterWeights * kernel
Definition uops.h:317
SwsPixel * ptr
Definition uops.h:318
void * opaque
Definition uops.h:324
SwsPixelType type
Definition uops.h:310
SwsShuffleMask shuffle
Definition uops.h:322
SwsPixel mat4x5[4][5]
Definition uops.h:321
SwsPixel vec4[4]
Definition uops.h:320
int size
float f32
Definition uops.h:85
uint32_t u32
Definition uops.h:84
char data[4]
Definition uops.h:80
uint8_t u8
Definition uops.h:82
uint16_t u16
Definition uops.h:83
SwsMoveUOp move
Definition uops.h:300
SwsClearUOp clear
Definition uops.h:302
SwsDitherUOp dither
Definition uops.h:304
SwsFilterUOp filter
Definition uops.h:298
SwsLut3DUOp lut3d
Definition uops.h:305
SwsShuffleUOp shuffle
Definition uops.h:297
SwsLinearUOp lin
Definition uops.h:303
SwsShiftUOp shift
Definition uops.h:299
SwsPackUOp pack
Definition uops.h:301
int ff_sws_ops_translate(SwsContext *ctx, const SwsOpList *ops, SwsUOpFlags flags, SwsUOpList *uops)
Translate a list of operations down to micro-ops, which can be further optimized and then directly ex...
Definition uops.c:644
@ SWS_COMP_ALL
Definition uops.h:132
@ SWS_COMP_NONE
Definition uops.h:131
uint32_t SwsUOpFlags
Definition uops.h:158
int ff_sws_dither_height(const SwsDitherUOp *dither)
Computes (1 << size_log2) + MAX(y_offset).
Definition uops.c:218
int ff_sws_uop_list_append(SwsUOpList *uops, SwsUOp *uop)
Definition uops.c:181
SwsPixelType
Definition uops.h:40
@ SWS_PIXEL_F32
Definition uops.h:45
@ SWS_PIXEL_U32
Definition uops.h:44
@ SWS_PIXEL_U16
Definition uops.h:43
@ SWS_PIXEL_TYPE_NB
Definition uops.h:46
@ SWS_PIXEL_NONE
Definition uops.h:41
@ SWS_PIXEL_U8
Definition uops.h:42
void ff_sws_uop_list_print(void *log_ctx, int log_level, const SwsUOpList *uops)
Print the micro-ops of a compiled list at the given log level.
Definition uops.c:205
int ff_sws_uop_list_optimize(SwsContext *ctx, SwsUOpFlags flags, SwsUOpList *uops)
Called internally by ff_sws_ops_translate().
#define SWS_UOP_MOVE_MAX
Definition uops.h:246
void ff_sws_uop_name(const SwsUOp *op, char buf[SWS_UOP_NAME_MAX])
Definition uops.c:54
int ff_sws_uop_cmp(const SwsUOp *a, const SwsUOp *b)
Compare two SwsUOps for equality (excluding constant data).
Definition uops.c:35
#define SWS_COMP_TEST(mask, X)
Definition uops.h:134
SwsUOpType
Definition uops.h:169
@ SWS_UOP_TO_U8
Definition uops.h:199
@ SWS_UOP_PACK
Definition uops.h:212
@ SWS_UOP_PERMUTE
Definition uops.h:191
@ SWS_UOP_EXPAND_QUAD
Definition uops.h:198
@ SWS_UOP_READ_PLANAR
Definition uops.h:173
@ SWS_UOP_WRITE_PLANAR
Definition uops.h:182
@ SWS_UOP_READ_NIBBLE
Definition uops.h:178
@ SWS_UOP_MAX
Definition uops.h:208
@ SWS_UOP_READ_BIT
Definition uops.h:179
@ SWS_UOP_SWAP_BYTES
Definition uops.h:195
@ SWS_UOP_MIN
Definition uops.h:207
@ SWS_UOP_LINEAR
Definition uops.h:216
@ SWS_UOP_RSHIFT
Definition uops.h:214
@ SWS_UOP_COPY
Definition uops.h:192
@ SWS_UOP_WRITE_NIBBLE
Definition uops.h:184
@ SWS_UOP_INVALID
Definition uops.h:170
@ SWS_UOP_LINEAR_FMA
Definition uops.h:217
@ SWS_UOP_READ_PLANAR_FH
Definition uops.h:174
@ SWS_UOP_SCALE
Definition uops.h:205
@ SWS_UOP_WRITE_PACKED
Definition uops.h:183
@ SWS_UOP_WRITE_BIT
Definition uops.h:185
@ SWS_UOP_READ_PLANAR_FV_FMA
Definition uops.h:176
@ SWS_UOP_READ_PACKED
Definition uops.h:177
@ SWS_UOP_LUT_3D
Definition uops.h:219
@ SWS_UOP_EXPAND_PAIR
Definition uops.h:197
@ SWS_UOP_TO_U16
Definition uops.h:200
@ SWS_UOP_DITHER
Definition uops.h:218
@ SWS_UOP_ADD
Definition uops.h:206
@ SWS_UOP_TYPE_NB
Definition uops.h:222
@ SWS_UOP_CLEAR
Definition uops.h:215
@ SWS_UOP_READ_PALETTE
Definition uops.h:180
@ SWS_UOP_EXPAND_BIT
Definition uops.h:196
@ SWS_UOP_READ_PLANAR_FV
Definition uops.h:175
@ SWS_UOP_TO_U32
Definition uops.h:201
@ SWS_UOP_RW_SHUFFLE
Definition uops.h:188
@ SWS_UOP_UNPACK
Definition uops.h:211
@ SWS_UOP_TO_F32
Definition uops.h:202
@ SWS_UOP_LSHIFT
Definition uops.h:213
SwsUOpList * ff_sws_uop_list_alloc(void)
Definition uops.c:176
const char * ff_sws_pixel_type_name(SwsPixelType type)
Definition ops.c:56
static int ff_sws_uop_cmp_v(const void *a, const void *b)
Definition uops.h:333
void ff_sws_uop_list_remove_at(SwsUOpList *uops, int index, int count)
Definition uops.c:194
static bool ff_sws_pixel_is_1s(SwsPixelType type, SwsPixel val)
Definition uops.h:115
static char * ff_sws_comp_mask_print(SwsCompMask mask, char buf[5])
Definition uops.h:147
static SwsPixel ff_sws_pixel_expand32(SwsPixelType type, SwsPixel val)
Definition uops.h:105
static SwsPixel ff_sws_pixel_from_q64(SwsPixelType type, AVRational64 val)
Definition uops.h:91
SwsUOpFlagBits
Definition uops.h:159
@ SWS_UOP_FLAG_FMA
Definition uops.h:161
@ SWS_UOP_FLAG_PSHUFB
Definition uops.h:162
@ SWS_UOP_FLAG_EXPAND_BIT
Definition uops.h:163
@ SWS_UOP_FLAG_NONE
Definition uops.h:160
@ SWS_UOP_FLAG_ADD
Definition uops.h:165
@ SWS_UOP_FLAG_READ_PALETTE
Definition uops.h:164
@ SWS_UOP_FLAG_PUNNING
Definition uops.h:166
int ff_sws_shuffle_mask(const SwsUOp *uop, int8_t shuffle[], int size)
Compute a shuffle mask for pshufb-style ASM functions, by repeating the shuffle pattern for as many g...
#define SWS_UOP_NAME_MAX
Generate a unique name for a SwsUOp.
Definition uops.h:341
static av_const bool ff_sws_pixel_type_is_int(SwsPixelType type)
Definition uops.h:64
uint8_t SwsCompMask
Bit-mask of components.
Definition uops.h:129
static av_const int ff_sws_pixel_type_size(SwsPixelType type)
Definition uops.h:51
void ff_sws_uop_list_free(SwsUOpList **ops)
Definition uops.c:162
static const uint16_t dither[8][8]
Definition vf_gradfun.c:46
static double c[64]