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 
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 
128  ff_graph_thread_free(*graph);
129 
130  av_freep(&(*graph)->sink_links);
131 
132  av_freep(&(*graph)->scale_sws_opts);
133  av_freep(&(*graph)->aresample_swr_opts);
134 #if FF_API_LAVR_OPTS
135  av_freep(&(*graph)->resample_lavr_opts);
136 #endif
137  av_freep(&(*graph)->filters);
138  av_freep(&(*graph)->internal);
139  av_freep(graph);
140 }
141 
143  const char *name, const char *args, void *opaque,
144  AVFilterGraph *graph_ctx)
145 {
146  int ret;
147 
148  *filt_ctx = avfilter_graph_alloc_filter(graph_ctx, filt, name);
149  if (!*filt_ctx)
150  return AVERROR(ENOMEM);
151 
152  ret = avfilter_init_str(*filt_ctx, args);
153  if (ret < 0)
154  goto fail;
155 
156  return 0;
157 
158 fail:
159  if (*filt_ctx)
160  avfilter_free(*filt_ctx);
161  *filt_ctx = NULL;
162  return ret;
163 }
164 
166 {
167  graph->disable_auto_convert = flags;
168 }
169 
171  const AVFilter *filter,
172  const char *name)
173 {
175 
176  if (graph->thread_type && !graph->internal->thread_execute) {
177  if (graph->execute) {
178  graph->internal->thread_execute = graph->execute;
179  } else {
180  int ret = ff_graph_thread_init(graph);
181  if (ret < 0) {
182  av_log(graph, AV_LOG_ERROR, "Error initializing threading: %s.\n", av_err2str(ret));
183  return NULL;
184  }
185  }
186  }
187 
188  s = ff_filter_alloc(filter, name);
189  if (!s)
190  return NULL;
191 
192  filters = av_realloc(graph->filters, sizeof(*filters) * (graph->nb_filters + 1));
193  if (!filters) {
194  avfilter_free(s);
195  return NULL;
196  }
197 
198  graph->filters = filters;
199  graph->filters[graph->nb_filters++] = s;
200 
201  s->graph = graph;
202 
203  return s;
204 }
205 
206 /**
207  * Check for the validity of graph.
208  *
209  * A graph is considered valid if all its input and output pads are
210  * connected.
211  *
212  * @return >= 0 in case of success, a negative value otherwise
213  */
214 static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx)
215 {
217  int i, j;
218 
219  for (i = 0; i < graph->nb_filters; i++) {
220  const AVFilterPad *pad;
221  filt = graph->filters[i];
222 
223  for (j = 0; j < filt->nb_inputs; j++) {
224  if (!filt->inputs[j] || !filt->inputs[j]->src) {
225  pad = &filt->input_pads[j];
226  av_log(log_ctx, AV_LOG_ERROR,
227  "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",
228  pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
229  return AVERROR(EINVAL);
230  }
231  }
232 
233  for (j = 0; j < filt->nb_outputs; j++) {
234  if (!filt->outputs[j] || !filt->outputs[j]->dst) {
235  pad = &filt->output_pads[j];
236  av_log(log_ctx, AV_LOG_ERROR,
237  "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",
238  pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
239  return AVERROR(EINVAL);
240  }
241  }
242  }
243 
244  return 0;
245 }
246 
247 /**
248  * Configure all the links of graphctx.
249  *
250  * @return >= 0 in case of success, a negative value otherwise
251  */
252 static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx)
253 {
255  int i, ret;
256 
257  for (i = 0; i < graph->nb_filters; i++) {
258  filt = graph->filters[i];
259 
260  if (!filt->nb_outputs) {
261  if ((ret = avfilter_config_links(filt)))
262  return ret;
263  }
264  }
265 
266  return 0;
267 }
268 
269 static int graph_check_links(AVFilterGraph *graph, AVClass *log_ctx)
270 {
272  AVFilterLink *l;
273  unsigned i, j;
274  int ret;
275 
276  for (i = 0; i < graph->nb_filters; i++) {
277  f = graph->filters[i];
278  for (j = 0; j < f->nb_outputs; j++) {
279  l = f->outputs[j];
280  if (l->type == AVMEDIA_TYPE_VIDEO) {
281  ret = av_image_check_size2(l->w, l->h, INT64_MAX, l->format, 0, f);
282  if (ret < 0)
283  return ret;
284  }
285  }
286  }
287  return 0;
288 }
289 
291 {
292  int i;
293 
294  for (i = 0; i < graph->nb_filters; i++)
295  if (graph->filters[i]->name && !strcmp(name, graph->filters[i]->name))
296  return graph->filters[i];
297 
298  return NULL;
299 }
300 
302 {
303  if (!l)
304  return;
305  if (l->nb_channel_layouts) {
306  if (l->all_layouts || l->all_counts)
307  av_log(log, AV_LOG_WARNING, "All layouts set on non-empty list\n");
308  l->all_layouts = l->all_counts = 0;
309  } else {
310  if (l->all_counts && !l->all_layouts)
311  av_log(log, AV_LOG_WARNING, "All counts without all layouts\n");
312  l->all_layouts = 1;
313  }
314 }
315 
317 {
318  int ret, i;
320  AVFilterChannelLayouts *chlayouts;
321  AVFilterFormats *samplerates;
322  enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
323  ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
325 
326  if ((ret = ctx->filter->query_formats(ctx)) < 0) {
327  if (ret != AVERROR(EAGAIN))
328  av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
329  ctx->name, av_err2str(ret));
330  return ret;
331  }
332 
333  for (i = 0; i < ctx->nb_inputs; i++)
335  for (i = 0; i < ctx->nb_outputs; i++)
337 
338  formats = ff_all_formats(type);
339  if ((ret = ff_set_common_formats(ctx, formats)) < 0)
340  return ret;
341  if (type == AVMEDIA_TYPE_AUDIO) {
342  samplerates = ff_all_samplerates();
343  if ((ret = ff_set_common_samplerates(ctx, samplerates)) < 0)
344  return ret;
345  chlayouts = ff_all_channel_layouts();
346  if ((ret = ff_set_common_channel_layouts(ctx, chlayouts)) < 0)
347  return ret;
348  }
349  return 0;
350 }
351 
353 {
354  int i;
355 
356  for (i = 0; i < f->nb_inputs; i++) {
357  if (!f->inputs[i]->out_formats)
358  return 0;
359  if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&
360  !(f->inputs[i]->out_samplerates &&
361  f->inputs[i]->out_channel_layouts))
362  return 0;
363  }
364  for (i = 0; i < f->nb_outputs; i++) {
365  if (!f->outputs[i]->in_formats)
366  return 0;
367  if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&
368  !(f->outputs[i]->in_samplerates &&
369  f->outputs[i]->in_channel_layouts))
370  return 0;
371  }
372  return 1;
373 }
374 
376 {
377  AVFilterFormats *a = av_memdup(arg, sizeof(*arg));
378  if (a) {
379  a->refcount = 0;
380  a->refs = NULL;
381  a->formats = av_memdup(a->formats, sizeof(*a->formats) * a->nb_formats);
382  if (!a->formats && arg->formats)
383  av_freep(&a);
384  }
385  return a;
386 }
387 
389  AVFilterFormats *b_arg,
390  enum AVMediaType type,
391  int is_sample_rate)
392 {
393  AVFilterFormats *a, *b, *ret;
394  if (a_arg == b_arg)
395  return 1;
396  a = clone_filter_formats(a_arg);
397  b = clone_filter_formats(b_arg);
398 
399  if (!a || !b) {
400  if (a)
401  av_freep(&a->formats);
402  if (b)
403  av_freep(&b->formats);
404 
405  av_freep(&a);
406  av_freep(&b);
407 
408  return 0;
409  }
410 
411  if (is_sample_rate) {
412  ret = ff_merge_samplerates(a, b);
413  } else {
414  ret = ff_merge_formats(a, b, type);
415  }
416  if (ret) {
417  av_freep(&ret->formats);
418  av_freep(&ret->refs);
419  av_freep(&ret);
420  return 1;
421  } else {
422  if (a)
423  av_freep(&a->formats);
424  if (b)
425  av_freep(&b->formats);
426  av_freep(&a);
427  av_freep(&b);
428  return 0;
429  }
430 }
431 
432 /**
433  * Perform one round of query_formats() and merging formats lists on the
434  * filter graph.
435  * @return >=0 if all links formats lists could be queried and merged;
436  * AVERROR(EAGAIN) some progress was made in the queries or merging
437  * and a later call may succeed;
438  * AVERROR(EIO) (may be changed) plus a log message if no progress
439  * was made and the negotiation is stuck;
440  * a negative error code if some other error happened
441  */
442 static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
443 {
444  int i, j, ret;
445  int scaler_count = 0, resampler_count = 0;
446  int count_queried = 0; /* successful calls to query_formats() */
447  int count_merged = 0; /* successful merge of formats lists */
448  int count_already_merged = 0; /* lists already merged */
449  int count_delayed = 0; /* lists that need to be merged later */
450 
451  for (i = 0; i < graph->nb_filters; i++) {
452  AVFilterContext *f = graph->filters[i];
453  if (formats_declared(f))
454  continue;
455  if (f->filter->query_formats)
456  ret = filter_query_formats(f);
457  else
458  ret = ff_default_query_formats(f);
459  if (ret < 0 && ret != AVERROR(EAGAIN))
460  return ret;
461  /* note: EAGAIN could indicate a partial success, not counted yet */
462  count_queried += ret >= 0;
463  }
464 
465  /* go through and merge as many format lists as possible */
466  for (i = 0; i < graph->nb_filters; i++) {
467  AVFilterContext *filter = graph->filters[i];
468 
469  for (j = 0; j < filter->nb_inputs; j++) {
470  AVFilterLink *link = filter->inputs[j];
471  int convert_needed = 0;
472 
473  if (!link)
474  continue;
475 
476  if (link->in_formats != link->out_formats
477  && link->in_formats && link->out_formats)
478  if (!can_merge_formats(link->in_formats, link->out_formats,
479  link->type, 0))
480  convert_needed = 1;
481  if (link->type == AVMEDIA_TYPE_AUDIO) {
482  if (link->in_samplerates != link->out_samplerates
483  && link->in_samplerates && link->out_samplerates)
485  link->out_samplerates,
486  0, 1))
487  convert_needed = 1;
488  }
489 
490 #define MERGE_DISPATCH(field, statement) \
491  if (!(link->in_ ## field && link->out_ ## field)) { \
492  count_delayed++; \
493  } else if (link->in_ ## field == link->out_ ## field) { \
494  count_already_merged++; \
495  } else if (!convert_needed) { \
496  count_merged++; \
497  statement \
498  }
499 
500  if (link->type == AVMEDIA_TYPE_AUDIO) {
503  link->out_channel_layouts))
504  convert_needed = 1;
505  )
506  MERGE_DISPATCH(samplerates,
508  link->out_samplerates))
509  convert_needed = 1;
510  )
511  }
513  if (!ff_merge_formats(link->in_formats, link->out_formats,
514  link->type))
515  convert_needed = 1;
516  )
517 #undef MERGE_DISPATCH
518 
519  if (convert_needed) {
521  const AVFilter *filter;
522  AVFilterLink *inlink, *outlink;
523  char inst_name[30];
524 
525  if (graph->disable_auto_convert) {
526  av_log(log_ctx, AV_LOG_ERROR,
527  "The filters '%s' and '%s' do not have a common format "
528  "and automatic conversion is disabled.\n",
529  link->src->name, link->dst->name);
530  return AVERROR(EINVAL);
531  }
532 
533  /* couldn't merge format lists. auto-insert conversion filter */
534  switch (link->type) {
535  case AVMEDIA_TYPE_VIDEO:
536  if (!(filter = avfilter_get_by_name("scale"))) {
537  av_log(log_ctx, AV_LOG_ERROR, "'scale' filter "
538  "not present, cannot convert pixel formats.\n");
539  return AVERROR(EINVAL);
540  }
541 
542  snprintf(inst_name, sizeof(inst_name), "auto_scaler_%d",
543  scaler_count++);
544 
545  if ((ret = avfilter_graph_create_filter(&convert, filter,
546  inst_name, graph->scale_sws_opts, NULL,
547  graph)) < 0)
548  return ret;
549  break;
550  case AVMEDIA_TYPE_AUDIO:
551  if (!(filter = avfilter_get_by_name("aresample"))) {
552  av_log(log_ctx, AV_LOG_ERROR, "'aresample' filter "
553  "not present, cannot convert audio formats.\n");
554  return AVERROR(EINVAL);
555  }
556 
557  snprintf(inst_name, sizeof(inst_name), "auto_resampler_%d",
558  resampler_count++);
559  if ((ret = avfilter_graph_create_filter(&convert, filter,
560  inst_name, graph->aresample_swr_opts,
561  NULL, graph)) < 0)
562  return ret;
563  break;
564  default:
565  return AVERROR(EINVAL);
566  }
567 
568  if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
569  return ret;
570 
571  if ((ret = filter_query_formats(convert)) < 0)
572  return ret;
573 
574  inlink = convert->inputs[0];
575  outlink = convert->outputs[0];
576  av_assert0( inlink-> in_formats->refcount > 0);
577  av_assert0( inlink->out_formats->refcount > 0);
578  av_assert0(outlink-> in_formats->refcount > 0);
579  av_assert0(outlink->out_formats->refcount > 0);
580  if (outlink->type == AVMEDIA_TYPE_AUDIO) {
581  av_assert0( inlink-> in_samplerates->refcount > 0);
582  av_assert0( inlink->out_samplerates->refcount > 0);
583  av_assert0(outlink-> in_samplerates->refcount > 0);
584  av_assert0(outlink->out_samplerates->refcount > 0);
585  av_assert0( inlink-> in_channel_layouts->refcount > 0);
586  av_assert0( inlink->out_channel_layouts->refcount > 0);
587  av_assert0(outlink-> in_channel_layouts->refcount > 0);
588  av_assert0(outlink->out_channel_layouts->refcount > 0);
589  }
590  if (!ff_merge_formats( inlink->in_formats, inlink->out_formats, inlink->type) ||
591  !ff_merge_formats(outlink->in_formats, outlink->out_formats, outlink->type))
592  ret = AVERROR(ENOSYS);
593  if (inlink->type == AVMEDIA_TYPE_AUDIO &&
595  inlink->out_samplerates) ||
597  inlink->out_channel_layouts)))
598  ret = AVERROR(ENOSYS);
599  if (outlink->type == AVMEDIA_TYPE_AUDIO &&
601  outlink->out_samplerates) ||
603  outlink->out_channel_layouts)))
604  ret = AVERROR(ENOSYS);
605 
606  if (ret < 0) {
607  av_log(log_ctx, AV_LOG_ERROR,
608  "Impossible to convert between the formats supported by the filter "
609  "'%s' and the filter '%s'\n", link->src->name, link->dst->name);
610  return ret;
611  }
612  }
613  }
614  }
615 
616  av_log(graph, AV_LOG_DEBUG, "query_formats: "
617  "%d queried, %d merged, %d already done, %d delayed\n",
618  count_queried, count_merged, count_already_merged, count_delayed);
619  if (count_delayed) {
620  AVBPrint bp;
621 
622  /* if count_queried > 0, one filter at least did set its formats,
623  that will give additional information to its neighbour;
624  if count_merged > 0, one pair of formats lists at least was merged,
625  that will give additional information to all connected filters;
626  in both cases, progress was made and a new round must be done */
627  if (count_queried || count_merged)
628  return AVERROR(EAGAIN);
630  for (i = 0; i < graph->nb_filters; i++)
631  if (!formats_declared(graph->filters[i]))
632  av_bprintf(&bp, "%s%s", bp.len ? ", " : "",
633  graph->filters[i]->name);
634  av_log(graph, AV_LOG_ERROR,
635  "The following filters could not choose their formats: %s\n"
636  "Consider inserting the (a)format filter near their input or "
637  "output.\n", bp.str);
638  return AVERROR(EIO);
639  }
640  return 0;
641 }
642 
643 static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
644 {
645  int score = 0;
646 
647  if (av_sample_fmt_is_planar(dst_fmt) != av_sample_fmt_is_planar(src_fmt))
648  score ++;
649 
650  if (av_get_bytes_per_sample(dst_fmt) < av_get_bytes_per_sample(src_fmt)) {
651  score += 100 * (av_get_bytes_per_sample(src_fmt) - av_get_bytes_per_sample(dst_fmt));
652  }else
653  score += 10 * (av_get_bytes_per_sample(dst_fmt) - av_get_bytes_per_sample(src_fmt));
654 
657  score += 20;
658 
661  score += 2;
662 
663  return score;
664 }
665 
667  enum AVSampleFormat src_fmt)
668 {
669  int score1, score2;
670 
671  score1 = get_fmt_score(dst_fmt1, src_fmt);
672  score2 = get_fmt_score(dst_fmt2, src_fmt);
673 
674  return score1 < score2 ? dst_fmt1 : dst_fmt2;
675 }
676 
678 {
679  if (!link || !link->in_formats)
680  return 0;
681 
682  if (link->type == AVMEDIA_TYPE_VIDEO) {
683  if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
684  //FIXME: This should check for AV_PIX_FMT_FLAG_ALPHA after PAL8 pixel format without alpha is implemented
685  int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
686  enum AVPixelFormat best= AV_PIX_FMT_NONE;
687  int i;
688  for (i=0; i<link->in_formats->nb_formats; i++) {
689  enum AVPixelFormat p = link->in_formats->formats[i];
690  best= av_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL);
691  }
692  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",
694  av_get_pix_fmt_name(ref->format), has_alpha);
695  link->in_formats->formats[0] = best;
696  }
697  } else if (link->type == AVMEDIA_TYPE_AUDIO) {
698  if(ref && ref->type == AVMEDIA_TYPE_AUDIO){
700  int i;
701  for (i=0; i<link->in_formats->nb_formats; i++) {
702  enum AVSampleFormat p = link->in_formats->formats[i];
703  best = find_best_sample_fmt_of_2(best, p, ref->format);
704  }
705  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s\n",
708  link->in_formats->formats[0] = best;
709  }
710  }
711 
712  link->in_formats->nb_formats = 1;
713  link->format = link->in_formats->formats[0];
714 
715  if (link->type == AVMEDIA_TYPE_AUDIO) {
716  if (!link->in_samplerates->nb_formats) {
717  av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
718  " the link between filters %s and %s.\n", link->src->name,
719  link->dst->name);
720  return AVERROR(EINVAL);
721  }
722  link->in_samplerates->nb_formats = 1;
723  link->sample_rate = link->in_samplerates->formats[0];
724 
725  if (link->in_channel_layouts->all_layouts) {
726  av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
727  " the link between filters %s and %s.\n", link->src->name,
728  link->dst->name);
729  if (!link->in_channel_layouts->all_counts)
730  av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not "
731  "supported, try specifying a channel layout using "
732  "'aformat=channel_layouts=something'.\n");
733  return AVERROR(EINVAL);
734  }
737  if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout)))
738  link->channel_layout = 0;
739  else
741  }
742 
749 
750  return 0;
751 }
752 
753 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format, unref_format) \
754 do { \
755  for (i = 0; i < filter->nb_inputs; i++) { \
756  AVFilterLink *link = filter->inputs[i]; \
757  fmt_type fmt; \
758  \
759  if (!link->out_ ## list || link->out_ ## list->nb != 1) \
760  continue; \
761  fmt = link->out_ ## list->var[0]; \
762  \
763  for (j = 0; j < filter->nb_outputs; j++) { \
764  AVFilterLink *out_link = filter->outputs[j]; \
765  list_type *fmts; \
766  \
767  if (link->type != out_link->type || \
768  out_link->in_ ## list->nb == 1) \
769  continue; \
770  fmts = out_link->in_ ## list; \
771  \
772  if (!out_link->in_ ## list->nb) { \
773  if ((ret = add_format(&out_link->in_ ##list, fmt)) < 0)\
774  return ret; \
775  ret = 1; \
776  break; \
777  } \
778  \
779  for (k = 0; k < out_link->in_ ## list->nb; k++) \
780  if (fmts->var[k] == fmt) { \
781  fmts->var[0] = fmt; \
782  fmts->nb = 1; \
783  ret = 1; \
784  break; \
785  } \
786  } \
787  } \
788 } while (0)
789 
791 {
792  int i, j, k, ret = 0;
793 
795  nb_formats, ff_add_format, ff_formats_unref);
796  REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats,
797  nb_formats, ff_add_format, ff_formats_unref);
798 
799  /* reduce channel layouts */
800  for (i = 0; i < filter->nb_inputs; i++) {
801  AVFilterLink *inlink = filter->inputs[i];
802  uint64_t fmt;
803 
804  if (!inlink->out_channel_layouts ||
806  continue;
807  fmt = inlink->out_channel_layouts->channel_layouts[0];
808 
809  for (j = 0; j < filter->nb_outputs; j++) {
810  AVFilterLink *outlink = filter->outputs[j];
812 
813  fmts = outlink->in_channel_layouts;
814  if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
815  continue;
816 
817  if (fmts->all_layouts &&
818  (!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) {
819  /* Turn the infinite list into a singleton */
820  fmts->all_layouts = fmts->all_counts = 0;
821  if (ff_add_channel_layout(&outlink->in_channel_layouts, fmt) < 0)
822  ret = 1;
823  break;
824  }
825 
826  for (k = 0; k < outlink->in_channel_layouts->nb_channel_layouts; k++) {
827  if (fmts->channel_layouts[k] == fmt) {
828  fmts->channel_layouts[0] = fmt;
829  fmts->nb_channel_layouts = 1;
830  ret = 1;
831  break;
832  }
833  }
834  }
835  }
836 
837  return ret;
838 }
839 
840 static int reduce_formats(AVFilterGraph *graph)
841 {
842  int i, reduced, ret;
843 
844  do {
845  reduced = 0;
846 
847  for (i = 0; i < graph->nb_filters; i++) {
848  if ((ret = reduce_formats_on_filter(graph->filters[i])) < 0)
849  return ret;
850  reduced |= ret;
851  }
852  } while (reduced);
853 
854  return 0;
855 }
856 
858 {
860  int sample_rate;
861  int i, j;
862 
863  for (i = 0; i < filter->nb_inputs; i++) {
864  link = filter->inputs[i];
865 
866  if (link->type == AVMEDIA_TYPE_AUDIO &&
867  link->out_samplerates->nb_formats== 1)
868  break;
869  }
870  if (i == filter->nb_inputs)
871  return;
872 
873  sample_rate = link->out_samplerates->formats[0];
874 
875  for (i = 0; i < filter->nb_outputs; i++) {
876  AVFilterLink *outlink = filter->outputs[i];
877  int best_idx, best_diff = INT_MAX;
878 
879  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
880  outlink->in_samplerates->nb_formats < 2)
881  continue;
882 
883  for (j = 0; j < outlink->in_samplerates->nb_formats; j++) {
884  int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
885 
886  av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
887 
888  if (diff < best_diff) {
889  best_diff = diff;
890  best_idx = j;
891  }
892  }
893  FFSWAP(int, outlink->in_samplerates->formats[0],
894  outlink->in_samplerates->formats[best_idx]);
895  }
896 }
897 
898 static void swap_samplerates(AVFilterGraph *graph)
899 {
900  int i;
901 
902  for (i = 0; i < graph->nb_filters; i++)
904 }
905 
906 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
907 #define CH_FRONT_PAIR (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)
908 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)
909 #define CH_WIDE_PAIR (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)
910 #define CH_SIDE_PAIR (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
911 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
912 #define CH_BACK_PAIR (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
913 
914 /* allowable substitutions for channel pairs when comparing layouts,
915  * ordered by priority for both values */
916 static const uint64_t ch_subst[][2] = {
921  { CH_CENTER_PAIR, CH_WIDE_PAIR },
922  { CH_CENTER_PAIR, AV_CH_FRONT_CENTER },
923  { CH_WIDE_PAIR, CH_FRONT_PAIR },
924  { CH_WIDE_PAIR, CH_CENTER_PAIR },
925  { CH_WIDE_PAIR, AV_CH_FRONT_CENTER },
926  { AV_CH_FRONT_CENTER, CH_FRONT_PAIR },
927  { AV_CH_FRONT_CENTER, CH_CENTER_PAIR },
928  { AV_CH_FRONT_CENTER, CH_WIDE_PAIR },
932  { CH_BACK_PAIR, CH_DIRECT_PAIR },
934  { CH_BACK_PAIR, AV_CH_BACK_CENTER },
935  { AV_CH_BACK_CENTER, CH_BACK_PAIR },
936  { AV_CH_BACK_CENTER, CH_DIRECT_PAIR },
937  { AV_CH_BACK_CENTER, CH_SIDE_PAIR },
938 };
939 
941 {
943  int i, j, k;
944 
945  for (i = 0; i < filter->nb_inputs; i++) {
946  link = filter->inputs[i];
947 
948  if (link->type == AVMEDIA_TYPE_AUDIO &&
950  break;
951  }
952  if (i == filter->nb_inputs)
953  return;
954 
955  for (i = 0; i < filter->nb_outputs; i++) {
956  AVFilterLink *outlink = filter->outputs[i];
957  int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
958 
959  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
961  continue;
962 
963  for (j = 0; j < outlink->in_channel_layouts->nb_channel_layouts; j++) {
964  uint64_t in_chlayout = link->out_channel_layouts->channel_layouts[0];
965  uint64_t out_chlayout = outlink->in_channel_layouts->channel_layouts[j];
966  int in_channels = av_get_channel_layout_nb_channels(in_chlayout);
967  int out_channels = av_get_channel_layout_nb_channels(out_chlayout);
968  int count_diff = out_channels - in_channels;
969  int matched_channels, extra_channels;
970  int score = 100000;
971 
972  if (FF_LAYOUT2COUNT(in_chlayout) || FF_LAYOUT2COUNT(out_chlayout)) {
973  /* Compute score in case the input or output layout encodes
974  a channel count; in this case the score is not altered by
975  the computation afterwards, as in_chlayout and
976  out_chlayout have both been set to 0 */
977  if (FF_LAYOUT2COUNT(in_chlayout))
978  in_channels = FF_LAYOUT2COUNT(in_chlayout);
979  if (FF_LAYOUT2COUNT(out_chlayout))
980  out_channels = FF_LAYOUT2COUNT(out_chlayout);
981  score -= 10000 + FFABS(out_channels - in_channels) +
982  (in_channels > out_channels ? 10000 : 0);
983  in_chlayout = out_chlayout = 0;
984  /* Let the remaining computation run, even if the score
985  value is not altered */
986  }
987 
988  /* channel substitution */
989  for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {
990  uint64_t cmp0 = ch_subst[k][0];
991  uint64_t cmp1 = ch_subst[k][1];
992  if (( in_chlayout & cmp0) && (!(out_chlayout & cmp0)) &&
993  (out_chlayout & cmp1) && (!( in_chlayout & cmp1))) {
994  in_chlayout &= ~cmp0;
995  out_chlayout &= ~cmp1;
996  /* add score for channel match, minus a deduction for
997  having to do the substitution */
998  score += 10 * av_get_channel_layout_nb_channels(cmp1) - 2;
999  }
1000  }
1001 
1002  /* no penalty for LFE channel mismatch */
1003  if ( (in_chlayout & AV_CH_LOW_FREQUENCY) &&
1004  (out_chlayout & AV_CH_LOW_FREQUENCY))
1005  score += 10;
1006  in_chlayout &= ~AV_CH_LOW_FREQUENCY;
1007  out_chlayout &= ~AV_CH_LOW_FREQUENCY;
1008 
1009  matched_channels = av_get_channel_layout_nb_channels(in_chlayout &
1010  out_chlayout);
1011  extra_channels = av_get_channel_layout_nb_channels(out_chlayout &
1012  (~in_chlayout));
1013  score += 10 * matched_channels - 5 * extra_channels;
1014 
1015  if (score > best_score ||
1016  (count_diff < best_count_diff && score == best_score)) {
1017  best_score = score;
1018  best_idx = j;
1019  best_count_diff = count_diff;
1020  }
1021  }
1022  av_assert0(best_idx >= 0);
1023  FFSWAP(uint64_t, outlink->in_channel_layouts->channel_layouts[0],
1024  outlink->in_channel_layouts->channel_layouts[best_idx]);
1025  }
1026 
1027 }
1028 
1030 {
1031  int i;
1032 
1033  for (i = 0; i < graph->nb_filters; i++)
1035 }
1036 
1038 {
1039  AVFilterLink *link = NULL;
1040  int format, bps;
1041  int i, j;
1042 
1043  for (i = 0; i < filter->nb_inputs; i++) {
1044  link = filter->inputs[i];
1045 
1046  if (link->type == AVMEDIA_TYPE_AUDIO &&
1047  link->out_formats->nb_formats == 1)
1048  break;
1049  }
1050  if (i == filter->nb_inputs)
1051  return;
1052 
1053  format = link->out_formats->formats[0];
1054  bps = av_get_bytes_per_sample(format);
1055 
1056  for (i = 0; i < filter->nb_outputs; i++) {
1057  AVFilterLink *outlink = filter->outputs[i];
1058  int best_idx = -1, best_score = INT_MIN;
1059 
1060  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
1061  outlink->in_formats->nb_formats < 2)
1062  continue;
1063 
1064  for (j = 0; j < outlink->in_formats->nb_formats; j++) {
1065  int out_format = outlink->in_formats->formats[j];
1066  int out_bps = av_get_bytes_per_sample(out_format);
1067  int score;
1068 
1069  if (av_get_packed_sample_fmt(out_format) == format ||
1070  av_get_planar_sample_fmt(out_format) == format) {
1071  best_idx = j;
1072  break;
1073  }
1074 
1075  /* for s32 and float prefer double to prevent loss of information */
1076  if (bps == 4 && out_bps == 8) {
1077  best_idx = j;
1078  break;
1079  }
1080 
1081  /* prefer closest higher or equal bps */
1082  score = -abs(out_bps - bps);
1083  if (out_bps >= bps)
1084  score += INT_MAX/2;
1085 
1086  if (score > best_score) {
1087  best_score = score;
1088  best_idx = j;
1089  }
1090  }
1091  av_assert0(best_idx >= 0);
1092  FFSWAP(int, outlink->in_formats->formats[0],
1093  outlink->in_formats->formats[best_idx]);
1094  }
1095 }
1096 
1097 static void swap_sample_fmts(AVFilterGraph *graph)
1098 {
1099  int i;
1100 
1101  for (i = 0; i < graph->nb_filters; i++)
1103 
1104 }
1105 
1106 static int pick_formats(AVFilterGraph *graph)
1107 {
1108  int i, j, ret;
1109  int change;
1110 
1111  do{
1112  change = 0;
1113  for (i = 0; i < graph->nb_filters; i++) {
1114  AVFilterContext *filter = graph->filters[i];
1115  if (filter->nb_inputs){
1116  for (j = 0; j < filter->nb_inputs; j++){
1117  if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->nb_formats == 1) {
1118  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1119  return ret;
1120  change = 1;
1121  }
1122  }
1123  }
1124  if (filter->nb_outputs){
1125  for (j = 0; j < filter->nb_outputs; j++){
1126  if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->nb_formats == 1) {
1127  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1128  return ret;
1129  change = 1;
1130  }
1131  }
1132  }
1133  if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
1134  for (j = 0; j < filter->nb_outputs; j++) {
1135  if(filter->outputs[j]->format<0) {
1136  if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
1137  return ret;
1138  change = 1;
1139  }
1140  }
1141  }
1142  }
1143  }while(change);
1144 
1145  for (i = 0; i < graph->nb_filters; i++) {
1146  AVFilterContext *filter = graph->filters[i];
1147 
1148  for (j = 0; j < filter->nb_inputs; j++)
1149  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1150  return ret;
1151  for (j = 0; j < filter->nb_outputs; j++)
1152  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1153  return ret;
1154  }
1155  return 0;
1156 }
1157 
1158 /**
1159  * Configure the formats of all the links in the graph.
1160  */
1161 static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
1162 {
1163  int ret;
1164 
1165  /* find supported formats from sub-filters, and merge along links */
1166  while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN))
1167  av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n");
1168  if (ret < 0)
1169  return ret;
1170 
1171  /* Once everything is merged, it's possible that we'll still have
1172  * multiple valid media format choices. We try to minimize the amount
1173  * of format conversion inside filters */
1174  if ((ret = reduce_formats(graph)) < 0)
1175  return ret;
1176 
1177  /* for audio filters, ensure the best format, sample rate and channel layout
1178  * is selected */
1179  swap_sample_fmts(graph);
1180  swap_samplerates(graph);
1181  swap_channel_layouts(graph);
1182 
1183  if ((ret = pick_formats(graph)) < 0)
1184  return ret;
1185 
1186  return 0;
1187 }
1188 
1190  AVClass *log_ctx)
1191 {
1192  unsigned i, j;
1193  int sink_links_count = 0, n = 0;
1194  AVFilterContext *f;
1195  AVFilterLink **sinks;
1196 
1197  for (i = 0; i < graph->nb_filters; i++) {
1198  f = graph->filters[i];
1199  for (j = 0; j < f->nb_inputs; j++) {
1200  f->inputs[j]->graph = graph;
1201  f->inputs[j]->age_index = -1;
1202  }
1203  for (j = 0; j < f->nb_outputs; j++) {
1204  f->outputs[j]->graph = graph;
1205  f->outputs[j]->age_index= -1;
1206  }
1207  if (!f->nb_outputs) {
1208  if (f->nb_inputs > INT_MAX - sink_links_count)
1209  return AVERROR(EINVAL);
1210  sink_links_count += f->nb_inputs;
1211  }
1212  }
1213  sinks = av_calloc(sink_links_count, sizeof(*sinks));
1214  if (!sinks)
1215  return AVERROR(ENOMEM);
1216  for (i = 0; i < graph->nb_filters; i++) {
1217  f = graph->filters[i];
1218  if (!f->nb_outputs) {
1219  for (j = 0; j < f->nb_inputs; j++) {
1220  sinks[n] = f->inputs[j];
1221  f->inputs[j]->age_index = n++;
1222  }
1223  }
1224  }
1225  av_assert0(n == sink_links_count);
1226  graph->sink_links = sinks;
1227  graph->sink_links_count = sink_links_count;
1228  return 0;
1229 }
1230 
1231 static int graph_insert_fifos(AVFilterGraph *graph, AVClass *log_ctx)
1232 {
1233  AVFilterContext *f;
1234  int i, j, ret;
1235  int fifo_count = 0;
1236 
1237  for (i = 0; i < graph->nb_filters; i++) {
1238  f = graph->filters[i];
1239 
1240  for (j = 0; j < f->nb_inputs; j++) {
1241  AVFilterLink *link = f->inputs[j];
1242  AVFilterContext *fifo_ctx;
1243  const AVFilter *fifo;
1244  char name[32];
1245 
1246  if (!link->dstpad->needs_fifo)
1247  continue;
1248 
1249  fifo = f->inputs[j]->type == AVMEDIA_TYPE_VIDEO ?
1250  avfilter_get_by_name("fifo") :
1251  avfilter_get_by_name("afifo");
1252 
1253  snprintf(name, sizeof(name), "auto_fifo_%d", fifo_count++);
1254 
1255  ret = avfilter_graph_create_filter(&fifo_ctx, fifo, name, NULL,
1256  NULL, graph);
1257  if (ret < 0)
1258  return ret;
1259 
1260  ret = avfilter_insert_filter(link, fifo_ctx, 0, 0);
1261  if (ret < 0)
1262  return ret;
1263  }
1264  }
1265 
1266  return 0;
1267 }
1268 
1269 int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
1270 {
1271  int ret;
1272 
1273  if ((ret = graph_check_validity(graphctx, log_ctx)))
1274  return ret;
1275  if ((ret = graph_insert_fifos(graphctx, log_ctx)) < 0)
1276  return ret;
1277  if ((ret = graph_config_formats(graphctx, log_ctx)))
1278  return ret;
1279  if ((ret = graph_config_links(graphctx, log_ctx)))
1280  return ret;
1281  if ((ret = graph_check_links(graphctx, log_ctx)))
1282  return ret;
1283  if ((ret = graph_config_pointers(graphctx, log_ctx)))
1284  return ret;
1285 
1286  return 0;
1287 }
1288 
1289 int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
1290 {
1291  int i, r = AVERROR(ENOSYS);
1292 
1293  if (!graph)
1294  return r;
1295 
1296  if ((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) {
1297  r = avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);
1298  if (r != AVERROR(ENOSYS))
1299  return r;
1300  }
1301 
1302  if (res_len && res)
1303  res[0] = 0;
1304 
1305  for (i = 0; i < graph->nb_filters; i++) {
1306  AVFilterContext *filter = graph->filters[i];
1307  if (!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)) {
1308  r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);
1309  if (r != AVERROR(ENOSYS)) {
1310  if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0)
1311  return r;
1312  }
1313  }
1314  }
1315 
1316  return r;
1317 }
1318 
1319 int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
1320 {
1321  int i;
1322 
1323  if(!graph)
1324  return 0;
1325 
1326  for (i = 0; i < graph->nb_filters; i++) {
1327  AVFilterContext *filter = graph->filters[i];
1328  if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){
1329  AVFilterCommand **queue = &filter->command_queue, *next;
1330  while (*queue && (*queue)->time <= ts)
1331  queue = &(*queue)->next;
1332  next = *queue;
1333  *queue = av_mallocz(sizeof(AVFilterCommand));
1334  if (!*queue)
1335  return AVERROR(ENOMEM);
1336 
1337  (*queue)->command = av_strdup(command);
1338  (*queue)->arg = av_strdup(arg);
1339  (*queue)->time = ts;
1340  (*queue)->flags = flags;
1341  (*queue)->next = next;
1342  if(flags & AVFILTER_CMD_FLAG_ONE)
1343  return 0;
1344  }
1345  }
1346 
1347  return 0;
1348 }
1349 
1350 static void heap_bubble_up(AVFilterGraph *graph,
1351  AVFilterLink *link, int index)
1352 {
1353  AVFilterLink **links = graph->sink_links;
1354 
1355  av_assert0(index >= 0);
1356 
1357  while (index) {
1358  int parent = (index - 1) >> 1;
1359  if (links[parent]->current_pts_us >= link->current_pts_us)
1360  break;
1361  links[index] = links[parent];
1362  links[index]->age_index = index;
1363  index = parent;
1364  }
1365  links[index] = link;
1366  link->age_index = index;
1367 }
1368 
1369 static void heap_bubble_down(AVFilterGraph *graph,
1370  AVFilterLink *link, int index)
1371 {
1372  AVFilterLink **links = graph->sink_links;
1373 
1374  av_assert0(index >= 0);
1375 
1376  while (1) {
1377  int child = 2 * index + 1;
1378  if (child >= graph->sink_links_count)
1379  break;
1380  if (child + 1 < graph->sink_links_count &&
1381  links[child + 1]->current_pts_us < links[child]->current_pts_us)
1382  child++;
1383  if (link->current_pts_us < links[child]->current_pts_us)
1384  break;
1385  links[index] = links[child];
1386  links[index]->age_index = index;
1387  index = child;
1388  }
1389  links[index] = link;
1390  link->age_index = index;
1391 }
1392 
1394 {
1395  heap_bubble_up (graph, link, link->age_index);
1396  heap_bubble_down(graph, link, link->age_index);
1397 }
1398 
1400 {
1401  AVFilterLink *oldest = graph->sink_links[0];
1402  int64_t frame_count;
1403  int r;
1404 
1405  while (graph->sink_links_count) {
1406  oldest = graph->sink_links[0];
1407  if (oldest->dst->filter->activate) {
1408  /* For now, buffersink is the only filter implementing activate. */
1409  r = av_buffersink_get_frame_flags(oldest->dst, NULL,
1411  if (r != AVERROR_EOF)
1412  return r;
1413  } else {
1414  r = ff_request_frame(oldest);
1415  }
1416  if (r != AVERROR_EOF)
1417  break;
1418  av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
1419  oldest->dst ? oldest->dst->name : "unknown",
1420  oldest->dstpad ? oldest->dstpad->name : "unknown");
1421  /* EOF: remove the link from the heap */
1422  if (oldest->age_index < --graph->sink_links_count)
1423  heap_bubble_down(graph, graph->sink_links[graph->sink_links_count],
1424  oldest->age_index);
1425  oldest->age_index = -1;
1426  }
1427  if (!graph->sink_links_count)
1428  return AVERROR_EOF;
1429  av_assert1(!oldest->dst->filter->activate);
1430  av_assert1(oldest->age_index >= 0);
1431  frame_count = oldest->frame_count_out;
1432  while (frame_count == oldest->frame_count_out) {
1433  r = ff_filter_graph_run_once(graph);
1434  if (r == AVERROR(EAGAIN) &&
1435  !oldest->frame_wanted_out && !oldest->frame_blocked_in &&
1436  !oldest->status_in)
1437  ff_request_frame(oldest);
1438  else if (r < 0)
1439  return r;
1440  }
1441  return 0;
1442 }
1443 
1445 {
1447  unsigned i;
1448 
1449  av_assert0(graph->nb_filters);
1450  filter = graph->filters[0];
1451  for (i = 1; i < graph->nb_filters; i++)
1452  if (graph->filters[i]->ready > filter->ready)
1453  filter = graph->filters[i];
1454  if (!filter->ready)
1455  return AVERROR(EAGAIN);
1456  return ff_filter_activate(filter);
1457 }
AVFilterContext ** filters
Definition: avfilter.h:842
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
#define NULL
Definition: coverity.c:32
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:549
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
int sink_links_count
Definition: avfilter.h:907
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
Definition: avfilter.c:663
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
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.
int thread_type
Type of multithreading allowed for filters in this graph.
Definition: avfilter.h:862
static void swap_samplerates(AVFilterGraph *graph)
AVOption.
Definition: opt.h:246
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:135
static void swap_sample_fmts(AVFilterGraph *graph)
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:760
static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
const char * fmt
Definition: avisynth_c.h:861
misc image utilities
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:83
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Main libavfilter public API header.
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
Definition: avfilter.h:1014
static int reduce_formats(AVFilterGraph *graph)
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1305
static const uint64_t ch_subst[][2]
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
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
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
static int reduce_formats_on_filter(AVFilterContext *filter)
int(* activate)(AVFilterContext *ctx)
Filter activation function.
Definition: avfilter.h:327
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
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 format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
static int graph_insert_fifos(AVFilterGraph *graph, AVClass *log_ctx)
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
Definition: avfilter.h:845
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Definition: avfilter.h:333
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:355
#define OFFSET(x)
Definition: avfiltergraph.c:45
memory buffer sink API for audio and video
const char * name
Pad name.
Definition: internal.h:60
static int pick_format(AVFilterLink *link, AVFilterLink *ref)
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:72
int ff_filter_graph_run_once(AVFilterGraph *graph)
Run one round of processing on a filter graph.
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
char * name
name of this filter instance
Definition: avfilter.h:343
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
avfilter_execute_func * execute
This callback may be set by the caller immediately after allocating the graph and before adding any f...
Definition: avfilter.h:895
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:349
unsigned ready
Ready status of the filter.
Definition: avfilter.h:408
AVOptions.
#define FF_LAYOUT2COUNT(l)
Decode a channel count encoded as a channel layout.
Definition: formats.h:108
#define f(width, name)
Definition: cbs_vp9.c:255
AVS_FilterInfo AVS_Value child
Definition: avisynth_c.h:807
struct AVFilterFormats *** refs
references to this list
Definition: formats.h:69
#define AV_CH_LOW_FREQUENCY
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.
static int pick_formats(AVFilterGraph *graph)
int nb_threads
Maximum number of threads used by filters in this graph.
Definition: avfilter.h:869
int avfilter_config_links(AVFilterContext *filter)
Negotiate the media format, dimensions, etc of all inputs to a filter.
Definition: avfilter.c:277
#define AVERROR_EOF
End of file.
Definition: error.h:55
AVFilterContext * avfilter_graph_get_filter(AVFilterGraph *graph, const char *name)
Get a filter instance identified by instance name from graph.
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
signed 32 bits
Definition: samplefmt.h:62
#define av_log(a,...)
AVFilterFormats * ff_all_formats(enum AVMediaType type)
Return a list of all formats supported by FFmpeg for the given media type.
Definition: formats.c:350
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
A filter pad used for either input or output.
Definition: internal.h:54
unsigned refcount
number of references to this list
Definition: formats.h:68
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:345
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:568
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
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:343
const AVClass * av_class
Definition: avfilter.h:841
unsigned nb_outputs
number of output pads
Definition: avfilter.h:351
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
const char * r
Definition: vf_curves.c:114
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
uint64_t * channel_layouts
list of channel layouts
Definition: formats.h:86
const char * arg
Definition: jacosubdec.c:66
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
Add fmt to the list of media formats contained in *avff.
Definition: formats.c:337
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
static void heap_bubble_down(AVFilterGraph *graph, AVFilterLink *link, int index)
#define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format, unref_format)
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:283
AVFilterLink ** sink_links
Private fields.
Definition: avfilter.h:906
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:119
#define CH_DIRECT_PAIR
#define fail()
Definition: checkasm.h:121
char all_counts
accept any channel layout or count
Definition: formats.h:89
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:488
common internal API header
static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
Configure the formats of all the links in the graph.
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
#define b
Definition: input.c:41
audio channel layout utility functions
static void sanitize_channel_layouts(void *log, AVFilterChannelLayouts *l)
unsigned nb_inputs
number of input pads
Definition: avfilter.h:347
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
static void swap_sample_fmts_on_filter(AVFilterContext *filter)
struct AVFilterCommand * next
Definition: internal.h:43
#define CH_CENTER_PAIR
static const AVOption filtergraph_options[]
Definition: avfiltergraph.c:49
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVFormatContext * ctx
Definition: movenc.c:48
static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx)
Check for the validity of graph.
static int convert(uint8_t x)
Definition: xbmdec.c:29
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
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
unsigned nb_formats
number of formats
Definition: formats.h:65
int n
Definition: avisynth_c.h:760
#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:691
#define AV_CH_FRONT_CENTER
static enum AVSampleFormat find_best_sample_fmt_of_2(enum AVSampleFormat dst_fmt1, enum AVSampleFormat dst_fmt2, enum AVSampleFormat src_fmt)
static AVFilterFormats * clone_filter_formats(AVFilterFormats *arg)
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (...
Definition: formats.c:401
static int can_merge_formats(AVFilterFormats *a_arg, AVFilterFormats *b_arg, enum AVMediaType type, int is_sample_rate)
#define FF_ARRAY_ELEMS(a)
A list of supported channel layouts.
Definition: formats.h:85
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:924
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:240
void ff_graph_thread_free(AVFilterGraph *graph)
Definition: avfiltergraph.c:71
int ff_default_query_formats(AVFilterContext *ctx)
Definition: formats.c:597
sample_rate
#define AV_BPRINT_SIZE_AUTOMATIC
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:251
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
static void heap_bubble_up(AVFilterGraph *graph, AVFilterLink *link, int index)
static int formats_declared(AVFilterContext *f)
AVFilterGraphInternal * internal
Opaque object for libavfilter internal use.
Definition: avfilter.h:874
char all_layouts
accept any known channel layout
Definition: formats.h:88
#define abs(x)
Definition: cuda_runtime.h:35
AVFilterChannelLayouts * ff_merge_channel_layouts(AVFilterChannelLayouts *a, AVFilterChannelLayouts *b)
Return a channel layouts/samplerates list which contains the intersection of the layouts/samplerates ...
Definition: formats.c:166
AVFilterFormats * ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b, enum AVMediaType type)
Return a format list which contains the intersection of the formats of a and b.
Definition: formats.c:92
#define V
Definition: avfiltergraph.c:47
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:869
void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
Update the position of a link in the age heap.
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:481
int avfilter_graph_request_oldest(AVFilterGraph *graph)
Request a frame on the oldest sink link.
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:557
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:113
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
int index
Definition: gxfenc.c:89
int(* query_formats)(AVFilterContext *)
Query formats supported by the filter on its inputs and outputs.
Definition: avfilter.h:282
#define AVFILTER_CMD_FLAG_FAST
Only execute command when its fast (like a video out that supports contrast adjustment in hw) ...
Definition: avfilter.h:692
#define CH_BACK_PAIR
AVMediaType
Definition: avutil.h:199
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:476
const char * name
Filter name.
Definition: avfilter.h:148
unsigned nb_filters
Definition: avfilter.h:843
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
#define snprintf
Definition: snprintf.h:34
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
static void swap_channel_layouts_on_filter(AVFilterContext *filter)
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:395
static const int8_t filt[NUMTAPS]
Definition: af_earwax.c:39
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
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define AV_CH_BACK_CENTER
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
Perform one round of query_formats() and merging formats lists on the filter graph.
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
int ff_graph_thread_init(AVFilterGraph *graph)
Definition: avfiltergraph.c:75
static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx)
Configure all the links of graphctx.
static void swap_channel_layouts(AVFilterGraph *graph)
#define MERGE_DISPATCH(field, statement)
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
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int nb_channel_layouts
number of channel layouts
Definition: formats.h:87
#define CH_FRONT_PAIR
struct AVFilterCommand * command_queue
Definition: avfilter.h:380
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.
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:253
unsigned bps
Definition: movenc.c:1532
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:2811
static void swap_samplerates_on_filter(AVFilterContext *filter)
char * aresample_swr_opts
swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions ...
Definition: avfilter.h:897
void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
Remove a filter from a graph;.
#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:53
static av_always_inline int diff(const uint32_t a, const uint32_t b)
avfilter_execute_func * thread_execute
Definition: internal.h:150
#define F
Definition: avfiltergraph.c:46
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
static const struct PPFilter filters[]
Definition: postprocess.c:134
unsigned refcount
number of references to this list
Definition: formats.h:91
A list of supported formats for one end of a filter link.
Definition: formats.h:64
void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
Init a global structure.
Definition: framequeue.c:30
static int graph_check_links(AVFilterGraph *graph, AVClass *log_ctx)
static const AVClass filtergraph_class
Definition: avfiltergraph.c:62
An instance of a filter.
Definition: avfilter.h:338
#define av_freep(p)
#define CH_SIDE_PAIR
FFFrameQueueGlobal frame_queues
Definition: internal.h:151
double time
time expressed in seconds
Definition: internal.h:39
int needs_fifo
The filter expects a fifo to be inserted on its input link, typically because it has a delay...
Definition: internal.h:137
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:407
formats
Definition: signature.h:48
#define FFSWAP(type, a, b)
Definition: common.h:99
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:2438
static int filter_query_formats(AVFilterContext *ctx)
AVFilterFormats * ff_merge_samplerates(AVFilterFormats *a, AVFilterFormats *b)
Definition: formats.c:139
internal API functions
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 A
Definition: avfiltergraph.c:48
int ff_filter_activate(AVFilterContext *filter)
Definition: avfilter.c:1421
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#define CH_WIDE_PAIR
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:556
unsigned disable_auto_convert
Definition: avfilter.h:909
static int graph_config_pointers(AVFilterGraph *graph, AVClass *log_ctx)
const char * name
Definition: opengl_enc.c:102
int * formats
list of media formats
Definition: formats.h:66