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;
319 
320  switch (link->type) {
321 
322  case AVMEDIA_TYPE_VIDEO:
323  if ((ret = ff_formats_check_pixel_formats(log, cfg->formats)) < 0)
324  return ret;
325  break;
326 
327  case AVMEDIA_TYPE_AUDIO:
328  if ((ret = ff_formats_check_sample_formats(log, cfg->formats)) < 0 ||
329  (ret = ff_formats_check_sample_rates(log, cfg->samplerates)) < 0 ||
330  (ret = ff_formats_check_channel_layouts(log, cfg->channel_layouts)) < 0)
331  return ret;
332  break;
333 
334  default:
335  av_assert0(!"reached");
336  }
337  return 0;
338 }
339 
340 /**
341  * Check the validity of the formats / etc. lists set by query_formats().
342  *
343  * In particular, check they do not contain any redundant element.
344  */
346 {
347  unsigned i;
348  int ret;
349 
350  for (i = 0; i < ctx->nb_inputs; i++) {
351  ret = filter_link_check_formats(ctx, ctx->inputs[i], &ctx->inputs[i]->outcfg);
352  if (ret < 0)
353  return ret;
354  }
355  for (i = 0; i < ctx->nb_outputs; i++) {
356  ret = filter_link_check_formats(ctx, ctx->outputs[i], &ctx->outputs[i]->incfg);
357  if (ret < 0)
358  return ret;
359  }
360  return 0;
361 }
362 
364 {
365  int ret, i;
367  AVFilterChannelLayouts *chlayouts;
368  AVFilterFormats *samplerates;
369  enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
370  ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
372 
373  if ((ret = ctx->filter->query_formats(ctx)) < 0) {
374  if (ret != AVERROR(EAGAIN))
375  av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
376  ctx->name, av_err2str(ret));
377  return ret;
378  }
379  ret = filter_check_formats(ctx);
380  if (ret < 0)
381  return ret;
382 
383  for (i = 0; i < ctx->nb_inputs; i++)
385  for (i = 0; i < ctx->nb_outputs; i++)
387 
388  formats = ff_all_formats(type);
389  if ((ret = ff_set_common_formats(ctx, formats)) < 0)
390  return ret;
391  if (type == AVMEDIA_TYPE_AUDIO) {
392  samplerates = ff_all_samplerates();
393  if ((ret = ff_set_common_samplerates(ctx, samplerates)) < 0)
394  return ret;
395  chlayouts = ff_all_channel_layouts();
396  if ((ret = ff_set_common_channel_layouts(ctx, chlayouts)) < 0)
397  return ret;
398  }
399  return 0;
400 }
401 
403 {
404  int i;
405 
406  for (i = 0; i < f->nb_inputs; i++) {
407  if (!f->inputs[i]->outcfg.formats)
408  return 0;
409  if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&
410  !(f->inputs[i]->outcfg.samplerates &&
411  f->inputs[i]->outcfg.channel_layouts))
412  return 0;
413  }
414  for (i = 0; i < f->nb_outputs; i++) {
415  if (!f->outputs[i]->incfg.formats)
416  return 0;
417  if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&
418  !(f->outputs[i]->incfg.samplerates &&
419  f->outputs[i]->incfg.channel_layouts))
420  return 0;
421  }
422  return 1;
423 }
424 
425 /**
426  * Perform one round of query_formats() and merging formats lists on the
427  * filter graph.
428  * @return >=0 if all links formats lists could be queried and merged;
429  * AVERROR(EAGAIN) some progress was made in the queries or merging
430  * and a later call may succeed;
431  * AVERROR(EIO) (may be changed) plus a log message if no progress
432  * was made and the negotiation is stuck;
433  * a negative error code if some other error happened
434  */
435 static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
436 {
437  int i, j, ret;
438  int scaler_count = 0, resampler_count = 0;
439  int count_queried = 0; /* successful calls to query_formats() */
440  int count_merged = 0; /* successful merge of formats lists */
441  int count_already_merged = 0; /* lists already merged */
442  int count_delayed = 0; /* lists that need to be merged later */
443 
444  for (i = 0; i < graph->nb_filters; i++) {
445  AVFilterContext *f = graph->filters[i];
446  if (formats_declared(f))
447  continue;
448  if (f->filter->query_formats)
449  ret = filter_query_formats(f);
450  else
451  ret = ff_default_query_formats(f);
452  if (ret < 0 && ret != AVERROR(EAGAIN))
453  return ret;
454  /* note: EAGAIN could indicate a partial success, not counted yet */
455  count_queried += ret >= 0;
456  }
457 
458  /* go through and merge as many format lists as possible */
459  for (i = 0; i < graph->nb_filters; i++) {
460  AVFilterContext *filter = graph->filters[i];
461 
462  for (j = 0; j < filter->nb_inputs; j++) {
463  AVFilterLink *link = filter->inputs[j];
464  int convert_needed = 0;
465 
466  if (!link)
467  continue;
468 
469  if (link->incfg.formats != link->outcfg.formats
470  && link->incfg.formats && link->outcfg.formats)
471  if (!ff_can_merge_formats(link->incfg.formats, link->outcfg.formats,
472  link->type))
473  convert_needed = 1;
474  if (link->type == AVMEDIA_TYPE_AUDIO) {
475  if (link->incfg.samplerates != link->outcfg.samplerates
476  && link->incfg.samplerates && link->outcfg.samplerates)
478  link->outcfg.samplerates))
479  convert_needed = 1;
480  }
481 
482 #define CHECKED_MERGE(field, ...) ((ret = ff_merge_ ## field(__VA_ARGS__)) <= 0)
483 #define MERGE_DISPATCH(field, ...) \
484  if (!(link->incfg.field && link->outcfg.field)) { \
485  count_delayed++; \
486  } else if (link->incfg.field == link->outcfg.field) { \
487  count_already_merged++; \
488  } else if (!convert_needed) { \
489  count_merged++; \
490  if (CHECKED_MERGE(field, __VA_ARGS__)) { \
491  if (ret < 0) \
492  return ret; \
493  convert_needed = 1; \
494  } \
495  }
496 
497  if (link->type == AVMEDIA_TYPE_AUDIO) {
499  link->outcfg.channel_layouts)
500  MERGE_DISPATCH(samplerates, link->incfg.samplerates,
501  link->outcfg.samplerates)
502  }
504  link->outcfg.formats, link->type)
505 #undef MERGE_DISPATCH
506 
507  if (convert_needed) {
509  const AVFilter *filter;
510  AVFilterLink *inlink, *outlink;
511  char inst_name[30];
512 
513  if (graph->disable_auto_convert) {
514  av_log(log_ctx, AV_LOG_ERROR,
515  "The filters '%s' and '%s' do not have a common format "
516  "and automatic conversion is disabled.\n",
517  link->src->name, link->dst->name);
518  return AVERROR(EINVAL);
519  }
520 
521  /* couldn't merge format lists. auto-insert conversion filter */
522  switch (link->type) {
523  case AVMEDIA_TYPE_VIDEO:
524  if (!(filter = avfilter_get_by_name("scale"))) {
525  av_log(log_ctx, AV_LOG_ERROR, "'scale' filter "
526  "not present, cannot convert pixel formats.\n");
527  return AVERROR(EINVAL);
528  }
529 
530  snprintf(inst_name, sizeof(inst_name), "auto_scaler_%d",
531  scaler_count++);
532 
533  if ((ret = avfilter_graph_create_filter(&convert, filter,
534  inst_name, graph->scale_sws_opts, NULL,
535  graph)) < 0)
536  return ret;
537  break;
538  case AVMEDIA_TYPE_AUDIO:
539  if (!(filter = avfilter_get_by_name("aresample"))) {
540  av_log(log_ctx, AV_LOG_ERROR, "'aresample' filter "
541  "not present, cannot convert audio formats.\n");
542  return AVERROR(EINVAL);
543  }
544 
545  snprintf(inst_name, sizeof(inst_name), "auto_resampler_%d",
546  resampler_count++);
547  if ((ret = avfilter_graph_create_filter(&convert, filter,
548  inst_name, graph->aresample_swr_opts,
549  NULL, graph)) < 0)
550  return ret;
551  break;
552  default:
553  return AVERROR(EINVAL);
554  }
555 
556  if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
557  return ret;
558 
559  if ((ret = filter_query_formats(convert)) < 0)
560  return ret;
561 
562  inlink = convert->inputs[0];
563  outlink = convert->outputs[0];
564  av_assert0( inlink->incfg.formats->refcount > 0);
565  av_assert0( inlink->outcfg.formats->refcount > 0);
566  av_assert0(outlink->incfg.formats->refcount > 0);
567  av_assert0(outlink->outcfg.formats->refcount > 0);
568  if (outlink->type == AVMEDIA_TYPE_AUDIO) {
569  av_assert0( inlink-> incfg.samplerates->refcount > 0);
570  av_assert0( inlink->outcfg.samplerates->refcount > 0);
571  av_assert0(outlink-> incfg.samplerates->refcount > 0);
572  av_assert0(outlink->outcfg.samplerates->refcount > 0);
573  av_assert0( inlink-> incfg.channel_layouts->refcount > 0);
574  av_assert0( inlink->outcfg.channel_layouts->refcount > 0);
575  av_assert0(outlink-> incfg.channel_layouts->refcount > 0);
576  av_assert0(outlink->outcfg.channel_layouts->refcount > 0);
577  }
578  if (CHECKED_MERGE(formats, inlink->incfg.formats,
579  inlink->outcfg.formats, inlink->type) ||
581  outlink->outcfg.formats, outlink->type) ||
582  inlink->type == AVMEDIA_TYPE_AUDIO &&
583  (CHECKED_MERGE(samplerates, inlink->incfg.samplerates,
584  inlink->outcfg.samplerates) ||
586  inlink->outcfg.channel_layouts)) ||
587  outlink->type == AVMEDIA_TYPE_AUDIO &&
588  (CHECKED_MERGE(samplerates, outlink->incfg.samplerates,
589  outlink->outcfg.samplerates) ||
591  outlink->outcfg.channel_layouts))) {
592  if (ret < 0)
593  return ret;
594  av_log(log_ctx, AV_LOG_ERROR,
595  "Impossible to convert between the formats supported by the filter "
596  "'%s' and the filter '%s'\n", link->src->name, link->dst->name);
597  return AVERROR(ENOSYS);
598  }
599  }
600  }
601  }
602 
603  av_log(graph, AV_LOG_DEBUG, "query_formats: "
604  "%d queried, %d merged, %d already done, %d delayed\n",
605  count_queried, count_merged, count_already_merged, count_delayed);
606  if (count_delayed) {
607  AVBPrint bp;
608 
609  /* if count_queried > 0, one filter at least did set its formats,
610  that will give additional information to its neighbour;
611  if count_merged > 0, one pair of formats lists at least was merged,
612  that will give additional information to all connected filters;
613  in both cases, progress was made and a new round must be done */
614  if (count_queried || count_merged)
615  return AVERROR(EAGAIN);
617  for (i = 0; i < graph->nb_filters; i++)
618  if (!formats_declared(graph->filters[i]))
619  av_bprintf(&bp, "%s%s", bp.len ? ", " : "",
620  graph->filters[i]->name);
621  av_log(graph, AV_LOG_ERROR,
622  "The following filters could not choose their formats: %s\n"
623  "Consider inserting the (a)format filter near their input or "
624  "output.\n", bp.str);
625  return AVERROR(EIO);
626  }
627  return 0;
628 }
629 
630 static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
631 {
632  int score = 0;
633 
634  if (av_sample_fmt_is_planar(dst_fmt) != av_sample_fmt_is_planar(src_fmt))
635  score ++;
636 
637  if (av_get_bytes_per_sample(dst_fmt) < av_get_bytes_per_sample(src_fmt)) {
638  score += 100 * (av_get_bytes_per_sample(src_fmt) - av_get_bytes_per_sample(dst_fmt));
639  }else
640  score += 10 * (av_get_bytes_per_sample(dst_fmt) - av_get_bytes_per_sample(src_fmt));
641 
644  score += 20;
645 
648  score += 2;
649 
650  return score;
651 }
652 
654  enum AVSampleFormat src_fmt)
655 {
656  int score1, score2;
657 
658  score1 = get_fmt_score(dst_fmt1, src_fmt);
659  score2 = get_fmt_score(dst_fmt2, src_fmt);
660 
661  return score1 < score2 ? dst_fmt1 : dst_fmt2;
662 }
663 
665 {
666  if (!link || !link->incfg.formats)
667  return 0;
668 
669  if (link->type == AVMEDIA_TYPE_VIDEO) {
670  if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
671  //FIXME: This should check for AV_PIX_FMT_FLAG_ALPHA after PAL8 pixel format without alpha is implemented
672  int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
673  enum AVPixelFormat best= AV_PIX_FMT_NONE;
674  int i;
675  for (i = 0; i < link->incfg.formats->nb_formats; i++) {
676  enum AVPixelFormat p = link->incfg.formats->formats[i];
677  best= av_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL);
678  }
679  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",
681  av_get_pix_fmt_name(ref->format), has_alpha);
682  link->incfg.formats->formats[0] = best;
683  }
684  } else if (link->type == AVMEDIA_TYPE_AUDIO) {
685  if(ref && ref->type == AVMEDIA_TYPE_AUDIO){
687  int i;
688  for (i = 0; i < link->incfg.formats->nb_formats; i++) {
689  enum AVSampleFormat p = link->incfg.formats->formats[i];
690  best = find_best_sample_fmt_of_2(best, p, ref->format);
691  }
692  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s\n",
695  link->incfg.formats->formats[0] = best;
696  }
697  }
698 
699  link->incfg.formats->nb_formats = 1;
700  link->format = link->incfg.formats->formats[0];
701 
702  if (link->type == AVMEDIA_TYPE_AUDIO) {
703  if (!link->incfg.samplerates->nb_formats) {
704  av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
705  " the link between filters %s and %s.\n", link->src->name,
706  link->dst->name);
707  return AVERROR(EINVAL);
708  }
709  link->incfg.samplerates->nb_formats = 1;
710  link->sample_rate = link->incfg.samplerates->formats[0];
711 
712  if (link->incfg.channel_layouts->all_layouts) {
713  av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
714  " the link between filters %s and %s.\n", link->src->name,
715  link->dst->name);
716  if (!link->incfg.channel_layouts->all_counts)
717  av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not "
718  "supported, try specifying a channel layout using "
719  "'aformat=channel_layouts=something'.\n");
720  return AVERROR(EINVAL);
721  }
724  if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout)))
725  link->channel_layout = 0;
726  else
728  }
729 
736 
737  return 0;
738 }
739 
740 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
741 do { \
742  for (i = 0; i < filter->nb_inputs; i++) { \
743  AVFilterLink *link = filter->inputs[i]; \
744  fmt_type fmt; \
745  \
746  if (!link->outcfg.list || link->outcfg.list->nb != 1) \
747  continue; \
748  fmt = link->outcfg.list->var[0]; \
749  \
750  for (j = 0; j < filter->nb_outputs; j++) { \
751  AVFilterLink *out_link = filter->outputs[j]; \
752  list_type *fmts; \
753  \
754  if (link->type != out_link->type || \
755  out_link->incfg.list->nb == 1) \
756  continue; \
757  fmts = out_link->incfg.list; \
758  \
759  if (!out_link->incfg.list->nb) { \
760  if ((ret = add_format(&out_link->incfg.list, fmt)) < 0)\
761  return ret; \
762  ret = 1; \
763  break; \
764  } \
765  \
766  for (k = 0; k < out_link->incfg.list->nb; k++) \
767  if (fmts->var[k] == fmt) { \
768  fmts->var[0] = fmt; \
769  fmts->nb = 1; \
770  ret = 1; \
771  break; \
772  } \
773  } \
774  } \
775 } while (0)
776 
778 {
779  int i, j, k, ret = 0;
780 
782  nb_formats, ff_add_format);
783  REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats,
784  nb_formats, ff_add_format);
785 
786  /* reduce channel layouts */
787  for (i = 0; i < filter->nb_inputs; i++) {
788  AVFilterLink *inlink = filter->inputs[i];
789  uint64_t fmt;
790 
791  if (!inlink->outcfg.channel_layouts ||
793  continue;
794  fmt = inlink->outcfg.channel_layouts->channel_layouts[0];
795 
796  for (j = 0; j < filter->nb_outputs; j++) {
797  AVFilterLink *outlink = filter->outputs[j];
799 
800  fmts = outlink->incfg.channel_layouts;
801  if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
802  continue;
803 
804  if (fmts->all_layouts &&
805  (!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) {
806  /* Turn the infinite list into a singleton */
807  fmts->all_layouts = fmts->all_counts = 0;
808  if (ff_add_channel_layout(&outlink->incfg.channel_layouts, fmt) < 0)
809  ret = 1;
810  break;
811  }
812 
813  for (k = 0; k < outlink->incfg.channel_layouts->nb_channel_layouts; k++) {
814  if (fmts->channel_layouts[k] == fmt) {
815  fmts->channel_layouts[0] = fmt;
816  fmts->nb_channel_layouts = 1;
817  ret = 1;
818  break;
819  }
820  }
821  }
822  }
823 
824  return ret;
825 }
826 
827 static int reduce_formats(AVFilterGraph *graph)
828 {
829  int i, reduced, ret;
830 
831  do {
832  reduced = 0;
833 
834  for (i = 0; i < graph->nb_filters; i++) {
835  if ((ret = reduce_formats_on_filter(graph->filters[i])) < 0)
836  return ret;
837  reduced |= ret;
838  }
839  } while (reduced);
840 
841  return 0;
842 }
843 
845 {
847  int sample_rate;
848  int i, j;
849 
850  for (i = 0; i < filter->nb_inputs; i++) {
851  link = filter->inputs[i];
852 
853  if (link->type == AVMEDIA_TYPE_AUDIO &&
854  link->outcfg.samplerates->nb_formats== 1)
855  break;
856  }
857  if (i == filter->nb_inputs)
858  return;
859 
860  sample_rate = link->outcfg.samplerates->formats[0];
861 
862  for (i = 0; i < filter->nb_outputs; i++) {
863  AVFilterLink *outlink = filter->outputs[i];
864  int best_idx, best_diff = INT_MAX;
865 
866  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
867  outlink->incfg.samplerates->nb_formats < 2)
868  continue;
869 
870  for (j = 0; j < outlink->incfg.samplerates->nb_formats; j++) {
871  int diff = abs(sample_rate - outlink->incfg.samplerates->formats[j]);
872 
873  av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
874 
875  if (diff < best_diff) {
876  best_diff = diff;
877  best_idx = j;
878  }
879  }
880  FFSWAP(int, outlink->incfg.samplerates->formats[0],
881  outlink->incfg.samplerates->formats[best_idx]);
882  }
883 }
884 
885 static void swap_samplerates(AVFilterGraph *graph)
886 {
887  int i;
888 
889  for (i = 0; i < graph->nb_filters; i++)
891 }
892 
893 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
894 #define CH_FRONT_PAIR (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)
895 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)
896 #define CH_WIDE_PAIR (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)
897 #define CH_SIDE_PAIR (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
898 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
899 #define CH_BACK_PAIR (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
900 
901 /* allowable substitutions for channel pairs when comparing layouts,
902  * ordered by priority for both values */
903 static const uint64_t ch_subst[][2] = {
908  { CH_CENTER_PAIR, CH_WIDE_PAIR },
909  { CH_CENTER_PAIR, AV_CH_FRONT_CENTER },
910  { CH_WIDE_PAIR, CH_FRONT_PAIR },
911  { CH_WIDE_PAIR, CH_CENTER_PAIR },
912  { CH_WIDE_PAIR, AV_CH_FRONT_CENTER },
913  { AV_CH_FRONT_CENTER, CH_FRONT_PAIR },
914  { AV_CH_FRONT_CENTER, CH_CENTER_PAIR },
915  { AV_CH_FRONT_CENTER, CH_WIDE_PAIR },
919  { CH_BACK_PAIR, CH_DIRECT_PAIR },
921  { CH_BACK_PAIR, AV_CH_BACK_CENTER },
922  { AV_CH_BACK_CENTER, CH_BACK_PAIR },
923  { AV_CH_BACK_CENTER, CH_DIRECT_PAIR },
924  { AV_CH_BACK_CENTER, CH_SIDE_PAIR },
925 };
926 
928 {
930  int i, j, k;
931 
932  for (i = 0; i < filter->nb_inputs; i++) {
933  link = filter->inputs[i];
934 
935  if (link->type == AVMEDIA_TYPE_AUDIO &&
937  break;
938  }
939  if (i == filter->nb_inputs)
940  return;
941 
942  for (i = 0; i < filter->nb_outputs; i++) {
943  AVFilterLink *outlink = filter->outputs[i];
944  int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
945 
946  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
948  continue;
949 
950  for (j = 0; j < outlink->incfg.channel_layouts->nb_channel_layouts; j++) {
951  uint64_t in_chlayout = link->outcfg.channel_layouts->channel_layouts[0];
952  uint64_t out_chlayout = outlink->incfg.channel_layouts->channel_layouts[j];
953  int in_channels = av_get_channel_layout_nb_channels(in_chlayout);
954  int out_channels = av_get_channel_layout_nb_channels(out_chlayout);
955  int count_diff = out_channels - in_channels;
956  int matched_channels, extra_channels;
957  int score = 100000;
958 
959  if (FF_LAYOUT2COUNT(in_chlayout) || FF_LAYOUT2COUNT(out_chlayout)) {
960  /* Compute score in case the input or output layout encodes
961  a channel count; in this case the score is not altered by
962  the computation afterwards, as in_chlayout and
963  out_chlayout have both been set to 0 */
964  if (FF_LAYOUT2COUNT(in_chlayout))
965  in_channels = FF_LAYOUT2COUNT(in_chlayout);
966  if (FF_LAYOUT2COUNT(out_chlayout))
967  out_channels = FF_LAYOUT2COUNT(out_chlayout);
968  score -= 10000 + FFABS(out_channels - in_channels) +
969  (in_channels > out_channels ? 10000 : 0);
970  in_chlayout = out_chlayout = 0;
971  /* Let the remaining computation run, even if the score
972  value is not altered */
973  }
974 
975  /* channel substitution */
976  for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {
977  uint64_t cmp0 = ch_subst[k][0];
978  uint64_t cmp1 = ch_subst[k][1];
979  if (( in_chlayout & cmp0) && (!(out_chlayout & cmp0)) &&
980  (out_chlayout & cmp1) && (!( in_chlayout & cmp1))) {
981  in_chlayout &= ~cmp0;
982  out_chlayout &= ~cmp1;
983  /* add score for channel match, minus a deduction for
984  having to do the substitution */
985  score += 10 * av_get_channel_layout_nb_channels(cmp1) - 2;
986  }
987  }
988 
989  /* no penalty for LFE channel mismatch */
990  if ( (in_chlayout & AV_CH_LOW_FREQUENCY) &&
991  (out_chlayout & AV_CH_LOW_FREQUENCY))
992  score += 10;
993  in_chlayout &= ~AV_CH_LOW_FREQUENCY;
994  out_chlayout &= ~AV_CH_LOW_FREQUENCY;
995 
996  matched_channels = av_get_channel_layout_nb_channels(in_chlayout &
997  out_chlayout);
998  extra_channels = av_get_channel_layout_nb_channels(out_chlayout &
999  (~in_chlayout));
1000  score += 10 * matched_channels - 5 * extra_channels;
1001 
1002  if (score > best_score ||
1003  (count_diff < best_count_diff && score == best_score)) {
1004  best_score = score;
1005  best_idx = j;
1006  best_count_diff = count_diff;
1007  }
1008  }
1009  av_assert0(best_idx >= 0);
1010  FFSWAP(uint64_t, outlink->incfg.channel_layouts->channel_layouts[0],
1011  outlink->incfg.channel_layouts->channel_layouts[best_idx]);
1012  }
1013 
1014 }
1015 
1017 {
1018  int i;
1019 
1020  for (i = 0; i < graph->nb_filters; i++)
1022 }
1023 
1025 {
1026  AVFilterLink *link = NULL;
1027  int format, bps;
1028  int i, j;
1029 
1030  for (i = 0; i < filter->nb_inputs; i++) {
1031  link = filter->inputs[i];
1032 
1033  if (link->type == AVMEDIA_TYPE_AUDIO &&
1034  link->outcfg.formats->nb_formats == 1)
1035  break;
1036  }
1037  if (i == filter->nb_inputs)
1038  return;
1039 
1040  format = link->outcfg.formats->formats[0];
1041  bps = av_get_bytes_per_sample(format);
1042 
1043  for (i = 0; i < filter->nb_outputs; i++) {
1044  AVFilterLink *outlink = filter->outputs[i];
1045  int best_idx = -1, best_score = INT_MIN;
1046 
1047  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
1048  outlink->incfg.formats->nb_formats < 2)
1049  continue;
1050 
1051  for (j = 0; j < outlink->incfg.formats->nb_formats; j++) {
1052  int out_format = outlink->incfg.formats->formats[j];
1053  int out_bps = av_get_bytes_per_sample(out_format);
1054  int score;
1055 
1056  if (av_get_packed_sample_fmt(out_format) == format ||
1057  av_get_planar_sample_fmt(out_format) == format) {
1058  best_idx = j;
1059  break;
1060  }
1061 
1062  /* for s32 and float prefer double to prevent loss of information */
1063  if (bps == 4 && out_bps == 8) {
1064  best_idx = j;
1065  break;
1066  }
1067 
1068  /* prefer closest higher or equal bps */
1069  score = -abs(out_bps - bps);
1070  if (out_bps >= bps)
1071  score += INT_MAX/2;
1072 
1073  if (score > best_score) {
1074  best_score = score;
1075  best_idx = j;
1076  }
1077  }
1078  av_assert0(best_idx >= 0);
1079  FFSWAP(int, outlink->incfg.formats->formats[0],
1080  outlink->incfg.formats->formats[best_idx]);
1081  }
1082 }
1083 
1084 static void swap_sample_fmts(AVFilterGraph *graph)
1085 {
1086  int i;
1087 
1088  for (i = 0; i < graph->nb_filters; i++)
1090 
1091 }
1092 
1093 static int pick_formats(AVFilterGraph *graph)
1094 {
1095  int i, j, ret;
1096  int change;
1097 
1098  do{
1099  change = 0;
1100  for (i = 0; i < graph->nb_filters; i++) {
1101  AVFilterContext *filter = graph->filters[i];
1102  if (filter->nb_inputs){
1103  for (j = 0; j < filter->nb_inputs; j++){
1104  if (filter->inputs[j]->incfg.formats && filter->inputs[j]->incfg.formats->nb_formats == 1) {
1105  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1106  return ret;
1107  change = 1;
1108  }
1109  }
1110  }
1111  if (filter->nb_outputs){
1112  for (j = 0; j < filter->nb_outputs; j++){
1113  if (filter->outputs[j]->incfg.formats && filter->outputs[j]->incfg.formats->nb_formats == 1) {
1114  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1115  return ret;
1116  change = 1;
1117  }
1118  }
1119  }
1120  if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
1121  for (j = 0; j < filter->nb_outputs; j++) {
1122  if (filter->outputs[j]->format<0) {
1123  if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
1124  return ret;
1125  change = 1;
1126  }
1127  }
1128  }
1129  }
1130  }while(change);
1131 
1132  for (i = 0; i < graph->nb_filters; i++) {
1133  AVFilterContext *filter = graph->filters[i];
1134 
1135  for (j = 0; j < filter->nb_inputs; j++)
1136  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1137  return ret;
1138  for (j = 0; j < filter->nb_outputs; j++)
1139  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1140  return ret;
1141  }
1142  return 0;
1143 }
1144 
1145 /**
1146  * Configure the formats of all the links in the graph.
1147  */
1148 static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
1149 {
1150  int ret;
1151 
1152  /* find supported formats from sub-filters, and merge along links */
1153  while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN))
1154  av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n");
1155  if (ret < 0)
1156  return ret;
1157 
1158  /* Once everything is merged, it's possible that we'll still have
1159  * multiple valid media format choices. We try to minimize the amount
1160  * of format conversion inside filters */
1161  if ((ret = reduce_formats(graph)) < 0)
1162  return ret;
1163 
1164  /* for audio filters, ensure the best format, sample rate and channel layout
1165  * is selected */
1166  swap_sample_fmts(graph);
1167  swap_samplerates(graph);
1168  swap_channel_layouts(graph);
1169 
1170  if ((ret = pick_formats(graph)) < 0)
1171  return ret;
1172 
1173  return 0;
1174 }
1175 
1177  AVClass *log_ctx)
1178 {
1179  unsigned i, j;
1180  int sink_links_count = 0, n = 0;
1181  AVFilterContext *f;
1182  AVFilterLink **sinks;
1183 
1184  for (i = 0; i < graph->nb_filters; i++) {
1185  f = graph->filters[i];
1186  for (j = 0; j < f->nb_inputs; j++) {
1187  f->inputs[j]->graph = graph;
1188  f->inputs[j]->age_index = -1;
1189  }
1190  for (j = 0; j < f->nb_outputs; j++) {
1191  f->outputs[j]->graph = graph;
1192  f->outputs[j]->age_index= -1;
1193  }
1194  if (!f->nb_outputs) {
1195  if (f->nb_inputs > INT_MAX - sink_links_count)
1196  return AVERROR(EINVAL);
1197  sink_links_count += f->nb_inputs;
1198  }
1199  }
1200  sinks = av_calloc(sink_links_count, sizeof(*sinks));
1201  if (!sinks)
1202  return AVERROR(ENOMEM);
1203  for (i = 0; i < graph->nb_filters; i++) {
1204  f = graph->filters[i];
1205  if (!f->nb_outputs) {
1206  for (j = 0; j < f->nb_inputs; j++) {
1207  sinks[n] = f->inputs[j];
1208  f->inputs[j]->age_index = n++;
1209  }
1210  }
1211  }
1212  av_assert0(n == sink_links_count);
1213  graph->sink_links = sinks;
1214  graph->sink_links_count = sink_links_count;
1215  return 0;
1216 }
1217 
1218 int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
1219 {
1220  int ret;
1221 
1222  if ((ret = graph_check_validity(graphctx, log_ctx)))
1223  return ret;
1224  if ((ret = graph_config_formats(graphctx, log_ctx)))
1225  return ret;
1226  if ((ret = graph_config_links(graphctx, log_ctx)))
1227  return ret;
1228  if ((ret = graph_check_links(graphctx, log_ctx)))
1229  return ret;
1230  if ((ret = graph_config_pointers(graphctx, log_ctx)))
1231  return ret;
1232 
1233  return 0;
1234 }
1235 
1236 int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
1237 {
1238  int i, r = AVERROR(ENOSYS);
1239 
1240  if (!graph)
1241  return r;
1242 
1243  if ((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) {
1244  r = avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);
1245  if (r != AVERROR(ENOSYS))
1246  return r;
1247  }
1248 
1249  if (res_len && res)
1250  res[0] = 0;
1251 
1252  for (i = 0; i < graph->nb_filters; i++) {
1253  AVFilterContext *filter = graph->filters[i];
1254  if (!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)) {
1255  r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);
1256  if (r != AVERROR(ENOSYS)) {
1257  if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0)
1258  return r;
1259  }
1260  }
1261  }
1262 
1263  return r;
1264 }
1265 
1266 int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
1267 {
1268  int i;
1269 
1270  if(!graph)
1271  return 0;
1272 
1273  for (i = 0; i < graph->nb_filters; i++) {
1274  AVFilterContext *filter = graph->filters[i];
1275  if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){
1276  AVFilterCommand **queue = &filter->command_queue, *next;
1277  while (*queue && (*queue)->time <= ts)
1278  queue = &(*queue)->next;
1279  next = *queue;
1280  *queue = av_mallocz(sizeof(AVFilterCommand));
1281  if (!*queue)
1282  return AVERROR(ENOMEM);
1283 
1284  (*queue)->command = av_strdup(command);
1285  (*queue)->arg = av_strdup(arg);
1286  (*queue)->time = ts;
1287  (*queue)->flags = flags;
1288  (*queue)->next = next;
1289  if(flags & AVFILTER_CMD_FLAG_ONE)
1290  return 0;
1291  }
1292  }
1293 
1294  return 0;
1295 }
1296 
1297 static void heap_bubble_up(AVFilterGraph *graph,
1298  AVFilterLink *link, int index)
1299 {
1300  AVFilterLink **links = graph->sink_links;
1301 
1302  av_assert0(index >= 0);
1303 
1304  while (index) {
1305  int parent = (index - 1) >> 1;
1306  if (links[parent]->current_pts_us >= link->current_pts_us)
1307  break;
1308  links[index] = links[parent];
1309  links[index]->age_index = index;
1310  index = parent;
1311  }
1312  links[index] = link;
1313  link->age_index = index;
1314 }
1315 
1316 static void heap_bubble_down(AVFilterGraph *graph,
1317  AVFilterLink *link, int index)
1318 {
1319  AVFilterLink **links = graph->sink_links;
1320 
1321  av_assert0(index >= 0);
1322 
1323  while (1) {
1324  int child = 2 * index + 1;
1325  if (child >= graph->sink_links_count)
1326  break;
1327  if (child + 1 < graph->sink_links_count &&
1328  links[child + 1]->current_pts_us < links[child]->current_pts_us)
1329  child++;
1330  if (link->current_pts_us < links[child]->current_pts_us)
1331  break;
1332  links[index] = links[child];
1333  links[index]->age_index = index;
1334  index = child;
1335  }
1336  links[index] = link;
1337  link->age_index = index;
1338 }
1339 
1341 {
1342  heap_bubble_up (graph, link, link->age_index);
1343  heap_bubble_down(graph, link, link->age_index);
1344 }
1345 
1347 {
1348  AVFilterLink *oldest = graph->sink_links[0];
1349  int64_t frame_count;
1350  int r;
1351 
1352  while (graph->sink_links_count) {
1353  oldest = graph->sink_links[0];
1354  if (oldest->dst->filter->activate) {
1355  /* For now, buffersink is the only filter implementing activate. */
1356  r = av_buffersink_get_frame_flags(oldest->dst, NULL,
1358  if (r != AVERROR_EOF)
1359  return r;
1360  } else {
1361  r = ff_request_frame(oldest);
1362  }
1363  if (r != AVERROR_EOF)
1364  break;
1365  av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
1366  oldest->dst ? oldest->dst->name : "unknown",
1367  oldest->dstpad ? oldest->dstpad->name : "unknown");
1368  /* EOF: remove the link from the heap */
1369  if (oldest->age_index < --graph->sink_links_count)
1370  heap_bubble_down(graph, graph->sink_links[graph->sink_links_count],
1371  oldest->age_index);
1372  oldest->age_index = -1;
1373  }
1374  if (!graph->sink_links_count)
1375  return AVERROR_EOF;
1376  av_assert1(!oldest->dst->filter->activate);
1377  av_assert1(oldest->age_index >= 0);
1378  frame_count = oldest->frame_count_out;
1379  while (frame_count == oldest->frame_count_out) {
1380  r = ff_filter_graph_run_once(graph);
1381  if (r == AVERROR(EAGAIN) &&
1382  !oldest->frame_wanted_out && !oldest->frame_blocked_in &&
1383  !oldest->status_in)
1384  ff_request_frame(oldest);
1385  else if (r < 0)
1386  return r;
1387  }
1388  return 0;
1389 }
1390 
1392 {
1394  unsigned i;
1395 
1396  av_assert0(graph->nb_filters);
1397  filter = graph->filters[0];
1398  for (i = 1; i < graph->nb_filters; i++)
1399  if (graph->filters[i]->ready > filter->ready)
1400  filter = graph->filters[i];
1401  if (!filter->ready)
1402  return AVERROR(EAGAIN);
1403  return ff_filter_activate(filter);
1404 }
AVFilterContext ** filters
Definition: avfilter.h:857
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
Lists of formats / etc.
Definition: avfilter.h:440
#define NULL
Definition: coverity.c:32
int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid pixel formats list.
Definition: formats.c:687
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
int sink_links_count
Definition: avfilter.h:922
AVFilterContext * ff_filter_alloc(const AVFilter *filter, const char *inst_name)
Allocate a new filter context and return it.
Definition: avfilter.c:661
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
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:877
static void swap_samplerates(AVFilterGraph *graph)
AVOption.
Definition: opt.h:248
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
static void swap_sample_fmts(AVFilterGraph *graph)
void avfilter_free(AVFilterContext *filter)
Free a filter context.
Definition: avfilter.c:758
static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
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:200
#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:1029
static int reduce_formats(AVFilterGraph *graph)
static int filter_check_formats(AVFilterContext *ctx)
Check the validity of the formats / etc.
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
Definition: opt.c:1357
static const uint64_t ch_subst[][2]
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
GLint GLenum type
Definition: opengl_enc.c:104
enum AVMediaType type
AVFilterPad type.
Definition: internal.h:65
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *channel_layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:569
static int reduce_formats_on_filter(AVFilterContext *filter)
int(* activate)(AVFilterContext *ctx)
Filter activation function.
Definition: avfilter.h:330
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
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
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
Definition: avfilter.h:860
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Definition: avfilter.h:336
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:358
#define OFFSET(x)
Definition: avfiltergraph.c:45
memory buffer sink API for audio and video
const char * name
Pad name.
Definition: internal.h:60
#define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format)
static int pick_format(AVFilterLink *link, AVFilterLink *ref)
int ff_can_merge_samplerates(const AVFilterFormats *a, const AVFilterFormats *b)
Definition: formats.c:158
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:349
char * name
name of this filter instance
Definition: avfilter.h:346
#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:910
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:352
unsigned ready
Ready status of the filter.
Definition: avfilter.h:411
AVOptions.
#define FF_LAYOUT2COUNT(l)
Decode a channel count encoded as a channel layout.
Definition: formats.h:109
int ff_can_merge_formats(const AVFilterFormats *a, const AVFilterFormats *b, enum AVMediaType type)
Check the formats/samplerates lists for compatibility for merging without actually merging...
Definition: formats.c:135
#define f(width, name)
Definition: cbs_vp9.c:255
#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:884
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:346
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:69
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:348
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:588
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:339
int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid sample formats list.
Definition: formats.c:692
const AVClass * av_class
Definition: avfilter.h:856
unsigned nb_outputs
number of output pads
Definition: avfilter.h:354
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:215
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:445
uint64_t * channel_layouts
list of channel layouts
Definition: formats.h:87
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:333
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)
AVFilterLink ** sink_links
Private fields.
Definition: avfilter.h:921
int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
Get a frame with filtered data from sink and put it in frame.
Definition: buffersink.c:140
#define CH_DIRECT_PAIR
#define fail()
Definition: checkasm.h:123
char all_counts
accept any channel layout or count
Definition: formats.h:90
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:525
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
audio channel layout utility functions
static void sanitize_channel_layouts(void *log, AVFilterChannelLayouts *l)
unsigned nb_inputs
number of input pads
Definition: avfilter.h:350
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:455
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:66
#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:706
#define AV_CH_FRONT_CENTER
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:450
static enum AVSampleFormat find_best_sample_fmt_of_2(enum AVSampleFormat dst_fmt1, enum AVSampleFormat dst_fmt2, enum AVSampleFormat src_fmt)
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (...
Definition: formats.c:428
#define FF_ARRAY_ELEMS(a)
A list of supported channel layouts.
Definition: formats.h:86
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:935
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:594
sample_rate
#define AV_BPRINT_SIZE_AUTOMATIC
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
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:889
char all_layouts
accept any known channel layout
Definition: formats.h:89
#define abs(x)
Definition: cuda_runtime.h:35
#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:871
int ff_formats_check_channel_layouts(void *log, const AVFilterChannelLayouts *fmts)
Check that fmts is a valid channel layouts list.
Definition: formats.c:711
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:509
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:539
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:145
int index
Definition: gxfenc.c:89
int(* query_formats)(AVFilterContext *)
Query formats supported by the filter on its inputs and outputs.
Definition: avfilter.h:283
#define AVFILTER_CMD_FLAG_FAST
Only execute command when its fast (like a video out that supports contrast adjustment in hw) ...
Definition: avfilter.h:707
#define CH_BACK_PAIR
static int filter_link_check_formats(void *log, AVFilterLink *link, AVFilterFormatsConfig *cfg)
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:504
const char * name
Filter name.
Definition: avfilter.h:149
unsigned nb_filters
Definition: avfilter.h:858
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
int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid sample rates list.
Definition: formats.c:697
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:353
static void swap_channel_layouts_on_filter(AVFilterContext *filter)
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:422
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:560
#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)
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:88
#define CH_FRONT_PAIR
struct AVFilterCommand * command_queue
Definition: avfilter.h:383
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:288
unsigned bps
Definition: movenc.c:1598
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:2862
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:912
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:89
static av_always_inline int diff(const uint32_t a, const uint32_t b)
avfilter_execute_func * thread_execute
Definition: internal.h:131
#define MERGE_DISPATCH(field,...)
#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:92
A list of supported formats for one end of a filter link.
Definition: formats.h:65
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:341
#define av_freep(p)
#define CH_SIDE_PAIR
FFFrameQueueGlobal frame_queues
Definition: internal.h:132
double time
time expressed in seconds
Definition: internal.h:39
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:2489
static int filter_query_formats(AVFilterContext *ctx)
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:1429
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#define CH_WIDE_PAIR
#define CHECKED_MERGE(field,...)
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:344
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:576
int i
Definition: input.c:407
unsigned disable_auto_convert
Definition: avfilter.h:924
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:67