FFmpeg
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 "filters.h"
40 #include "formats.h"
41 #include "framequeue.h"
42 #include "video.h"
43 
44 #define OFFSET(x) offsetof(AVFilterGraph, x)
45 #define F AV_OPT_FLAG_FILTERING_PARAM
46 #define V AV_OPT_FLAG_VIDEO_PARAM
47 #define A AV_OPT_FLAG_AUDIO_PARAM
48 static const AVOption filtergraph_options[] = {
49  { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
50  { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, F|V|A, .unit = "thread_type" },
51  { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = F|V|A, .unit = "thread_type" },
52  { "threads", "Maximum number of threads", OFFSET(nb_threads), AV_OPT_TYPE_INT,
53  { .i64 = 0 }, 0, INT_MAX, F|V|A, .unit = "threads"},
54  {"auto", "autodetect a suitable number of threads to use", 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, .flags = F|V|A, .unit = "threads"},
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  {"max_buffered_frames" , "maximum number of buffered frames allowed", OFFSET(max_buffered_frames),
60  AV_OPT_TYPE_UINT, {.i64 = 0}, 0, UINT_MAX, F|V|A },
61  { NULL },
62 };
63 
64 static const AVClass filtergraph_class = {
65  .class_name = "AVFilterGraph",
66  .item_name = av_default_item_name,
67  .version = LIBAVUTIL_VERSION_INT,
68  .option = filtergraph_options,
69  .category = AV_CLASS_CATEGORY_FILTER,
70 };
71 
72 #if !HAVE_THREADS
74 {
75 }
76 
78 {
79  graph->p.thread_type = 0;
80  graph->p.nb_threads = 1;
81  return 0;
82 }
83 #endif
84 
86 {
87  FFFilterGraph *graph = av_mallocz(sizeof(*graph));
89 
90  if (!graph)
91  return NULL;
92 
93  ret = &graph->p;
94  ret->av_class = &filtergraph_class;
97 
98  return ret;
99 }
100 
102 {
103  int i, j;
104  for (i = 0; i < graph->nb_filters; i++) {
105  if (graph->filters[i] == filter) {
106  FFSWAP(AVFilterContext*, graph->filters[i],
107  graph->filters[graph->nb_filters - 1]);
108  graph->nb_filters--;
109  filter->graph = NULL;
110  for (j = 0; j<filter->nb_outputs; j++)
111  if (filter->outputs[j])
112  ff_filter_link(filter->outputs[j])->graph = NULL;
113 
114  return;
115  }
116  }
117 }
118 
120 {
121  AVFilterGraph *graph = *graphp;
122  FFFilterGraph *graphi = fffiltergraph(graph);
123 
124  if (!graph)
125  return;
126 
127  while (graph->nb_filters)
128  avfilter_free(graph->filters[0]);
129 
130  ff_graph_thread_free(graphi);
131 
132  av_freep(&graphi->sink_links);
133 
134  av_opt_free(graph);
135 
136  av_freep(&graph->filters);
137  av_freep(graphp);
138 }
139 
141  const char *name, const char *args, void *opaque,
142  AVFilterGraph *graph_ctx)
143 {
144  int ret;
145 
146  *filt_ctx = avfilter_graph_alloc_filter(graph_ctx, filt, name);
147  if (!*filt_ctx)
148  return AVERROR(ENOMEM);
149 
150  ret = avfilter_init_str(*filt_ctx, args);
151  if (ret < 0)
152  goto fail;
153 
154  return 0;
155 
156 fail:
157  avfilter_free(*filt_ctx);
158  *filt_ctx = NULL;
159  return ret;
160 }
161 
163 {
165 }
166 
168  const AVFilter *filter,
169  const char *name)
170 {
172  FFFilterGraph *graphi = fffiltergraph(graph);
173 
174  if (graph->thread_type && !graphi->thread_execute) {
175  if (graph->execute) {
176  graphi->thread_execute = graph->execute;
177  } else {
178  int ret = ff_graph_thread_init(graphi);
179  if (ret < 0) {
180  av_log(graph, AV_LOG_ERROR, "Error initializing threading: %s.\n", av_err2str(ret));
181  return NULL;
182  }
183  }
184  }
185 
186  filters = av_realloc_array(graph->filters, graph->nb_filters + 1, sizeof(*filters));
187  if (!filters)
188  return NULL;
189  graph->filters = filters;
190 
192  if (!s)
193  return NULL;
194 
195  graph->filters[graph->nb_filters++] = s;
196 
197  s->graph = graph;
198 
199  return s;
200 }
201 
202 /**
203  * Check for the validity of graph.
204  *
205  * A graph is considered valid if all its input and output pads are
206  * connected.
207  *
208  * @return >= 0 in case of success, a negative value otherwise
209  */
210 static int graph_check_validity(AVFilterGraph *graph, void *log_ctx)
211 {
213  int i, j;
214 
215  for (i = 0; i < graph->nb_filters; i++) {
216  const AVFilterPad *pad;
217  filt = graph->filters[i];
218 
219  for (j = 0; j < filt->nb_inputs; j++) {
220  if (!filt->inputs[j] || !filt->inputs[j]->src) {
221  pad = &filt->input_pads[j];
222  av_log(log_ctx, AV_LOG_ERROR,
223  "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",
224  pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
225  return AVERROR(EINVAL);
226  }
227  }
228 
229  for (j = 0; j < filt->nb_outputs; j++) {
230  if (!filt->outputs[j] || !filt->outputs[j]->dst) {
231  pad = &filt->output_pads[j];
232  av_log(log_ctx, AV_LOG_ERROR,
233  "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",
234  pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
235  return AVERROR(EINVAL);
236  }
237  }
238  }
239 
240  return 0;
241 }
242 
243 /**
244  * Configure all the links of graphctx.
245  *
246  * @return >= 0 in case of success, a negative value otherwise
247  */
248 static int graph_config_links(AVFilterGraph *graph, void *log_ctx)
249 {
251  int i, ret;
252 
253  for (i = 0; i < graph->nb_filters; i++) {
254  filt = graph->filters[i];
255 
256  if (!filt->nb_outputs) {
258  return ret;
259  }
260  }
261 
262  return 0;
263 }
264 
265 static int graph_check_links(AVFilterGraph *graph, void *log_ctx)
266 {
268  AVFilterLink *l;
269  unsigned i, j;
270  int ret;
271 
272  for (i = 0; i < graph->nb_filters; i++) {
273  f = graph->filters[i];
274  for (j = 0; j < f->nb_outputs; j++) {
275  l = f->outputs[j];
276  if (l->type == AVMEDIA_TYPE_VIDEO) {
277  ret = av_image_check_size2(l->w, l->h, INT64_MAX, l->format, 0, f);
278  if (ret < 0)
279  return ret;
280  }
281  }
282  }
283  return 0;
284 }
285 
287 {
288  int i;
289 
290  for (i = 0; i < graph->nb_filters; i++)
291  if (graph->filters[i]->name && !strcmp(name, graph->filters[i]->name))
292  return graph->filters[i];
293 
294  return NULL;
295 }
296 
298 {
299  int ret;
300 
301  switch (link->type) {
302 
303  case AVMEDIA_TYPE_VIDEO:
304  if ((ret = ff_formats_check_pixel_formats(log, cfg->formats)) < 0 ||
307  return ret;
308  break;
309 
310  case AVMEDIA_TYPE_AUDIO:
311  if ((ret = ff_formats_check_sample_formats(log, cfg->formats)) < 0 ||
314  return ret;
315  break;
316 
317  default:
318  av_assert0(!"reached");
319  }
320  return 0;
321 }
322 
323 /**
324  * Check the validity of the formats / etc. lists set by query_formats().
325  *
326  * In particular, check they do not contain any redundant element.
327  */
329 {
330  unsigned i;
331  int ret;
332 
333  for (i = 0; i < ctx->nb_inputs; i++) {
334  ret = filter_link_check_formats(ctx, ctx->inputs[i], &ctx->inputs[i]->outcfg);
335  if (ret < 0)
336  return ret;
337  }
338  for (i = 0; i < ctx->nb_outputs; i++) {
339  ret = filter_link_check_formats(ctx, ctx->outputs[i], &ctx->outputs[i]->incfg);
340  if (ret < 0)
341  return ret;
342  }
343  return 0;
344 }
345 
347 {
348  const FFFilter *const filter = fffilter(ctx->filter);
349  int ret;
350 
351  if (filter->formats_state == FF_FILTER_FORMATS_QUERY_FUNC) {
352  if ((ret = filter->formats.query_func(ctx)) < 0) {
353  if (ret != AVERROR(EAGAIN))
354  av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
355  ctx->name, av_err2str(ret));
356  return ret;
357  }
358  } else if (filter->formats_state == FF_FILTER_FORMATS_QUERY_FUNC2) {
359  AVFilterFormatsConfig *cfg_in_stack[64], *cfg_out_stack[64];
360  AVFilterFormatsConfig **cfg_in_dyn = NULL, **cfg_out_dyn = NULL;
361  AVFilterFormatsConfig **cfg_in, **cfg_out;
362 
363  if (ctx->nb_inputs > FF_ARRAY_ELEMS(cfg_in_stack)) {
364  cfg_in_dyn = av_malloc_array(ctx->nb_inputs, sizeof(*cfg_in_dyn));
365  if (!cfg_in_dyn)
366  return AVERROR(ENOMEM);
367  cfg_in = cfg_in_dyn;
368  } else
369  cfg_in = ctx->nb_inputs ? cfg_in_stack : NULL;
370 
371  for (unsigned i = 0; i < ctx->nb_inputs; i++) {
372  AVFilterLink *l = ctx->inputs[i];
373  cfg_in[i] = &l->outcfg;
374  }
375 
376  if (ctx->nb_outputs > FF_ARRAY_ELEMS(cfg_out_stack)) {
377  cfg_out_dyn = av_malloc_array(ctx->nb_outputs, sizeof(*cfg_out_dyn));
378  if (!cfg_out_dyn) {
379  av_freep(&cfg_in_dyn);
380  return AVERROR(ENOMEM);
381  }
382  cfg_out = cfg_out_dyn;
383  } else
384  cfg_out = ctx->nb_outputs ? cfg_out_stack : NULL;
385 
386  for (unsigned i = 0; i < ctx->nb_outputs; i++) {
387  AVFilterLink *l = ctx->outputs[i];
388  cfg_out[i] = &l->incfg;
389  }
390 
391  ret = filter->formats.query_func2(ctx, cfg_in, cfg_out);
392  av_freep(&cfg_in_dyn);
393  av_freep(&cfg_out_dyn);
394  if (ret < 0) {
395  if (ret != AVERROR(EAGAIN))
396  av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
397  ctx->name, av_err2str(ret));
398  return ret;
399  }
400  }
401 
402  if (filter->formats_state == FF_FILTER_FORMATS_QUERY_FUNC ||
403  filter->formats_state == FF_FILTER_FORMATS_QUERY_FUNC2) {
405  if (ret < 0)
406  return ret;
407  }
408 
410 }
411 
413 {
414  int i;
415 
416  for (i = 0; i < f->nb_inputs; i++) {
417  if (!f->inputs[i]->outcfg.formats)
418  return 0;
419  if (f->inputs[i]->type == AVMEDIA_TYPE_VIDEO &&
420  !(f->inputs[i]->outcfg.color_ranges &&
421  f->inputs[i]->outcfg.color_spaces))
422  return 0;
423  if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&
424  !(f->inputs[i]->outcfg.samplerates &&
425  f->inputs[i]->outcfg.channel_layouts))
426  return 0;
427  }
428  for (i = 0; i < f->nb_outputs; i++) {
429  if (!f->outputs[i]->incfg.formats)
430  return 0;
431  if (f->outputs[i]->type == AVMEDIA_TYPE_VIDEO &&
432  !(f->outputs[i]->incfg.color_ranges &&
433  f->outputs[i]->incfg.color_spaces))
434  return 0;
435  if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&
436  !(f->outputs[i]->incfg.samplerates &&
437  f->outputs[i]->incfg.channel_layouts))
438  return 0;
439  }
440  return 1;
441 }
442 
443 /**
444  * Perform one round of query_formats() and merging formats lists on the
445  * filter graph.
446  * @return >=0 if all links formats lists could be queried and merged;
447  * AVERROR(EAGAIN) some progress was made in the queries or merging
448  * and a later call may succeed;
449  * AVERROR(EIO) (may be changed) plus a log message if no progress
450  * was made and the negotiation is stuck;
451  * a negative error code if some other error happened
452  */
453 static int query_formats(AVFilterGraph *graph, void *log_ctx)
454 {
455  int i, j, ret;
456  int converter_count = 0;
457  int count_queried = 0; /* successful calls to query_formats() */
458  int count_merged = 0; /* successful merge of formats lists */
459  int count_already_merged = 0; /* lists already merged */
460  int count_delayed = 0; /* lists that need to be merged later */
461 
462  for (i = 0; i < graph->nb_filters; i++) {
463  AVFilterContext *f = graph->filters[i];
464  if (formats_declared(f))
465  continue;
467  if (ret < 0 && ret != AVERROR(EAGAIN))
468  return ret;
469  /* note: EAGAIN could indicate a partial success, not counted yet */
470  count_queried += ret >= 0;
471  }
472 
473  /* go through and merge as many format lists as possible */
474  for (i = 0; i < graph->nb_filters; i++) {
475  AVFilterContext *filter = graph->filters[i];
476 
477  for (j = 0; j < filter->nb_inputs; j++) {
478  AVFilterLink *link = filter->inputs[j];
479  const AVFilterNegotiation *neg;
480  unsigned neg_step;
481  int convert_needed = 0;
482 
483  if (!link)
484  continue;
485 
487  av_assert0(neg);
488  for (neg_step = 0; neg_step < neg->nb_mergers; neg_step++) {
489  const AVFilterFormatsMerger *m = &neg->mergers[neg_step];
490  void *a = FF_FIELD_AT(void *, m->offset, link->incfg);
491  void *b = FF_FIELD_AT(void *, m->offset, link->outcfg);
492  if (a && b && a != b && !m->can_merge(a, b)) {
493  convert_needed = 1;
494  break;
495  }
496  }
497  for (neg_step = 0; neg_step < neg->nb_mergers; neg_step++) {
498  const AVFilterFormatsMerger *m = &neg->mergers[neg_step];
499  void *a = FF_FIELD_AT(void *, m->offset, link->incfg);
500  void *b = FF_FIELD_AT(void *, m->offset, link->outcfg);
501  if (!(a && b)) {
502  count_delayed++;
503  } else if (a == b) {
504  count_already_merged++;
505  } else if (!convert_needed) {
506  count_merged++;
507  ret = m->merge(a, b);
508  if (ret < 0)
509  return ret;
510  if (!ret)
511  convert_needed = 1;
512  }
513  }
514 
515  if (convert_needed) {
517  const AVFilter *filter;
518  AVFilterLink *inlink, *outlink;
519  char inst_name[30];
520  const char *opts;
521 
522  if (fffiltergraph(graph)->disable_auto_convert) {
523  av_log(log_ctx, AV_LOG_ERROR,
524  "The filters '%s' and '%s' do not have a common format "
525  "and automatic conversion is disabled.\n",
526  link->src->name, link->dst->name);
527  return AVERROR(EINVAL);
528  }
529 
530  /* couldn't merge format lists. auto-insert conversion filter */
532  av_log(log_ctx, AV_LOG_ERROR,
533  "'%s' filter not present, cannot convert formats.\n",
534  neg->conversion_filter);
535  return AVERROR(EINVAL);
536  }
537  snprintf(inst_name, sizeof(inst_name), "auto_%s_%d",
538  neg->conversion_filter, converter_count++);
539  opts = FF_FIELD_AT(char *, neg->conversion_opts_offset, *graph);
540  ret = avfilter_graph_create_filter(&convert, filter, inst_name, opts, NULL, graph);
541  if (ret < 0)
542  return ret;
543  if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
544  return ret;
545 
546  if ((ret = filter_query_formats(convert)) < 0)
547  return ret;
548 
549  inlink = convert->inputs[0];
550  outlink = convert->outputs[0];
551  av_assert0( inlink->incfg.formats->refcount > 0);
552  av_assert0( inlink->outcfg.formats->refcount > 0);
553  av_assert0(outlink->incfg.formats->refcount > 0);
554  av_assert0(outlink->outcfg.formats->refcount > 0);
555  if (outlink->type == AVMEDIA_TYPE_VIDEO) {
556  av_assert0( inlink-> incfg.color_spaces->refcount > 0);
557  av_assert0( inlink->outcfg.color_spaces->refcount > 0);
558  av_assert0(outlink-> incfg.color_spaces->refcount > 0);
559  av_assert0(outlink->outcfg.color_spaces->refcount > 0);
560  av_assert0( inlink-> incfg.color_ranges->refcount > 0);
561  av_assert0( inlink->outcfg.color_ranges->refcount > 0);
562  av_assert0(outlink-> incfg.color_ranges->refcount > 0);
563  av_assert0(outlink->outcfg.color_ranges->refcount > 0);
564  } else if (outlink->type == AVMEDIA_TYPE_AUDIO) {
565  av_assert0( inlink-> incfg.samplerates->refcount > 0);
566  av_assert0( inlink->outcfg.samplerates->refcount > 0);
567  av_assert0(outlink-> incfg.samplerates->refcount > 0);
568  av_assert0(outlink->outcfg.samplerates->refcount > 0);
569  av_assert0( inlink-> incfg.channel_layouts->refcount > 0);
570  av_assert0( inlink->outcfg.channel_layouts->refcount > 0);
571  av_assert0(outlink-> incfg.channel_layouts->refcount > 0);
572  av_assert0(outlink->outcfg.channel_layouts->refcount > 0);
573  }
574 #define MERGE(merger, link) \
575  ((merger)->merge(FF_FIELD_AT(void *, (merger)->offset, (link)->incfg), \
576  FF_FIELD_AT(void *, (merger)->offset, (link)->outcfg)))
577  for (neg_step = 0; neg_step < neg->nb_mergers; neg_step++) {
578  const AVFilterFormatsMerger *m = &neg->mergers[neg_step];
579  if ((ret = MERGE(m, inlink)) <= 0 ||
580  (ret = MERGE(m, outlink)) <= 0) {
581  if (ret < 0)
582  return ret;
583  av_log(log_ctx, AV_LOG_ERROR,
584  "Impossible to convert between the formats supported by the filter "
585  "'%s' and the filter '%s'\n", link->src->name, link->dst->name);
586  return AVERROR(ENOSYS);
587  }
588  }
589  }
590  }
591  }
592 
593  av_log(graph, AV_LOG_DEBUG, "query_formats: "
594  "%d queried, %d merged, %d already done, %d delayed\n",
595  count_queried, count_merged, count_already_merged, count_delayed);
596  if (count_delayed) {
597  AVBPrint bp;
598 
599  /* if count_queried > 0, one filter at least did set its formats,
600  that will give additional information to its neighbour;
601  if count_merged > 0, one pair of formats lists at least was merged,
602  that will give additional information to all connected filters;
603  in both cases, progress was made and a new round must be done */
604  if (count_queried || count_merged)
605  return AVERROR(EAGAIN);
607  for (i = 0; i < graph->nb_filters; i++)
608  if (!formats_declared(graph->filters[i]))
609  av_bprintf(&bp, "%s%s", bp.len ? ", " : "",
610  graph->filters[i]->name);
611  av_log(graph, AV_LOG_ERROR,
612  "The following filters could not choose their formats: %s\n"
613  "Consider inserting the (a)format filter near their input or "
614  "output.\n", bp.str);
615  return AVERROR(EIO);
616  }
617  return 0;
618 }
619 
620 static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
621 {
622  int score = 0;
623 
624  if (av_sample_fmt_is_planar(dst_fmt) != av_sample_fmt_is_planar(src_fmt))
625  score ++;
626 
627  if (av_get_bytes_per_sample(dst_fmt) < av_get_bytes_per_sample(src_fmt)) {
628  score += 100 * (av_get_bytes_per_sample(src_fmt) - av_get_bytes_per_sample(dst_fmt));
629  }else
630  score += 10 * (av_get_bytes_per_sample(dst_fmt) - av_get_bytes_per_sample(src_fmt));
631 
634  score += 20;
635 
638  score += 2;
639 
640  return score;
641 }
642 
644  enum AVSampleFormat src_fmt)
645 {
646  int score1, score2;
647 
648  score1 = get_fmt_score(dst_fmt1, src_fmt);
649  score2 = get_fmt_score(dst_fmt2, src_fmt);
650 
651  return score1 < score2 ? dst_fmt1 : dst_fmt2;
652 }
653 
655 {
657  if (!desc)
658  return 0;
659  if (desc->nb_components < 3)
660  return 0; /* Grayscale is explicitly full-range in swscale */
662  return !(desc->flags & (AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_PAL |
664 }
665 
666 
668 {
669  switch (fmt) {
670  case AV_PIX_FMT_YUVJ420P:
671  case AV_PIX_FMT_YUVJ422P:
672  case AV_PIX_FMT_YUVJ444P:
673  case AV_PIX_FMT_YUVJ440P:
674  case AV_PIX_FMT_YUVJ411P:
675  return 1;
676  default:
677  return 0;
678  }
679 }
680 
682 {
683  if (!link || !link->incfg.formats)
684  return 0;
685 
686  if (link->type == AVMEDIA_TYPE_VIDEO) {
687  if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
688  //FIXME: This should check for AV_PIX_FMT_FLAG_ALPHA after PAL8 pixel format without alpha is implemented
689  int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
690  enum AVPixelFormat best= AV_PIX_FMT_NONE;
691  int i;
692  for (i = 0; i < link->incfg.formats->nb_formats; i++) {
693  enum AVPixelFormat p = link->incfg.formats->formats[i];
694  best= av_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL);
695  }
696  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",
697  av_get_pix_fmt_name(best), link->incfg.formats->nb_formats,
698  av_get_pix_fmt_name(ref->format), has_alpha);
699  link->incfg.formats->formats[0] = best;
700  }
701  } else if (link->type == AVMEDIA_TYPE_AUDIO) {
702  if(ref && ref->type == AVMEDIA_TYPE_AUDIO){
704  int i;
705  for (i = 0; i < link->incfg.formats->nb_formats; i++) {
706  enum AVSampleFormat p = link->incfg.formats->formats[i];
707  best = find_best_sample_fmt_of_2(best, p, ref->format);
708  }
709  av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s\n",
710  av_get_sample_fmt_name(best), link->incfg.formats->nb_formats,
711  av_get_sample_fmt_name(ref->format));
712  link->incfg.formats->formats[0] = best;
713  }
714  }
715 
716  link->incfg.formats->nb_formats = 1;
717  link->format = link->incfg.formats->formats[0];
718 
719  if (link->type == AVMEDIA_TYPE_VIDEO) {
720  enum AVPixelFormat swfmt = link->format;
722  // FIXME: this is a hack - we'd like to use the sw_format of
723  // link->hw_frames_ctx here, but it is not yet available.
724  // To make this work properly we will need to either reorder
725  // things so that it is available here or somehow negotiate
726  // sw_format separately.
727  swfmt = AV_PIX_FMT_YUV420P;
728  }
729 
730  if (!ff_fmt_is_regular_yuv(swfmt)) {
732  /* These fields are explicitly documented as affecting YUV only,
733  * so set them to sane values for other formats. */
734  if (desc->flags & AV_PIX_FMT_FLAG_FLOAT)
736  else
738  if (desc->flags & (AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_XYZ)) {
740  } else {
742  }
743  } else {
744  if (!link->incfg.color_spaces->nb_formats) {
745  av_log(link->src, AV_LOG_ERROR, "Cannot select color space for"
746  " the link between filters %s and %s.\n", link->src->name,
747  link->dst->name);
748  return AVERROR(EINVAL);
749  }
750  link->incfg.color_spaces->nb_formats = 1;
751  link->colorspace = link->incfg.color_spaces->formats[0];
752 
753  if (ff_fmt_is_forced_full_range(swfmt)) {
755  } else {
756  if (!link->incfg.color_ranges->nb_formats) {
757  av_log(link->src, AV_LOG_ERROR, "Cannot select color range for"
758  " the link between filters %s and %s.\n", link->src->name,
759  link->dst->name);
760  return AVERROR(EINVAL);
761  }
762  link->incfg.color_ranges->nb_formats = 1;
763  link->color_range = link->incfg.color_ranges->formats[0];
764  }
765  }
766  } else if (link->type == AVMEDIA_TYPE_AUDIO) {
767  int ret;
768 
769  if (!link->incfg.samplerates->nb_formats) {
770  av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
771  " the link between filters %s and %s.\n", link->src->name,
772  link->dst->name);
773  return AVERROR(EINVAL);
774  }
775  link->incfg.samplerates->nb_formats = 1;
776  link->sample_rate = link->incfg.samplerates->formats[0];
777 
778  if (link->incfg.channel_layouts->all_layouts) {
779  av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
780  " the link between filters %s and %s.\n", link->src->name,
781  link->dst->name);
782  if (!link->incfg.channel_layouts->all_counts)
783  av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not "
784  "supported, try specifying a channel layout using "
785  "'aformat=channel_layouts=something'.\n");
786  return AVERROR(EINVAL);
787  }
788  link->incfg.channel_layouts->nb_channel_layouts = 1;
789  ret = av_channel_layout_copy(&link->ch_layout, &link->incfg.channel_layouts->channel_layouts[0]);
790  if (ret < 0)
791  return ret;
792  }
793 
794  ff_formats_unref(&link->incfg.formats);
795  ff_formats_unref(&link->outcfg.formats);
796  ff_formats_unref(&link->incfg.samplerates);
797  ff_formats_unref(&link->outcfg.samplerates);
798  ff_channel_layouts_unref(&link->incfg.channel_layouts);
799  ff_channel_layouts_unref(&link->outcfg.channel_layouts);
800  ff_formats_unref(&link->incfg.color_spaces);
801  ff_formats_unref(&link->outcfg.color_spaces);
802  ff_formats_unref(&link->incfg.color_ranges);
803  ff_formats_unref(&link->outcfg.color_ranges);
804 
805  return 0;
806 }
807 
808 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
809 do { \
810  for (i = 0; i < filter->nb_inputs; i++) { \
811  AVFilterLink *link = filter->inputs[i]; \
812  fmt_type fmt; \
813  \
814  if (!link->outcfg.list || link->outcfg.list->nb != 1) \
815  continue; \
816  fmt = link->outcfg.list->var[0]; \
817  \
818  for (j = 0; j < filter->nb_outputs; j++) { \
819  AVFilterLink *out_link = filter->outputs[j]; \
820  list_type *fmts; \
821  \
822  if (link->type != out_link->type || \
823  out_link->incfg.list->nb == 1) \
824  continue; \
825  fmts = out_link->incfg.list; \
826  \
827  if (!out_link->incfg.list->nb) { \
828  if ((ret = add_format(&out_link->incfg.list, fmt)) < 0)\
829  return ret; \
830  ret = 1; \
831  break; \
832  } \
833  \
834  for (k = 0; k < out_link->incfg.list->nb; k++) \
835  if (fmts->var[k] == fmt) { \
836  fmts->var[0] = fmt; \
837  fmts->nb = 1; \
838  ret = 1; \
839  break; \
840  } \
841  } \
842  } \
843 } while (0)
844 
846 {
847  int i, j, k, ret = 0;
848 
850  nb_formats, ff_add_format);
851  REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats,
852  nb_formats, ff_add_format);
853  REDUCE_FORMATS(int, AVFilterFormats, color_spaces, formats,
854  nb_formats, ff_add_format);
855  REDUCE_FORMATS(int, AVFilterFormats, color_ranges, formats,
856  nb_formats, ff_add_format);
857 
858  /* reduce channel layouts */
859  for (i = 0; i < filter->nb_inputs; i++) {
860  AVFilterLink *inlink = filter->inputs[i];
861  const AVChannelLayout *fmt;
862 
863  if (!inlink->outcfg.channel_layouts ||
864  inlink->outcfg.channel_layouts->nb_channel_layouts != 1)
865  continue;
866  fmt = &inlink->outcfg.channel_layouts->channel_layouts[0];
867 
868  for (j = 0; j < filter->nb_outputs; j++) {
869  AVFilterLink *outlink = filter->outputs[j];
871 
872  fmts = outlink->incfg.channel_layouts;
873  if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
874  continue;
875 
876  if (fmts->all_layouts &&
877  (KNOWN(fmt) || fmts->all_counts)) {
878  /* Turn the infinite list into a singleton */
879  fmts->all_layouts = fmts->all_counts = 0;
881  if (ret < 0)
882  return ret;
883  ret = 1;
884  break;
885  }
886 
887  for (k = 0; k < outlink->incfg.channel_layouts->nb_channel_layouts; k++) {
888  if (!av_channel_layout_compare(&fmts->channel_layouts[k], fmt)) {
889  ret = av_channel_layout_copy(&fmts->channel_layouts[0], fmt);
890  if (ret < 0)
891  return ret;
892  fmts->nb_channel_layouts = 1;
893  ret = 1;
894  break;
895  }
896  }
897  }
898  }
899 
900  return ret;
901 }
902 
903 static int reduce_formats(AVFilterGraph *graph)
904 {
905  int i, reduced, ret;
906 
907  do {
908  reduced = 0;
909 
910  for (i = 0; i < graph->nb_filters; i++) {
911  if ((ret = reduce_formats_on_filter(graph->filters[i])) < 0)
912  return ret;
913  reduced |= ret;
914  }
915  } while (reduced);
916 
917  return 0;
918 }
919 
921 {
923  int sample_rate;
924  int i, j;
925 
926  for (i = 0; i < filter->nb_inputs; i++) {
927  link = filter->inputs[i];
928 
929  if (link->type == AVMEDIA_TYPE_AUDIO &&
930  link->outcfg.samplerates->nb_formats== 1)
931  break;
932  }
933  if (i == filter->nb_inputs)
934  return;
935 
936  sample_rate = link->outcfg.samplerates->formats[0];
937 
938  for (i = 0; i < filter->nb_outputs; i++) {
939  AVFilterLink *outlink = filter->outputs[i];
940  int best_idx, best_diff = INT_MAX;
941 
942  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
943  outlink->incfg.samplerates->nb_formats < 2)
944  continue;
945 
946  for (j = 0; j < outlink->incfg.samplerates->nb_formats; j++) {
947  int diff = abs(sample_rate - outlink->incfg.samplerates->formats[j]);
948 
949  av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
950 
951  if (diff < best_diff) {
952  best_diff = diff;
953  best_idx = j;
954  }
955  }
956  FFSWAP(int, outlink->incfg.samplerates->formats[0],
957  outlink->incfg.samplerates->formats[best_idx]);
958  }
959 }
960 
961 static void swap_samplerates(AVFilterGraph *graph)
962 {
963  int i;
964 
965  for (i = 0; i < graph->nb_filters; i++)
967 }
968 
969 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
970 #define CH_FRONT_PAIR (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)
971 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)
972 #define CH_WIDE_PAIR (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)
973 #define CH_SIDE_PAIR (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
974 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
975 #define CH_BACK_PAIR (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
976 
977 /* allowable substitutions for channel pairs when comparing layouts,
978  * ordered by priority for both values */
979 static const uint64_t ch_subst[][2] = {
1001 };
1002 
1004 {
1005  AVFilterLink *link = NULL;
1006  int i, j, k;
1007 
1008  for (i = 0; i < filter->nb_inputs; i++) {
1009  link = filter->inputs[i];
1010 
1011  if (link->type == AVMEDIA_TYPE_AUDIO &&
1012  link->outcfg.channel_layouts->nb_channel_layouts == 1)
1013  break;
1014  }
1015  if (i == filter->nb_inputs)
1016  return;
1017 
1018  for (i = 0; i < filter->nb_outputs; i++) {
1019  AVFilterLink *outlink = filter->outputs[i];
1020  int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
1021 
1022  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
1024  continue;
1025 
1026  for (j = 0; j < outlink->incfg.channel_layouts->nb_channel_layouts; j++) {
1027  AVChannelLayout in_chlayout = { 0 }, out_chlayout = { 0 };
1028  int in_channels;
1029  int out_channels;
1030  int count_diff;
1031  int matched_channels, extra_channels;
1032  int score = 100000;
1033 
1034  av_channel_layout_copy(&in_chlayout, &link->outcfg.channel_layouts->channel_layouts[0]);
1035  av_channel_layout_copy(&out_chlayout, &outlink->incfg.channel_layouts->channel_layouts[j]);
1036  in_channels = in_chlayout.nb_channels;
1037  out_channels = out_chlayout.nb_channels;
1038  count_diff = out_channels - in_channels;
1039  if (!KNOWN(&in_chlayout) || !KNOWN(&out_chlayout)) {
1040  /* Compute score in case the input or output layout encodes
1041  a channel count; in this case the score is not altered by
1042  the computation afterwards, as in_chlayout and
1043  out_chlayout have both been set to 0 */
1044  if (!KNOWN(&in_chlayout))
1045  in_channels = FF_LAYOUT2COUNT(&in_chlayout);
1046  if (!KNOWN(&out_chlayout))
1047  out_channels = FF_LAYOUT2COUNT(&out_chlayout);
1048  score -= 10000 + FFABS(out_channels - in_channels) +
1049  (in_channels > out_channels ? 10000 : 0);
1050  av_channel_layout_uninit(&in_chlayout);
1051  av_channel_layout_uninit(&out_chlayout);
1052  /* Let the remaining computation run, even if the score
1053  value is not altered */
1054  }
1055 
1056  /* channel substitution */
1057  for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {
1058  uint64_t cmp0 = ch_subst[k][0];
1059  uint64_t cmp1 = ch_subst[k][1];
1060  if ( av_channel_layout_subset(& in_chlayout, cmp0) &&
1061  !av_channel_layout_subset(&out_chlayout, cmp0) &&
1062  av_channel_layout_subset(&out_chlayout, cmp1) &&
1063  !av_channel_layout_subset(& in_chlayout, cmp1)) {
1064  av_channel_layout_from_mask(&in_chlayout, av_channel_layout_subset(& in_chlayout, ~cmp0));
1065  av_channel_layout_from_mask(&out_chlayout, av_channel_layout_subset(&out_chlayout, ~cmp1));
1066  /* add score for channel match, minus a deduction for
1067  having to do the substitution */
1068  score += 10 * av_popcount64(cmp1) - 2;
1069  }
1070  }
1071 
1072  /* no penalty for LFE channel mismatch */
1075  score += 10;
1078 
1079  matched_channels = av_popcount64(in_chlayout.u.mask & out_chlayout.u.mask);
1080  extra_channels = av_popcount64(out_chlayout.u.mask & (~in_chlayout.u.mask));
1081  score += 10 * matched_channels - 5 * extra_channels;
1082 
1083  if (score > best_score ||
1084  (count_diff < best_count_diff && score == best_score)) {
1085  best_score = score;
1086  best_idx = j;
1087  best_count_diff = count_diff;
1088  }
1089  }
1090  av_assert0(best_idx >= 0);
1092  outlink->incfg.channel_layouts->channel_layouts[best_idx]);
1093  }
1094 
1095 }
1096 
1098 {
1099  int i;
1100 
1101  for (i = 0; i < graph->nb_filters; i++)
1103 }
1104 
1106 {
1107  AVFilterLink *link = NULL;
1108  int format, bps;
1109  int i, j;
1110 
1111  for (i = 0; i < filter->nb_inputs; i++) {
1112  link = filter->inputs[i];
1113 
1114  if (link->type == AVMEDIA_TYPE_AUDIO &&
1115  link->outcfg.formats->nb_formats == 1)
1116  break;
1117  }
1118  if (i == filter->nb_inputs)
1119  return;
1120 
1121  format = link->outcfg.formats->formats[0];
1123 
1124  for (i = 0; i < filter->nb_outputs; i++) {
1125  AVFilterLink *outlink = filter->outputs[i];
1126  int best_idx = -1, best_score = INT_MIN;
1127 
1128  if (outlink->type != AVMEDIA_TYPE_AUDIO ||
1129  outlink->incfg.formats->nb_formats < 2)
1130  continue;
1131 
1132  for (j = 0; j < outlink->incfg.formats->nb_formats; j++) {
1133  int out_format = outlink->incfg.formats->formats[j];
1134  int out_bps = av_get_bytes_per_sample(out_format);
1135  int score;
1136 
1137  if (av_get_packed_sample_fmt(out_format) == format ||
1138  av_get_planar_sample_fmt(out_format) == format) {
1139  best_idx = j;
1140  break;
1141  }
1142 
1143  /* for s32 and float prefer double to prevent loss of information */
1144  if (bps == 4 && out_bps == 8) {
1145  best_idx = j;
1146  break;
1147  }
1148 
1149  /* prefer closest higher or equal bps */
1150  score = -abs(out_bps - bps);
1151  if (out_bps >= bps)
1152  score += INT_MAX/2;
1153 
1154  if (score > best_score) {
1155  best_score = score;
1156  best_idx = j;
1157  }
1158  }
1159  av_assert0(best_idx >= 0);
1160  FFSWAP(int, outlink->incfg.formats->formats[0],
1161  outlink->incfg.formats->formats[best_idx]);
1162  }
1163 }
1164 
1165 static void swap_sample_fmts(AVFilterGraph *graph)
1166 {
1167  int i;
1168 
1169  for (i = 0; i < graph->nb_filters; i++)
1171 
1172 }
1173 
1174 static int pick_formats(AVFilterGraph *graph)
1175 {
1176  int i, j, ret;
1177  int change;
1178 
1179  do{
1180  change = 0;
1181  for (i = 0; i < graph->nb_filters; i++) {
1182  AVFilterContext *filter = graph->filters[i];
1183  if (filter->nb_inputs){
1184  for (j = 0; j < filter->nb_inputs; j++){
1185  if (filter->inputs[j]->incfg.formats && filter->inputs[j]->incfg.formats->nb_formats == 1) {
1186  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1187  return ret;
1188  change = 1;
1189  }
1190  }
1191  }
1192  if (filter->nb_outputs){
1193  for (j = 0; j < filter->nb_outputs; j++){
1194  if (filter->outputs[j]->incfg.formats && filter->outputs[j]->incfg.formats->nb_formats == 1) {
1195  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1196  return ret;
1197  change = 1;
1198  }
1199  }
1200  }
1201  if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
1202  for (j = 0; j < filter->nb_outputs; j++) {
1203  if (filter->outputs[j]->format<0) {
1204  if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
1205  return ret;
1206  change = 1;
1207  }
1208  }
1209  }
1210  }
1211  }while(change);
1212 
1213  for (i = 0; i < graph->nb_filters; i++) {
1214  AVFilterContext *filter = graph->filters[i];
1215 
1216  for (j = 0; j < filter->nb_inputs; j++)
1217  if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
1218  return ret;
1219  for (j = 0; j < filter->nb_outputs; j++)
1220  if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
1221  return ret;
1222  }
1223  return 0;
1224 }
1225 
1226 /**
1227  * Configure the formats of all the links in the graph.
1228  */
1229 static int graph_config_formats(AVFilterGraph *graph, void *log_ctx)
1230 {
1231  int ret;
1232 
1233  /* find supported formats from sub-filters, and merge along links */
1234  while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN))
1235  av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n");
1236  if (ret < 0)
1237  return ret;
1238 
1239  /* Once everything is merged, it's possible that we'll still have
1240  * multiple valid media format choices. We try to minimize the amount
1241  * of format conversion inside filters */
1242  if ((ret = reduce_formats(graph)) < 0)
1243  return ret;
1244 
1245  /* for audio filters, ensure the best format, sample rate and channel layout
1246  * is selected */
1247  swap_sample_fmts(graph);
1248  swap_samplerates(graph);
1249  swap_channel_layouts(graph);
1250 
1251  if ((ret = pick_formats(graph)) < 0)
1252  return ret;
1253 
1254  return 0;
1255 }
1256 
1257 static int graph_config_pointers(AVFilterGraph *graph, void *log_ctx)
1258 {
1259  unsigned i, j;
1260  int sink_links_count = 0, n = 0;
1261  AVFilterContext *f;
1262  FilterLinkInternal **sinks;
1263 
1264  for (i = 0; i < graph->nb_filters; i++) {
1265  f = graph->filters[i];
1266  for (j = 0; j < f->nb_inputs; j++) {
1267  ff_link_internal(f->inputs[j])->age_index = -1;
1268  }
1269  for (j = 0; j < f->nb_outputs; j++) {
1270  ff_link_internal(f->outputs[j])->age_index = -1;
1271  }
1272  if (!f->nb_outputs) {
1273  if (f->nb_inputs > INT_MAX - sink_links_count)
1274  return AVERROR(EINVAL);
1275  sink_links_count += f->nb_inputs;
1276  }
1277  }
1278  sinks = av_calloc(sink_links_count, sizeof(*sinks));
1279  if (!sinks)
1280  return AVERROR(ENOMEM);
1281  for (i = 0; i < graph->nb_filters; i++) {
1282  f = graph->filters[i];
1283  if (!f->nb_outputs) {
1284  for (j = 0; j < f->nb_inputs; j++) {
1285  sinks[n] = ff_link_internal(f->inputs[j]);
1286  sinks[n]->age_index = n;
1287  n++;
1288  }
1289  }
1290  }
1291  av_assert0(n == sink_links_count);
1292  fffiltergraph(graph)->sink_links = sinks;
1293  fffiltergraph(graph)->sink_links_count = sink_links_count;
1294  return 0;
1295 }
1296 
1297 int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
1298 {
1299  int ret;
1300 
1301  if (graphctx->max_buffered_frames)
1303  if ((ret = graph_check_validity(graphctx, log_ctx)))
1304  return ret;
1305  if ((ret = graph_config_formats(graphctx, log_ctx)))
1306  return ret;
1307  if ((ret = graph_config_links(graphctx, log_ctx)))
1308  return ret;
1309  if ((ret = graph_check_links(graphctx, log_ctx)))
1310  return ret;
1311  if ((ret = graph_config_pointers(graphctx, log_ctx)))
1312  return ret;
1313 
1314  return 0;
1315 }
1316 
1317 int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
1318 {
1319  int i, r = AVERROR(ENOSYS);
1320 
1321  if (!graph)
1322  return r;
1323 
1325  r = avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);
1326  if (r != AVERROR(ENOSYS))
1327  return r;
1328  }
1329 
1330  if (res_len && res)
1331  res[0] = 0;
1332 
1333  for (i = 0; i < graph->nb_filters; i++) {
1334  AVFilterContext *filter = graph->filters[i];
1335  if (!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)) {
1336  r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);
1337  if (r != AVERROR(ENOSYS)) {
1338  if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0)
1339  return r;
1340  }
1341  }
1342  }
1343 
1344  return r;
1345 }
1346 
1347 int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
1348 {
1349  int i;
1350 
1351  if(!graph)
1352  return 0;
1353 
1354  for (i = 0; i < graph->nb_filters; i++) {
1355  AVFilterContext *filter = graph->filters[i];
1357  if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){
1358  AVFilterCommand **queue = &ctxi->command_queue, *next;
1359  while (*queue && (*queue)->time <= ts)
1360  queue = &(*queue)->next;
1361  next = *queue;
1362  *queue = av_mallocz(sizeof(AVFilterCommand));
1363  if (!*queue)
1364  return AVERROR(ENOMEM);
1365 
1366  (*queue)->command = av_strdup(command);
1367  (*queue)->arg = av_strdup(arg);
1368  (*queue)->time = ts;
1369  (*queue)->flags = flags;
1370  (*queue)->next = next;
1372  return 0;
1373  }
1374  }
1375 
1376  return 0;
1377 }
1378 
1379 static void heap_bubble_up(FFFilterGraph *graph,
1380  FilterLinkInternal *li, int index)
1381 {
1382  FilterLinkInternal **links = graph->sink_links;
1383 
1384  av_assert0(index >= 0);
1385 
1386  while (index) {
1387  int parent = (index - 1) >> 1;
1388  if (links[parent]->l.current_pts_us >= li->l.current_pts_us)
1389  break;
1390  links[index] = links[parent];
1391  links[index]->age_index = index;
1392  index = parent;
1393  }
1394  links[index] = li;
1395  li->age_index = index;
1396 }
1397 
1398 static void heap_bubble_down(FFFilterGraph *graph,
1399  FilterLinkInternal *li, int index)
1400 {
1401  FilterLinkInternal **links = graph->sink_links;
1402 
1403  av_assert0(index >= 0);
1404 
1405  while (1) {
1406  int child = 2 * index + 1;
1407  if (child >= graph->sink_links_count)
1408  break;
1409  if (child + 1 < graph->sink_links_count &&
1410  links[child + 1]->l.current_pts_us < links[child]->l.current_pts_us)
1411  child++;
1412  if (li->l.current_pts_us < links[child]->l.current_pts_us)
1413  break;
1414  links[index] = links[child];
1415  links[index]->age_index = index;
1416  index = child;
1417  }
1418  links[index] = li;
1419  li->age_index = index;
1420 }
1421 
1423 {
1424  FFFilterGraph *graphi = fffiltergraph(graph);
1425 
1426  heap_bubble_up (graphi, li, li->age_index);
1427  heap_bubble_down(graphi, li, li->age_index);
1428 }
1429 
1431 {
1432  FFFilterGraph *graphi = fffiltergraph(graph);
1433  FilterLinkInternal *oldesti = graphi->sink_links[0];
1434  AVFilterLink *oldest = &oldesti->l.pub;
1435  int64_t frame_count;
1436  int r;
1437 
1438  while (graphi->sink_links_count) {
1439  oldesti = graphi->sink_links[0];
1440  oldest = &oldesti->l.pub;
1441  if (fffilter(oldest->dst->filter)->activate) {
1444  if (r != AVERROR_EOF)
1445  return r;
1446  } else {
1447  r = ff_request_frame(oldest);
1448  }
1449  if (r != AVERROR_EOF)
1450  break;
1451  av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
1452  oldest->dst->name,
1453  oldest->dstpad->name);
1454  /* EOF: remove the link from the heap */
1455  if (oldesti->age_index < --graphi->sink_links_count)
1456  heap_bubble_down(graphi, graphi->sink_links[graphi->sink_links_count],
1457  oldesti->age_index);
1458  oldesti->age_index = -1;
1459  }
1460  if (!graphi->sink_links_count)
1461  return AVERROR_EOF;
1462  av_assert1(!fffilter(oldest->dst->filter)->activate);
1463  av_assert1(oldesti->age_index >= 0);
1464  frame_count = oldesti->l.frame_count_out;
1465  while (frame_count == oldesti->l.frame_count_out) {
1466  r = ff_filter_graph_run_once(graph);
1467  if (r == FFERROR_BUFFERSRC_EMPTY)
1468  r = 0;
1469  if (r == AVERROR(EAGAIN) &&
1470  !oldesti->frame_wanted_out && !oldesti->frame_blocked_in &&
1471  !oldesti->status_in)
1472  (void)ff_request_frame(oldest);
1473  else if (r < 0)
1474  return r;
1475  }
1476  return 0;
1477 }
1478 
1480 {
1481  FFFilterContext *ctxi;
1482  unsigned i;
1483 
1484  av_assert0(graph->nb_filters);
1485  ctxi = fffilterctx(graph->filters[0]);
1486  for (i = 1; i < graph->nb_filters; i++) {
1487  FFFilterContext *ctxi_other = fffilterctx(graph->filters[i]);
1488 
1489  if (ctxi_other->ready > ctxi->ready)
1490  ctxi = ctxi_other;
1491  }
1492 
1493  if (!ctxi->ready)
1494  return AVERROR(EAGAIN);
1495  return ff_filter_activate(&ctxi->p);
1496 }
flags
const SwsFlags flags[]
Definition: swscale.c:61
formats
formats
Definition: signature.h:47
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:629
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:462
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:672
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AVFilterFormatsConfig::samplerates
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:131
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:45
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:1678
ff_link_internal
static FilterLinkInternal * ff_link_internal(AVFilterLink *link)
Definition: avfilter_internal.h:90
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
FF_FILTER_FORMATS_QUERY_FUNC
@ FF_FILTER_FORMATS_QUERY_FUNC
formats.query active.
Definition: filters.h:229
opt.h
AVFilterGraph::nb_threads
int nb_threads
Maximum number of threads used by filters in this graph.
Definition: avfilter.h:608
AVFilterFormatsConfig::channel_layouts
AVFilterChannelLayouts * channel_layouts
Lists of supported channel layouts, only for audio.
Definition: avfilter.h:136
ch_subst
static const uint64_t ch_subst[][2]
Definition: avfiltergraph.c:979
REDUCE_FORMATS
#define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format)
Definition: avfiltergraph.c:808
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:157
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3441
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:150
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:1106
int64_t
long long int64_t
Definition: coverity.c:34
FFFilterGraph
Definition: avfilter_internal.h:134
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
filter_query_formats
static int filter_query_formats(AVFilterContext *ctx)
Definition: avfiltergraph.c:346
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:1441
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:683
swap_sample_fmts
static void swap_sample_fmts(AVFilterGraph *graph)
Definition: avfiltergraph.c:1165
pixdesc.h
AVFilterNegotiation::conversion_filter
const char * conversion_filter
Definition: formats.h:563
graph_check_validity
static int graph_check_validity(AVFilterGraph *graph, void *log_ctx)
Check for the validity of graph.
Definition: avfiltergraph.c:210
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:767
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:453
AVOption
AVOption.
Definition: opt.h:429
FFFilterGraph::sink_links
struct FilterLinkInternal ** sink_links
Definition: avfilter_internal.h:140
b
#define b
Definition: input.c:42
pick_formats
static int pick_formats(AVFilterGraph *graph)
Definition: avfiltergraph.c:1174
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:480
FilterLinkInternal::l
FilterLink l
Definition: avfilter_internal.h:35
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:691
filter
void(* filter)(uint8_t *src, int stride, int qscale)
Definition: h263dsp.c:29
pick_format
static int pick_format(AVFilterLink *link, AVFilterLink *ref)
Definition: avfiltergraph.c:681
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:1479
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:351
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
video.h
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:654
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:698
convert
static void convert(float y, float u, float v, float *b, float *g, float *r)
Definition: exr.c:968
swap_samplerates
static void swap_samplerates(AVFilterGraph *graph)
Definition: avfiltergraph.c:961
FF_LAYOUT2COUNT
#define FF_LAYOUT2COUNT(l)
Decode a channel count encoded as a channel layout.
Definition: formats.h:108
fffilter
static const FFFilter * fffilter(const AVFilter *f)
Definition: filters.h:463
avfilter_graph_free
void avfilter_graph_free(AVFilterGraph **graphp)
Free a graph, destroy its links, and set *graph to NULL.
Definition: avfiltergraph.c:119
FilterLinkInternal
Definition: avfilter_internal.h:34
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:620
FFFrameQueueGlobal::max_queued
size_t max_queued
Maximum number of allowed frames in the queues combined.
Definition: framequeue.h:49
ff_fmt_is_forced_full_range
int ff_fmt_is_forced_full_range(enum AVPixelFormat fmt)
Returns true if a YUV pixel format is forced full range (i.e.
Definition: avfiltergraph.c:667
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)
A convenience wrapper that allocates and initializes a filter in a single step.
Definition: avfiltergraph.c:140
avfilter_graph_alloc_filter
AVFilterContext * avfilter_graph_alloc_filter(AVFilterGraph *graph, const AVFilter *filter, const char *name)
Create a new filter instance in a filter graph.
Definition: avfiltergraph.c:167
fail
#define fail()
Definition: checkasm.h:198
avfilter_graph_alloc
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:85
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:77
reduce_formats
static int reduce_formats(AVFilterGraph *graph)
Definition: avfiltergraph.c:903
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:282
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:1229
OFFSET
#define OFFSET(x)
Definition: avfiltergraph.c:44
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1949
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:764
FFFilterContext::p
AVFilterContext p
The public AVFilterContext.
Definition: avfilter_internal.h:99
AVFILTER_THREAD_SLICE
#define AVFILTER_THREAD_SLICE
Process multiple parts of the frame concurrently.
Definition: avfilter.h:266
AVFilterNegotiation
Callbacks and properties to describe the steps of a format negotiation.
Definition: formats.h:560
FFFilterGraph::sink_links_count
int sink_links_count
Definition: avfilter_internal.h:141
heap_bubble_up
static void heap_bubble_up(FFFilterGraph *graph, FilterLinkInternal *li, int index)
Definition: avfiltergraph.c:1379
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: filters.h:39
AVFilterNegotiation::nb_mergers
unsigned nb_mergers
Definition: formats.h:561
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:325
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:845
avassert.h
FFFilterGraph::thread_execute
avfilter_execute_func * thread_execute
Definition: avfilter_internal.h:146
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
MERGE
#define MERGE(merger, link)
FFFilter
Definition: filters.h:266
AV_CH_LOW_FREQUENCY
#define AV_CH_LOW_FREQUENCY
Definition: channel_layout.h:178
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:84
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
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:607
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
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:252
filters
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
Definition: af_crystalizer.c:55
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
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
filters.h
filtergraph_options
static const AVOption filtergraph_options[]
Definition: avfiltergraph.c:48
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
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:141
CH_DIRECT_PAIR
#define CH_DIRECT_PAIR
Definition: avfiltergraph.c:974
graph_config_pointers
static int graph_config_pointers(AVFilterGraph *graph, void *log_ctx)
Definition: avfiltergraph.c:1257
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:562
command
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:1187
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:74
avfilter_get_by_name
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:642
opts
AVDictionary * opts
Definition: movenc.c:51
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
FFFilter::activate
int(* activate)(AVFilterContext *ctx)
Filter activation function.
Definition: filters.h:460
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
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:1297
NULL
#define NULL
Definition: coverity.c:32
ff_filter_get_negotiation
const AVFilterNegotiation * ff_filter_get_negotiation(AVFilterLink *link)
Definition: formats.c:397
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
avfilter_graph_set_auto_convert
void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
Enable or disable automatic format conversion inside the graph.
Definition: avfiltergraph.c:162
framequeue.h
AV_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:584
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:240
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:504
AVFilterContext::name
char * name
name of this filter instance
Definition: avfilter.h:274
fffiltergraph
static FFFilterGraph * fffiltergraph(AVFilterGraph *graph)
Definition: avfilter_internal.h:150
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:286
avfilter_graph_request_oldest
int avfilter_graph_request_oldest(AVFilterGraph *graph)
Request a frame on the oldest sink link.
Definition: avfiltergraph.c:1430
graph_config_links
static int graph_config_links(AVFilterGraph *graph, void *log_ctx)
Configure all the links of graphctx.
Definition: avfiltergraph.c:248
abs
#define abs(x)
Definition: cuda_runtime.h:35
avfilter_internal.h
AVFilterGraph
Definition: avfilter.h:582
AV_OPT_TYPE_UINT
@ AV_OPT_TYPE_UINT
Underlying C type is unsigned int.
Definition: opt.h:335
AV_CH_FRONT_CENTER
#define AV_CH_FRONT_CENTER
Definition: channel_layout.h:177
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)
Definition: formats.c:521
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:729
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:733
index
int index
Definition: gxfenc.c:90
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:121
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:198
AV_CLASS_CATEGORY_FILTER
@ AV_CLASS_CATEGORY_FILTER
Definition: log.h:36
FFFilterContext::command_queue
struct AVFilterCommand * command_queue
Definition: avfilter_internal.h:118
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:1111
ff_graph_thread_free
void ff_graph_thread_free(FFFilterGraph *graph)
Definition: avfiltergraph.c:73
FFERROR_BUFFERSRC_EMPTY
#define FFERROR_BUFFERSRC_EMPTY
Definition: filters.h:34
f
f
Definition: af_crystalizer.c:122
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:1123
CH_BACK_PAIR
#define CH_BACK_PAIR
Definition: avfiltergraph.c:975
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:1025
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
FilterLinkInternal::age_index
int age_index
Index in the age array.
Definition: avfilter_internal.h:80
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:1422
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:131
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:584
bps
unsigned bps
Definition: movenc.c:1935
CH_CENTER_PAIR
#define CH_CENTER_PAIR
Definition: avfiltergraph.c:969
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:1347
AVFilterChannelLayouts::channel_layouts
AVChannelLayout * channel_layouts
list of channel layouts
Definition: formats.h:86
FFFilterGraph::frame_queues
FFFrameQueueGlobal frame_queues
Definition: avfilter_internal.h:147
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:508
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:1146
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:166
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:643
AVFilterFormatsConfig::color_ranges
AVFilterFormats * color_ranges
AVColorRange.
Definition: avfilter.h:142
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:809
avfilter_init_str
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:954
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:49
filter_link_check_formats
static int filter_link_check_formats(void *log, AVFilterLink *link, AVFilterFormatsConfig *cfg)
Definition: avfiltergraph.c:297
CH_FRONT_PAIR
#define CH_FRONT_PAIR
Definition: avfiltergraph.c:970
swap_sample_fmts_on_filter
static void swap_sample_fmts_on_filter(AVFilterContext *filter)
Definition: avfiltergraph.c:1105
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:717
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:1116
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:143
fffilterctx
static FFFilterContext * fffilterctx(AVFilterContext *ctx)
Definition: avfilter_internal.h:121
swap_channel_layouts_on_filter
static void swap_channel_layouts_on_filter(AVFilterContext *filter)
Definition: avfiltergraph.c:1003
graph_check_links
static int graph_check_links(AVFilterGraph *graph, void *log_ctx)
Definition: avfiltergraph.c:265
AVFilterCommand
Definition: avfilter_internal.h:126
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
FilterLinkInternal::status_in
int status_in
Link input status.
Definition: avfilter_internal.h:56
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
AV_CH_BACK_CENTER
#define AV_CH_BACK_CENTER
Definition: channel_layout.h:183
V
#define V
Definition: avfiltergraph.c:46
FilterLinkInternal::frame_wanted_out
int frame_wanted_out
True if a frame is currently wanted on the output of this filter.
Definition: avfilter_internal.h:75
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:601
filt
static const int8_t filt[NUMTAPS *2]
Definition: af_earwax.c:40
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:693
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:1097
ff_formats_check_color_ranges
int ff_formats_check_color_ranges(void *log, const AVFilterFormats *fmts)
Definition: formats.c:1134
AVFilter
Filter definition.
Definition: avfilter.h:211
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:463
FFFilterContext::ready
unsigned ready
Ready status of the filter.
Definition: avfilter_internal.h:111
ret
ret
Definition: filter_design.txt:187
AVFilterPad::type
enum AVMediaType type
AVFilterPad type.
Definition: filters.h:50
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:81
AVFilterNegotiation::conversion_opts_offset
unsigned conversion_opts_offset
Definition: formats.h:564
CH_SIDE_PAIR
#define CH_SIDE_PAIR
Definition: avfiltergraph.c:973
heap_bubble_down
static void heap_bubble_down(FFFilterGraph *graph, FilterLinkInternal *li, int index)
Definition: avfiltergraph.c:1398
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
FF_FILTER_FORMATS_QUERY_FUNC2
@ FF_FILTER_FORMATS_QUERY_FUNC2
formats.query_func2 active.
Definition: filters.h:230
formats_declared
static int formats_declared(AVFilterContext *f)
Definition: avfiltergraph.c:412
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:3720
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:865
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:101
av_channel_layout_index_from_channel
int av_channel_layout_index_from_channel(const AVChannelLayout *channel_layout, enum AVChannel channel)
Get the index of a given channel in a channel layout.
Definition: channel_layout.c:713
CH_WIDE_PAIR
#define CH_WIDE_PAIR
Definition: avfiltergraph.c:972
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
Underlying C type is int.
Definition: opt.h:259
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:442
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
FFFilterContext
Definition: avfilter_internal.h:95
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
KNOWN
#define KNOWN(l)
Definition: formats.h:111
FFFilterGraph::p
AVFilterGraph p
The public AVFilterGraph.
Definition: avfilter_internal.h:138
AVFilterContext
An instance of a filter.
Definition: avfilter.h:269
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:449
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:200
AVFilterChannelLayouts::nb_channel_layouts
int nb_channel_layouts
number of channel layouts
Definition: formats.h:87
mem.h
AVFilterFormatsConfig::formats
AVFilterFormats * formats
List of supported formats (pixel or sample).
Definition: avfilter.h:126
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:794
A
#define A
Definition: avfiltergraph.c:47
swap_samplerates_on_filter
static void swap_samplerates_on_filter(AVFilterContext *filter)
Definition: avfiltergraph.c:920
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVFilterGraph::max_buffered_frames
unsigned max_buffered_frames
Sets the maximum number of buffered frames in the filtergraph combined.
Definition: avfilter.h:639
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
AVChannelLayout::u
union AVChannelLayout::@471 u
Details about which channels are present in this layout.
imgutils.h
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:1317
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:585
AVFilterContext::filter
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:272
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
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:328
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:64
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
AV_SAMPLE_FMT_FLT
@ AV_SAMPLE_FMT_FLT
float
Definition: samplefmt.h:60
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:3361
AVFilterCommand::time
double time
time expressed in seconds
Definition: avfilter_internal.h:127