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