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