Go to the documentation of this file.
32 #define KNOWN(l) (!FF_LAYOUT2COUNT(l))
37 #define MERGE_REF(ret, a, fmts, type, fail) \
42 if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
47 for (i = 0; i < a->refcount; i ++) { \
48 ret->refs[ret->refcount] = a->refs[i]; \
49 *ret->refs[ret->refcount++] = ret; \
61 #define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail) \
63 int i, j, k = 0, count = FFMIN(a->nb, b->nb); \
65 if (!(ret = av_mallocz(sizeof(*ret)))) \
69 if (!(ret->fmts = av_malloc_array(count, sizeof(*ret->fmts)))) \
71 for (i = 0; i < a->nb; i++) \
72 for (j = 0; j < b->nb; j++) \
73 if (a->fmts[i] == b->fmts[j]) { \
74 if(k >= FFMIN(a->nb, b->nb)){ \
75 av_log(NULL, AV_LOG_ERROR, "Duplicate formats in %s detected\n", __FUNCTION__); \
80 ret->fmts[k++] = a->fmts[i]; \
88 MERGE_REF(ret, a, fmts, type, fail); \
89 MERGE_REF(ret, b, fmts, type, fail); \
97 int alpha1=0, alpha2=0;
98 int chroma1=0, chroma2=0;
111 for (
i = 0;
i <
a->nb_formats;
i++)
112 for (j = 0; j <
b->nb_formats; j++) {
117 if (
a->formats[
i] ==
b->formats[j]) {
124 if (alpha2 > alpha1 || chroma2 > chroma1)
144 if (
a ==
b)
return a;
146 if (
a->nb_formats &&
b->nb_formats) {
148 }
else if (
a->nb_formats) {
170 unsigned a_all =
a->all_layouts +
a->all_counts;
171 unsigned b_all =
b->all_layouts +
b->all_counts;
172 int ret_max, ret_nb = 0,
i, j,
round;
174 if (
a ==
b)
return a;
179 FFSWAP(
unsigned, a_all, b_all);
182 if (a_all == 1 && !b_all) {
184 for (
i = j = 0;
i <
b->nb_channel_layouts;
i++)
185 if (
KNOWN(
b->channel_layouts[
i]))
186 b->channel_layouts[j++] =
b->channel_layouts[
i];
191 b->nb_channel_layouts = j;
197 ret_max =
a->nb_channel_layouts +
b->nb_channel_layouts;
200 sizeof(*
ret->channel_layouts))))
204 for (
i = 0;
i <
a->nb_channel_layouts;
i++) {
205 if (!
KNOWN(
a->channel_layouts[
i]))
207 for (j = 0; j <
b->nb_channel_layouts; j++) {
208 if (
a->channel_layouts[
i] ==
b->channel_layouts[j]) {
209 ret->channel_layouts[ret_nb++] =
a->channel_layouts[
i];
210 a->channel_layouts[
i] =
b->channel_layouts[j] = 0;
217 for (
i = 0;
i <
a->nb_channel_layouts;
i++) {
218 uint64_t fmt =
a->channel_layouts[
i], bfmt;
219 if (!fmt || !
KNOWN(fmt))
222 for (j = 0; j <
b->nb_channel_layouts; j++)
223 if (
b->channel_layouts[j] == bfmt)
224 ret->channel_layouts[ret_nb++] =
a->channel_layouts[
i];
230 for (
i = 0;
i <
a->nb_channel_layouts;
i++) {
231 if (
KNOWN(
a->channel_layouts[
i]))
233 for (j = 0; j <
b->nb_channel_layouts; j++)
234 if (
a->channel_layouts[
i] ==
b->channel_layouts[j])
235 ret->channel_layouts[ret_nb++] =
a->channel_layouts[
i];
238 ret->nb_channel_layouts = ret_nb;
239 if (!
ret->nb_channel_layouts)
258 for (p = fmts; *p != -1; p++) {
265 #define MAKE_FORMAT_LIST(type, field, count_field) \
269 for (count = 0; fmts[count] != -1; count++) \
271 formats = av_mallocz(sizeof(*formats)); \
274 formats->count_field = count; \
276 formats->field = av_malloc_array(count, sizeof(*formats->field)); \
277 if (!formats->field) { \
278 av_freep(&formats); \
287 formats->formats[count] = fmts[count];
297 memcpy(
formats->channel_layouts, fmts,
298 sizeof(*
formats->channel_layouts) * count);
308 memcpy(
formats->channel_layouts, fmts,
309 sizeof(*
formats->channel_layouts) * count);
314 #define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
319 if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
320 return AVERROR(ENOMEM); \
323 fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
324 sizeof(*(*f)->list)); \
329 return AVERROR(ENOMEM); \
333 (*f)->list[(*f)->nb++] = fmt; \
373 unsigned nb_formats, fmt,
flags;
378 for (fmt = 0;; fmt++) {
385 (
desc->log2_chroma_w ||
desc->log2_chroma_h))
387 if ((
flags & (want | rej)) != want)
390 formats->formats[nb_formats] = fmt;
401 formats->nb_formats = nb_formats;
436 ret->all_layouts = 1;
445 ret->all_layouts =
ret->all_counts = 1;
449 #define FORMATS_REF(f, ref, unref_fn) \
453 return AVERROR(ENOMEM); \
455 tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1); \
458 return AVERROR(ENOMEM); \
461 f->refs[f->refcount++] = ref; \
475 #define FIND_REF_INDEX(ref, idx) \
478 for (i = 0; i < (*ref)->refcount; i ++) \
479 if((*ref)->refs[i] == ref) { \
485 #define FORMATS_UNREF(ref, list) \
489 if (!ref || !*ref || !(*ref)->refs) \
492 FIND_REF_INDEX(ref, idx); \
495 memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
496 sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
498 if(!--(*ref)->refcount) { \
499 av_free((*ref)->list); \
500 av_free((*ref)->refs); \
516 #define FORMATS_CHANGEREF(oldref, newref) \
520 FIND_REF_INDEX(oldref, idx); \
523 (*oldref)->refs[idx] = newref; \
540 #define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref_fn, unref_fn, list) \
544 return AVERROR(ENOMEM); \
546 for (i = 0; i < ctx->nb_inputs; i++) { \
547 if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \
548 int ret = ref_fn(fmts, &ctx->inputs[i]->out_fmts); \
552 av_freep(&fmts->list); \
559 for (i = 0; i < ctx->nb_outputs; i++) { \
560 if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \
561 int ret = ref_fn(fmts, &ctx->outputs[i]->in_fmts); \
565 av_freep(&fmts->list); \
574 av_freep(&fmts->list); \
575 av_freep(&fmts->refs); \
611 ctx->outputs &&
ctx->outputs[0] ?
ctx->outputs[0]->type :
661 sfmt = strtol(
arg, &tail, 0);
686 if (*tail || srate < 1 || (
int)srate != srate || srate > INT_MAX) {
704 if (!chlayout && !nret) {
A list of supported channel layouts.
AVPixelFormat
Pixel format.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
#define FFSWAP(type, a, b)
enum MovChannelLayoutTag * layouts
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
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 type
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static enum AVPixelFormat pix_fmt
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
uint8_t nb_components
The number of components each pixel has, (1-4)
Rational number (pair of numerator and denominator).
int av_parse_ratio(AVRational *q, const char *str, int max, int log_offset, void *log_ctx)
Parse str and store the parsed ratio in q.
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
char all_layouts
accept any known channel layout
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
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
#define i(width, name, range_min, range_max)
static av_always_inline av_const double round(double x)
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
enum AVSampleFormat av_get_sample_fmt(const char *name)
Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.
#define av_malloc_array(a, b)
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
AVSampleFormat
Audio sample formats.
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
static int ref[MAX_W *MAX_W]
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
int av_get_extended_channel_layout(const char *name, uint64_t *channel_layout, int *nb_channels)
Return a channel layout and the number of channels based on the specified name.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
static const uint16_t channel_layouts[7]
#define flags(name, subs,...)