FFmpeg
ffmpeg_filter.c
Go to the documentation of this file.
1 /*
2  * ffmpeg filter configuration
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 
23 #include "ffmpeg.h"
24 
25 #include "libavfilter/avfilter.h"
26 #include "libavfilter/buffersink.h"
27 #include "libavfilter/buffersrc.h"
28 
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/bprint.h"
33 #include "libavutil/display.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/pixfmt.h"
37 #include "libavutil/imgutils.h"
38 #include "libavutil/samplefmt.h"
39 
40 // FIXME: YUV420P etc. are actually supported with full color range,
41 // yet the latter information isn't available here.
42 static const enum AVPixelFormat *get_compliance_normal_pix_fmts(const AVCodec *codec, const enum AVPixelFormat default_formats[])
43 {
44  static const enum AVPixelFormat mjpeg_formats[] =
47 
48  if (!strcmp(codec->name, "mjpeg")) {
49  return mjpeg_formats;
50  } else {
51  return default_formats;
52  }
53 }
54 
56  const AVCodec *codec, enum AVPixelFormat target)
57 {
58  if (codec && codec->pix_fmts) {
59  const enum AVPixelFormat *p = codec->pix_fmts;
61  //FIXME: This should check for AV_PIX_FMT_FLAG_ALPHA after PAL8 pixel format without alpha is implemented
62  int has_alpha = desc ? desc->nb_components % 2 == 0 : 0;
63  enum AVPixelFormat best= AV_PIX_FMT_NONE;
64 
66  p = get_compliance_normal_pix_fmts(codec, p);
67  }
68  for (; *p != AV_PIX_FMT_NONE; p++) {
69  best = av_find_best_pix_fmt_of_2(best, *p, target, has_alpha, NULL);
70  if (*p == target)
71  break;
72  }
73  if (*p == AV_PIX_FMT_NONE) {
74  if (target != AV_PIX_FMT_NONE)
76  "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
77  av_get_pix_fmt_name(target),
78  codec->name,
79  av_get_pix_fmt_name(best));
80  return best;
81  }
82  }
83  return target;
84 }
85 
86 static char *choose_pix_fmts(OutputFilter *ofilter)
87 {
88  OutputStream *ost = ofilter->ost;
89  AVDictionaryEntry *strict_dict = av_dict_get(ost->encoder_opts, "strict", NULL, 0);
90  if (strict_dict)
91  // used by choose_pixel_fmt() and below
92  av_opt_set(ost->enc_ctx, "strict", strict_dict->value, 0);
93 
94  if (ost->keep_pix_fmt) {
98  return NULL;
100  }
101  if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
103  } else if (ost->enc && ost->enc->pix_fmts) {
104  const enum AVPixelFormat *p;
105  AVIOContext *s = NULL;
106  uint8_t *ret;
107  int len;
108 
109  if (avio_open_dyn_buf(&s) < 0)
110  exit_program(1);
111 
112  p = ost->enc->pix_fmts;
115  }
116 
117  for (; *p != AV_PIX_FMT_NONE; p++) {
118  const char *name = av_get_pix_fmt_name(*p);
119  avio_printf(s, "%s|", name);
120  }
122  ret[len - 1] = 0;
123  return ret;
124  } else
125  return NULL;
126 }
127 
128 /* Define a function for appending a list of allowed formats
129  * to an AVBPrint. If nonempty, the list will have a header. */
130 #define DEF_CHOOSE_FORMAT(name, type, var, supported_list, none, printf_format, get_name) \
131 static void choose_ ## name (OutputFilter *ofilter, AVBPrint *bprint) \
132 { \
133  if (ofilter->var == none && !ofilter->supported_list) \
134  return; \
135  av_bprintf(bprint, #name "="); \
136  if (ofilter->var != none) { \
137  av_bprintf(bprint, printf_format, get_name(ofilter->var)); \
138  } else { \
139  const type *p; \
140  \
141  for (p = ofilter->supported_list; *p != none; p++) { \
142  av_bprintf(bprint, printf_format "|", get_name(*p)); \
143  } \
144  if (bprint->len > 0) \
145  bprint->str[--bprint->len] = '\0'; \
146  } \
147  av_bprint_chars(bprint, ':', 1); \
148 }
149 
150 //DEF_CHOOSE_FORMAT(pix_fmts, enum AVPixelFormat, format, formats, AV_PIX_FMT_NONE,
151 // GET_PIX_FMT_NAME)
152 
155 
157  "%d", )
158 
159 DEF_CHOOSE_FORMAT(channel_layouts, uint64_t, channel_layout, channel_layouts, 0,
160  "0x%"PRIx64, )
161 
163 {
164  FilterGraph *fg = av_mallocz(sizeof(*fg));
165 
166  if (!fg)
167  exit_program(1);
169 
170  GROW_ARRAY(fg->outputs, fg->nb_outputs);
171  if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
172  exit_program(1);
173  fg->outputs[0]->ost = ost;
174  fg->outputs[0]->graph = fg;
175  fg->outputs[0]->format = -1;
176 
177  ost->filter = fg->outputs[0];
178 
179  GROW_ARRAY(fg->inputs, fg->nb_inputs);
180  if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
181  exit_program(1);
182  fg->inputs[0]->ist = ist;
183  fg->inputs[0]->graph = fg;
184  fg->inputs[0]->format = -1;
185 
186  fg->inputs[0]->frame_queue = av_fifo_alloc(8 * sizeof(AVFrame*));
187  if (!fg->inputs[0]->frame_queue)
188  exit_program(1);
189 
190  GROW_ARRAY(ist->filters, ist->nb_filters);
191  ist->filters[ist->nb_filters - 1] = fg->inputs[0];
192 
195 
196  return 0;
197 }
198 
199 static char *describe_filter_link(FilterGraph *fg, AVFilterInOut *inout, int in)
200 {
201  AVFilterContext *ctx = inout->filter_ctx;
202  AVFilterPad *pads = in ? ctx->input_pads : ctx->output_pads;
203  int nb_pads = in ? ctx->nb_inputs : ctx->nb_outputs;
204  AVIOContext *pb;
205  uint8_t *res = NULL;
206 
207  if (avio_open_dyn_buf(&pb) < 0)
208  exit_program(1);
209 
210  avio_printf(pb, "%s", ctx->filter->name);
211  if (nb_pads > 1)
212  avio_printf(pb, ":%s", avfilter_pad_get_name(pads, inout->pad_idx));
213  avio_w8(pb, 0);
214  avio_close_dyn_buf(pb, &res);
215  return res;
216 }
217 
219 {
220  InputStream *ist = NULL;
222  int i;
223 
224  // TODO: support other filter types
226  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters supported "
227  "currently.\n");
228  exit_program(1);
229  }
230 
231  if (in->name) {
233  AVStream *st = NULL;
234  char *p;
235  int file_idx = strtol(in->name, &p, 0);
236 
237  if (file_idx < 0 || file_idx >= nb_input_files) {
238  av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
239  file_idx, fg->graph_desc);
240  exit_program(1);
241  }
242  s = input_files[file_idx]->ctx;
243 
244  for (i = 0; i < s->nb_streams; i++) {
245  enum AVMediaType stream_type = s->streams[i]->codecpar->codec_type;
246  if (stream_type != type &&
247  !(stream_type == AVMEDIA_TYPE_SUBTITLE &&
248  type == AVMEDIA_TYPE_VIDEO /* sub2video hack */))
249  continue;
250  if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
251  st = s->streams[i];
252  break;
253  }
254  }
255  if (!st) {
256  av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
257  "matches no streams.\n", p, fg->graph_desc);
258  exit_program(1);
259  }
260  ist = input_streams[input_files[file_idx]->ist_index + st->index];
261  if (ist->user_set_discard == AVDISCARD_ALL) {
262  av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
263  "matches a disabled input stream.\n", p, fg->graph_desc);
264  exit_program(1);
265  }
266  } else {
267  /* find the first unused stream of corresponding type */
268  for (i = 0; i < nb_input_streams; i++) {
269  ist = input_streams[i];
270  if (ist->user_set_discard == AVDISCARD_ALL)
271  continue;
272  if (ist->dec_ctx->codec_type == type && ist->discard)
273  break;
274  }
275  if (i == nb_input_streams) {
276  av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
277  "unlabeled input pad %d on filter %s\n", in->pad_idx,
278  in->filter_ctx->name);
279  exit_program(1);
280  }
281  }
282  av_assert0(ist);
283 
284  ist->discard = 0;
285  ist->decoding_needed |= DECODING_FOR_FILTER;
286  ist->st->discard = AVDISCARD_NONE;
287 
288  GROW_ARRAY(fg->inputs, fg->nb_inputs);
289  if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
290  exit_program(1);
291  fg->inputs[fg->nb_inputs - 1]->ist = ist;
292  fg->inputs[fg->nb_inputs - 1]->graph = fg;
293  fg->inputs[fg->nb_inputs - 1]->format = -1;
294  fg->inputs[fg->nb_inputs - 1]->type = ist->st->codecpar->codec_type;
295  fg->inputs[fg->nb_inputs - 1]->name = describe_filter_link(fg, in, 1);
296 
297  fg->inputs[fg->nb_inputs - 1]->frame_queue = av_fifo_alloc(8 * sizeof(AVFrame*));
298  if (!fg->inputs[fg->nb_inputs - 1]->frame_queue)
299  exit_program(1);
300 
301  GROW_ARRAY(ist->filters, ist->nb_filters);
302  ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
303 }
304 
306 {
307  AVFilterInOut *inputs, *outputs, *cur;
309  int ret = 0;
310 
311  /* this graph is only used for determining the kinds of inputs
312  * and outputs we have, and is discarded on exit from this function */
314  if (!graph)
315  return AVERROR(ENOMEM);
316  graph->nb_threads = 1;
317 
319  if (ret < 0)
320  goto fail;
321 
322  for (cur = inputs; cur; cur = cur->next)
323  init_input_filter(fg, cur);
324 
325  for (cur = outputs; cur;) {
326  GROW_ARRAY(fg->outputs, fg->nb_outputs);
327  fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]));
328  if (!fg->outputs[fg->nb_outputs - 1])
329  exit_program(1);
330 
331  fg->outputs[fg->nb_outputs - 1]->graph = fg;
332  fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
334  cur->pad_idx);
335  fg->outputs[fg->nb_outputs - 1]->name = describe_filter_link(fg, cur, 0);
336  cur = cur->next;
337  fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
338  }
339 
340 fail:
343  return ret;
344 }
345 
346 static int insert_trim(int64_t start_time, int64_t duration,
347  AVFilterContext **last_filter, int *pad_idx,
348  const char *filter_name)
349 {
350  AVFilterGraph *graph = (*last_filter)->graph;
352  const AVFilter *trim;
353  enum AVMediaType type = avfilter_pad_get_type((*last_filter)->output_pads, *pad_idx);
354  const char *name = (type == AVMEDIA_TYPE_VIDEO) ? "trim" : "atrim";
355  int ret = 0;
356 
357  if (duration == INT64_MAX && start_time == AV_NOPTS_VALUE)
358  return 0;
359 
360  trim = avfilter_get_by_name(name);
361  if (!trim) {
362  av_log(NULL, AV_LOG_ERROR, "%s filter not present, cannot limit "
363  "recording time.\n", name);
365  }
366 
367  ctx = avfilter_graph_alloc_filter(graph, trim, filter_name);
368  if (!ctx)
369  return AVERROR(ENOMEM);
370 
371  if (duration != INT64_MAX) {
372  ret = av_opt_set_int(ctx, "durationi", duration,
374  }
375  if (ret >= 0 && start_time != AV_NOPTS_VALUE) {
376  ret = av_opt_set_int(ctx, "starti", start_time,
378  }
379  if (ret < 0) {
380  av_log(ctx, AV_LOG_ERROR, "Error configuring the %s filter", name);
381  return ret;
382  }
383 
385  if (ret < 0)
386  return ret;
387 
388  ret = avfilter_link(*last_filter, *pad_idx, ctx, 0);
389  if (ret < 0)
390  return ret;
391 
392  *last_filter = ctx;
393  *pad_idx = 0;
394  return 0;
395 }
396 
397 static int insert_filter(AVFilterContext **last_filter, int *pad_idx,
398  const char *filter_name, const char *args)
399 {
400  AVFilterGraph *graph = (*last_filter)->graph;
402  int ret;
403 
405  avfilter_get_by_name(filter_name),
406  filter_name, args, NULL, graph);
407  if (ret < 0)
408  return ret;
409 
410  ret = avfilter_link(*last_filter, *pad_idx, ctx, 0);
411  if (ret < 0)
412  return ret;
413 
414  *last_filter = ctx;
415  *pad_idx = 0;
416  return 0;
417 }
418 
420 {
421  char *pix_fmts;
422  OutputStream *ost = ofilter->ost;
424  AVFilterContext *last_filter = out->filter_ctx;
425  int pad_idx = out->pad_idx;
426  int ret;
427  char name[255];
428 
429  snprintf(name, sizeof(name), "out_%d_%d", ost->file_index, ost->index);
431  avfilter_get_by_name("buffersink"),
432  name, NULL, NULL, fg->graph);
433 
434  if (ret < 0)
435  return ret;
436 
437  if ((ofilter->width || ofilter->height) && ofilter->ost->autoscale) {
438  char args[255];
440  AVDictionaryEntry *e = NULL;
441 
442  snprintf(args, sizeof(args), "%d:%d",
443  ofilter->width, ofilter->height);
444 
445  while ((e = av_dict_get(ost->sws_dict, "", e,
447  av_strlcatf(args, sizeof(args), ":%s=%s", e->key, e->value);
448  }
449 
450  snprintf(name, sizeof(name), "scaler_out_%d_%d",
451  ost->file_index, ost->index);
453  name, args, NULL, fg->graph)) < 0)
454  return ret;
455  if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
456  return ret;
457 
458  last_filter = filter;
459  pad_idx = 0;
460  }
461 
462  if ((pix_fmts = choose_pix_fmts(ofilter))) {
464 
466  avfilter_get_by_name("format"),
467  "format", pix_fmts, NULL, fg->graph);
468  av_freep(&pix_fmts);
469  if (ret < 0)
470  return ret;
471  if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
472  return ret;
473 
474  last_filter = filter;
475  pad_idx = 0;
476  }
477 
478  if (ost->frame_rate.num && 0) {
479  AVFilterContext *fps;
480  char args[255];
481 
482  snprintf(args, sizeof(args), "fps=%d/%d", ost->frame_rate.num,
483  ost->frame_rate.den);
484  snprintf(name, sizeof(name), "fps_out_%d_%d",
485  ost->file_index, ost->index);
487  name, args, NULL, fg->graph);
488  if (ret < 0)
489  return ret;
490 
491  ret = avfilter_link(last_filter, pad_idx, fps, 0);
492  if (ret < 0)
493  return ret;
494  last_filter = fps;
495  pad_idx = 0;
496  }
497 
498  snprintf(name, sizeof(name), "trim_out_%d_%d",
499  ost->file_index, ost->index);
501  &last_filter, &pad_idx, name);
502  if (ret < 0)
503  return ret;
504 
505 
506  if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
507  return ret;
508 
509  return 0;
510 }
511 
513 {
514  OutputStream *ost = ofilter->ost;
516  AVCodecContext *codec = ost->enc_ctx;
517  AVFilterContext *last_filter = out->filter_ctx;
518  int pad_idx = out->pad_idx;
519  AVBPrint args;
520  char name[255];
521  int ret;
522 
523  snprintf(name, sizeof(name), "out_%d_%d", ost->file_index, ost->index);
525  avfilter_get_by_name("abuffersink"),
526  name, NULL, NULL, fg->graph);
527  if (ret < 0)
528  return ret;
529  if ((ret = av_opt_set_int(ofilter->filter, "all_channel_counts", 1, AV_OPT_SEARCH_CHILDREN)) < 0)
530  return ret;
531 
532 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \
533  AVFilterContext *filt_ctx; \
534  \
535  av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
536  "similarly to -af " filter_name "=%s.\n", arg); \
537  \
538  ret = avfilter_graph_create_filter(&filt_ctx, \
539  avfilter_get_by_name(filter_name), \
540  filter_name, arg, NULL, fg->graph); \
541  if (ret < 0) \
542  goto fail; \
543  \
544  ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0); \
545  if (ret < 0) \
546  goto fail; \
547  \
548  last_filter = filt_ctx; \
549  pad_idx = 0; \
550 } while (0)
552  if (ost->audio_channels_mapped) {
553  int i;
554  av_bprintf(&args, "0x%"PRIx64,
556  for (i = 0; i < ost->audio_channels_mapped; i++)
557  if (ost->audio_channels_map[i] != -1)
558  av_bprintf(&args, "|c%d=c%d", i, ost->audio_channels_map[i]);
559 
560  AUTO_INSERT_FILTER("-map_channel", "pan", args.str);
561  av_bprint_clear(&args);
562  }
563 
564  if (codec->channels && !codec->channel_layout)
566 
567  choose_sample_fmts(ofilter, &args);
568  choose_sample_rates(ofilter, &args);
569  choose_channel_layouts(ofilter, &args);
570  if (!av_bprint_is_complete(&args)) {
571  ret = AVERROR(ENOMEM);
572  goto fail;
573  }
574  if (args.len) {
576 
577  snprintf(name, sizeof(name), "format_out_%d_%d",
578  ost->file_index, ost->index);
580  avfilter_get_by_name("aformat"),
581  name, args.str, NULL, fg->graph);
582  if (ret < 0)
583  goto fail;
584 
585  ret = avfilter_link(last_filter, pad_idx, format, 0);
586  if (ret < 0)
587  goto fail;
588 
589  last_filter = format;
590  pad_idx = 0;
591  }
592 
593  if (ost->apad && of->shortest) {
594  int i;
595 
596  for (i=0; i<of->ctx->nb_streams; i++)
598  break;
599 
600  if (i<of->ctx->nb_streams) {
601  AUTO_INSERT_FILTER("-apad", "apad", ost->apad);
602  }
603  }
604 
605  snprintf(name, sizeof(name), "trim for output stream %d:%d",
606  ost->file_index, ost->index);
608  &last_filter, &pad_idx, name);
609  if (ret < 0)
610  goto fail;
611 
612  if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
613  goto fail;
614 fail:
615  av_bprint_finalize(&args, NULL);
616 
617  return ret;
618 }
619 
622 {
623  if (!ofilter->ost) {
624  av_log(NULL, AV_LOG_FATAL, "Filter %s has an unconnected output\n", ofilter->name);
625  exit_program(1);
626  }
627 
628  switch (avfilter_pad_get_type(out->filter_ctx->output_pads, out->pad_idx)) {
629  case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
630  case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
631  default: av_assert0(0);
632  }
633 }
634 
636 {
637  int i;
638  for (i = 0; i < nb_filtergraphs; i++) {
639  int n;
640  for (n = 0; n < filtergraphs[i]->nb_outputs; n++) {
641  OutputFilter *output = filtergraphs[i]->outputs[n];
642  if (!output->ost) {
643  av_log(NULL, AV_LOG_FATAL, "Filter %s has an unconnected output\n", output->name);
644  exit_program(1);
645  }
646  }
647  }
648 }
649 
651 {
652  AVFormatContext *avf = input_files[ist->file_index]->ctx;
653  int i, w, h;
654 
655  /* Compute the size of the canvas for the subtitles stream.
656  If the subtitles codecpar has set a size, use it. Otherwise use the
657  maximum dimensions of the video streams in the same file. */
658  w = ifilter->width;
659  h = ifilter->height;
660  if (!(w && h)) {
661  for (i = 0; i < avf->nb_streams; i++) {
663  w = FFMAX(w, avf->streams[i]->codecpar->width);
664  h = FFMAX(h, avf->streams[i]->codecpar->height);
665  }
666  }
667  if (!(w && h)) {
668  w = FFMAX(w, 720);
669  h = FFMAX(h, 576);
670  }
671  av_log(avf, AV_LOG_INFO, "sub2video: using %dx%d canvas\n", w, h);
672  }
673  ist->sub2video.w = ifilter->width = w;
674  ist->sub2video.h = ifilter->height = h;
675 
676  ifilter->width = ist->dec_ctx->width ? ist->dec_ctx->width : ist->sub2video.w;
677  ifilter->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
678 
679  /* rectangles are AV_PIX_FMT_PAL8, but we have no guarantee that the
680  palettes for all rectangles are identical or compatible */
681  ifilter->format = AV_PIX_FMT_RGB32;
682 
683  ist->sub2video.frame = av_frame_alloc();
684  if (!ist->sub2video.frame)
685  return AVERROR(ENOMEM);
686  ist->sub2video.last_pts = INT64_MIN;
687  ist->sub2video.end_pts = INT64_MIN;
688 
689  /* sub2video structure has been (re-)initialized.
690  Mark it as such so that the system will be
691  initialized with the first received heartbeat. */
692  ist->sub2video.initialize = 1;
693 
694  return 0;
695 }
696 
698  AVFilterInOut *in)
699 {
700  AVFilterContext *last_filter;
701  const AVFilter *buffer_filt = avfilter_get_by_name("buffer");
702  InputStream *ist = ifilter->ist;
703  InputFile *f = input_files[ist->file_index];
704  AVRational tb = ist->framerate.num ? av_inv_q(ist->framerate) :
705  ist->st->time_base;
706  AVRational fr = ist->framerate;
707  AVRational sar;
708  AVBPrint args;
709  char name[255];
710  int ret, pad_idx = 0;
711  int64_t tsoffset = 0;
713 
714  if (!par)
715  return AVERROR(ENOMEM);
716  memset(par, 0, sizeof(*par));
717  par->format = AV_PIX_FMT_NONE;
718 
719  if (ist->dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
720  av_log(NULL, AV_LOG_ERROR, "Cannot connect video filter to audio input\n");
721  ret = AVERROR(EINVAL);
722  goto fail;
723  }
724 
725  if (!fr.num)
726  fr = av_guess_frame_rate(input_files[ist->file_index]->ctx, ist->st, NULL);
727 
728  if (ist->dec_ctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
729  ret = sub2video_prepare(ist, ifilter);
730  if (ret < 0)
731  goto fail;
732  }
733 
734  sar = ifilter->sample_aspect_ratio;
735  if(!sar.den)
736  sar = (AVRational){0,1};
738  av_bprintf(&args,
739  "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:"
740  "pixel_aspect=%d/%d",
741  ifilter->width, ifilter->height, ifilter->format,
742  tb.num, tb.den, sar.num, sar.den);
743  if (fr.num && fr.den)
744  av_bprintf(&args, ":frame_rate=%d/%d", fr.num, fr.den);
745  snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
746  ist->file_index, ist->st->index);
747 
748 
749  if ((ret = avfilter_graph_create_filter(&ifilter->filter, buffer_filt, name,
750  args.str, NULL, fg->graph)) < 0)
751  goto fail;
752  par->hw_frames_ctx = ifilter->hw_frames_ctx;
753  ret = av_buffersrc_parameters_set(ifilter->filter, par);
754  if (ret < 0)
755  goto fail;
756  av_freep(&par);
757  last_filter = ifilter->filter;
758 
759  if (ist->autorotate) {
760  double theta = get_rotation(ist->st);
761 
762  if (fabs(theta - 90) < 1.0) {
763  ret = insert_filter(&last_filter, &pad_idx, "transpose", "clock");
764  } else if (fabs(theta - 180) < 1.0) {
765  ret = insert_filter(&last_filter, &pad_idx, "hflip", NULL);
766  if (ret < 0)
767  return ret;
768  ret = insert_filter(&last_filter, &pad_idx, "vflip", NULL);
769  } else if (fabs(theta - 270) < 1.0) {
770  ret = insert_filter(&last_filter, &pad_idx, "transpose", "cclock");
771  } else if (fabs(theta) > 1.0) {
772  char rotate_buf[64];
773  snprintf(rotate_buf, sizeof(rotate_buf), "%f*PI/180", theta);
774  ret = insert_filter(&last_filter, &pad_idx, "rotate", rotate_buf);
775  }
776  if (ret < 0)
777  return ret;
778  }
779 
780  if (do_deinterlace) {
781  AVFilterContext *yadif;
782 
783  snprintf(name, sizeof(name), "deinterlace_in_%d_%d",
784  ist->file_index, ist->st->index);
785  if ((ret = avfilter_graph_create_filter(&yadif,
786  avfilter_get_by_name("yadif"),
787  name, "", NULL,
788  fg->graph)) < 0)
789  return ret;
790 
791  if ((ret = avfilter_link(last_filter, 0, yadif, 0)) < 0)
792  return ret;
793 
794  last_filter = yadif;
795  }
796 
797  snprintf(name, sizeof(name), "trim_in_%d_%d",
798  ist->file_index, ist->st->index);
799  if (copy_ts) {
800  tsoffset = f->start_time == AV_NOPTS_VALUE ? 0 : f->start_time;
801  if (!start_at_zero && f->ctx->start_time != AV_NOPTS_VALUE)
802  tsoffset += f->ctx->start_time;
803  }
804  ret = insert_trim(((f->start_time == AV_NOPTS_VALUE) || !f->accurate_seek) ?
805  AV_NOPTS_VALUE : tsoffset, f->recording_time,
806  &last_filter, &pad_idx, name);
807  if (ret < 0)
808  return ret;
809 
810  if ((ret = avfilter_link(last_filter, 0, in->filter_ctx, in->pad_idx)) < 0)
811  return ret;
812  return 0;
813 fail:
814  av_freep(&par);
815 
816  return ret;
817 }
818 
820  AVFilterInOut *in)
821 {
822  AVFilterContext *last_filter;
823  const AVFilter *abuffer_filt = avfilter_get_by_name("abuffer");
824  InputStream *ist = ifilter->ist;
825  InputFile *f = input_files[ist->file_index];
826  AVBPrint args;
827  char name[255];
828  int ret, pad_idx = 0;
829  int64_t tsoffset = 0;
830 
831  if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_AUDIO) {
832  av_log(NULL, AV_LOG_ERROR, "Cannot connect audio filter to non audio input\n");
833  return AVERROR(EINVAL);
834  }
835 
837  av_bprintf(&args, "time_base=%d/%d:sample_rate=%d:sample_fmt=%s",
838  1, ifilter->sample_rate,
839  ifilter->sample_rate,
840  av_get_sample_fmt_name(ifilter->format));
841  if (ifilter->channel_layout)
842  av_bprintf(&args, ":channel_layout=0x%"PRIx64,
843  ifilter->channel_layout);
844  else
845  av_bprintf(&args, ":channels=%d", ifilter->channels);
846  snprintf(name, sizeof(name), "graph_%d_in_%d_%d", fg->index,
847  ist->file_index, ist->st->index);
848 
849  if ((ret = avfilter_graph_create_filter(&ifilter->filter, abuffer_filt,
850  name, args.str, NULL,
851  fg->graph)) < 0)
852  return ret;
853  last_filter = ifilter->filter;
854 
855 #define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do { \
856  AVFilterContext *filt_ctx; \
857  \
858  av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
859  "similarly to -af " filter_name "=%s.\n", arg); \
860  \
861  snprintf(name, sizeof(name), "graph_%d_%s_in_%d_%d", \
862  fg->index, filter_name, ist->file_index, ist->st->index); \
863  ret = avfilter_graph_create_filter(&filt_ctx, \
864  avfilter_get_by_name(filter_name), \
865  name, arg, NULL, fg->graph); \
866  if (ret < 0) \
867  return ret; \
868  \
869  ret = avfilter_link(last_filter, 0, filt_ctx, 0); \
870  if (ret < 0) \
871  return ret; \
872  \
873  last_filter = filt_ctx; \
874 } while (0)
875 
876  if (audio_sync_method > 0) {
877  char args[256] = {0};
878 
879  av_strlcatf(args, sizeof(args), "async=%d", audio_sync_method);
880  if (audio_drift_threshold != 0.1)
881  av_strlcatf(args, sizeof(args), ":min_hard_comp=%f", audio_drift_threshold);
882  if (!fg->reconfiguration)
883  av_strlcatf(args, sizeof(args), ":first_pts=0");
884  AUTO_INSERT_FILTER_INPUT("-async", "aresample", args);
885  }
886 
887 // if (ost->audio_channels_mapped) {
888 // int i;
889 // AVBPrint pan_buf;
890 // av_bprint_init(&pan_buf, 256, 8192);
891 // av_bprintf(&pan_buf, "0x%"PRIx64,
892 // av_get_default_channel_layout(ost->audio_channels_mapped));
893 // for (i = 0; i < ost->audio_channels_mapped; i++)
894 // if (ost->audio_channels_map[i] != -1)
895 // av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
896 // AUTO_INSERT_FILTER_INPUT("-map_channel", "pan", pan_buf.str);
897 // av_bprint_finalize(&pan_buf, NULL);
898 // }
899 
900  if (audio_volume != 256) {
901  char args[256];
902 
903  av_log(NULL, AV_LOG_WARNING, "-vol has been deprecated. Use the volume "
904  "audio filter instead.\n");
905 
906  snprintf(args, sizeof(args), "%f", audio_volume / 256.);
907  AUTO_INSERT_FILTER_INPUT("-vol", "volume", args);
908  }
909 
910  snprintf(name, sizeof(name), "trim for input stream %d:%d",
911  ist->file_index, ist->st->index);
912  if (copy_ts) {
913  tsoffset = f->start_time == AV_NOPTS_VALUE ? 0 : f->start_time;
914  if (!start_at_zero && f->ctx->start_time != AV_NOPTS_VALUE)
915  tsoffset += f->ctx->start_time;
916  }
917  ret = insert_trim(((f->start_time == AV_NOPTS_VALUE) || !f->accurate_seek) ?
918  AV_NOPTS_VALUE : tsoffset, f->recording_time,
919  &last_filter, &pad_idx, name);
920  if (ret < 0)
921  return ret;
922 
923  if ((ret = avfilter_link(last_filter, 0, in->filter_ctx, in->pad_idx)) < 0)
924  return ret;
925 
926  return 0;
927 }
928 
930  AVFilterInOut *in)
931 {
932  if (!ifilter->ist->dec) {
934  "No decoder for stream #%d:%d, filtering impossible\n",
935  ifilter->ist->file_index, ifilter->ist->st->index);
937  }
938  switch (avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx)) {
939  case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, ifilter, in);
940  case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, ifilter, in);
941  default: av_assert0(0);
942  }
943 }
944 
946 {
947  int i;
948  for (i = 0; i < fg->nb_outputs; i++)
949  fg->outputs[i]->filter = (AVFilterContext *)NULL;
950  for (i = 0; i < fg->nb_inputs; i++)
951  fg->inputs[i]->filter = (AVFilterContext *)NULL;
953 }
954 
956 {
957  AVFilterInOut *inputs, *outputs, *cur;
958  int ret, i, simple = filtergraph_is_simple(fg);
959  const char *graph_desc = simple ? fg->outputs[0]->ost->avfilter :
960  fg->graph_desc;
961 
963  if (!(fg->graph = avfilter_graph_alloc()))
964  return AVERROR(ENOMEM);
965 
966  if (simple) {
967  OutputStream *ost = fg->outputs[0]->ost;
968  char args[512];
969  AVDictionaryEntry *e = NULL;
970 
972 
973  args[0] = 0;
974  while ((e = av_dict_get(ost->sws_dict, "", e,
976  av_strlcatf(args, sizeof(args), "%s=%s:", e->key, e->value);
977  }
978  if (strlen(args))
979  args[strlen(args)-1] = 0;
980  fg->graph->scale_sws_opts = av_strdup(args);
981 
982  args[0] = 0;
983  while ((e = av_dict_get(ost->swr_opts, "", e,
985  av_strlcatf(args, sizeof(args), "%s=%s:", e->key, e->value);
986  }
987  if (strlen(args))
988  args[strlen(args)-1] = 0;
989  av_opt_set(fg->graph, "aresample_swr_opts", args, 0);
990 
991  args[0] = '\0';
992  while ((e = av_dict_get(fg->outputs[0]->ost->resample_opts, "", e,
994  av_strlcatf(args, sizeof(args), "%s=%s:", e->key, e->value);
995  }
996  if (strlen(args))
997  args[strlen(args) - 1] = '\0';
998 
999  e = av_dict_get(ost->encoder_opts, "threads", NULL, 0);
1000  if (e)
1001  av_opt_set(fg->graph, "threads", e->value, 0);
1002  } else {
1004  }
1005 
1006  if ((ret = avfilter_graph_parse2(fg->graph, graph_desc, &inputs, &outputs)) < 0)
1007  goto fail;
1008 
1010  if (ret < 0)
1011  goto fail;
1012 
1013  if (simple && (!inputs || inputs->next || !outputs || outputs->next)) {
1014  const char *num_inputs;
1015  const char *num_outputs;
1016  if (!outputs) {
1017  num_outputs = "0";
1018  } else if (outputs->next) {
1019  num_outputs = ">1";
1020  } else {
1021  num_outputs = "1";
1022  }
1023  if (!inputs) {
1024  num_inputs = "0";
1025  } else if (inputs->next) {
1026  num_inputs = ">1";
1027  } else {
1028  num_inputs = "1";
1029  }
1030  av_log(NULL, AV_LOG_ERROR, "Simple filtergraph '%s' was expected "
1031  "to have exactly 1 input and 1 output."
1032  " However, it had %s input(s) and %s output(s)."
1033  " Please adjust, or use a complex filtergraph (-filter_complex) instead.\n",
1034  graph_desc, num_inputs, num_outputs);
1035  ret = AVERROR(EINVAL);
1036  goto fail;
1037  }
1038 
1039  for (cur = inputs, i = 0; cur; cur = cur->next, i++)
1040  if ((ret = configure_input_filter(fg, fg->inputs[i], cur)) < 0) {
1043  goto fail;
1044  }
1046 
1047  for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1048  configure_output_filter(fg, fg->outputs[i], cur);
1050 
1053  if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1054  goto fail;
1055 
1056  /* limit the lists of allowed formats to the ones selected, to
1057  * make sure they stay the same if the filtergraph is reconfigured later */
1058  for (i = 0; i < fg->nb_outputs; i++) {
1059  OutputFilter *ofilter = fg->outputs[i];
1060  AVFilterContext *sink = ofilter->filter;
1061 
1062  ofilter->format = av_buffersink_get_format(sink);
1063 
1064  ofilter->width = av_buffersink_get_w(sink);
1065  ofilter->height = av_buffersink_get_h(sink);
1066 
1067  ofilter->sample_rate = av_buffersink_get_sample_rate(sink);
1069  }
1070 
1071  fg->reconfiguration = 1;
1072 
1073  for (i = 0; i < fg->nb_outputs; i++) {
1074  OutputStream *ost = fg->outputs[i]->ost;
1075  if (!ost->enc) {
1076  /* identical to the same check in ffmpeg.c, needed because
1077  complex filter graphs are initialized earlier */
1078  av_log(NULL, AV_LOG_ERROR, "Encoder (codec %s) not found for output stream #%d:%d\n",
1080  ret = AVERROR(EINVAL);
1081  goto fail;
1082  }
1083  if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
1084  !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
1086  ost->enc_ctx->frame_size);
1087  }
1088 
1089  for (i = 0; i < fg->nb_inputs; i++) {
1090  while (av_fifo_size(fg->inputs[i]->frame_queue)) {
1091  AVFrame *tmp;
1092  av_fifo_generic_read(fg->inputs[i]->frame_queue, &tmp, sizeof(tmp), NULL);
1094  av_frame_free(&tmp);
1095  if (ret < 0)
1096  goto fail;
1097  }
1098  }
1099 
1100  /* send the EOFs for the finished inputs */
1101  for (i = 0; i < fg->nb_inputs; i++) {
1102  if (fg->inputs[i]->eof) {
1104  if (ret < 0)
1105  goto fail;
1106  }
1107  }
1108 
1109  /* process queued up subtitle packets */
1110  for (i = 0; i < fg->nb_inputs; i++) {
1111  InputStream *ist = fg->inputs[i]->ist;
1112  if (ist->sub2video.sub_queue && ist->sub2video.frame) {
1113  while (av_fifo_size(ist->sub2video.sub_queue)) {
1114  AVSubtitle tmp;
1115  av_fifo_generic_read(ist->sub2video.sub_queue, &tmp, sizeof(tmp), NULL);
1116  sub2video_update(ist, INT64_MIN, &tmp);
1117  avsubtitle_free(&tmp);
1118  }
1119  }
1120  }
1121 
1122  return 0;
1123 
1124 fail:
1125  cleanup_filtergraph(fg);
1126  return ret;
1127 }
1128 
1130 {
1131  av_buffer_unref(&ifilter->hw_frames_ctx);
1132 
1133  ifilter->format = frame->format;
1134 
1135  ifilter->width = frame->width;
1136  ifilter->height = frame->height;
1137  ifilter->sample_aspect_ratio = frame->sample_aspect_ratio;
1138 
1139  ifilter->sample_rate = frame->sample_rate;
1140  ifilter->channels = frame->channels;
1141  ifilter->channel_layout = frame->channel_layout;
1142 
1143  if (frame->hw_frames_ctx) {
1144  ifilter->hw_frames_ctx = av_buffer_ref(frame->hw_frames_ctx);
1145  if (!ifilter->hw_frames_ctx)
1146  return AVERROR(ENOMEM);
1147  }
1148 
1149  return 0;
1150 }
1151 
1153 {
1154  return !fg->graph_desc;
1155 }
AVSubtitle
Definition: avcodec.h:2276
formats
formats
Definition: signature.h:48
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1001
init_complex_filtergraph
int init_complex_filtergraph(FilterGraph *fg)
Definition: ffmpeg_filter.c:305
InputFilter::sample_aspect_ratio
AVRational sample_aspect_ratio
Definition: ffmpeg.h:253
AVCodec
AVCodec.
Definition: codec.h:197
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:187
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
audio_sync_method
int audio_sync_method
Definition: ffmpeg_opt.c:155
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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
OutputFilter::graph
struct FilterGraph * graph
Definition: ffmpeg.h:267
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
nb_input_files
int nb_input_files
Definition: ffmpeg.c:151
opt.h
OutputStream::enc
AVCodecContext * enc
Definition: muxing.c:56
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVFilterGraph::nb_threads
int nb_threads
Maximum number of threads used by filters in this graph.
Definition: avfilter.h:824
avfilter_pad_get_name
const char * avfilter_pad_get_name(const AVFilterPad *pads, int pad_idx)
Get the name of an AVFilterPad.
Definition: avfilter.c:932
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1032
InputFilter::width
int width
Definition: ffmpeg.h:252
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
out
FILE * out
Definition: movenc.c:54
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
FilterGraph::graph_desc
const char * graph_desc
Definition: ffmpeg.h:289
OutputStream::enc_ctx
AVCodecContext * enc_ctx
Definition: ffmpeg.h:475
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:953
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2541
FilterGraph::inputs
InputFilter ** inputs
Definition: ffmpeg.h:294
output
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 output
Definition: filter_design.txt:225
OutputStream::keep_pix_fmt
int keep_pix_fmt
Definition: ffmpeg.h:541
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:218
graph
fg outputs[0] graph
Definition: ffmpeg_filter.c:174
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
OutputFile::start_time
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:581
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
AVFilterInOut::next
struct AVFilterInOut * next
next input/input in the list, NULL if this is the last
Definition: avfilter.h:969
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1165
w
uint8_t w
Definition: llviddspenc.c:39
OutputStream::index
int index
Definition: ffmpeg.h:455
av_buffersrc_add_frame
int attribute_align_arg av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame)
Add a frame to the buffer source.
Definition: buffersrc.c:147
FilterGraph::index
int index
Definition: ffmpeg.h:288
check_filter_outputs
void check_filter_outputs(void)
Definition: ffmpeg_filter.c:635
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:70
OutputStream::sws_dict
AVDictionary * sws_dict
Definition: ffmpeg.h:521
ffmpeg.h
FilterGraph::nb_inputs
int nb_inputs
Definition: ffmpeg.h:295
AVFilterContext::output_pads
AVFilterPad * output_pads
array of output pads
Definition: avfilter.h:344
av_fifo_generic_read
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
av_strlcatf
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
Definition: avstring.c:101
sample_rate
sample_rate
Definition: ffmpeg_filter.c:156
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: avcodec.h:1273
avfilter_graph_free
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
Definition: avfiltergraph.c:120
InputFilter::channel_layout
uint64_t channel_layout
Definition: ffmpeg.h:257
InputFilter::ist
struct InputStream * ist
Definition: ffmpeg.h:242
init_simple_filtergraph
int init_simple_filtergraph(InputStream *ist, OutputStream *ost)
configure_filtergraph
int configure_filtergraph(FilterGraph *fg)
Definition: ffmpeg_filter.c:955
AUTO_INSERT_FILTER
#define AUTO_INSERT_FILTER(opt_name, filter_name, arg)
exit_program
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:132
InputStream
Definition: ffmpeg.h:300
do_deinterlace
int do_deinterlace
Definition: ffmpeg_opt.c:158
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:139
av_buffersink_set_frame_size
void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size)
Set the frame size for an audio buffer sink.
Definition: buffersink.c:198
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:134
InputFilter::type
enum AVMediaType type
Definition: ffmpeg.h:245
avfilter_graph_alloc
AVFilterGraph * avfilter_graph_alloc(void)
Allocate a filter graph.
Definition: avfiltergraph.c:83
samplefmt.h
AVDISCARD_NONE
@ AVDISCARD_NONE
discard nothing
Definition: defs.h:48
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
OutputFilter::sample_rate
int sample_rate
Definition: ffmpeg.h:278
type
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 type
Definition: writing_filters.txt:86
InputFilter::frame_queue
AVFifoBuffer * frame_queue
Definition: ffmpeg.h:247
ist
fg inputs[0] ist
Definition: ffmpeg_filter.c:182
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:465
AVRational::num
int num
Numerator.
Definition: rational.h:59
InputFile
Definition: ffmpeg.h:401
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:54
avsubtitle_free
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: avcodec.c:427
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:98
avio_close_dyn_buf
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1407
AVFilterContext::input_pads
AVFilterPad * input_pads
array of input pads
Definition: avfilter.h:340
check_stream_specifier
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:2083
OutputFile::shortest
int shortest
Definition: ffmpeg.h:584
avfilter_inout_free
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:212
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
inputs
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
Definition: filter_design.txt:243
duration
int64_t duration
Definition: movenc.c:64
avio_open_dyn_buf
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1362
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
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:79
OutputFilter::width
int width
Definition: ffmpeg.h:275
input_streams
InputStream ** input_streams
Definition: ffmpeg.c:148
s
#define s(width, name)
Definition: cbs_vp9.c:257
FilterGraph::outputs
OutputFilter ** outputs
Definition: ffmpeg.h:296
configure_input_audio_filter
static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
Definition: ffmpeg_filter.c:819
AVDictionaryEntry::key
char * key
Definition: dict.h:82
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
OutputStream::audio_channels_mapped
int audio_channels_mapped
Definition: ffmpeg.h:510
InputFilter
Definition: ffmpeg.h:240
av_buffersink_get_format
int av_buffersink_get_format(const AVFilterContext *ctx)
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
outputs
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
OutputFilter::ost
struct OutputStream * ost
Definition: ffmpeg.h:266
OutputStream::avfilter
char * avfilter
Definition: ffmpeg.h:516
ctx
AVFormatContext * ctx
Definition: movenc.c:48
audio_drift_threshold
float audio_drift_threshold
Definition: ffmpeg_opt.c:150
InputFilter::graph
struct FilterGraph * graph
Definition: ffmpeg.h:243
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:49
f
#define f(width, name)
Definition: cbs_vp9.c:255
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:80
OutputStream::encoder_opts
AVDictionary * encoder_opts
Definition: ffmpeg.h:520
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1097
avfilter_get_by_name
const AVFilter * avfilter_get_by_name(const char *name)
Get a filter definition matching the given name.
Definition: allfilters.c:547
OutputFilter::height
int height
Definition: ffmpeg.h:275
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:984
OutputFilter::name
uint8_t * name
Definition: ffmpeg.h:268
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
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:1215
NULL
#define NULL
Definition: coverity.c:32
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:125
InputStream::st
AVStream * st
Definition: ffmpeg.h:302
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
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
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:78
AVFilterContext::name
char * name
name of this filter instance
Definition: avfilter.h:338
OutputStream::audio_channels_map
int * audio_channels_map
Definition: ffmpeg.h:509
InputFilter::channels
int channels
Definition: ffmpeg.h:256
OutputStream::frame_rate
AVRational frame_rate
Definition: ffmpeg.h:488
OutputStream::resample_opts
AVDictionary * resample_opts
Definition: ffmpeg.h:523
InputFilter::eof
int eof
Definition: ffmpeg.h:261
AV_CODEC_CAP_VARIABLE_FRAME_SIZE
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: codec.h:129
OutputFilter::channel_layout
uint64_t channel_layout
Definition: ffmpeg.h:279
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:193
AVFilterGraph
Definition: avfilter.h:798
nb_input_streams
int nb_input_streams
Definition: ffmpeg.c:149
avfilter_graph_parse2
int avfilter_graph_parse2(AVFilterGraph *graph, const char *filters, AVFilterInOut **inputs, AVFilterInOut **outputs)
Add a graph described by a string to a graph.
Definition: graphparser.c:418
av_buffersink_get_channel_layout
uint64_t av_buffersink_get_channel_layout(const AVFilterContext *ctx)
FilterGraph::nb_outputs
int nb_outputs
Definition: ffmpeg.h:297
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:586
input_files
InputFile ** input_files
Definition: ffmpeg.c:150
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
FilterGraph
Definition: ffmpeg.h:287
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1153
InputFilter::filter
AVFilterContext * filter
Definition: ffmpeg.h:241
AVFilterInOut::pad_idx
int pad_idx
index of the filt_ctx pad to use for linking
Definition: avfilter.h:966
AVFilterGraph::scale_sws_opts
char * scale_sws_opts
sws options to use for the auto-inserted scale filters
Definition: avfilter.h:803
OutputStream::filter
OutputFilter * filter
Definition: ffmpeg.h:515
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
AVMediaType
AVMediaType
Definition: avutil.h:199
av_buffersrc_parameters_alloc
AVBufferSrcParameters * av_buffersrc_parameters_alloc(void)
Allocate a new AVBufferSrcParameters instance.
Definition: buffersrc.c:87
InputStream::file_index
int file_index
Definition: ffmpeg.h:301
AVFilterInOut::filter_ctx
AVFilterContext * filter_ctx
filter context associated to this input/output
Definition: avfilter.h:963
output_files
OutputFile ** output_files
Definition: ffmpeg.c:155
avfilter_link
int avfilter_link(AVFilterContext *src, unsigned srcpad, AVFilterContext *dst, unsigned dstpad)
Link two filters together.
Definition: avfilter.c:135
AVBufferSrcParameters::hw_frames_ctx
AVBufferRef * hw_frames_ctx
Video with a hwaccel pixel format only.
Definition: buffersrc.h:106
start_time
static int64_t start_time
Definition: ffplay.c:332
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
FilterGraph::graph
AVFilterGraph * graph
Definition: ffmpeg.h:291
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
GROW_ARRAY
GROW_ARRAY(fg->outputs, fg->nb_outputs)
insert_trim
static int insert_trim(int64_t start_time, int64_t duration, AVFilterContext **last_filter, int *pad_idx, const char *filter_name)
Definition: ffmpeg_filter.c:346
copy_ts
int copy_ts
Definition: ffmpeg_opt.c:163
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
av_guess_frame_rate
AVRational av_guess_frame_rate(AVFormatContext *ctx, AVStream *stream, AVFrame *frame)
Guess the frame rate, based on both the container and codec information.
Definition: utils.c:4993
sub2video_update
void sub2video_update(InputStream *ist, int64_t heartbeat_pts, AVSubtitle *sub)
Definition: ffmpeg.c:241
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:560
OutputFilter::filter
AVFilterContext * filter
Definition: ffmpeg.h:265
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:362
OutputFilter::type
enum AVMediaType type
Definition: ffmpeg.h:272
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:192
sample_rates
sample_rates
Definition: ffmpeg_filter.c:156
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:982
avfilter_init_str
int avfilter_init_str(AVFilterContext *filter, const char *args)
Initialize a filter with the supplied parameters.
Definition: avfilter.c:898
buffersink.h
choose_pixel_fmt
static enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodecContext *enc_ctx, const AVCodec *codec, enum AVPixelFormat target)
Definition: ffmpeg_filter.c:55
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:448
ifilter_parameters_from_frame
int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame)
Definition: ffmpeg_filter.c:1129
av_buffersink_get_w
int av_buffersink_get_w(const AVFilterContext *ctx)
OutputStream::apad
char * apad
Definition: ffmpeg.h:524
bprint.h
av_buffersrc_parameters_set
int av_buffersrc_parameters_set(AVFilterContext *ctx, AVBufferSrcParameters *param)
Initialize the buffersrc or abuffersrc filter with the provided parameters.
Definition: buffersrc.c:98
i
int i
Definition: input.c:407
DECODING_FOR_FILTER
#define DECODING_FOR_FILTER
Definition: ffmpeg.h:307
configure_input_filter
static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
Definition: ffmpeg_filter.c:929
configure_output_filter
static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
Definition: ffmpeg_filter.c:620
AVCodecParameters::height
int height
Definition: codec_par.h:127
display.h
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
hw_device_setup_for_filter
int hw_device_setup_for_filter(FilterGraph *fg)
Definition: ffmpeg_hw.c:525
InputFile::ctx
AVFormatContext * ctx
Definition: ffmpeg.h:402
tb
#define tb
Definition: regdef.h:68
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:244
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
len
int len
Definition: vorbis_enc_data.h:426
init_input_filter
static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
Definition: ffmpeg_filter.c:218
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:594
av_buffersink_get_h
int av_buffersink_get_h(const AVFilterContext *ctx)
AVFilter
Filter definition.
Definition: avfilter.h:145
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:837
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:175
pixfmt.h
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
InputFilter::name
uint8_t * name
Definition: ffmpeg.h:244
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1269
insert_filter
static int insert_filter(AVFilterContext **last_filter, int *pad_idx, const char *filter_name, const char *args)
Definition: ffmpeg_filter.c:397
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
InputFile::ist_index
int ist_index
Definition: ffmpeg.h:405
ost
OutputStream * ost
Definition: ffmpeg_filter.c:163
get_compliance_normal_pix_fmts
static enum AVPixelFormat * get_compliance_normal_pix_fmts(const AVCodec *codec, const enum AVPixelFormat default_formats[])
Definition: ffmpeg_filter.c:42
InputFilter::sample_rate
int sample_rate
Definition: ffmpeg.h:255
avfilter_pad_get_type
enum AVMediaType avfilter_pad_get_type(const AVFilterPad *pads, int pad_idx)
Get the type of an AVFilterPad.
Definition: avfilter.c:937
avio_printf
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
OutputFilter::format
int format
Definition: ffmpeg.h:277
configure_input_video_filter
static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter, AVFilterInOut *in)
Definition: ffmpeg_filter.c:697
AVCodecContext
main external API structure.
Definition: avcodec.h:384
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:838
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:227
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:2832
choose_pix_fmts
static char * choose_pix_fmts(OutputFilter *ofilter)
Definition: ffmpeg_filter.c:86
get_rotation
double get_rotation(AVStream *st)
Definition: cmdutils.c:2188
DEF_CHOOSE_FORMAT
#define DEF_CHOOSE_FORMAT(name, type, var, supported_list, none, printf_format, get_name)
Definition: ffmpeg_filter.c:130
channel_layout.h
AVBufferSrcParameters
This structure contains the parameters describing the frames that will be passed to this filter.
Definition: buffersrc.h:73
av_buffersink_get_sample_rate
int av_buffersink_get_sample_rate(const AVFilterContext *ctx)
InputFilter::format
int format
Definition: ffmpeg.h:250
AVBufferSrcParameters::format
int format
video: the pixel format, value corresponds to enum AVPixelFormat audio: the sample format,...
Definition: buffersrc.h:78
describe_filter_link
static char * describe_filter_link(FilterGraph *fg, AVFilterInOut *inout, int in)
Definition: ffmpeg_filter.c:199
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
filter_nbthreads
int filter_nbthreads
Definition: ffmpeg_opt.c:174
avfilter.h
InputFilter::height
int height
Definition: ffmpeg.h:252
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
AVERROR_FILTER_NOT_FOUND
#define AVERROR_FILTER_NOT_FOUND
Filter not found.
Definition: error.h:58
AVFilterContext
An instance of a filter.
Definition: avfilter.h:333
OutputFilter
Definition: ffmpeg.h:264
cleanup_filtergraph
static void cleanup_filtergraph(FilterGraph *fg)
Definition: ffmpeg_filter.c:945
AVERROR_DECODER_NOT_FOUND
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:52
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:260
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
start_at_zero
int start_at_zero
Definition: ffmpeg_opt.c:164
AVFILTER_AUTO_CONVERT_NONE
@ AVFILTER_AUTO_CONVERT_NONE
all automatic conversions disabled
Definition: avfilter.h:931
OutputStream::file_index
int file_index
Definition: ffmpeg.h:454
audio_volume
int audio_volume
Definition: ffmpeg_opt.c:154
OutputFile::ctx
AVFormatContext * ctx
Definition: ffmpeg.h:577
OutputFilter::out_tmp
AVFilterInOut * out_tmp
Definition: ffmpeg.h:271
av_get_default_channel_layout
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
Definition: channel_layout.c:231
auto_conversion_filters
int auto_conversion_filters
Definition: ffmpeg_opt.c:177
av_fifo_size
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:70
OutputStream::autoscale
int autoscale
Definition: ffmpeg.h:494
InputFilter::hw_frames_ctx
AVBufferRef * hw_frames_ctx
Definition: ffmpeg.h:259
AVDictionaryEntry
Definition: dict.h:81
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
FilterGraph::reconfiguration
int reconfiguration
Definition: ffmpeg.h:292
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
filtergraph_is_simple
int filtergraph_is_simple(FilterGraph *fg)
Definition: ffmpeg_filter.c:1152
format
fg outputs[0] format
Definition: ffmpeg_filter.c:175
nb_filtergraphs
int nb_filtergraphs
Definition: ffmpeg.c:159
AVFilterInOut::name
char * name
unique name for this input/output in the list
Definition: avfilter.h:960
d
d
Definition: ffmpeg_filter.c:156
av_fifo_alloc
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
imgutils.h
OutputStream
Definition: muxing.c:54
OutputStream::st
AVStream * st
Definition: muxing.c:55
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
configure_output_video_filter
static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
Definition: ffmpeg_filter.c:419
h
h
Definition: vp9dsp_template.c:2038
AVDictionaryEntry::value
char * value
Definition: dict.h:83
avstring.h
OutputStream::swr_opts
AVDictionary * swr_opts
Definition: ffmpeg.h:522
OutputFile::recording_time
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:580
AVFilterInOut
A linked-list of the inputs/outputs of the filter chain.
Definition: avfilter.h:958
InputStream::dec
const AVCodec * dec
Definition: ffmpeg.h:310
snprintf
#define snprintf
Definition: snprintf.h:34
filter
ost filter
Definition: ffmpeg_filter.c:177
buffersrc.h
AUTO_INSERT_FILTER_INPUT
#define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg)
configure_output_audio_filter
static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
Definition: ffmpeg_filter.c:512
filtergraphs
filtergraphs[nb_filtergraphs - 1]
Definition: ffmpeg_filter.c:194
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:2461
filter_complex_nbthreads
int filter_complex_nbthreads
Definition: ffmpeg_opt.c:175
OutputFile
Definition: ffmpeg.h:576
sub2video_prepare
static int sub2video_prepare(InputStream *ist, InputFilter *ifilter)
Definition: ffmpeg_filter.c:650