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  av_freep(&a->formats);
423  av_freep(&b->formats);
424  av_freep(&a);
425  av_freep(&b);
426  return 0;
427  }
428 }
429 
430 /**
431  * Perform one round of query_formats() and merging formats lists on the
432  * filter graph.
433  * @return >=0 if all links formats lists could be queried and merged;
434  * AVERROR(EAGAIN) some progress was made in the queries or merging
435  * and a later call may succeed;
436  * AVERROR(EIO) (may be changed) plus a log message if no progress
437  * was made and the negotiation is stuck;
438  * a negative error code if some other error happened
439  */
440 static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
441 {
442  int i, j, ret;
443  int scaler_count = 0, resampler_count = 0;
444  int count_queried = 0; /* successful calls to query_formats() */
445  int count_merged = 0; /* successful merge of formats lists */
446  int count_already_merged = 0; /* lists already merged */
447  int count_delayed = 0; /* lists that need to be merged later */
448 
449  for (i = 0; i < graph->nb_filters; i++) {
450  AVFilterContext *f = graph->filters[i];
451  if (formats_declared(f))
452  continue;
453  if (f->filter->query_formats)
454  ret = filter_query_formats(f);
455  else
456  ret = ff_default_query_formats(f);
457  if (ret < 0 && ret != AVERROR(EAGAIN))
458  return ret;
459  /* note: EAGAIN could indicate a partial success, not counted yet */
460  count_queried += ret >= 0;
461  }
462 
463  /* go through and merge as many format lists as possible */
464  for (i = 0; i < graph->nb_filters; i++) {
465  AVFilterContext *filter = graph->filters[i];
466 
467  for (j = 0; j < filter->nb_inputs; j++) {
468  AVFilterLink *link = filter->inputs[j];
469  int convert_needed = 0;
470 
471  if (!link)
472  continue;
473 
474  if (link->in_formats != link->out_formats
475  && link->in_formats && link->out_formats)
476  if (!can_merge_formats(link->in_formats, link->out_formats,
477  link->type, 0))
478  convert_needed = 1;
479  if (link->type == AVMEDIA_TYPE_AUDIO) {
480  if (link->in_samplerates != link->out_samplerates
481  && link->in_samplerates && link->out_samplerates)
483  link->out_samplerates,
484  0, 1))
485  convert_needed = 1;
486  }
487 
488 #define MERGE_DISPATCH(field, statement) \
489  if (!(link->in_ ## field && link->out_ ## field)) { \
490  count_delayed++; \
491  } else if (link->in_ ## field == link->out_ ## field) { \
492  count_already_merged++; \
493  } else if (!convert_needed) { \
494  count_merged++; \
495  statement \
496  }
497 
498  if (link->type == AVMEDIA_TYPE_AUDIO) {
501  link->out_channel_layouts))
502  convert_needed = 1;
503  )
504  MERGE_DISPATCH(samplerates,
506  link->out_samplerates))
507  convert_needed = 1;
508  )
509  }
511  if (!ff_merge_formats(link->in_formats, link->out_formats,
512  link->type))
513  convert_needed = 1;
514  )
515 #undef MERGE_DISPATCH
516 
517  if (convert_needed) {
519  const AVFilter *filter;
520  AVFilterLink *inlink, *outlink;
521  char inst_name[30];
522 
523  if (graph->disable_auto_convert) {
524  av_log(log_ctx, AV_LOG_ERROR,
525  "The filters '%s' and '%s' do not have a common format "
526  "and automatic conversion is disabled.\n",
527  link->src->name, link->dst->name);
528  return AVERROR(EINVAL);
529  }
530 
531  /* couldn't merge format lists. auto-insert conversion filter */
532  switch (link->type) {
533  case AVMEDIA_TYPE_VIDEO:
534  if (!(filter = avfilter_get_by_name("scale"))) {
535  av_log(log_ctx, AV_LOG_ERROR, "'scale' filter "
536  "not present, cannot convert pixel formats.\n");
537  return AVERROR(EINVAL);
538  }
539 
540  snprintf(inst_name, sizeof(inst_name), "auto_scaler_%d",
541  scaler_count++);
542 
543  if ((ret = avfilter_graph_create_filter(&convert, filter,
544  inst_name, graph->scale_sws_opts, NULL,
545  graph)) < 0)
546  return ret;
547  break;
548  case AVMEDIA_TYPE_AUDIO:
549  if (!(filter = avfilter_get_by_name("aresample"))) {
550  av_log(log_ctx, AV_LOG_ERROR, "'aresample' filter "
551  "not present, cannot convert audio formats.\n");
552  return AVERROR(EINVAL);
553  }
554 
555  snprintf(inst_name, sizeof(inst_name), "auto_resampler_%d",
556  resampler_count++);
557  if ((ret = avfilter_graph_create_filter(&convert, filter,
558  inst_name, graph->aresample_swr_opts,
559  NULL, graph)) < 0)
560  return ret;
561  break;
562  default:
563  return AVERROR(EINVAL);
564  }
565 
566  if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
567  return ret;
568 
569  if ((ret = filter_query_formats(convert)) < 0)
570  return ret;
571 
572  inlink = convert->inputs[0];
573  outlink = convert->outputs[0];
574  av_assert0( inlink-> in_formats->refcount > 0);
575  av_assert0( inlink->out_formats->refcount > 0);
576  av_assert0(outlink-> in_formats->refcount > 0);
577  av_assert0(outlink->out_formats->refcount > 0);
578  if (outlink->type == AVMEDIA_TYPE_AUDIO) {
579  av_assert0( inlink-> in_samplerates->refcount > 0);
580  av_assert0( inlink->out_samplerates->refcount > 0);
581  av_assert0(outlink-> in_samplerates->refcount > 0);
582  av_assert0(outlink->out_samplerates->refcount > 0);
583  av_assert0( inlink-> in_channel_layouts->refcount > 0);
584  av_assert0( inlink->out_channel_layouts->refcount > 0);
585  av_assert0(outlink-> in_channel_layouts->refcount > 0);
586  av_assert0(outlink->out_channel_layouts->refcount > 0);
587  }
588  if (!ff_merge_formats( inlink->in_formats, inlink->out_formats, inlink->type) ||
589  !ff_merge_formats(outlink->in_formats, outlink->out_formats, outlink->type))
590  ret = AVERROR(ENOSYS);
591  if (inlink->type == AVMEDIA_TYPE_AUDIO &&
593  inlink->out_samplerates) ||
595  inlink->out_channel_layouts)))
596  ret = AVERROR(ENOSYS);
597  if (outlink->type == AVMEDIA_TYPE_AUDIO &&
599  outlink->out_samplerates) ||
601  outlink->out_channel_layouts)))
602  ret = AVERROR(ENOSYS);
603 
604  if (ret < 0) {
605  av_log(log_ctx, AV_LOG_ERROR,
606  "Impossible to convert between the formats supported by the filter "
607  "'%s' and the filter '%s'\n", link->src->name, link->dst->name);
608  return ret;
609  }
610  }
611  }
612  }
613 
614  av_log(graph, AV_LOG_DEBUG, "query_formats: "
615  "%d queried, %d merged, %d already done, %d delayed\n",
616  count_queried, count_merged, count_already_merged, count_delayed);
617  if (count_delayed) {
618  AVBPrint bp;
619 
620  /* if count_queried > 0, one filter at least did set its formats,
621  that will give additional information to its neighbour;
622  if count_merged > 0, one pair of formats lists at least was merged,
623  that will give additional information to all connected filters;
624  in both cases, progress was made and a new round must be done */
625  if (count_queried || count_merged)
626  return AVERROR(EAGAIN);
628  for (i = 0; i < graph->nb_filters; i++)
629  if (!formats_declared(graph->filters[i]))
630  av_bprintf(&bp, "%s%s", bp.len ? ", " : "",
631  graph->filters[i]->name);
632  av_log(graph, AV_LOG_ERROR,
633  "The following filters could not choose their formats: %s\n"
634  "Consider inserting the (a)format filter near their input or "
635  "output.\n", bp.str);
636  return AVERROR(EIO);
637  }
638  return 0;
639 }
640 
641 static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
642 {
643  int score = 0;
644 
645  if (av_sample_fmt_is_planar(dst_fmt) != av_sample_fmt_is_planar(src_fmt))
646  score ++;
647 
648  if (av_get_bytes_per_sample(dst_fmt) < av_get_bytes_per_sample(src_fmt)) {
649  score += 100 * (av_get_bytes_per_sample(src_fmt) - av_get_bytes_per_sample(dst_fmt));
650  }else
651  score += 10 * (av_get_bytes_per_sample(dst_fmt) - av_get_bytes_per_sample(src_fmt));
652 
655  score += 20;
656 
659  score += 2;
660 
661  return score;
662 }
663 
665  enum AVSampleFormat src_fmt)
666 {
667  int score1, score2;
668 
669  score1 = get_fmt_score(dst_fmt1, src_fmt);
670  score2 = get_fmt_score(dst_fmt2, src_fmt);
671 
672  return score1 < score2 ? dst_fmt1 : dst_fmt2;
673 }
674 
676 {
677  if (!link || !link->in_formats)
678  return 0;
679 
680  if (link->type == AVMEDIA_TYPE_VIDEO) {
681  if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
682  //FIXME: This should check for AV_PIX_FMT_FLAG_ALPHA after PAL8 pixel format without alpha is implemented
683  int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
684  enum AVPixelFormat best= AV_PIX_FMT_NONE;
685  int i;
686  for (i=0; i<link->in_formats->nb_formats; i++) {
687  enum AVPixelFormat p = link->in_formats->formats[i];
688  best= av_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL);
689  }
690  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",
692  av_get_pix_fmt_name(ref->format), has_alpha);
693  link->in_formats->formats[0] = best;
694  }
695  } else if (link->type == AVMEDIA_TYPE_AUDIO) {
696  if(ref && ref->type == AVMEDIA_TYPE_AUDIO){
698  int i;
699  for (i=0; i<link->in_formats->nb_formats; i++) {
700  enum AVSampleFormat p = link->in_formats->formats[i];
701  best = find_best_sample_fmt_of_2(best, p, ref->format);
702  }
703  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s\n",
706  link->in_formats->formats[0] = best;
707  }
708  }
709 
710  link->in_formats->nb_formats = 1;
711  link->format = link->in_formats->formats[0];
712 
713  if (link->type == AVMEDIA_TYPE_AUDIO) {
714  if (!link->in_samplerates->nb_formats) {
715  av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
716  " the link between filters %s and %s.\n", link->src->name,
717  link->dst->name);
718  return AVERROR(EINVAL);
719  }
720  link->in_samplerates->nb_formats = 1;
721  link->sample_rate = link->in_samplerates->formats[0];
722 
723  if (link->in_channel_layouts->all_layouts) {
724  av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
725  " the link between filters %s and %s.\n", link->src->name,
726  link->dst->name);
727  if (!link->in_channel_layouts->all_counts)
728  av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not "
729  "supported, try specifying a channel layout using "
730  "'aformat=channel_layouts=something'.\n");
731  return AVERROR(EINVAL);
732  }
735  if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout)))
736  link->channel_layout = 0;
737  else
739  }
740 
747 
748  return 0;
749 }
750 
751 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format, unref_format) \
752 do { \
753  for (i = 0; i < filter->nb_inputs; i++) { \
754  AVFilterLink *link = filter->inputs[i]; \
755  fmt_type fmt; \
756  \
757  if (!link->out_ ## list || link->out_ ## list->nb != 1) \
758  continue; \
759  fmt = link->out_ ## list->var[0]; \
760  \
761  for (j = 0; j < filter->nb_outputs; j++) { \
762  AVFilterLink *out_link = filter->outputs[j]; \
763  list_type *fmts; \
764  \
765  if (link->type != out_link->type || \
766  out_link->in_ ## list->nb == 1) \
767  continue; \
768  fmts = out_link->in_ ## list; \
769  \
770  if (!out_link->in_ ## list->nb) { \
771  if ((ret = add_format(&out_link->in_ ##list, fmt)) < 0)\
772  return ret; \
773  ret = 1; \
774  break; \
775  } \
776  \
777  for (k = 0; k < out_link->in_ ## list->nb; k++) \
778  if (fmts->var[k] == fmt) { \
779  fmts->var[0] = fmt; \
780  fmts->nb = 1; \
781  ret = 1; \
782  break; \
783  } \
784  } \
785  } \
786 } while (0)
787 
789 {
790  int i, j, k, ret = 0;
791 
793  nb_formats, ff_add_format, ff_formats_unref);
794  REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats,
795  nb_formats, ff_add_format, ff_formats_unref);
796 
797  /* reduce channel layouts */
798  for (i = 0; i < filter->nb_inputs; i++) {
799  AVFilterLink *inlink = filter->inputs[i];
800  uint64_t fmt;
801 
802  if (!inlink->out_channel_layouts ||
804  continue;
805  fmt = inlink->out_channel_layouts->channel_layouts[0];
806 
807  for (j = 0; j < filter->nb_outputs; j++) {
808  AVFilterLink *outlink = filter->outputs[j];
810 
811  fmts = outlink->in_channel_layouts;
812  if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
813  continue;
814 
815  if (fmts->all_layouts &&
816  (!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) {
817  /* Turn the infinite list into a singleton */
818  fmts->all_layouts = fmts->all_counts = 0;
819  if (ff_add_channel_layout(&outlink->in_channel_layouts, fmt) < 0)
820  ret = 1;
821  break;
822  }
823 
824  for (k = 0; k < outlink->in_channel_layouts->nb_channel_layouts; k++) {
825  if (fmts->channel_layouts[k] == fmt) {
826  fmts->channel_layouts[0] = fmt;
827  fmts->nb_channel_layouts = 1;
828  ret = 1;
829  break;
830  }
831  }
832  }
833  }
834 
835  return ret;
836 }
837 
838 static int reduce_formats(AVFilterGraph *graph)
839 {
840  int i, reduced, ret;
841 
842  do {
843  reduced = 0;
844 
845  for (i = 0; i < graph->nb_filters; i++) {
846  if ((ret = reduce_formats_on_filter(graph->filters[i])) < 0)
847  return ret;
848  reduced |= ret;
849  }
850  } while (reduced);
851 
852  return 0;
853 }
854 
856 {
858  int sample_rate;
859  int i, j;
860 
861  for (i = 0; i < filter->nb_inputs; i++) {
862  link = filter->inputs[i];
863 
864  if (link->type == AVMEDIA_TYPE_AUDIO &&
865  link->out_samplerates->nb_formats== 1)
866  break;
867  }
868  if (i == filter->nb_inputs)
869  return;
870 
871  sample_rate = link->out_samplerates->formats[0];
872 
873  for (i = 0; i < filter->nb_outputs; i++) {
874  AVFilterLink *outlink = filter->outputs[i];
875  int best_idx, best_diff = INT_MAX;
876 
877  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
878  outlink->in_samplerates->nb_formats < 2)
879  continue;
880 
881  for (j = 0; j < outlink->in_samplerates->nb_formats; j++) {
882  int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
883 
884  av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
885 
886  if (diff < best_diff) {
887  best_diff = diff;
888  best_idx = j;
889  }
890  }
891  FFSWAP(int, outlink->in_samplerates->formats[0],
892  outlink->in_samplerates->formats[best_idx]);
893  }
894 }
895 
896 static void swap_samplerates(AVFilterGraph *graph)
897 {
898  int i;
899 
900  for (i = 0; i < graph->nb_filters; i++)
902 }
903 
904 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
905 #define CH_FRONT_PAIR (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)
906 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)
907 #define CH_WIDE_PAIR (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)
908 #define CH_SIDE_PAIR (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
909 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
910 #define CH_BACK_PAIR (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
911 
912 /* allowable substitutions for channel pairs when comparing layouts,
913  * ordered by priority for both values */
914 static const uint64_t ch_subst[][2] = {
919  { CH_CENTER_PAIR, CH_WIDE_PAIR },
920  { CH_CENTER_PAIR, AV_CH_FRONT_CENTER },
921  { CH_WIDE_PAIR, CH_FRONT_PAIR },
922  { CH_WIDE_PAIR, CH_CENTER_PAIR },
923  { CH_WIDE_PAIR, AV_CH_FRONT_CENTER },
924  { AV_CH_FRONT_CENTER, CH_FRONT_PAIR },
925  { AV_CH_FRONT_CENTER, CH_CENTER_PAIR },
926  { AV_CH_FRONT_CENTER, CH_WIDE_PAIR },
930  { CH_BACK_PAIR, CH_DIRECT_PAIR },
932  { CH_BACK_PAIR, AV_CH_BACK_CENTER },
933  { AV_CH_BACK_CENTER, CH_BACK_PAIR },
934  { AV_CH_BACK_CENTER, CH_DIRECT_PAIR },
935  { AV_CH_BACK_CENTER, CH_SIDE_PAIR },
936 };
937 
939 {
941  int i, j, k;
942 
943  for (i = 0; i < filter->nb_inputs; i++) {
944  link = filter->inputs[i];
945 
946  if (link->type == AVMEDIA_TYPE_AUDIO &&
948  break;
949  }
950  if (i == filter->nb_inputs)
951  return;
952 
953  for (i = 0; i < filter->nb_outputs; i++) {
954  AVFilterLink *outlink = filter->outputs[i];
955  int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
956 
957  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
959  continue;
960 
961  for (j = 0; j < outlink->in_channel_layouts->nb_channel_layouts; j++) {
962  uint64_t in_chlayout = link->out_channel_layouts->channel_layouts[0];
963  uint64_t out_chlayout = outlink->in_channel_layouts->channel_layouts[j];
964  int in_channels = av_get_channel_layout_nb_channels(in_chlayout);
965  int out_channels = av_get_channel_layout_nb_channels(out_chlayout);
966  int count_diff = out_channels - in_channels;
967  int matched_channels, extra_channels;
968  int score = 100000;
969 
970  if (FF_LAYOUT2COUNT(in_chlayout) || FF_LAYOUT2COUNT(out_chlayout)) {
971  /* Compute score in case the input or output layout encodes
972  a channel count; in this case the score is not altered by
973  the computation afterwards, as in_chlayout and
974  out_chlayout have both been set to 0 */
975  if (FF_LAYOUT2COUNT(in_chlayout))
976  in_channels = FF_LAYOUT2COUNT(in_chlayout);
977  if (FF_LAYOUT2COUNT(out_chlayout))
978  out_channels = FF_LAYOUT2COUNT(out_chlayout);
979  score -= 10000 + FFABS(out_channels - in_channels) +
980  (in_channels > out_channels ? 10000 : 0);
981  in_chlayout = out_chlayout = 0;
982  /* Let the remaining computation run, even if the score
983  value is not altered */
984  }
985 
986  /* channel substitution */
987  for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {
988  uint64_t cmp0 = ch_subst[k][0];
989  uint64_t cmp1 = ch_subst[k][1];
990  if (( in_chlayout & cmp0) && (!(out_chlayout & cmp0)) &&
991  (out_chlayout & cmp1) && (!( in_chlayout & cmp1))) {
992  in_chlayout &= ~cmp0;
993  out_chlayout &= ~cmp1;
994  /* add score for channel match, minus a deduction for
995  having to do the substitution */
996  score += 10 * av_get_channel_layout_nb_channels(cmp1) - 2;
997  }
998  }
999 
1000  /* no penalty for LFE channel mismatch */
1001  if ( (in_chlayout & AV_CH_LOW_FREQUENCY) &&
1002  (out_chlayout & AV_CH_LOW_FREQUENCY))
1003  score += 10;
1004  in_chlayout &= ~AV_CH_LOW_FREQUENCY;
1005  out_chlayout &= ~AV_CH_LOW_FREQUENCY;
1006 
1007  matched_channels = av_get_channel_layout_nb_channels(in_chlayout &
1008  out_chlayout);
1009  extra_channels = av_get_channel_layout_nb_channels(out_chlayout &
1010  (~in_chlayout));
1011  score += 10 * matched_channels - 5 * extra_channels;
1012 
1013  if (score > best_score ||
1014  (count_diff < best_count_diff && score == best_score)) {
1015  best_score = score;
1016  best_idx = j;
1017  best_count_diff = count_diff;
1018  }
1019  }
1020  av_assert0(best_idx >= 0);
1021  FFSWAP(uint64_t, outlink->in_channel_layouts->channel_layouts[0],
1022  outlink->in_channel_layouts->channel_layouts[best_idx]);
1023  }
1024 
1025 }
1026 
1028 {
1029  int i;
1030 
1031  for (i = 0; i < graph->nb_filters; i++)
1033 }
1034 
1036 {
1037  AVFilterLink *link = NULL;
1038  int format, bps;
1039  int i, j;
1040 
1041  for (i = 0; i < filter->nb_inputs; i++) {
1042  link = filter->inputs[i];
1043 
1044  if (link->type == AVMEDIA_TYPE_AUDIO &&
1045  link->out_formats->nb_formats == 1)
1046  break;
1047  }
1048  if (i == filter->nb_inputs)
1049  return;
1050 
1051  format = link->out_formats->formats[0];
1052  bps = av_get_bytes_per_sample(format);
1053 
1054  for (i = 0; i < filter->nb_outputs; i++) {
1055  AVFilterLink *outlink = filter->outputs[i];
1056  int best_idx = -1, best_score = INT_MIN;
1057 
1058  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
1059  outlink->in_formats->nb_formats < 2)
1060  continue;
1061 
1062  for (j = 0; j < outlink->in_formats->nb_formats; j++) {
1063  int out_format = outlink->in_formats->formats[j];
1064  int out_bps = av_get_bytes_per_sample(out_format);
1065  int score;
1066 
1067  if (av_get_packed_sample_fmt(out_format) == format ||
1068  av_get_planar_sample_fmt(out_format) == format) {
1069  best_idx = j;
1070  break;
1071  }
1072 
1073  /* for s32 and float prefer double to prevent loss of information */
1074  if (bps == 4 && out_bps == 8) {
1075  best_idx = j;
1076  break;
1077  }
1078 
1079  /* prefer closest higher or equal bps */
1080  score = -abs(out_bps - bps);
1081  if (out_bps >= bps)
1082  score += INT_MAX/2;
1083 
1084  if (score > best_score) {
1085  best_score = score;
1086  best_idx = j;
1087  }
1088  }
1089  av_assert0(best_idx >= 0);
1090  FFSWAP(int, outlink->in_formats->formats[0],
1091  outlink->in_formats->formats[best_idx]);
1092  }
1093 }
1094 
1095 static void swap_sample_fmts(AVFilterGraph *graph)
1096 {
1097  int i;
1098 
1099  for (i = 0; i < graph->nb_filters; i++)
1101 
1102 }
1103 
1104 static int pick_formats(AVFilterGraph *graph)
1105 {
1106  int i, j, ret;
1107  int change;
1108 
1109  do{
1110  change = 0;
1111  for (i = 0; i < graph->nb_filters; i++) {
1112  AVFilterContext *filter = graph->filters[i];
1113  if (filter->nb_inputs){
1114  for (j = 0; j < filter->nb_inputs; j++){
1115  if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->nb_formats == 1) {
1116  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1117  return ret;
1118  change = 1;
1119  }
1120  }
1121  }
1122  if (filter->nb_outputs){
1123  for (j = 0; j < filter->nb_outputs; j++){
1124  if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->nb_formats == 1) {
1125  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1126  return ret;
1127  change = 1;
1128  }
1129  }
1130  }
1131  if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
1132  for (j = 0; j < filter->nb_outputs; j++) {
1133  if(filter->outputs[j]->format<0) {
1134  if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
1135  return ret;
1136  change = 1;
1137  }
1138  }
1139  }
1140  }
1141  }while(change);
1142 
1143  for (i = 0; i < graph->nb_filters; i++) {
1144  AVFilterContext *filter = graph->filters[i];
1145 
1146  for (j = 0; j < filter->nb_inputs; j++)
1147  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1148  return ret;
1149  for (j = 0; j < filter->nb_outputs; j++)
1150  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1151  return ret;
1152  }
1153  return 0;
1154 }
1155 
1156 /**
1157  * Configure the formats of all the links in the graph.
1158  */
1159 static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
1160 {
1161  int ret;
1162 
1163  /* find supported formats from sub-filters, and merge along links */
1164  while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN))
1165  av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n");
1166  if (ret < 0)
1167  return ret;
1168 
1169  /* Once everything is merged, it's possible that we'll still have
1170  * multiple valid media format choices. We try to minimize the amount
1171  * of format conversion inside filters */
1172  if ((ret = reduce_formats(graph)) < 0)
1173  return ret;
1174 
1175  /* for audio filters, ensure the best format, sample rate and channel layout
1176  * is selected */
1177  swap_sample_fmts(graph);
1178  swap_samplerates(graph);
1179  swap_channel_layouts(graph);
1180 
1181  if ((ret = pick_formats(graph)) < 0)
1182  return ret;
1183 
1184  return 0;
1185 }
1186 
1188  AVClass *log_ctx)
1189 {
1190  unsigned i, j;
1191  int sink_links_count = 0, n = 0;
1192  AVFilterContext *f;
1193  AVFilterLink **sinks;
1194 
1195  for (i = 0; i < graph->nb_filters; i++) {
1196  f = graph->filters[i];
1197  for (j = 0; j < f->nb_inputs; j++) {
1198  f->inputs[j]->graph = graph;
1199  f->inputs[j]->age_index = -1;
1200  }
1201  for (j = 0; j < f->nb_outputs; j++) {
1202  f->outputs[j]->graph = graph;
1203  f->outputs[j]->age_index= -1;
1204  }
1205  if (!f->nb_outputs) {
1206  if (f->nb_inputs > INT_MAX - sink_links_count)
1207  return AVERROR(EINVAL);
1208  sink_links_count += f->nb_inputs;
1209  }
1210  }
1211  sinks = av_calloc(sink_links_count, sizeof(*sinks));
1212  if (!sinks)
1213  return AVERROR(ENOMEM);
1214  for (i = 0; i < graph->nb_filters; i++) {
1215  f = graph->filters[i];
1216  if (!f->nb_outputs) {
1217  for (j = 0; j < f->nb_inputs; j++) {
1218  sinks[n] = f->inputs[j];
1219  f->inputs[j]->age_index = n++;
1220  }
1221  }
1222  }
1223  av_assert0(n == sink_links_count);
1224  graph->sink_links = sinks;
1225  graph->sink_links_count = sink_links_count;
1226  return 0;
1227 }
1228 
1229 static int graph_insert_fifos(AVFilterGraph *graph, AVClass *log_ctx)
1230 {
1231  AVFilterContext *f;
1232  int i, j, ret;
1233  int fifo_count = 0;
1234 
1235  for (i = 0; i < graph->nb_filters; i++) {
1236  f = graph->filters[i];
1237 
1238  for (j = 0; j < f->nb_inputs; j++) {
1239  AVFilterLink *link = f->inputs[j];
1240  AVFilterContext *fifo_ctx;
1241  const AVFilter *fifo;
1242  char name[32];
1243 
1244  if (!link->dstpad->needs_fifo)
1245  continue;
1246 
1247  fifo = f->inputs[j]->type == AVMEDIA_TYPE_VIDEO ?
1248  avfilter_get_by_name("fifo") :
1249  avfilter_get_by_name("afifo");
1250 
1251  snprintf(name, sizeof(name), "auto_fifo_%d", fifo_count++);
1252 
1253  ret = avfilter_graph_create_filter(&fifo_ctx, fifo, name, NULL,
1254  NULL, graph);
1255  if (ret < 0)
1256  return ret;
1257 
1258  ret = avfilter_insert_filter(link, fifo_ctx, 0, 0);
1259  if (ret < 0)
1260  return ret;
1261  }
1262  }
1263 
1264  return 0;
1265 }
1266 
1267 int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
1268 {
1269  int ret;
1270 
1271  if ((ret = graph_check_validity(graphctx, log_ctx)))
1272  return ret;
1273  if ((ret = graph_insert_fifos(graphctx, log_ctx)) < 0)
1274  return ret;
1275  if ((ret = graph_config_formats(graphctx, log_ctx)))
1276  return ret;
1277  if ((ret = graph_config_links(graphctx, log_ctx)))
1278  return ret;
1279  if ((ret = graph_check_links(graphctx, log_ctx)))
1280  return ret;
1281  if ((ret = graph_config_pointers(graphctx, log_ctx)))
1282  return ret;
1283 
1284  return 0;
1285 }
1286 
1287 int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
1288 {
1289  int i, r = AVERROR(ENOSYS);
1290 
1291  if (!graph)
1292  return r;
1293 
1294  if ((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) {
1295  r = avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);
1296  if (r != AVERROR(ENOSYS))
1297  return r;
1298  }
1299 
1300  if (res_len && res)
1301  res[0] = 0;
1302 
1303  for (i = 0; i < graph->nb_filters; i++) {
1304  AVFilterContext *filter = graph->filters[i];
1305  if (!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)) {
1306  r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);
1307  if (r != AVERROR(ENOSYS)) {
1308  if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0)
1309  return r;
1310  }
1311  }
1312  }
1313 
1314  return r;
1315 }
1316 
1317 int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
1318 {
1319  int i;
1320 
1321  if(!graph)
1322  return 0;
1323 
1324  for (i = 0; i < graph->nb_filters; i++) {
1325  AVFilterContext *filter = graph->filters[i];
1326  if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){
1327  AVFilterCommand **queue = &filter->command_queue, *next;
1328  while (*queue && (*queue)->time <= ts)
1329  queue = &(*queue)->next;
1330  next = *queue;
1331  *queue = av_mallocz(sizeof(AVFilterCommand));
1332  if (!*queue)
1333  return AVERROR(ENOMEM);
1334 
1335  (*queue)->command = av_strdup(command);
1336  (*queue)->arg = av_strdup(arg);
1337  (*queue)->time = ts;
1338  (*queue)->flags = flags;
1339  (*queue)->next = next;
1340  if(flags & AVFILTER_CMD_FLAG_ONE)
1341  return 0;
1342  }
1343  }
1344 
1345  return 0;
1346 }
1347 
1348 static void heap_bubble_up(AVFilterGraph *graph,
1349  AVFilterLink *link, int index)
1350 {
1351  AVFilterLink **links = graph->sink_links;
1352 
1353  av_assert0(index >= 0);
1354 
1355  while (index) {
1356  int parent = (index - 1) >> 1;
1357  if (links[parent]->current_pts_us >= link->current_pts_us)
1358  break;
1359  links[index] = links[parent];
1360  links[index]->age_index = index;
1361  index = parent;
1362  }
1363  links[index] = link;
1364  link->age_index = index;
1365 }
1366 
1367 static void heap_bubble_down(AVFilterGraph *graph,
1368  AVFilterLink *link, int index)
1369 {
1370  AVFilterLink **links = graph->sink_links;
1371 
1372  av_assert0(index >= 0);
1373 
1374  while (1) {
1375  int child = 2 * index + 1;
1376  if (child >= graph->sink_links_count)
1377  break;
1378  if (child + 1 < graph->sink_links_count &&
1379  links[child + 1]->current_pts_us < links[child]->current_pts_us)
1380  child++;
1381  if (link->current_pts_us < links[child]->current_pts_us)
1382  break;
1383  links[index] = links[child];
1384  links[index]->age_index = index;
1385  index = child;
1386  }
1387  links[index] = link;
1388  link->age_index = index;
1389 }
1390 
1392 {
1393  heap_bubble_up (graph, link, link->age_index);
1394  heap_bubble_down(graph, link, link->age_index);
1395 }
1396 
1398 {
1399  AVFilterLink *oldest = graph->sink_links[0];
1400  int64_t frame_count;
1401  int r;
1402 
1403  while (graph->sink_links_count) {
1404  oldest = graph->sink_links[0];
1405  if (oldest->dst->filter->activate) {
1406  /* For now, buffersink is the only filter implementing activate. */
1407  r = av_buffersink_get_frame_flags(oldest->dst, NULL,
1409  if (r != AVERROR_EOF)
1410  return r;
1411  } else {
1412  r = ff_request_frame(oldest);
1413  }
1414  if (r != AVERROR_EOF)
1415  break;
1416  av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
1417  oldest->dst ? oldest->dst->name : "unknown",
1418  oldest->dstpad ? oldest->dstpad->name : "unknown");
1419  /* EOF: remove the link from the heap */
1420  if (oldest->age_index < --graph->sink_links_count)
1421  heap_bubble_down(graph, graph->sink_links[graph->sink_links_count],
1422  oldest->age_index);
1423  oldest->age_index = -1;
1424  }
1425  if (!graph->sink_links_count)
1426  return AVERROR_EOF;
1427  av_assert1(!oldest->dst->filter->activate);
1428  av_assert1(oldest->age_index >= 0);
1429  frame_count = oldest->frame_count_out;
1430  while (frame_count == oldest->frame_count_out) {
1431  r = ff_filter_graph_run_once(graph);
1432  if (r == AVERROR(EAGAIN) &&
1433  !oldest->frame_wanted_out && !oldest->frame_blocked_in &&
1434  !oldest->status_in)
1435  ff_request_frame(oldest);
1436  else if (r < 0)
1437  return r;
1438  }
1439  return 0;
1440 }
1441 
1443 {
1445  unsigned i;
1446 
1447  av_assert0(graph->nb_filters);
1448  filter = graph->filters[0];
1449  for (i = 1; i < graph->nb_filters; i++)
1450  if (graph->filters[i]->ready > filter->ready)
1451  filter = graph->filters[i];
1452  if (!filter->ready)
1453  return AVERROR(EAGAIN);
1454  return ff_filter_activate(filter);
1455 }
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:2498
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:769
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:105
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:731
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 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:118
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:475
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:684
#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
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:863
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:606
#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:1502
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:2787
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:2414
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:103
int * formats
list of media formats
Definition: formats.h:66