FFmpeg
avfiltergraph.c
Go to the documentation of this file.
1 /*
2  * filter graphs
3  * Copyright (c) 2008 Vitor Sessak
4  * Copyright (c) 2007 Bobby Bingham
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "config.h"
24 
25 #include <string.h>
26 
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/bprint.h"
31 #include "libavutil/imgutils.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/opt.h"
34 #include "libavutil/pixdesc.h"
35 
36 #define FF_INTERNAL_FIELDS 1
37 #include "framequeue.h"
38 
39 #include "avfilter.h"
40 #include "buffersink.h"
41 #include "formats.h"
42 #include "internal.h"
43 #include "thread.h"
44 
45 #define OFFSET(x) offsetof(AVFilterGraph, x)
46 #define F AV_OPT_FLAG_FILTERING_PARAM
47 #define V AV_OPT_FLAG_VIDEO_PARAM
48 #define A AV_OPT_FLAG_AUDIO_PARAM
49 static const AVOption filtergraph_options[] = {
50  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
51  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, F|V|A, "thread_type" },
52  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = F|V|A, .unit = "thread_type" },
53  { "threads", "Maximum number of threads", OFFSET(nb_threads),
54  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, F|V|A },
55  {"scale_sws_opts" , "default scale filter options" , OFFSET(scale_sws_opts) ,
56  AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, F|V },
57  {"aresample_swr_opts" , "default aresample filter options" , OFFSET(aresample_swr_opts) ,
58  AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, F|A },
59  { NULL },
60 };
61 
62 static const AVClass filtergraph_class = {
63  .class_name = "AVFilterGraph",
64  .item_name = av_default_item_name,
65  .version = LIBAVUTIL_VERSION_INT,
66  .option = filtergraph_options,
67  .category = AV_CLASS_CATEGORY_FILTER,
68 };
69 
70 #if !HAVE_THREADS
72 {
73 }
74 
76 {
77  graph->thread_type = 0;
78  graph->nb_threads = 1;
79  return 0;
80 }
81 #endif
82 
84 {
85  AVFilterGraph *ret = av_mallocz(sizeof(*ret));
86  if (!ret)
87  return NULL;
88 
89  ret->internal = av_mallocz(sizeof(*ret->internal));
90  if (!ret->internal) {
91  av_freep(&ret);
92  return NULL;
93  }
94 
95  ret->av_class = &filtergraph_class;
97  ff_framequeue_global_init(&ret->internal->frame_queues);
98 
99  return ret;
100 }
101 
103 {
104  int i, j;
105  for (i = 0; i < graph->nb_filters; i++) {
106  if (graph->filters[i] == filter) {
107  FFSWAP(AVFilterContext*, graph->filters[i],
108  graph->filters[graph->nb_filters - 1]);
109  graph->nb_filters--;
110  filter->graph = NULL;
111  for (j = 0; j<filter->nb_outputs; j++)
112  if (filter->outputs[j])
113  filter->outputs[j]->graph = NULL;
114 
115  return;
116  }
117  }
118 }
119 
121 {
122  if (!*graph)
123  return;
124 
125  while ((*graph)->nb_filters)
126  avfilter_free((*graph)->filters[0]);
127 
129 
130  av_freep(&(*graph)->sink_links);
131 
132  av_freep(&(*graph)->scale_sws_opts);
133  av_freep(&(*graph)->aresample_swr_opts);
134  av_freep(&(*graph)->filters);
135  av_freep(&(*graph)->internal);
136  av_freep(graph);
137 }
138 
140  const char *name, const char *args, void *opaque,
141  AVFilterGraph *graph_ctx)
142 {
143  int ret;
144 
145  *filt_ctx = avfilter_graph_alloc_filter(graph_ctx, filt, name);
146  if (!*filt_ctx)
147  return AVERROR(ENOMEM);
148 
149  ret = avfilter_init_str(*filt_ctx, args);
150  if (ret < 0)
151  goto fail;
152 
153  return 0;
154 
155 fail:
156  if (*filt_ctx)
157  avfilter_free(*filt_ctx);
158  *filt_ctx = NULL;
159  return ret;
160 }
161 
163 {
164  graph->disable_auto_convert = flags;
165 }
166 
168  const AVFilter *filter,
169  const char *name)
170 {
172 
173  if (graph->thread_type && !graph->internal->thread_execute) {
174  if (graph->execute) {
175  graph->internal->thread_execute = graph->execute;
176  } else {
178  if (ret < 0) {
179  av_log(graph, AV_LOG_ERROR, "Error initializing threading: %s.\n", av_err2str(ret));
180  return NULL;
181  }
182  }
183  }
184 
186  if (!s)
187  return NULL;
188 
189  filters = av_realloc(graph->filters, sizeof(*filters) * (graph->nb_filters + 1));
190  if (!filters) {
191  avfilter_free(s);
192  return NULL;
193  }
194 
195  graph->filters = filters;
196  graph->filters[graph->nb_filters++] = s;
197 
198  s->graph = graph;
199 
200  return s;
201 }
202 
203 /**
204  * Check for the validity of graph.
205  *
206  * A graph is considered valid if all its input and output pads are
207  * connected.
208  *
209  * @return >= 0 in case of success, a negative value otherwise
210  */
212 {
214  int i, j;
215 
216  for (i = 0; i < graph->nb_filters; i++) {
217  const AVFilterPad *pad;
218  filt = graph->filters[i];
219 
220  for (j = 0; j < filt->nb_inputs; j++) {
221  if (!filt->inputs[j] || !filt->inputs[j]->src) {
222  pad = &filt->input_pads[j];
223  av_log(log_ctx, AV_LOG_ERROR,
224  "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",
225  pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
226  return AVERROR(EINVAL);
227  }
228  }
229 
230  for (j = 0; j < filt->nb_outputs; j++) {
231  if (!filt->outputs[j] || !filt->outputs[j]->dst) {
232  pad = &filt->output_pads[j];
233  av_log(log_ctx, AV_LOG_ERROR,
234  "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",
235  pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
236  return AVERROR(EINVAL);
237  }
238  }
239  }
240 
241  return 0;
242 }
243 
244 /**
245  * Configure all the links of graphctx.
246  *
247  * @return >= 0 in case of success, a negative value otherwise
248  */
250 {
252  int i, ret;
253 
254  for (i = 0; i < graph->nb_filters; i++) {
255  filt = graph->filters[i];
256 
257  if (!filt->nb_outputs) {
258  if ((ret = avfilter_config_links(filt)))
259  return ret;
260  }
261  }
262 
263  return 0;
264 }
265 
267 {
269  AVFilterLink *l;
270  unsigned i, j;
271  int ret;
272 
273  for (i = 0; i < graph->nb_filters; i++) {
274  f = graph->filters[i];
275  for (j = 0; j < f->nb_outputs; j++) {
276  l = f->outputs[j];
277  if (l->type == AVMEDIA_TYPE_VIDEO) {
278  ret = av_image_check_size2(l->w, l->h, INT64_MAX, l->format, 0, f);
279  if (ret < 0)
280  return ret;
281  }
282  }
283  }
284  return 0;
285 }
286 
288 {
289  int i;
290 
291  for (i = 0; i < graph->nb_filters; i++)
292  if (graph->filters[i]->name && !strcmp(name, graph->filters[i]->name))
293  return graph->filters[i];
294 
295  return NULL;
296 }
297 
299 {
300  if (!l)
301  return;
302  if (l->nb_channel_layouts) {
303  if (l->all_layouts || l->all_counts)
304  av_log(log, AV_LOG_WARNING, "All layouts set on non-empty list\n");
305  l->all_layouts = l->all_counts = 0;
306  } else {
307  if (l->all_counts && !l->all_layouts)
308  av_log(log, AV_LOG_WARNING, "All counts without all layouts\n");
309  l->all_layouts = 1;
310  }
311 }
312 
314 {
315  int ret;
316 
317  switch (link->type) {
318 
319  case AVMEDIA_TYPE_VIDEO:
320  if ((ret = ff_formats_check_pixel_formats(log, cfg->formats)) < 0)
321  return ret;
322  break;
323 
324  case AVMEDIA_TYPE_AUDIO:
325  if ((ret = ff_formats_check_sample_formats(log, cfg->formats)) < 0 ||
326  (ret = ff_formats_check_sample_rates(log, cfg->samplerates)) < 0 ||
328  return ret;
329  break;
330 
331  default:
332  av_assert0(!"reached");
333  }
334  return 0;
335 }
336 
337 /**
338  * Check the validity of the formats / etc. lists set by query_formats().
339  *
340  * In particular, check they do not contain any redundant element.
341  */
343 {
344  unsigned i;
345  int ret;
346 
347  for (i = 0; i < ctx->nb_inputs; i++) {
348  ret = filter_link_check_formats(ctx, ctx->inputs[i], &ctx->inputs[i]->outcfg);
349  if (ret < 0)
350  return ret;
351  }
352  for (i = 0; i < ctx->nb_outputs; i++) {
353  ret = filter_link_check_formats(ctx, ctx->outputs[i], &ctx->outputs[i]->incfg);
354  if (ret < 0)
355  return ret;
356  }
357  return 0;
358 }
359 
361 {
362  int ret, i;
364  AVFilterChannelLayouts *chlayouts;
365  AVFilterFormats *samplerates;
366  enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
367  ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
369 
370  if ((ret = ctx->filter->query_formats(ctx)) < 0) {
371  if (ret != AVERROR(EAGAIN))
372  av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
373  ctx->name, av_err2str(ret));
374  return ret;
375  }
377  if (ret < 0)
378  return ret;
379 
380  for (i = 0; i < ctx->nb_inputs; i++)
381  sanitize_channel_layouts(ctx, ctx->inputs[i]->outcfg.channel_layouts);
382  for (i = 0; i < ctx->nb_outputs; i++)
383  sanitize_channel_layouts(ctx, ctx->outputs[i]->incfg.channel_layouts);
384 
386  if ((ret = ff_set_common_formats(ctx, formats)) < 0)
387  return ret;
388  if (type == AVMEDIA_TYPE_AUDIO) {
389  samplerates = ff_all_samplerates();
390  if ((ret = ff_set_common_samplerates(ctx, samplerates)) < 0)
391  return ret;
392  chlayouts = ff_all_channel_layouts();
393  if ((ret = ff_set_common_channel_layouts(ctx, chlayouts)) < 0)
394  return ret;
395  }
396  return 0;
397 }
398 
400 {
401  int i;
402 
403  for (i = 0; i < f->nb_inputs; i++) {
404  if (!f->inputs[i]->outcfg.formats)
405  return 0;
406  if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&
407  !(f->inputs[i]->outcfg.samplerates &&
408  f->inputs[i]->outcfg.channel_layouts))
409  return 0;
410  }
411  for (i = 0; i < f->nb_outputs; i++) {
412  if (!f->outputs[i]->incfg.formats)
413  return 0;
414  if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&
415  !(f->outputs[i]->incfg.samplerates &&
416  f->outputs[i]->incfg.channel_layouts))
417  return 0;
418  }
419  return 1;
420 }
421 
422 /**
423  * Perform one round of query_formats() and merging formats lists on the
424  * filter graph.
425  * @return >=0 if all links formats lists could be queried and merged;
426  * AVERROR(EAGAIN) some progress was made in the queries or merging
427  * and a later call may succeed;
428  * AVERROR(EIO) (may be changed) plus a log message if no progress
429  * was made and the negotiation is stuck;
430  * a negative error code if some other error happened
431  */
432 static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
433 {
434  int i, j, ret;
435  int scaler_count = 0, resampler_count = 0;
436  int count_queried = 0; /* successful calls to query_formats() */
437  int count_merged = 0; /* successful merge of formats lists */
438  int count_already_merged = 0; /* lists already merged */
439  int count_delayed = 0; /* lists that need to be merged later */
440 
441  for (i = 0; i < graph->nb_filters; i++) {
442  AVFilterContext *f = graph->filters[i];
443  if (formats_declared(f))
444  continue;
445  if (f->filter->query_formats)
447  else
449  if (ret < 0 && ret != AVERROR(EAGAIN))
450  return ret;
451  /* note: EAGAIN could indicate a partial success, not counted yet */
452  count_queried += ret >= 0;
453  }
454 
455  /* go through and merge as many format lists as possible */
456  for (i = 0; i < graph->nb_filters; i++) {
457  AVFilterContext *filter = graph->filters[i];
458 
459  for (j = 0; j < filter->nb_inputs; j++) {
460  AVFilterLink *link = filter->inputs[j];
461  int convert_needed = 0;
462 
463  if (!link)
464  continue;
465 
466  if (link->incfg.formats != link->outcfg.formats
467  && link->incfg.formats && link->outcfg.formats)
468  if (!ff_can_merge_formats(link->incfg.formats, link->outcfg.formats,
469  link->type))
470  convert_needed = 1;
471  if (link->type == AVMEDIA_TYPE_AUDIO) {
472  if (link->incfg.samplerates != link->outcfg.samplerates
473  && link->incfg.samplerates && link->outcfg.samplerates)
474  if (!ff_can_merge_samplerates(link->incfg.samplerates,
475  link->outcfg.samplerates))
476  convert_needed = 1;
477  }
478 
479 #define CHECKED_MERGE(field, ...) ((ret = ff_merge_ ## field(__VA_ARGS__)) <= 0)
480 #define MERGE_DISPATCH(field, ...) \
481  if (!(link->incfg.field && link->outcfg.field)) { \
482  count_delayed++; \
483  } else if (link->incfg.field == link->outcfg.field) { \
484  count_already_merged++; \
485  } else if (!convert_needed) { \
486  count_merged++; \
487  if (CHECKED_MERGE(field, __VA_ARGS__)) { \
488  if (ret < 0) \
489  return ret; \
490  convert_needed = 1; \
491  } \
492  }
493 
494  if (link->type == AVMEDIA_TYPE_AUDIO) {
495  MERGE_DISPATCH(channel_layouts, link->incfg.channel_layouts,
496  link->outcfg.channel_layouts)
497  MERGE_DISPATCH(samplerates, link->incfg.samplerates,
498  link->outcfg.samplerates)
499  }
500  MERGE_DISPATCH(formats, link->incfg.formats,
501  link->outcfg.formats, link->type)
502 #undef MERGE_DISPATCH
503 
504  if (convert_needed) {
506  const AVFilter *filter;
507  AVFilterLink *inlink, *outlink;
508  char inst_name[30];
509 
510  if (graph->disable_auto_convert) {
511  av_log(log_ctx, AV_LOG_ERROR,
512  "The filters '%s' and '%s' do not have a common format "
513  "and automatic conversion is disabled.\n",
514  link->src->name, link->dst->name);
515  return AVERROR(EINVAL);
516  }
517 
518  /* couldn't merge format lists. auto-insert conversion filter */
519  switch (link->type) {
520  case AVMEDIA_TYPE_VIDEO:
521  if (!(filter = avfilter_get_by_name("scale"))) {
522  av_log(log_ctx, AV_LOG_ERROR, "'scale' filter "
523  "not present, cannot convert pixel formats.\n");
524  return AVERROR(EINVAL);
525  }
526 
527  snprintf(inst_name, sizeof(inst_name), "auto_scaler_%d",
528  scaler_count++);
529 
531  inst_name, graph->scale_sws_opts, NULL,
532  graph)) < 0)
533  return ret;
534  break;
535  case AVMEDIA_TYPE_AUDIO:
536  if (!(filter = avfilter_get_by_name("aresample"))) {
537  av_log(log_ctx, AV_LOG_ERROR, "'aresample' filter "
538  "not present, cannot convert audio formats.\n");
539  return AVERROR(EINVAL);
540  }
541 
542  snprintf(inst_name, sizeof(inst_name), "auto_resampler_%d",
543  resampler_count++);
545  inst_name, graph->aresample_swr_opts,
546  NULL, graph)) < 0)
547  return ret;
548  break;
549  default:
550  return AVERROR(EINVAL);
551  }
552 
553  if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
554  return ret;
555 
556  if ((ret = filter_query_formats(convert)) < 0)
557  return ret;
558 
559  inlink = convert->inputs[0];
560  outlink = convert->outputs[0];
561  av_assert0( inlink->incfg.formats->refcount > 0);
562  av_assert0( inlink->outcfg.formats->refcount > 0);
563  av_assert0(outlink->incfg.formats->refcount > 0);
564  av_assert0(outlink->outcfg.formats->refcount > 0);
565  if (outlink->type == AVMEDIA_TYPE_AUDIO) {
566  av_assert0( inlink-> incfg.samplerates->refcount > 0);
567  av_assert0( inlink->outcfg.samplerates->refcount > 0);
568  av_assert0(outlink-> incfg.samplerates->refcount > 0);
569  av_assert0(outlink->outcfg.samplerates->refcount > 0);
570  av_assert0( inlink-> incfg.channel_layouts->refcount > 0);
571  av_assert0( inlink->outcfg.channel_layouts->refcount > 0);
572  av_assert0(outlink-> incfg.channel_layouts->refcount > 0);
573  av_assert0(outlink->outcfg.channel_layouts->refcount > 0);
574  }
575  if (CHECKED_MERGE(formats, inlink->incfg.formats,
576  inlink->outcfg.formats, inlink->type) ||
578  outlink->outcfg.formats, outlink->type) ||
579  inlink->type == AVMEDIA_TYPE_AUDIO &&
580  (CHECKED_MERGE(samplerates, inlink->incfg.samplerates,
581  inlink->outcfg.samplerates) ||
582  CHECKED_MERGE(channel_layouts, inlink->incfg.channel_layouts,
583  inlink->outcfg.channel_layouts)) ||
584  outlink->type == AVMEDIA_TYPE_AUDIO &&
585  (CHECKED_MERGE(samplerates, outlink->incfg.samplerates,
586  outlink->outcfg.samplerates) ||
588  outlink->outcfg.channel_layouts))) {
589  if (ret < 0)
590  return ret;
591  av_log(log_ctx, AV_LOG_ERROR,
592  "Impossible to convert between the formats supported by the filter "
593  "'%s' and the filter '%s'\n", link->src->name, link->dst->name);
594  return AVERROR(ENOSYS);
595  }
596  }
597  }
598  }
599 
600  av_log(graph, AV_LOG_DEBUG, "query_formats: "
601  "%d queried, %d merged, %d already done, %d delayed\n",
602  count_queried, count_merged, count_already_merged, count_delayed);
603  if (count_delayed) {
604  AVBPrint bp;
605 
606  /* if count_queried > 0, one filter at least did set its formats,
607  that will give additional information to its neighbour;
608  if count_merged > 0, one pair of formats lists at least was merged,
609  that will give additional information to all connected filters;
610  in both cases, progress was made and a new round must be done */
611  if (count_queried || count_merged)
612  return AVERROR(EAGAIN);
614  for (i = 0; i < graph->nb_filters; i++)
615  if (!formats_declared(graph->filters[i]))
616  av_bprintf(&bp, "%s%s", bp.len ? ", " : "",
617  graph->filters[i]->name);
619  "The following filters could not choose their formats: %s\n"
620  "Consider inserting the (a)format filter near their input or "
621  "output.\n", bp.str);
622  return AVERROR(EIO);
623  }
624  return 0;
625 }
626 
627 static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
628 {
629  int score = 0;
630 
631  if (av_sample_fmt_is_planar(dst_fmt) != av_sample_fmt_is_planar(src_fmt))
632  score ++;
633 
634  if (av_get_bytes_per_sample(dst_fmt) < av_get_bytes_per_sample(src_fmt)) {
635  score += 100 * (av_get_bytes_per_sample(src_fmt) - av_get_bytes_per_sample(dst_fmt));
636  }else
637  score += 10 * (av_get_bytes_per_sample(dst_fmt) - av_get_bytes_per_sample(src_fmt));
638 
641  score += 20;
642 
645  score += 2;
646 
647  return score;
648 }
649 
651  enum AVSampleFormat src_fmt)
652 {
653  int score1, score2;
654 
655  score1 = get_fmt_score(dst_fmt1, src_fmt);
656  score2 = get_fmt_score(dst_fmt2, src_fmt);
657 
658  return score1 < score2 ? dst_fmt1 : dst_fmt2;
659 }
660 
662 {
663  if (!link || !link->incfg.formats)
664  return 0;
665 
666  if (link->type == AVMEDIA_TYPE_VIDEO) {
667  if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
668  //FIXME: This should check for AV_PIX_FMT_FLAG_ALPHA after PAL8 pixel format without alpha is implemented
669  int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
670  enum AVPixelFormat best= AV_PIX_FMT_NONE;
671  int i;
672  for (i = 0; i < link->incfg.formats->nb_formats; i++) {
673  enum AVPixelFormat p = link->incfg.formats->formats[i];
674  best= av_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL);
675  }
676  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",
677  av_get_pix_fmt_name(best), link->incfg.formats->nb_formats,
678  av_get_pix_fmt_name(ref->format), has_alpha);
679  link->incfg.formats->formats[0] = best;
680  }
681  } else if (link->type == AVMEDIA_TYPE_AUDIO) {
682  if(ref && ref->type == AVMEDIA_TYPE_AUDIO){
684  int i;
685  for (i = 0; i < link->incfg.formats->nb_formats; i++) {
686  enum AVSampleFormat p = link->incfg.formats->formats[i];
687  best = find_best_sample_fmt_of_2(best, p, ref->format);
688  }
689  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s\n",
690  av_get_sample_fmt_name(best), link->incfg.formats->nb_formats,
691  av_get_sample_fmt_name(ref->format));
692  link->incfg.formats->formats[0] = best;
693  }
694  }
695 
696  link->incfg.formats->nb_formats = 1;
697  link->format = link->incfg.formats->formats[0];
698 
699  if (link->type == AVMEDIA_TYPE_AUDIO) {
700  if (!link->incfg.samplerates->nb_formats) {
701  av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
702  " the link between filters %s and %s.\n", link->src->name,
703  link->dst->name);
704  return AVERROR(EINVAL);
705  }
706  link->incfg.samplerates->nb_formats = 1;
707  link->sample_rate = link->incfg.samplerates->formats[0];
708 
709  if (link->incfg.channel_layouts->all_layouts) {
710  av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
711  " the link between filters %s and %s.\n", link->src->name,
712  link->dst->name);
713  if (!link->incfg.channel_layouts->all_counts)
714  av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not "
715  "supported, try specifying a channel layout using "
716  "'aformat=channel_layouts=something'.\n");
717  return AVERROR(EINVAL);
718  }
719  link->incfg.channel_layouts->nb_channel_layouts = 1;
720  link->channel_layout = link->incfg.channel_layouts->channel_layouts[0];
722  link->channel_layout = 0;
723  else
725  }
726 
727  ff_formats_unref(&link->incfg.formats);
728  ff_formats_unref(&link->outcfg.formats);
729  ff_formats_unref(&link->incfg.samplerates);
730  ff_formats_unref(&link->outcfg.samplerates);
731  ff_channel_layouts_unref(&link->incfg.channel_layouts);
732  ff_channel_layouts_unref(&link->outcfg.channel_layouts);
733 
734  return 0;
735 }
736 
737 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
738 do { \
739  for (i = 0; i < filter->nb_inputs; i++) { \
740  AVFilterLink *link = filter->inputs[i]; \
741  fmt_type fmt; \
742  \
743  if (!link->outcfg.list || link->outcfg.list->nb != 1) \
744  continue; \
745  fmt = link->outcfg.list->var[0]; \
746  \
747  for (j = 0; j < filter->nb_outputs; j++) { \
748  AVFilterLink *out_link = filter->outputs[j]; \
749  list_type *fmts; \
750  \
751  if (link->type != out_link->type || \
752  out_link->incfg.list->nb == 1) \
753  continue; \
754  fmts = out_link->incfg.list; \
755  \
756  if (!out_link->incfg.list->nb) { \
757  if ((ret = add_format(&out_link->incfg.list, fmt)) < 0)\
758  return ret; \
759  ret = 1; \
760  break; \
761  } \
762  \
763  for (k = 0; k < out_link->incfg.list->nb; k++) \
764  if (fmts->var[k] == fmt) { \
765  fmts->var[0] = fmt; \
766  fmts->nb = 1; \
767  ret = 1; \
768  break; \
769  } \
770  } \
771  } \
772 } while (0)
773 
775 {
776  int i, j, k, ret = 0;
777 
779  nb_formats, ff_add_format);
780  REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats,
781  nb_formats, ff_add_format);
782 
783  /* reduce channel layouts */
784  for (i = 0; i < filter->nb_inputs; i++) {
785  AVFilterLink *inlink = filter->inputs[i];
786  uint64_t fmt;
787 
788  if (!inlink->outcfg.channel_layouts ||
789  inlink->outcfg.channel_layouts->nb_channel_layouts != 1)
790  continue;
791  fmt = inlink->outcfg.channel_layouts->channel_layouts[0];
792 
793  for (j = 0; j < filter->nb_outputs; j++) {
794  AVFilterLink *outlink = filter->outputs[j];
796 
797  fmts = outlink->incfg.channel_layouts;
798  if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
799  continue;
800 
801  if (fmts->all_layouts &&
802  (!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) {
803  /* Turn the infinite list into a singleton */
804  fmts->all_layouts = fmts->all_counts = 0;
805  if (ff_add_channel_layout(&outlink->incfg.channel_layouts, fmt) < 0)
806  ret = 1;
807  break;
808  }
809 
810  for (k = 0; k < outlink->incfg.channel_layouts->nb_channel_layouts; k++) {
811  if (fmts->channel_layouts[k] == fmt) {
812  fmts->channel_layouts[0] = fmt;
813  fmts->nb_channel_layouts = 1;
814  ret = 1;
815  break;
816  }
817  }
818  }
819  }
820 
821  return ret;
822 }
823 
825 {
826  int i, reduced, ret;
827 
828  do {
829  reduced = 0;
830 
831  for (i = 0; i < graph->nb_filters; i++) {
832  if ((ret = reduce_formats_on_filter(graph->filters[i])) < 0)
833  return ret;
834  reduced |= ret;
835  }
836  } while (reduced);
837 
838  return 0;
839 }
840 
842 {
844  int sample_rate;
845  int i, j;
846 
847  for (i = 0; i < filter->nb_inputs; i++) {
848  link = filter->inputs[i];
849 
850  if (link->type == AVMEDIA_TYPE_AUDIO &&
851  link->outcfg.samplerates->nb_formats== 1)
852  break;
853  }
854  if (i == filter->nb_inputs)
855  return;
856 
857  sample_rate = link->outcfg.samplerates->formats[0];
858 
859  for (i = 0; i < filter->nb_outputs; i++) {
860  AVFilterLink *outlink = filter->outputs[i];
861  int best_idx, best_diff = INT_MAX;
862 
863  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
864  outlink->incfg.samplerates->nb_formats < 2)
865  continue;
866 
867  for (j = 0; j < outlink->incfg.samplerates->nb_formats; j++) {
868  int diff = abs(sample_rate - outlink->incfg.samplerates->formats[j]);
869 
870  av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
871 
872  if (diff < best_diff) {
873  best_diff = diff;
874  best_idx = j;
875  }
876  }
877  FFSWAP(int, outlink->incfg.samplerates->formats[0],
878  outlink->incfg.samplerates->formats[best_idx]);
879  }
880 }
881 
883 {
884  int i;
885 
886  for (i = 0; i < graph->nb_filters; i++)
888 }
889 
890 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
891 #define CH_FRONT_PAIR (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)
892 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)
893 #define CH_WIDE_PAIR (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)
894 #define CH_SIDE_PAIR (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
895 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
896 #define CH_BACK_PAIR (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
897 
898 /* allowable substitutions for channel pairs when comparing layouts,
899  * ordered by priority for both values */
900 static const uint64_t ch_subst[][2] = {
922 };
923 
925 {
927  int i, j, k;
928 
929  for (i = 0; i < filter->nb_inputs; i++) {
930  link = filter->inputs[i];
931 
932  if (link->type == AVMEDIA_TYPE_AUDIO &&
933  link->outcfg.channel_layouts->nb_channel_layouts == 1)
934  break;
935  }
936  if (i == filter->nb_inputs)
937  return;
938 
939  for (i = 0; i < filter->nb_outputs; i++) {
940  AVFilterLink *outlink = filter->outputs[i];
941  int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
942 
943  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
945  continue;
946 
947  for (j = 0; j < outlink->incfg.channel_layouts->nb_channel_layouts; j++) {
948  uint64_t in_chlayout = link->outcfg.channel_layouts->channel_layouts[0];
949  uint64_t out_chlayout = outlink->incfg.channel_layouts->channel_layouts[j];
950  int in_channels = av_get_channel_layout_nb_channels(in_chlayout);
951  int out_channels = av_get_channel_layout_nb_channels(out_chlayout);
952  int count_diff = out_channels - in_channels;
953  int matched_channels, extra_channels;
954  int score = 100000;
955 
956  if (FF_LAYOUT2COUNT(in_chlayout) || FF_LAYOUT2COUNT(out_chlayout)) {
957  /* Compute score in case the input or output layout encodes
958  a channel count; in this case the score is not altered by
959  the computation afterwards, as in_chlayout and
960  out_chlayout have both been set to 0 */
961  if (FF_LAYOUT2COUNT(in_chlayout))
962  in_channels = FF_LAYOUT2COUNT(in_chlayout);
963  if (FF_LAYOUT2COUNT(out_chlayout))
964  out_channels = FF_LAYOUT2COUNT(out_chlayout);
965  score -= 10000 + FFABS(out_channels - in_channels) +
966  (in_channels > out_channels ? 10000 : 0);
967  in_chlayout = out_chlayout = 0;
968  /* Let the remaining computation run, even if the score
969  value is not altered */
970  }
971 
972  /* channel substitution */
973  for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {
974  uint64_t cmp0 = ch_subst[k][0];
975  uint64_t cmp1 = ch_subst[k][1];
976  if (( in_chlayout & cmp0) && (!(out_chlayout & cmp0)) &&
977  (out_chlayout & cmp1) && (!( in_chlayout & cmp1))) {
978  in_chlayout &= ~cmp0;
979  out_chlayout &= ~cmp1;
980  /* add score for channel match, minus a deduction for
981  having to do the substitution */
982  score += 10 * av_get_channel_layout_nb_channels(cmp1) - 2;
983  }
984  }
985 
986  /* no penalty for LFE channel mismatch */
987  if ( (in_chlayout & AV_CH_LOW_FREQUENCY) &&
988  (out_chlayout & AV_CH_LOW_FREQUENCY))
989  score += 10;
990  in_chlayout &= ~AV_CH_LOW_FREQUENCY;
991  out_chlayout &= ~AV_CH_LOW_FREQUENCY;
992 
993  matched_channels = av_get_channel_layout_nb_channels(in_chlayout &
994  out_chlayout);
995  extra_channels = av_get_channel_layout_nb_channels(out_chlayout &
996  (~in_chlayout));
997  score += 10 * matched_channels - 5 * extra_channels;
998 
999  if (score > best_score ||
1000  (count_diff < best_count_diff && score == best_score)) {
1001  best_score = score;
1002  best_idx = j;
1003  best_count_diff = count_diff;
1004  }
1005  }
1006  av_assert0(best_idx >= 0);
1007  FFSWAP(uint64_t, outlink->incfg.channel_layouts->channel_layouts[0],
1008  outlink->incfg.channel_layouts->channel_layouts[best_idx]);
1009  }
1010 
1011 }
1012 
1014 {
1015  int i;
1016 
1017  for (i = 0; i < graph->nb_filters; i++)
1019 }
1020 
1022 {
1023  AVFilterLink *link = NULL;
1024  int format, bps;
1025  int i, j;
1026 
1027  for (i = 0; i < filter->nb_inputs; i++) {
1028  link = filter->inputs[i];
1029 
1030  if (link->type == AVMEDIA_TYPE_AUDIO &&
1031  link->outcfg.formats->nb_formats == 1)
1032  break;
1033  }
1034  if (i == filter->nb_inputs)
1035  return;
1036 
1037  format = link->outcfg.formats->formats[0];
1039 
1040  for (i = 0; i < filter->nb_outputs; i++) {
1041  AVFilterLink *outlink = filter->outputs[i];
1042  int best_idx = -1, best_score = INT_MIN;
1043 
1044  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
1045  outlink->incfg.formats->nb_formats < 2)
1046  continue;
1047 
1048  for (j = 0; j < outlink->incfg.formats->nb_formats; j++) {
1049  int out_format = outlink->incfg.formats->formats[j];
1050  int out_bps = av_get_bytes_per_sample(out_format);
1051  int score;
1052 
1053  if (av_get_packed_sample_fmt(out_format) == format ||
1054  av_get_planar_sample_fmt(out_format) == format) {
1055  best_idx = j;
1056  break;
1057  }
1058 
1059  /* for s32 and float prefer double to prevent loss of information */
1060  if (bps == 4 && out_bps == 8) {
1061  best_idx = j;
1062  break;
1063  }
1064 
1065  /* prefer closest higher or equal bps */
1066  score = -abs(out_bps - bps);
1067  if (out_bps >= bps)
1068  score += INT_MAX/2;
1069 
1070  if (score > best_score) {
1071  best_score = score;
1072  best_idx = j;
1073  }
1074  }
1075  av_assert0(best_idx >= 0);
1076  FFSWAP(int, outlink->incfg.formats->formats[0],
1077  outlink->incfg.formats->formats[best_idx]);
1078  }
1079 }
1080 
1082 {
1083  int i;
1084 
1085  for (i = 0; i < graph->nb_filters; i++)
1086  swap_sample_fmts_on_filter(graph->filters[i]);
1087 
1088 }
1089 
1091 {
1092  int i, j, ret;
1093  int change;
1094 
1095  do{
1096  change = 0;
1097  for (i = 0; i < graph->nb_filters; i++) {
1098  AVFilterContext *filter = graph->filters[i];
1099  if (filter->nb_inputs){
1100  for (j = 0; j < filter->nb_inputs; j++){
1101  if (filter->inputs[j]->incfg.formats && filter->inputs[j]->incfg.formats->nb_formats == 1) {
1102  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1103  return ret;
1104  change = 1;
1105  }
1106  }
1107  }
1108  if (filter->nb_outputs){
1109  for (j = 0; j < filter->nb_outputs; j++){
1110  if (filter->outputs[j]->incfg.formats && filter->outputs[j]->incfg.formats->nb_formats == 1) {
1111  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1112  return ret;
1113  change = 1;
1114  }
1115  }
1116  }
1117  if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
1118  for (j = 0; j < filter->nb_outputs; j++) {
1119  if (filter->outputs[j]->format<0) {
1120  if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
1121  return ret;
1122  change = 1;
1123  }
1124  }
1125  }
1126  }
1127  }while(change);
1128 
1129  for (i = 0; i < graph->nb_filters; i++) {
1130  AVFilterContext *filter = graph->filters[i];
1131 
1132  for (j = 0; j < filter->nb_inputs; j++)
1133  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1134  return ret;
1135  for (j = 0; j < filter->nb_outputs; j++)
1136  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1137  return ret;
1138  }
1139  return 0;
1140 }
1141 
1142 /**
1143  * Configure the formats of all the links in the graph.
1144  */
1146 {
1147  int ret;
1148 
1149  /* find supported formats from sub-filters, and merge along links */
1150  while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN))
1151  av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n");
1152  if (ret < 0)
1153  return ret;
1154 
1155  /* Once everything is merged, it's possible that we'll still have
1156  * multiple valid media format choices. We try to minimize the amount
1157  * of format conversion inside filters */
1158  if ((ret = reduce_formats(graph)) < 0)
1159  return ret;
1160 
1161  /* for audio filters, ensure the best format, sample rate and channel layout
1162  * is selected */
1166 
1167  if ((ret = pick_formats(graph)) < 0)
1168  return ret;
1169 
1170  return 0;
1171 }
1172 
1174  AVClass *log_ctx)
1175 {
1176  unsigned i, j;
1177  int sink_links_count = 0, n = 0;
1178  AVFilterContext *f;
1179  AVFilterLink **sinks;
1180 
1181  for (i = 0; i < graph->nb_filters; i++) {
1182  f = graph->filters[i];
1183  for (j = 0; j < f->nb_inputs; j++) {
1184  f->inputs[j]->graph = graph;
1185  f->inputs[j]->age_index = -1;
1186  }
1187  for (j = 0; j < f->nb_outputs; j++) {
1188  f->outputs[j]->graph = graph;
1189  f->outputs[j]->age_index= -1;
1190  }
1191  if (!f->nb_outputs) {
1192  if (f->nb_inputs > INT_MAX - sink_links_count)
1193  return AVERROR(EINVAL);
1194  sink_links_count += f->nb_inputs;
1195  }
1196  }
1197  sinks = av_calloc(sink_links_count, sizeof(*sinks));
1198  if (!sinks)
1199  return AVERROR(ENOMEM);
1200  for (i = 0; i < graph->nb_filters; i++) {
1201  f = graph->filters[i];
1202  if (!f->nb_outputs) {
1203  for (j = 0; j < f->nb_inputs; j++) {
1204  sinks[n] = f->inputs[j];
1205  f->inputs[j]->age_index = n++;
1206  }
1207  }
1208  }
1209  av_assert0(n == sink_links_count);
1210  graph->sink_links = sinks;
1211  graph->sink_links_count = sink_links_count;
1212  return 0;
1213 }
1214 
1215 int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
1216 {
1217  int ret;
1218 
1219  if ((ret = graph_check_validity(graphctx, log_ctx)))
1220  return ret;
1221  if ((ret = graph_config_formats(graphctx, log_ctx)))
1222  return ret;
1223  if ((ret = graph_config_links(graphctx, log_ctx)))
1224  return ret;
1225  if ((ret = graph_check_links(graphctx, log_ctx)))
1226  return ret;
1227  if ((ret = graph_config_pointers(graphctx, log_ctx)))
1228  return ret;
1229 
1230  return 0;
1231 }
1232 
1233 int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
1234 {
1235  int i, r = AVERROR(ENOSYS);
1236 
1237  if (!graph)
1238  return r;
1239 
1241  r = avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);
1242  if (r != AVERROR(ENOSYS))
1243  return r;
1244  }
1245 
1246  if (res_len && res)
1247  res[0] = 0;
1248 
1249  for (i = 0; i < graph->nb_filters; i++) {
1250  AVFilterContext *filter = graph->filters[i];
1251  if (!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)) {
1252  r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);
1253  if (r != AVERROR(ENOSYS)) {
1254  if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0)
1255  return r;
1256  }
1257  }
1258  }
1259 
1260  return r;
1261 }
1262 
1263 int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
1264 {
1265  int i;
1266 
1267  if(!graph)
1268  return 0;
1269 
1270  for (i = 0; i < graph->nb_filters; i++) {
1271  AVFilterContext *filter = graph->filters[i];
1272  if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){
1273  AVFilterCommand **queue = &filter->command_queue, *next;
1274  while (*queue && (*queue)->time <= ts)
1275  queue = &(*queue)->next;
1276  next = *queue;
1277  *queue = av_mallocz(sizeof(AVFilterCommand));
1278  if (!*queue)
1279  return AVERROR(ENOMEM);
1280 
1281  (*queue)->command = av_strdup(command);
1282  (*queue)->arg = av_strdup(arg);
1283  (*queue)->time = ts;
1284  (*queue)->flags = flags;
1285  (*queue)->next = next;
1287  return 0;
1288  }
1289  }
1290 
1291  return 0;
1292 }
1293 
1295  AVFilterLink *link, int index)
1296 {
1297  AVFilterLink **links = graph->sink_links;
1298 
1299  av_assert0(index >= 0);
1300 
1301  while (index) {
1302  int parent = (index - 1) >> 1;
1303  if (links[parent]->current_pts_us >= link->current_pts_us)
1304  break;
1305  links[index] = links[parent];
1306  links[index]->age_index = index;
1307  index = parent;
1308  }
1309  links[index] = link;
1310  link->age_index = index;
1311 }
1312 
1314  AVFilterLink *link, int index)
1315 {
1316  AVFilterLink **links = graph->sink_links;
1317 
1318  av_assert0(index >= 0);
1319 
1320  while (1) {
1321  int child = 2 * index + 1;
1322  if (child >= graph->sink_links_count)
1323  break;
1324  if (child + 1 < graph->sink_links_count &&
1325  links[child + 1]->current_pts_us < links[child]->current_pts_us)
1326  child++;
1327  if (link->current_pts_us < links[child]->current_pts_us)
1328  break;
1329  links[index] = links[child];
1330  links[index]->age_index = index;
1331  index = child;
1332  }
1333  links[index] = link;
1334  link->age_index = index;
1335 }
1336 
1338 {
1339  heap_bubble_up (graph, link, link->age_index);
1340  heap_bubble_down(graph, link, link->age_index);
1341 }
1342 
1344 {
1345  AVFilterLink *oldest = graph->sink_links[0];
1346  int64_t frame_count;
1347  int r;
1348 
1349  while (graph->sink_links_count) {
1350  oldest = graph->sink_links[0];
1351  if (oldest->dst->filter->activate) {
1352  /* For now, buffersink is the only filter implementing activate. */
1355  if (r != AVERROR_EOF)
1356  return r;
1357  } else {
1358  r = ff_request_frame(oldest);
1359  }
1360  if (r != AVERROR_EOF)
1361  break;
1362  av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
1363  oldest->dst->name,
1364  oldest->dstpad->name);
1365  /* EOF: remove the link from the heap */
1366  if (oldest->age_index < --graph->sink_links_count)
1367  heap_bubble_down(graph, graph->sink_links[graph->sink_links_count],
1368  oldest->age_index);
1369  oldest->age_index = -1;
1370  }
1371  if (!graph->sink_links_count)
1372  return AVERROR_EOF;
1373  av_assert1(!oldest->dst->filter->activate);
1374  av_assert1(oldest->age_index >= 0);
1375  frame_count = oldest->frame_count_out;
1376  while (frame_count == oldest->frame_count_out) {
1378  if (r == AVERROR(EAGAIN) &&
1379  !oldest->frame_wanted_out && !oldest->frame_blocked_in &&
1380  !oldest->status_in)
1381  ff_request_frame(oldest);
1382  else if (r < 0)
1383  return r;
1384  }
1385  return 0;
1386 }
1387 
1389 {
1391  unsigned i;
1392 
1393  av_assert0(graph->nb_filters);
1394  filter = graph->filters[0];
1395  for (i = 1; i < graph->nb_filters; i++)
1396  if (graph->filters[i]->ready > filter->ready)
1397  filter = graph->filters[i];
1398  if (!filter->ready)
1399  return AVERROR(EAGAIN);
1400  return ff_filter_activate(filter);
1401 }
formats
formats
Definition: signature.h:48
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVFILTER_CMD_FLAG_ONE
#define AVFILTER_CMD_FLAG_ONE
Stop once a filter understood the command (for target=all for example), fast filters are favored auto...
Definition: avfilter.h:676
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVFilterFormatsConfig::samplerates
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:442
name
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 default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
F
#define F
Definition: avfiltergraph.c:46
r
const char * r
Definition: vf_curves.c:116
AVERROR
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
opt.h
av_opt_set_defaults
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1358
AVFilterFormatsConfig::channel_layouts
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:447
ch_subst
static const uint64_t ch_subst[][2]
Definition: avfiltergraph.c:900
REDUCE_FORMATS
#define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format)
Definition: avfiltergraph.c:737
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:68
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
av_buffersink_get_frame_flags
int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
Get a frame with filtered data from sink and put it in frame.
Definition: buffersink.c:140
ff_formats_check_pixel_formats
int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid pixel formats list.
Definition: formats.c:679
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
filter_query_formats
static int filter_query_formats(AVFilterContext *ctx)
Definition: avfiltergraph.c:360
graph
fg outputs[0] graph
Definition: ffmpeg_filter.c:174
thread.h
ff_filter_activate
int ff_filter_activate(AVFilterContext *filter)
Definition: avfilter.c:1316
swap_sample_fmts
static void swap_sample_fmts(AVFilterGraph *graph)
Definition: avfiltergraph.c:1081
AVFilterInOut::next
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
Definition: avfilter.h:969
pixdesc.h
index
fg index
Definition: ffmpeg_filter.c:168
CHECKED_MERGE
#define CHECKED_MERGE(field,...)
AVOption
AVOption.
Definition: opt.h:247
pick_formats
static int pick_formats(AVFilterGraph *graph)
Definition: avfiltergraph.c:1090
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:395
convert
Definition: convert.py:1
pick_format
static int pick_format(AVFilterLink *link, AVFilterLink *ref)
Definition: avfiltergraph.c:661
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
ff_filter_graph_run_once
int ff_filter_graph_run_once(AVFilterGraph *graph)
Run one round of processing on a filter graph.
Definition: avfiltergraph.c:1388
AVFilterFormats::formats
int * formats
list of media formats
Definition: formats.h:66
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
ff_filter_alloc
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
Definition: avfilter.c:623
convert
static void convert(float y, float u, float v, float *b, float *g, float *r)
Definition: exr.c:967
swap_samplerates
static void swap_samplerates(AVFilterGraph *graph)
Definition: avfiltergraph.c:882
FF_LAYOUT2COUNT
#define FF_LAYOUT2COUNT(l)
Decode a channel count encoded as a channel layout.
Definition: formats.h:108
avfilter_graph_free
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
Definition: avfiltergraph.c:120
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
get_fmt_score
static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
Definition: avfiltergraph.c:627
avfilter_graph_create_filter
int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt, const char *name, const char *args, void *opaque, AVFilterGraph *graph_ctx)
Create and add a filter instance into an existing graph.
Definition: avfiltergraph.c:139
avfilter_graph_alloc_filter
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
Definition: avfiltergraph.c:167
fail
#define fail()
Definition: checkasm.h:136
avfilter_graph_alloc
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:83
reduce_formats
static int reduce_formats(AVFilterGraph *graph)
Definition: avfiltergraph.c:824
avfilter_insert_filter
int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt, unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
Insert a filter in the middle of an existing link.
Definition: avfilter.c:228
OFFSET
#define OFFSET(x)
Definition: avfiltergraph.c:45
avfilter_config_links
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
Definition: avfilter.c:265
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
ff_can_merge_samplerates
int ff_can_merge_samplerates(const AVFilterFormats *a, const AVFilterFormats *b)
Definition: formats.c:157
type
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
Definition: writing_filters.txt:86
AVFILTER_THREAD_SLICE
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Definition: avfilter.h:328
heap_bubble_down
static void heap_bubble_down(AVFilterGraph *graph, AVFilterLink *link, int index)
Definition: avfiltergraph.c:1313
ff_all_formats
AVFilterFormats * ff_all_formats(enum AVMediaType type)
Return a list of all formats supported by FFmpeg for the given media type.
Definition: formats.c:338
av_image_check_size2
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:289
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
av_get_planar_sample_fmt
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
Definition: samplefmt.c:84
reduce_formats_on_filter
static int reduce_formats_on_filter(AVFilterContext *filter)
Definition: avfiltergraph.c:774
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:580
graph_config_formats
static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
Configure the formats of all the links in the graph.
Definition: avfiltergraph.c:1145
AV_CH_LOW_FREQUENCY
#define AV_CH_LOW_FREQUENCY
Definition: channel_layout.h:52
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:331
AV_BUFFERSINK_FLAG_PEEK
#define AV_BUFFERSINK_FLAG_PEEK
Tell av_buffersink_get_buffer_ref() to read video/samples buffer reference, but not remove it from th...
Definition: buffersink.h:89
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVFilterChannelLayouts::channel_layouts
uint64_t * channel_layouts
list of channel layouts
Definition: formats.h:86
AVFrame::channels
int channels
number of audio channels, only used for audio.
Definition: frame.h:592
avfilter_process_command
int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
Make the filter instance process a command.
Definition: avfilter.c:527
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
filtergraph_options
static const AVOption filtergraph_options[]
Definition: avfiltergraph.c:49
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
CH_DIRECT_PAIR
#define CH_DIRECT_PAIR
Definition: avfiltergraph.c:895
av_get_sample_fmt_name
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.
Definition: samplefmt.c:49
ff_can_merge_formats
int ff_can_merge_formats(const AVFilterFormats *a, const AVFilterFormats *b, enum AVMediaType type)
Check the formats/samplerates lists for compatibility for merging without actually merging.
Definition: formats.c:134
f
#define f(width, name)
Definition: cbs_vp9.c:255
command
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:906
link
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 link
Definition: filter_design.txt:23
arg
const char * arg
Definition: jacosubdec.c:67
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
AVFilter::activate
int(* activate)(AVFilterContext *ctx)
Filter activation function.
Definition: avfilter.h:322
avfilter_get_by_name
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:548
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
avfilter_graph_config
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
Definition: avfiltergraph.c:1215
NULL
#define NULL
Definition: coverity.c:32
sanitize_channel_layouts
static void sanitize_channel_layouts(void *log, AVFilterChannelLayouts *l)
Definition: avfiltergraph.c:298
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
avfilter_graph_set_auto_convert
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
Definition: avfiltergraph.c:162
framequeue.h
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
ff_add_format
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
Add fmt to the list of media formats contained in *avff.
Definition: formats.c:325
AVFilterContext::name
char * name
name of this filter instance
Definition: avfilter.h:338
AVFilterFormats::nb_formats
unsigned nb_formats
number of formats
Definition: formats.h:65
heap_bubble_up
static void heap_bubble_up(AVFilterGraph *graph, AVFilterLink *link, int index)
Definition: avfiltergraph.c:1294
avfilter_graph_get_filter
AVFilterContext * avfilter_graph_get_filter(AVFilterGraph *graph, const char *name)
Get a filter instance identified by instance name from graph.
Definition: avfiltergraph.c:287
avfilter_graph_request_oldest
int avfilter_graph_request_oldest(AVFilterGraph *graph)
Request a frame on the oldest sink link.
Definition: avfiltergraph.c:1343
abs
#define abs(x)
Definition: cuda_runtime.h:35
AVFilterGraph
Definition: avfilter.h:798
AV_CH_FRONT_CENTER
#define AV_CH_FRONT_CENTER
Definition: channel_layout.h:51
AVFilterFormats::refcount
unsigned refcount
number of references to this list
Definition: formats.h:68
ff_channel_layouts_unref
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:501
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:432
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:226
AV_CLASS_CATEGORY_FILTER
@ AV_CLASS_CATEGORY_FILTER
Definition: log.h:36
ff_formats_check_sample_formats
int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid sample formats list.
Definition: formats.c:684
CH_BACK_PAIR
#define CH_BACK_PAIR
Definition: avfiltergraph.c:896
AVMediaType
AVMediaType
Definition: avutil.h:199
ff_graph_thread_free
void ff_graph_thread_free(AVFilterGraph *graph)
Definition: avfiltergraph.c:71
ff_default_query_formats
int ff_default_query_formats(AVFilterContext *ctx)
Definition: formats.c:586
AVFilterCommand::next
struct AVFilterCommand * next
Definition: internal.h:43
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
AVFrame::sample_rate
int sample_rate
Sample rate of the audio data.
Definition: frame.h:458
bps
unsigned bps
Definition: movenc.c:1595
CH_CENTER_PAIR
#define CH_CENTER_PAIR
Definition: avfiltergraph.c:890
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
avfilter_graph_queue_command
int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
Queue a command for one or more filter instances.
Definition: avfiltergraph.c:1263
AVFilterChannelLayouts::all_layouts
char all_layouts
accept any known channel layout
Definition: formats.h:88
AVFilterChannelLayouts::all_counts
char all_counts
accept any channel layout or count
Definition: formats.h:89
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:376
ff_formats_check_channel_layouts
int ff_formats_check_channel_layouts(void *log, const AVFilterChannelLayouts *fmts)
Check that fmts is a valid channel layouts list.
Definition: formats.c:703
AVFrame::channel_layout
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:463
find_best_sample_fmt_of_2
static enum AVSampleFormat find_best_sample_fmt_of_2(enum AVSampleFormat dst_fmt1, enum AVSampleFormat dst_fmt2, enum AVSampleFormat src_fmt)
Definition: avfiltergraph.c:650
ff_all_channel_layouts
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:420
internal.h
avfilter_init_str
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:898
buffersink.h
filter_link_check_formats
static int filter_link_check_formats(void *log, AVFilterLink *link, AVFilterFormatsConfig *cfg)
Definition: avfiltergraph.c:313
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
CH_FRONT_PAIR
#define CH_FRONT_PAIR
Definition: avfiltergraph.c:891
swap_sample_fmts_on_filter
static void swap_sample_fmts_on_filter(AVFilterContext *filter)
Definition: avfiltergraph.c:1021
ff_formats_unref
void ff_formats_unref(AVFilterFormats **ref)
If *ref is non-NULL, remove *ref as a reference to the format list it currently points to,...
Definition: formats.c:496
bprint.h
i
int i
Definition: input.c:406
ff_formats_check_sample_rates
int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid sample rates list.
Definition: formats.c:689
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
internal.h
graph_check_validity
static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx)
Check for the validity of graph.
Definition: avfiltergraph.c:211
swap_channel_layouts_on_filter
static void swap_channel_layouts_on_filter(AVFilterContext *filter)
Definition: avfiltergraph.c:924
AVFilterCommand
Definition: internal.h:38
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AV_CH_BACK_CENTER
#define AV_CH_BACK_CENTER
Definition: channel_layout.h:57
V
#define V
Definition: avfiltergraph.c:47
MERGE_DISPATCH
#define MERGE_DISPATCH(field,...)
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:243
query_formats
static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
Perform one round of query_formats() and merging formats lists on the filter graph.
Definition: avfiltergraph.c:432
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:39
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:60
ff_graph_thread_init
int ff_graph_thread_init(AVFilterGraph *graph)
Definition: avfiltergraph.c:75
swap_channel_layouts
static void swap_channel_layouts(AVFilterGraph *graph)
Definition: avfiltergraph.c:1013
AVFilter
Filter definition.
Definition: avfilter.h:145
AVFILTER_CMD_FLAG_FAST
#define AVFILTER_CMD_FLAG_FAST
Only execute command when its fast (like a video out that supports contrast adjustment in hw)
Definition: avfilter.h:677
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
links
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 links
Definition: filter_design.txt:14
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
CH_SIDE_PAIR
#define CH_SIDE_PAIR
Definition: avfiltergraph.c:894
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:93
formats_declared
static int formats_declared(AVFilterContext *f)
Definition: avfiltergraph.c:399
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:76
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:414
av_find_best_pix_fmt_of_2
enum AVPixelFormat av_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2, enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr)
Compute what kind of losses will occur when converting from one specific pixel format to another.
Definition: pixdesc.c:2831
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:251
channel_layout.h
ff_filter_graph_remove_filter
void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
Remove a filter from a graph;.
Definition: avfiltergraph.c:102
CH_WIDE_PAIR
#define CH_WIDE_PAIR
Definition: avfiltergraph.c:893
ff_framequeue_global_init
void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
Init a global structure.
Definition: framequeue.c:30
ff_avfilter_graph_update_heap
void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
Update the position of a link in the age heap.
Definition: avfiltergraph.c:1337
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
avfilter.h
av_get_packed_sample_fmt
enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
Get the packed alternative form of the given sample format.
Definition: samplefmt.c:75
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AVFilterContext
An instance of a filter.
Definition: avfilter.h:333
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:259
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVFilterChannelLayouts::nb_channel_layouts
int nb_channel_layouts
number of channel layouts
Definition: formats.h:87
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:437
avfilter_free
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:720
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
A
#define A
Definition: avfiltergraph.c:48
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
swap_samplerates_on_filter
static void swap_samplerates_on_filter(AVFilterContext *filter)
Definition: avfiltergraph.c:841
filters
ist filters[ist->nb_filters - 1]
Definition: ffmpeg_filter.c:191
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
format
fg outputs[0] format
Definition: ffmpeg_filter.c:175
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:223
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
avfilter_graph_send_command
int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
Send a command to one or more filter instances.
Definition: avfiltergraph.c:1233
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:568
graph_config_pointers
static int graph_config_pointers(AVFilterGraph *graph, AVClass *log_ctx)
Definition: avfiltergraph.c:1173
avstring.h
AVFilterContext::filter
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:336
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
AVFilterChannelLayouts::refcount
unsigned refcount
number of references to this list
Definition: formats.h:91
filter_check_formats
static int filter_check_formats(AVFilterContext *ctx)
Check the validity of the formats / etc.
Definition: avfiltergraph.c:342
graph_config_links
static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx)
Configure all the links of graphctx.
Definition: avfiltergraph.c:249
graph_check_links
static int graph_check_links(AVFilterGraph *graph, AVClass *log_ctx)
Definition: avfiltergraph.c:266
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
filtergraph_class
static const AVClass filtergraph_class
Definition: avfiltergraph.c:62
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
snprintf
#define snprintf
Definition: snprintf.h:34
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:63
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2460
ff_set_common_channel_layouts
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *channel_layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates.
Definition: formats.c:561
AVFilterCommand::time
double time
time expressed in seconds
Definition: internal.h:39