FFmpeg
ffmpeg_opt.c
Go to the documentation of this file.
1 /*
2  * ffmpeg option parsing
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 "config.h"
22 
23 #include <stdint.h>
24 
25 #if HAVE_SYS_RESOURCE_H
26 #include <sys/time.h>
27 #include <sys/resource.h>
28 #endif
29 
30 #include "ffmpeg.h"
31 #include "ffmpeg_sched.h"
32 #include "cmdutils.h"
33 #include "opt_common.h"
34 
35 #include "libavformat/avformat.h"
36 
37 #include "libavcodec/avcodec.h"
38 #include "libavcodec/bsf.h"
39 
40 #include "libavfilter/avfilter.h"
41 
42 #include "libavutil/avassert.h"
43 #include "libavutil/avstring.h"
44 #include "libavutil/avutil.h"
45 #include "libavutil/mathematics.h"
46 #include "libavutil/mem.h"
47 #include "libavutil/opt.h"
48 #include "libavutil/parseutils.h"
49 
51 
53 
56 float dts_error_threshold = 3600*30;
57 
58 #if FFMPEG_OPT_VSYNC
60 #endif
62 int do_benchmark = 0;
64 int do_hex_dump = 0;
65 int do_pkt_dump = 0;
66 int copy_ts = 0;
67 int start_at_zero = 0;
68 int copy_tb = -1;
69 int debug_ts = 0;
70 int exit_on_error = 0;
72 int print_stats = -1;
74 float max_error_rate = 2.0/3;
79 int64_t stats_period = 500000;
80 
81 
82 static int file_overwrite = 0;
83 static int no_file_overwrite = 0;
86 int recast_media = 0;
87 
89 {
90  int i;
91 
92  /* all OPT_SPEC and OPT_TYPE_STRING can be freed in generic way */
93  for (const OptionDef *po = options; po->name; po++) {
94  void *dst;
95 
96  if (!(po->flags & OPT_FLAG_OFFSET))
97  continue;
98 
99  dst = (uint8_t*)o + po->u.off;
100  if (po->flags & OPT_FLAG_SPEC) {
101  SpecifierOptList *so = dst;
102  for (int i = 0; i < so->nb_opt; i++) {
103  av_freep(&so->opt[i].specifier);
104  if (po->type == OPT_TYPE_STRING)
105  av_freep(&so->opt[i].u.str);
106  }
107  av_freep(&so->opt);
108  so->nb_opt = 0;
109  } else if (po->type == OPT_TYPE_STRING)
110  av_freep(dst);
111  }
112 
113  for (i = 0; i < o->nb_stream_maps; i++)
115  av_freep(&o->stream_maps);
116 
117  for (i = 0; i < o->nb_attachments; i++)
118  av_freep(&o->attachments[i]);
119  av_freep(&o->attachments);
120 
121  av_dict_free(&o->streamid);
122 }
123 
125 {
126  memset(o, 0, sizeof(*o));
127 
128  o->stop_time = INT64_MAX;
129  o->mux_max_delay = 0.7;
132  o->recording_time = INT64_MAX;
133  o->limit_filesize = INT64_MAX;
134  o->chapters_input_file = INT_MAX;
135  o->accurate_seek = 1;
136  o->thread_queue_size = 0;
137  o->input_sync_ref = -1;
138  o->find_stream_info = 1;
139  o->shortest_buf_duration = 10.f;
140 }
141 
142 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
143 {
145 
146  printf("Hardware acceleration methods:\n");
147  while ((type = av_hwdevice_iterate_types(type)) !=
150  printf("\n");
151  return 0;
152 }
153 
154 /* return a copy of the input with the stream specifiers removed from the keys */
156 {
157  const AVDictionaryEntry *e = NULL;
158  AVDictionary *ret = NULL;
159 
160  while ((e = av_dict_iterate(dict, e))) {
161  char *p = strchr(e->key, ':');
162 
163  if (p)
164  *p = 0;
165  av_dict_set(&ret, e->key, e->value, 0);
166  if (p)
167  *p = ':';
168  }
169  return ret;
170 }
171 
173  char mediatype)
174 {
175  av_assert0(!sol->nb_opt || sol->type == OPT_TYPE_STRING);
176 
177  for (int i = 0; i < sol->nb_opt; i++) {
178  const char *spec = sol->opt[i].specifier;
179  if (spec[0] == mediatype && !spec[1])
180  return sol->opt[i].u.str;
181  }
182  return NULL;
183 }
184 
185 int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_idx, int is_global)
186 {
187  if (!av_strcasecmp(arg, "cfr")) *vsync_var = VSYNC_CFR;
188  else if (!av_strcasecmp(arg, "vfr")) *vsync_var = VSYNC_VFR;
189  else if (!av_strcasecmp(arg, "passthrough")) *vsync_var = VSYNC_PASSTHROUGH;
190 #if FFMPEG_OPT_VSYNC_DROP
191  else if (!av_strcasecmp(arg, "drop")) {
192  av_log(NULL, AV_LOG_WARNING, "-vsync/fps_mode drop is deprecated\n");
193  *vsync_var = VSYNC_DROP;
194  }
195 #endif
196  else if (!is_global && !av_strcasecmp(arg, "auto")) *vsync_var = VSYNC_AUTO;
197  else if (!is_global) {
198  av_log(NULL, AV_LOG_FATAL, "Invalid value %s specified for fps_mode of #%d:%d.\n", arg, file_idx, st_idx);
199  return AVERROR(EINVAL);
200  }
201 
202 #if FFMPEG_OPT_VSYNC
203  if (is_global && *vsync_var == VSYNC_AUTO) {
204  int ret;
205  double num;
206 
207  ret = parse_number("vsync", arg, OPT_TYPE_INT, VSYNC_AUTO, VSYNC_VFR, &num);
208  if (ret < 0)
209  return ret;
210 
211  video_sync_method = num;
212  av_log(NULL, AV_LOG_WARNING, "Passing a number to -vsync is deprecated,"
213  " use a string argument as described in the manual.\n");
214  }
215 #endif
216 
217  return 0;
218 }
219 
220 /* Correct input file start times based on enabled streams */
221 static void correct_input_start_times(void)
222 {
223  for (int i = 0; i < nb_input_files; i++) {
224  InputFile *ifile = input_files[i];
225  AVFormatContext *is = ifile->ctx;
226  int64_t new_start_time = INT64_MAX, diff, abs_start_seek;
227 
228  ifile->start_time_effective = is->start_time;
229 
230  if (is->start_time == AV_NOPTS_VALUE ||
231  !(is->iformat->flags & AVFMT_TS_DISCONT))
232  continue;
233 
234  for (int j = 0; j < is->nb_streams; j++) {
235  AVStream *st = is->streams[j];
236  if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
237  continue;
238  new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
239  }
240 
241  diff = new_start_time - is->start_time;
242  if (diff) {
243  av_log(NULL, AV_LOG_VERBOSE, "Correcting start time of Input #%d by %"PRId64" us.\n", i, diff);
244  ifile->start_time_effective = new_start_time;
245  if (copy_ts && start_at_zero)
246  ifile->ts_offset = -new_start_time;
247  else if (!copy_ts) {
248  abs_start_seek = is->start_time + (ifile->start_time != AV_NOPTS_VALUE) ? ifile->start_time : 0;
249  ifile->ts_offset = abs_start_seek > new_start_time ? -abs_start_seek : -new_start_time;
250  } else if (copy_ts)
251  ifile->ts_offset = 0;
252 
253  ifile->ts_offset += ifile->input_ts_offset;
254  }
255  }
256 }
257 
258 static int apply_sync_offsets(void)
259 {
260  for (int i = 0; i < nb_input_files; i++) {
261  InputFile *ref, *self = input_files[i];
262  int64_t adjustment;
263  int64_t self_start_time, ref_start_time, self_seek_start, ref_seek_start;
264  int start_times_set = 1;
265 
266  if (self->input_sync_ref == -1 || self->input_sync_ref == i) continue;
267  if (self->input_sync_ref >= nb_input_files || self->input_sync_ref < -1) {
268  av_log(NULL, AV_LOG_FATAL, "-isync for input %d references non-existent input %d.\n", i, self->input_sync_ref);
269  return AVERROR(EINVAL);
270  }
271 
272  if (copy_ts && !start_at_zero) {
273  av_log(NULL, AV_LOG_FATAL, "Use of -isync requires that start_at_zero be set if copyts is set.\n");
274  return AVERROR(EINVAL);
275  }
276 
277  ref = input_files[self->input_sync_ref];
278  if (ref->input_sync_ref != -1 && ref->input_sync_ref != self->input_sync_ref) {
279  av_log(NULL, AV_LOG_ERROR, "-isync for input %d references a resynced input %d. Sync not set.\n", i, self->input_sync_ref);
280  continue;
281  }
282 
283  if (self->ctx->start_time_realtime != AV_NOPTS_VALUE && ref->ctx->start_time_realtime != AV_NOPTS_VALUE) {
284  self_start_time = self->ctx->start_time_realtime;
285  ref_start_time = ref->ctx->start_time_realtime;
286  } else if (self->start_time_effective != AV_NOPTS_VALUE && ref->start_time_effective != AV_NOPTS_VALUE) {
287  self_start_time = self->start_time_effective;
288  ref_start_time = ref->start_time_effective;
289  } else {
290  start_times_set = 0;
291  }
292 
293  if (start_times_set) {
294  self_seek_start = self->start_time == AV_NOPTS_VALUE ? 0 : self->start_time;
295  ref_seek_start = ref->start_time == AV_NOPTS_VALUE ? 0 : ref->start_time;
296 
297  adjustment = (self_start_time - ref_start_time) + !copy_ts*(self_seek_start - ref_seek_start) + ref->input_ts_offset;
298 
299  self->ts_offset += adjustment;
300 
301  av_log(NULL, AV_LOG_INFO, "Adjusted ts offset for Input #%d by %"PRId64" us to sync with Input #%d.\n", i, adjustment, self->input_sync_ref);
302  } else {
303  av_log(NULL, AV_LOG_INFO, "Unable to identify start times for Inputs #%d and %d both. No sync adjustment made.\n", i, self->input_sync_ref);
304  }
305  }
306 
307  return 0;
308 }
309 
310 static int opt_filter_threads(void *optctx, const char *opt, const char *arg)
311 {
314  return 0;
315 }
316 
317 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
318 {
319  static const AVOption opts[] = {
320  { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, (double)INT64_MAX, .unit = "flags" },
321  { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
322  { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
323  { NULL },
324  };
325  static const AVClass class = {
326  .class_name = "",
327  .item_name = av_default_item_name,
328  .option = opts,
329  .version = LIBAVUTIL_VERSION_INT,
330  };
331  const AVClass *pclass = &class;
332 
333  return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
334 }
335 
336 static int opt_stats_period(void *optctx, const char *opt, const char *arg)
337 {
338  int64_t user_stats_period;
339  int ret = av_parse_time(&user_stats_period, arg, 1);
340  if (ret < 0)
341  return ret;
342 
343  if (user_stats_period <= 0) {
344  av_log(NULL, AV_LOG_ERROR, "stats_period %s must be positive.\n", arg);
345  return AVERROR(EINVAL);
346  }
347 
348  stats_period = user_stats_period;
349  av_log(NULL, AV_LOG_INFO, "ffmpeg stats and -progress period set to %s.\n", arg);
350 
351  return 0;
352 }
353 
354 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
355 {
356  OptionsContext *o = optctx;
357  return parse_option(o, "codec:a", arg, options);
358 }
359 
360 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
361 {
362  OptionsContext *o = optctx;
363  return parse_option(o, "codec:v", arg, options);
364 }
365 
366 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
367 {
368  OptionsContext *o = optctx;
369  return parse_option(o, "codec:s", arg, options);
370 }
371 
372 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
373 {
374  OptionsContext *o = optctx;
375  return parse_option(o, "codec:d", arg, options);
376 }
377 
378 static int opt_map(void *optctx, const char *opt, const char *arg)
379 {
380  OptionsContext *o = optctx;
381  StreamMap *m = NULL;
382  int i, negative = 0, file_idx, disabled = 0;
383  int ret;
384  char *map, *p;
385  char *allow_unused;
386 
387  if (*arg == '-') {
388  negative = 1;
389  arg++;
390  }
391  map = av_strdup(arg);
392  if (!map)
393  return AVERROR(ENOMEM);
394 
395  if (map[0] == '[') {
396  /* this mapping refers to lavfi output */
397  const char *c = map + 1;
398 
400  if (ret < 0)
401  goto fail;
402 
403  m = &o->stream_maps[o->nb_stream_maps - 1];
404  m->linklabel = av_get_token(&c, "]");
405  if (!m->linklabel) {
406  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
407  ret = AVERROR(EINVAL);
408  goto fail;
409  }
410  } else {
411  if (allow_unused = strchr(map, '?'))
412  *allow_unused = 0;
413  file_idx = strtol(map, &p, 0);
414  if (file_idx >= nb_input_files || file_idx < 0) {
415  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
416  ret = AVERROR(EINVAL);
417  goto fail;
418  }
419  if (negative)
420  /* disable some already defined maps */
421  for (i = 0; i < o->nb_stream_maps; i++) {
422  m = &o->stream_maps[i];
423  if (file_idx == m->file_index &&
426  *p == ':' ? p + 1 : p) > 0)
427  m->disabled = 1;
428  }
429  else
430  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
431  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
432  *p == ':' ? p + 1 : p) <= 0)
433  continue;
434  if (input_files[file_idx]->streams[i]->user_set_discard == AVDISCARD_ALL) {
435  disabled = 1;
436  continue;
437  }
439  if (ret < 0)
440  goto fail;
441 
442  m = &o->stream_maps[o->nb_stream_maps - 1];
443 
444  m->file_index = file_idx;
445  m->stream_index = i;
446  }
447  }
448 
449  if (!m) {
450  if (allow_unused) {
451  av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
452  } else if (disabled) {
453  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
454  "To ignore this, add a trailing '?' to the map.\n", arg);
455  ret = AVERROR(EINVAL);
456  goto fail;
457  } else {
458  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
459  "To ignore this, add a trailing '?' to the map.\n", arg);
460  ret = AVERROR(EINVAL);
461  goto fail;
462  }
463  }
464  ret = 0;
465 fail:
466  av_freep(&map);
467  return ret;
468 }
469 
470 static int opt_attach(void *optctx, const char *opt, const char *arg)
471 {
472  OptionsContext *o = optctx;
474  if (ret < 0)
475  return ret;
476 
477  o->attachments[o->nb_attachments - 1] = av_strdup(arg);
478  if (!o->attachments[o->nb_attachments - 1])
479  return AVERROR(ENOMEM);
480 
481  return 0;
482 }
483 
484 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
485 {
486  Scheduler *sch = optctx;
487  return sch_sdp_filename(sch, arg);
488 }
489 
490 #if CONFIG_VAAPI
491 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
492 {
493  const char *prefix = "vaapi:";
494  char *tmp;
495  int err;
496  tmp = av_asprintf("%s%s", prefix, arg);
497  if (!tmp)
498  return AVERROR(ENOMEM);
500  av_free(tmp);
501  return err;
502 }
503 #endif
504 
505 #if CONFIG_QSV
506 static int opt_qsv_device(void *optctx, const char *opt, const char *arg)
507 {
508  const char *prefix = "qsv=__qsv_device:hw_any,child_device=";
509  int err;
510  char *tmp = av_asprintf("%s%s", prefix, arg);
511 
512  if (!tmp)
513  return AVERROR(ENOMEM);
514 
516  av_free(tmp);
517 
518  return err;
519 }
520 #endif
521 
522 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
523 {
524  if (!strcmp(arg, "list")) {
526  printf("Supported hardware device types:\n");
527  while ((type = av_hwdevice_iterate_types(type)) !=
530  printf("\n");
531  return AVERROR_EXIT;
532  } else {
534  }
535 }
536 
537 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
538 {
539  if (filter_hw_device) {
540  av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
541  return AVERROR(EINVAL);
542  }
544  if (!filter_hw_device) {
545  av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
546  return AVERROR(EINVAL);
547  }
548  return 0;
549 }
550 
551 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
552 {
553  OptionsContext *o = optctx;
554  char buf[128];
555  int64_t recording_timestamp;
556  int ret;
557  struct tm time;
558 
559  ret = av_parse_time(&recording_timestamp, arg, 0);
560  if (ret < 0)
561  return ret;
562 
563  recording_timestamp /= 1e6;
564  time = *gmtime((time_t*)&recording_timestamp);
565  if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
566  return -1;
567  parse_option(o, "metadata", buf, options);
568 
569  av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
570  "tag instead.\n", opt);
571  return 0;
572 }
573 
574 int find_codec(void *logctx, const char *name,
575  enum AVMediaType type, int encoder, const AVCodec **pcodec)
576 {
577  const AVCodecDescriptor *desc;
578  const char *codec_string = encoder ? "encoder" : "decoder";
579  const AVCodec *codec;
580 
581  codec = encoder ?
584 
585  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
586  codec = encoder ? avcodec_find_encoder(desc->id) :
588  if (codec)
589  av_log(logctx, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
590  codec_string, codec->name, desc->name);
591  }
592 
593  if (!codec) {
594  av_log(logctx, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
595  return encoder ? AVERROR_ENCODER_NOT_FOUND :
597  }
598  if (codec->type != type && !recast_media) {
599  av_log(logctx, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
600  return AVERROR(EINVAL);
601  }
602 
603  *pcodec = codec;
604  return 0;;
605 }
606 
607 int assert_file_overwrite(const char *filename)
608 {
609  const char *proto_name = avio_find_protocol_name(filename);
610 
612  fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
613  return AVERROR(EINVAL);
614  }
615 
616  if (!file_overwrite) {
617  if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
619  fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
620  fflush(stderr);
621  term_exit();
622  signal(SIGINT, SIG_DFL);
623  if (!read_yesno()) {
624  av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
625  return AVERROR_EXIT;
626  }
627  term_init();
628  }
629  else {
630  av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
631  return AVERROR_EXIT;
632  }
633  }
634  }
635 
636  if (proto_name && !strcmp(proto_name, "file")) {
637  for (int i = 0; i < nb_input_files; i++) {
638  InputFile *file = input_files[i];
639  if (file->ctx->iformat->flags & AVFMT_NOFILE)
640  continue;
641  if (!strcmp(filename, file->ctx->url)) {
642  av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
643  av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
644  return AVERROR(EINVAL);
645  }
646  }
647  }
648 
649  return 0;
650 }
651 
652 /* arg format is "output-stream-index:streamid-value". */
653 static int opt_streamid(void *optctx, const char *opt, const char *arg)
654 {
655  OptionsContext *o = optctx;
656  char *p;
657  char idx_str[16];
658 
659  av_strlcpy(idx_str, arg, sizeof(idx_str));
660  p = strchr(idx_str, ':');
661  if (!p) {
663  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
664  arg, opt);
665  return AVERROR(EINVAL);
666  }
667  *p++ = '\0';
668 
669  return av_dict_set(&o->streamid, idx_str, p, 0);
670 }
671 
672 static int opt_target(void *optctx, const char *opt, const char *arg)
673 {
674  OptionsContext *o = optctx;
675  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
676  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
677 
678  if (!strncmp(arg, "pal-", 4)) {
679  norm = PAL;
680  arg += 4;
681  } else if (!strncmp(arg, "ntsc-", 5)) {
682  norm = NTSC;
683  arg += 5;
684  } else if (!strncmp(arg, "film-", 5)) {
685  norm = FILM;
686  arg += 5;
687  } else {
688  /* Try to determine PAL/NTSC by peeking in the input files */
689  if (nb_input_files) {
690  int i, j;
691  for (j = 0; j < nb_input_files; j++) {
692  for (i = 0; i < input_files[j]->nb_streams; i++) {
693  AVStream *st = input_files[j]->ctx->streams[i];
694  int64_t fr;
696  continue;
697  fr = st->time_base.den * 1000LL / st->time_base.num;
698  if (fr == 25000) {
699  norm = PAL;
700  break;
701  } else if ((fr == 29970) || (fr == 23976)) {
702  norm = NTSC;
703  break;
704  }
705  }
706  if (norm != UNKNOWN)
707  break;
708  }
709  }
710  if (norm != UNKNOWN)
711  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
712  }
713 
714  if (norm == UNKNOWN) {
715  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
716  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
717  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
718  return AVERROR(EINVAL);
719  }
720 
721  if (!strcmp(arg, "vcd")) {
722  opt_video_codec(o, "c:v", "mpeg1video");
723  opt_audio_codec(o, "c:a", "mp2");
724  parse_option(o, "f", "vcd", options);
725 
726  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
727  parse_option(o, "r", frame_rates[norm], options);
728  opt_default(NULL, "g", norm == PAL ? "15" : "18");
729 
730  opt_default(NULL, "b:v", "1150000");
731  opt_default(NULL, "maxrate:v", "1150000");
732  opt_default(NULL, "minrate:v", "1150000");
733  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
734 
735  opt_default(NULL, "b:a", "224000");
736  parse_option(o, "ar", "44100", options);
737  parse_option(o, "ac", "2", options);
738 
739  opt_default(NULL, "packetsize", "2324");
740  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
741 
742  /* We have to offset the PTS, so that it is consistent with the SCR.
743  SCR starts at 36000, but the first two packs contain only padding
744  and the first pack from the other stream, respectively, may also have
745  been written before.
746  So the real data starts at SCR 36000+3*1200. */
747  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
748  } else if (!strcmp(arg, "svcd")) {
749 
750  opt_video_codec(o, "c:v", "mpeg2video");
751  opt_audio_codec(o, "c:a", "mp2");
752  parse_option(o, "f", "svcd", options);
753 
754  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
755  parse_option(o, "r", frame_rates[norm], options);
756  parse_option(o, "pix_fmt", "yuv420p", options);
757  opt_default(NULL, "g", norm == PAL ? "15" : "18");
758 
759  opt_default(NULL, "b:v", "2040000");
760  opt_default(NULL, "maxrate:v", "2516000");
761  opt_default(NULL, "minrate:v", "0"); // 1145000;
762  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
763  opt_default(NULL, "scan_offset", "1");
764 
765  opt_default(NULL, "b:a", "224000");
766  parse_option(o, "ar", "44100", options);
767 
768  opt_default(NULL, "packetsize", "2324");
769 
770  } else if (!strcmp(arg, "dvd")) {
771 
772  opt_video_codec(o, "c:v", "mpeg2video");
773  opt_audio_codec(o, "c:a", "ac3");
774  parse_option(o, "f", "dvd", options);
775 
776  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
777  parse_option(o, "r", frame_rates[norm], options);
778  parse_option(o, "pix_fmt", "yuv420p", options);
779  opt_default(NULL, "g", norm == PAL ? "15" : "18");
780 
781  opt_default(NULL, "b:v", "6000000");
782  opt_default(NULL, "maxrate:v", "9000000");
783  opt_default(NULL, "minrate:v", "0"); // 1500000;
784  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
785 
786  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
787  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
788 
789  opt_default(NULL, "b:a", "448000");
790  parse_option(o, "ar", "48000", options);
791 
792  } else if (!strncmp(arg, "dv", 2)) {
793 
794  parse_option(o, "f", "dv", options);
795 
796  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
797  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
798  norm == PAL ? "yuv420p" : "yuv411p", options);
799  parse_option(o, "r", frame_rates[norm], options);
800 
801  parse_option(o, "ar", "48000", options);
802  parse_option(o, "ac", "2", options);
803 
804  } else {
805  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
806  return AVERROR(EINVAL);
807  }
808 
811 
812  return 0;
813 }
814 
815 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
816 {
819  return 0;
820 }
821 
822 static int opt_vstats(void *optctx, const char *opt, const char *arg)
823 {
824  char filename[40];
825  time_t today2 = time(NULL);
826  struct tm *today = localtime(&today2);
827 
828  if (!today) { // maybe tomorrow
829  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
830  return AVERROR(errno);
831  }
832 
833  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
834  today->tm_sec);
835  return opt_vstats_file(NULL, opt, filename);
836 }
837 
838 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
839 {
840  OptionsContext *o = optctx;
841  return parse_option(o, "frames:v", arg, options);
842 }
843 
844 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
845 {
846  OptionsContext *o = optctx;
847  return parse_option(o, "frames:a", arg, options);
848 }
849 
850 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
851 {
852  OptionsContext *o = optctx;
853  return parse_option(o, "frames:d", arg, options);
854 }
855 
856 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
857 {
858  int ret;
859  AVDictionary *cbak = codec_opts;
860  AVDictionary *fbak = format_opts;
861  codec_opts = NULL;
862  format_opts = NULL;
863 
864  ret = opt_default(NULL, opt, arg);
865 
866  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
870  codec_opts = cbak;
871  format_opts = fbak;
872 
873  return ret;
874 }
875 
876 static int opt_preset(void *optctx, const char *opt, const char *arg)
877 {
878  OptionsContext *o = optctx;
879  FILE *f=NULL;
880  char filename[1000], line[1000], tmp_line[1000];
881  const char *codec_name = NULL;
882  int ret = 0;
883 
884  codec_name = opt_match_per_type_str(&o->codec_names, *opt);
885 
886  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
887  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
888  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
889  }else
890  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
891  return AVERROR(ENOENT);
892  }
893 
894  while (fgets(line, sizeof(line), f)) {
895  char *key = tmp_line, *value, *endptr;
896 
897  if (strcspn(line, "#\n\r") == 0)
898  continue;
899  av_strlcpy(tmp_line, line, sizeof(tmp_line));
900  if (!av_strtok(key, "=", &value) ||
901  !av_strtok(value, "\r\n", &endptr)) {
902  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
903  ret = AVERROR(EINVAL);
904  goto fail;
905  }
906  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
907 
908  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
909  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
910  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
911  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
912  else if (opt_default_new(o, key, value) < 0) {
913  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
914  filename, line, key, value);
915  ret = AVERROR(EINVAL);
916  goto fail;
917  }
918  }
919 
920 fail:
921  fclose(f);
922 
923  return ret;
924 }
925 
926 static int opt_old2new(void *optctx, const char *opt, const char *arg)
927 {
928  OptionsContext *o = optctx;
929  int ret;
930  char *s = av_asprintf("%s:%c", opt + 1, *opt);
931  if (!s)
932  return AVERROR(ENOMEM);
933  ret = parse_option(o, s, arg, options);
934  av_free(s);
935  return ret;
936 }
937 
938 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
939 {
940  OptionsContext *o = optctx;
941 
942  if(!strcmp(opt, "ab")){
943  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
944  return 0;
945  } else if(!strcmp(opt, "b")){
946  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
947  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
948  return 0;
949  }
950  av_dict_set(&o->g->codec_opts, opt, arg, 0);
951  return 0;
952 }
953 
954 static int opt_qscale(void *optctx, const char *opt, const char *arg)
955 {
956  OptionsContext *o = optctx;
957  char *s;
958  int ret;
959  if(!strcmp(opt, "qscale")){
960  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
961  return parse_option(o, "q:v", arg, options);
962  }
963  s = av_asprintf("q%s", opt + 6);
964  if (!s)
965  return AVERROR(ENOMEM);
966  ret = parse_option(o, s, arg, options);
967  av_free(s);
968  return ret;
969 }
970 
971 static int opt_profile(void *optctx, const char *opt, const char *arg)
972 {
973  OptionsContext *o = optctx;
974  if(!strcmp(opt, "profile")){
975  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
976  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
977  return 0;
978  }
979  av_dict_set(&o->g->codec_opts, opt, arg, 0);
980  return 0;
981 }
982 
983 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
984 {
985  OptionsContext *o = optctx;
986  return parse_option(o, "filter:v", arg, options);
987 }
988 
989 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
990 {
991  OptionsContext *o = optctx;
992  return parse_option(o, "filter:a", arg, options);
993 }
994 
995 #if FFMPEG_OPT_VSYNC
996 static int opt_vsync(void *optctx, const char *opt, const char *arg)
997 {
998  av_log(NULL, AV_LOG_WARNING, "-vsync is deprecated. Use -fps_mode\n");
999  return parse_and_set_vsync(arg, &video_sync_method, -1, -1, 1);
1000 }
1001 #endif
1002 
1003 static int opt_timecode(void *optctx, const char *opt, const char *arg)
1004 {
1005  OptionsContext *o = optctx;
1006  int ret;
1007  char *tcr = av_asprintf("timecode=%s", arg);
1008  if (!tcr)
1009  return AVERROR(ENOMEM);
1010  ret = parse_option(o, "metadata:g", tcr, options);
1011  if (ret >= 0)
1012  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
1013  av_free(tcr);
1014  return ret;
1015 }
1016 
1017 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1018 {
1019  OptionsContext *o = optctx;
1020  return parse_option(o, "q:a", arg, options);
1021 }
1022 
1023 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1024 {
1025  Scheduler *sch = optctx;
1026  char *graph_desc = av_strdup(arg);
1027  if (!graph_desc)
1028  return AVERROR(ENOMEM);
1029 
1030  return fg_create(NULL, graph_desc, sch);
1031 }
1032 
1033 #if FFMPEG_OPT_FILTER_SCRIPT
1034 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1035 {
1036  Scheduler *sch = optctx;
1037  char *graph_desc = file_read(arg);
1038  if (!graph_desc)
1039  return AVERROR(EINVAL);
1040 
1041  av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -/filter_complex %s instead\n",
1042  opt, arg);
1043 
1044  return fg_create(NULL, graph_desc, sch);
1045 }
1046 #endif
1047 
1048 void show_help_default(const char *opt, const char *arg)
1049 {
1050  int show_advanced = 0, show_avoptions = 0;
1051 
1052  if (opt && *opt) {
1053  if (!strcmp(opt, "long"))
1054  show_advanced = 1;
1055  else if (!strcmp(opt, "full"))
1056  show_advanced = show_avoptions = 1;
1057  else
1058  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1059  }
1060 
1061  show_usage();
1062 
1063  printf("Getting help:\n"
1064  " -h -- print basic options\n"
1065  " -h long -- print more options\n"
1066  " -h full -- print all options (including all format and codec specific options, very long)\n"
1067  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
1068  " See man %s for detailed description of the options.\n"
1069  "\n"
1070  "Per-stream options can be followed by :<stream_spec> to apply that option to specific streams only. "
1071  "<stream_spec> can be a stream index, or v/a/s for video/audio/subtitle (see manual for full syntax).\n"
1072  "\n", program_name);
1073 
1074  show_help_options(options, "Print help / information / capabilities:",
1075  OPT_EXIT, OPT_EXPERT);
1076  if (show_advanced)
1077  show_help_options(options, "Advanced information / capabilities:",
1078  OPT_EXIT | OPT_EXPERT, 0);
1079 
1080  show_help_options(options, "Global options (affect whole program "
1081  "instead of just one file):",
1083  if (show_advanced)
1084  show_help_options(options, "Advanced global options:", OPT_EXPERT,
1085  OPT_PERFILE | OPT_EXIT);
1086 
1087  show_help_options(options, "Per-file options (input and output):",
1091  if (show_advanced)
1092  show_help_options(options, "Advanced per-file options (input and output):",
1096 
1097  show_help_options(options, "Per-file options (input-only):",
1101  if (show_advanced)
1102  show_help_options(options, "Advanced per-file options (input-only):",
1106 
1107  show_help_options(options, "Per-file options (output-only):",
1111  if (show_advanced)
1112  show_help_options(options, "Advanced per-file options (output-only):",
1116 
1117  show_help_options(options, "Per-stream options:",
1119  OPT_EXIT | OPT_EXPERT |
1121  if (show_advanced)
1122  show_help_options(options, "Advanced per-stream options:",
1124  OPT_EXIT |
1126 
1127  show_help_options(options, "Video options:",
1129  if (show_advanced)
1130  show_help_options(options, "Advanced Video options:",
1132 
1133  show_help_options(options, "Audio options:",
1135  if (show_advanced)
1136  show_help_options(options, "Advanced Audio options:",
1138 
1139  show_help_options(options, "Subtitle options:",
1141  if (show_advanced)
1142  show_help_options(options, "Advanced Subtitle options:",
1144 
1145  if (show_advanced)
1146  show_help_options(options, "Data stream options:",
1148  printf("\n");
1149 
1150  if (show_avoptions) {
1154 #if CONFIG_SWSCALE
1156 #endif
1157 #if CONFIG_SWRESAMPLE
1159 #endif
1162  }
1163 }
1164 
1165 void show_usage(void)
1166 {
1167  av_log(NULL, AV_LOG_INFO, "Universal media converter\n");
1168  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1169  av_log(NULL, AV_LOG_INFO, "\n");
1170 }
1171 
1172 enum OptGroup {
1173  GROUP_OUTFILE,
1174  GROUP_INFILE,
1175  GROUP_DECODER,
1176 };
1177 
1178 static const OptionGroupDef groups[] = {
1179  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
1180  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
1181  [GROUP_DECODER] = { "loopback decoder", "dec", OPT_DECODER },
1182 };
1183 
1184 static int open_files(OptionGroupList *l, const char *inout, Scheduler *sch,
1185  int (*open_file)(const OptionsContext*, const char*,
1186  Scheduler*))
1187 {
1188  int i, ret;
1189 
1190  for (i = 0; i < l->nb_groups; i++) {
1191  OptionGroup *g = &l->groups[i];
1192  OptionsContext o;
1193 
1194  init_options(&o);
1195  o.g = g;
1196 
1197  ret = parse_optgroup(&o, g, options);
1198  if (ret < 0) {
1199  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1200  "%s.\n", inout, g->arg);
1201  uninit_options(&o);
1202  return ret;
1203  }
1204 
1205  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1206  ret = open_file(&o, g->arg, sch);
1207  uninit_options(&o);
1208  if (ret < 0) {
1209  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1210  inout, g->arg);
1211  return ret;
1212  }
1213  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
1214  }
1215 
1216  return 0;
1217 }
1218 
1219 int ffmpeg_parse_options(int argc, char **argv, Scheduler *sch)
1220 {
1221  OptionParseContext octx;
1222  const char *errmsg = NULL;
1223  int ret;
1224 
1225  memset(&octx, 0, sizeof(octx));
1226 
1227  /* split the commandline into an internal representation */
1228  ret = split_commandline(&octx, argc, argv, options, groups,
1229  FF_ARRAY_ELEMS(groups));
1230  if (ret < 0) {
1231  errmsg = "splitting the argument list";
1232  goto fail;
1233  }
1234 
1235  /* apply global options */
1236  ret = parse_optgroup(sch, &octx.global_opts, options);
1237  if (ret < 0) {
1238  errmsg = "parsing global options";
1239  goto fail;
1240  }
1241 
1242  /* configure terminal and setup signal handlers */
1243  term_init();
1244 
1245  /* open input files */
1246  ret = open_files(&octx.groups[GROUP_INFILE], "input", sch, ifile_open);
1247  if (ret < 0) {
1248  errmsg = "opening input files";
1249  goto fail;
1250  }
1251 
1252  /* open output files */
1253  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", sch, of_open);
1254  if (ret < 0) {
1255  errmsg = "opening output files";
1256  goto fail;
1257  }
1258 
1259  /* create loopback decoders */
1260  ret = open_files(&octx.groups[GROUP_DECODER], "decoder", sch, dec_create);
1261  if (ret < 0) {
1262  errmsg = "creating loopback decoders";
1263  goto fail;
1264  }
1265 
1266  // bind unbound filtegraph inputs/outputs and check consistency
1268  if (ret < 0) {
1269  errmsg = "binding filtergraph inputs/outputs";
1270  goto fail;
1271  }
1272 
1274 
1275  ret = apply_sync_offsets();
1276  if (ret < 0)
1277  goto fail;
1278 
1279 fail:
1280  uninit_parse_context(&octx);
1281  if (ret < 0 && ret != AVERROR_EXIT) {
1282  av_log(NULL, AV_LOG_FATAL, "Error %s: %s\n",
1283  errmsg ? errmsg : "", av_err2str(ret));
1284  }
1285  return ret;
1286 }
1287 
1288 static int opt_progress(void *optctx, const char *opt, const char *arg)
1289 {
1290  AVIOContext *avio = NULL;
1291  int ret;
1292 
1293  if (!strcmp(arg, "-"))
1294  arg = "pipe:";
1295  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
1296  if (ret < 0) {
1297  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
1298  arg, av_err2str(ret));
1299  return ret;
1300  }
1301  progress_avio = avio;
1302  return 0;
1303 }
1304 
1305 int opt_timelimit(void *optctx, const char *opt, const char *arg)
1306 {
1307 #if HAVE_SETRLIMIT
1308  int ret;
1309  double lim;
1310  struct rlimit rl;
1311 
1312  ret = parse_number(opt, arg, OPT_TYPE_INT64, 0, INT_MAX, &lim);
1313  if (ret < 0)
1314  return ret;
1315 
1316  rl = (struct rlimit){ lim, lim + 1 };
1317  if (setrlimit(RLIMIT_CPU, &rl))
1318  perror("setrlimit");
1319 #else
1320  av_log(NULL, AV_LOG_WARNING, "-%s not implemented on this OS\n", opt);
1321 #endif
1322  return 0;
1323 }
1324 
1325 #if FFMPEG_OPT_QPHIST
1326 static int opt_qphist(void *optctx, const char *opt, const char *arg)
1327 {
1328  av_log(NULL, AV_LOG_WARNING, "Option -%s is deprecated and has no effect\n", opt);
1329  return 0;
1330 }
1331 #endif
1332 
1333 #if FFMPEG_OPT_ADRIFT_THRESHOLD
1334 static int opt_adrift_threshold(void *optctx, const char *opt, const char *arg)
1335 {
1336  av_log(NULL, AV_LOG_WARNING, "Option -%s is deprecated and has no effect\n", opt);
1337  return 0;
1338 }
1339 #endif
1340 
1341 static const char *const alt_bsf[] = { "absf", "vbsf", NULL };
1342 static const char *const alt_channel_layout[] = { "ch_layout", NULL};
1343 static const char *const alt_codec[] = { "c", "acodec", "vcodec", "scodec", "dcodec", NULL };
1344 static const char *const alt_filter[] = { "af", "vf", NULL };
1345 static const char *const alt_frames[] = { "aframes", "vframes", "dframes", NULL };
1346 static const char *const alt_pre[] = { "apre", "vpre", "spre", NULL};
1347 static const char *const alt_qscale[] = { "q", NULL};
1348 static const char *const alt_tag[] = { "atag", "vtag", "stag", NULL };
1349 
1350 #define OFFSET(x) offsetof(OptionsContext, x)
1351 const OptionDef options[] = {
1352  /* main options */
1355  { .off = OFFSET(format) },
1356  "force container format (auto-detected otherwise)", "fmt" },
1357  { "y", OPT_TYPE_BOOL, 0,
1358  { &file_overwrite },
1359  "overwrite output files" },
1360  { "n", OPT_TYPE_BOOL, 0,
1361  { &no_file_overwrite },
1362  "never overwrite output files" },
1363  { "ignore_unknown", OPT_TYPE_BOOL, OPT_EXPERT,
1365  "Ignore unknown stream types" },
1366  { "copy_unknown", OPT_TYPE_BOOL, OPT_EXPERT,
1367  { &copy_unknown_streams },
1368  "Copy unknown stream types" },
1369  { "recast_media", OPT_TYPE_BOOL, OPT_EXPERT,
1370  { &recast_media },
1371  "allow recasting stream type in order to force a decoder of different media type" },
1373  { .off = OFFSET(codec_names) },
1374  "select encoder/decoder ('copy' to copy stream without reencoding)", "codec",
1375  .u1.name_canon = "codec", },
1377  { .off = OFFSET(codec_names) },
1378  "alias for -c (select encoder/decoder)", "codec",
1379  .u1.names_alt = alt_codec, },
1381  { .off = OFFSET(presets) },
1382  "preset name", "preset",
1383  .u1.names_alt = alt_pre, },
1385  { .func_arg = opt_map },
1386  "set input stream mapping",
1387  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1388  { "map_metadata", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT | OPT_EXPERT,
1389  { .off = OFFSET(metadata_map) },
1390  "set metadata information of outfile from infile",
1391  "outfile[,metadata]:infile[,metadata]" },
1392  { "map_chapters", OPT_TYPE_INT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1393  { .off = OFFSET(chapters_input_file) },
1394  "set chapters mapping", "input_file_index" },
1396  { .off = OFFSET(recording_time) },
1397  "stop transcoding after specified duration",
1398  "duration" },
1400  { .off = OFFSET(stop_time) },
1401  "stop transcoding after specified time is reached",
1402  "time_stop" },
1404  { .off = OFFSET(limit_filesize) },
1405  "set the limit file size in bytes", "limit_size" },
1407  { .off = OFFSET(start_time) },
1408  "start transcoding at specified time", "time_off" },
1409  { "sseof", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT | OPT_EXPERT,
1410  { .off = OFFSET(start_time_eof) },
1411  "set the start time offset relative to EOF", "time_off" },
1412  { "seek_timestamp", OPT_TYPE_INT, OPT_OFFSET | OPT_INPUT | OPT_EXPERT,
1413  { .off = OFFSET(seek_timestamp) },
1414  "enable/disable seeking by timestamp with -ss" },
1415  { "accurate_seek", OPT_TYPE_BOOL, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1416  { .off = OFFSET(accurate_seek) },
1417  "enable/disable accurate seeking with -ss" },
1418  { "isync", OPT_TYPE_INT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1419  { .off = OFFSET(input_sync_ref) },
1420  "Indicate the input index for sync reference", "sync ref" },
1421  { "itsoffset", OPT_TYPE_TIME, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1422  { .off = OFFSET(input_ts_offset) },
1423  "set the input ts offset", "time_off" },
1425  { .off = OFFSET(ts_scale) },
1426  "set the input ts scale", "scale" },
1428  { .func_arg = opt_recording_timestamp },
1429  "set the recording timestamp ('now' to set the current time)", "time" },
1430  { "metadata", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
1431  { .off = OFFSET(metadata) },
1432  "add metadata", "key=value" },
1433  { "program", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
1434  { .off = OFFSET(program) },
1435  "add program with specified streams", "title=string:st=number..." },
1436  { "stream_group", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT | OPT_EXPERT,
1437  { .off = OFFSET(stream_groups) },
1438  "add stream group with specified streams and group type-specific arguments", "id=number:st=number..." },
1440  { .func_arg = opt_data_frames },
1441  "set the number of data frames to output", "number",
1442  .u1.name_canon = "frames" },
1443  { "benchmark", OPT_TYPE_BOOL, OPT_EXPERT,
1444  { &do_benchmark },
1445  "add timings for benchmarking" },
1446  { "benchmark_all", OPT_TYPE_BOOL, OPT_EXPERT,
1447  { &do_benchmark_all },
1448  "add timings for each task" },
1449  { "progress", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1450  { .func_arg = opt_progress },
1451  "write program-readable progress information", "url" },
1452  { "stdin", OPT_TYPE_BOOL, OPT_EXPERT,
1453  { &stdin_interaction },
1454  "enable or disable interaction on standard input" },
1455  { "timelimit", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1456  { .func_arg = opt_timelimit },
1457  "set max runtime in seconds in CPU user time", "limit" },
1458  { "dump", OPT_TYPE_BOOL, OPT_EXPERT,
1459  { &do_pkt_dump },
1460  "dump each input packet" },
1461  { "hex", OPT_TYPE_BOOL, OPT_EXPERT,
1462  { &do_hex_dump },
1463  "when dumping packets, also dump the payload" },
1465  { .off = OFFSET(rate_emu) },
1466  "read input at native frame rate; equivalent to -readrate 1", "" },
1467  { "readrate", OPT_TYPE_FLOAT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1468  { .off = OFFSET(readrate) },
1469  "read input at specified rate", "speed" },
1470  { "readrate_initial_burst", OPT_TYPE_DOUBLE, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
1471  { .off = OFFSET(readrate_initial_burst) },
1472  "The initial amount of input to burst read before imposing any readrate", "seconds" },
1474  { .func_arg = opt_target },
1475  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
1476  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
1477  { "frame_drop_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
1478  { &frame_drop_threshold },
1479  "frame drop threshold", "" },
1480  { "copyts", OPT_TYPE_BOOL, OPT_EXPERT,
1481  { &copy_ts },
1482  "copy timestamps" },
1483  { "start_at_zero", OPT_TYPE_BOOL, OPT_EXPERT,
1484  { &start_at_zero },
1485  "shift input timestamps to start at 0 when using copyts" },
1486  { "copytb", OPT_TYPE_INT, OPT_EXPERT,
1487  { &copy_tb },
1488  "copy input stream time base when stream copying", "mode" },
1489  { "shortest", OPT_TYPE_BOOL, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1490  { .off = OFFSET(shortest) },
1491  "finish encoding within shortest input" },
1492  { "shortest_buf_duration", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1493  { .off = OFFSET(shortest_buf_duration) },
1494  "maximum buffering duration (in seconds) for the -shortest option" },
1496  { .off = OFFSET(bitexact) },
1497  "bitexact mode" },
1499  { .off = OFFSET(apad) },
1500  "audio pad", "" },
1501  { "dts_delta_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
1502  { &dts_delta_threshold },
1503  "timestamp discontinuity delta threshold", "threshold" },
1504  { "dts_error_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
1505  { &dts_error_threshold },
1506  "timestamp error delta threshold", "threshold" },
1507  { "xerror", OPT_TYPE_BOOL, OPT_EXPERT,
1508  { &exit_on_error },
1509  "exit on error", "error" },
1510  { "abort_on", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1511  { .func_arg = opt_abort_on },
1512  "abort on the specified condition flags", "flags" },
1513  { "copyinkf", OPT_TYPE_BOOL, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1514  { .off = OFFSET(copy_initial_nonkeyframes) },
1515  "copy initial non-keyframes" },
1516  { "copypriorss", OPT_TYPE_INT, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1517  { .off = OFFSET(copy_prior_start) },
1518  "copy or discard frames before start time" },
1520  { .off = OFFSET(max_frames) },
1521  "set the number of frames to output", "number",
1522  .u1.names_alt = alt_frames, },
1524  { .off = OFFSET(codec_tags) },
1525  "force codec tag/fourcc", "fourcc/tag",
1526  .u1.names_alt = alt_tag, },
1528  { .off = OFFSET(qscale) },
1529  "use fixed quality scale (VBR)", "q",
1530  .u1.name_canon = "qscale", },
1532  { .func_arg = opt_qscale },
1533  "use fixed quality scale (VBR)", "q",
1534  .u1.names_alt = alt_qscale, },
1536  { .func_arg = opt_profile },
1537  "set profile", "profile" },
1539  { .off = OFFSET(filters) },
1540  "apply specified filters to audio/video", "filter_graph",
1541  .u1.names_alt = alt_filter, },
1542  { "filter_threads", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1543  { .func_arg = opt_filter_threads },
1544  "number of non-complex filter threads" },
1545 #if FFMPEG_OPT_FILTER_SCRIPT
1546  { "filter_script", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1547  { .off = OFFSET(filter_scripts) },
1548  "deprecated, use -/filter", "filename" },
1549 #endif
1550  { "reinit_filter", OPT_TYPE_INT, OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1551  { .off = OFFSET(reinit_filters) },
1552  "reinit filtergraph on input parameter changes", "" },
1553  { "filter_complex", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1554  { .func_arg = opt_filter_complex },
1555  "create a complex filtergraph", "graph_description" },
1556  { "filter_complex_threads", OPT_TYPE_INT, OPT_EXPERT,
1558  "number of threads for -filter_complex" },
1559  { "lavfi", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1560  { .func_arg = opt_filter_complex },
1561  "create a complex filtergraph", "graph_description" },
1562 #if FFMPEG_OPT_FILTER_SCRIPT
1563  { "filter_complex_script", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1564  { .func_arg = opt_filter_complex_script },
1565  "deprecated, use -/filter_complex instead", "filename" },
1566 #endif
1567  { "auto_conversion_filters", OPT_TYPE_BOOL, OPT_EXPERT,
1569  "enable automatic conversion filters globally" },
1570  { "stats", OPT_TYPE_BOOL, 0,
1571  { &print_stats },
1572  "print progress report during encoding", },
1573  { "stats_period", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1574  { .func_arg = opt_stats_period },
1575  "set the period at which ffmpeg updates stats and -progress output", "time" },
1577  { .func_arg = opt_attach },
1578  "add an attachment to the output file", "filename" },
1579  { "dump_attachment", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_INPUT,
1580  { .off = OFFSET(dump_attachment) },
1581  "extract an attachment into a file", "filename" },
1582  { "stream_loop", OPT_TYPE_INT, OPT_EXPERT | OPT_INPUT | OPT_OFFSET,
1583  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
1584  { "debug_ts", OPT_TYPE_BOOL, OPT_EXPERT,
1585  { &debug_ts },
1586  "print timestamp debugging info" },
1587  { "max_error_rate", OPT_TYPE_FLOAT, OPT_EXPERT,
1588  { &max_error_rate },
1589  "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
1591  { .off = OFFSET(discard) },
1592  "discard", "" },
1593  { "disposition", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_OUTPUT | OPT_EXPERT,
1594  { .off = OFFSET(disposition) },
1595  "disposition", "" },
1596  { "thread_queue_size", OPT_TYPE_INT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT,
1597  { .off = OFFSET(thread_queue_size) },
1598  "set the maximum number of queued packets from the demuxer" },
1599  { "find_stream_info", OPT_TYPE_BOOL, OPT_INPUT | OPT_EXPERT | OPT_OFFSET,
1600  { .off = OFFSET(find_stream_info) },
1601  "read and decode the streams to fill missing information with heuristics" },
1602  { "bits_per_raw_sample", OPT_TYPE_INT, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1603  { .off = OFFSET(bits_per_raw_sample) },
1604  "set the number of bits per raw sample", "number" },
1605 
1606  { "stats_enc_pre", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1607  { .off = OFFSET(enc_stats_pre) },
1608  "write encoding stats before encoding" },
1609  { "stats_enc_post", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1610  { .off = OFFSET(enc_stats_post) },
1611  "write encoding stats after encoding" },
1612  { "stats_mux_pre", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1613  { .off = OFFSET(mux_stats) },
1614  "write packets stats before muxing" },
1615  { "stats_enc_pre_fmt", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1616  { .off = OFFSET(enc_stats_pre_fmt) },
1617  "format of the stats written with -stats_enc_pre" },
1618  { "stats_enc_post_fmt", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1619  { .off = OFFSET(enc_stats_post_fmt) },
1620  "format of the stats written with -stats_enc_post" },
1621  { "stats_mux_pre_fmt", OPT_TYPE_STRING, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1622  { .off = OFFSET(mux_stats_fmt) },
1623  "format of the stats written with -stats_mux_pre" },
1624 
1625  /* video options */
1627  { .func_arg = opt_video_frames },
1628  "set the number of video frames to output", "number",
1629  .u1.name_canon = "frames", },
1631  { .off = OFFSET(frame_rates) },
1632  "override input framerate/convert to given output framerate (Hz value, fraction or abbreviation)", "rate" },
1634  { .off = OFFSET(max_frame_rates) },
1635  "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
1637  { .off = OFFSET(frame_sizes) },
1638  "set frame size (WxH or abbreviation)", "size" },
1640  { .off = OFFSET(frame_aspect_ratios) },
1641  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
1643  { .off = OFFSET(frame_pix_fmts) },
1644  "set pixel format", "format" },
1645  { "display_rotation", OPT_TYPE_DOUBLE, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1646  { .off = OFFSET(display_rotations) },
1647  "set pure counter-clockwise rotation in degrees for stream(s)",
1648  "angle" },
1649  { "display_hflip", OPT_TYPE_BOOL, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1650  { .off = OFFSET(display_hflips) },
1651  "set display horizontal flip for stream(s) "
1652  "(overrides any display rotation if it is not set)"},
1653  { "display_vflip", OPT_TYPE_BOOL, OPT_VIDEO | OPT_PERSTREAM | OPT_INPUT | OPT_EXPERT,
1654  { .off = OFFSET(display_vflips) },
1655  "set display vertical flip for stream(s) "
1656  "(overrides any display rotation if it is not set)"},
1658  { .off = OFFSET(video_disable) },
1659  "disable video" },
1661  { .off = OFFSET(rc_overrides) },
1662  "rate control override for specific intervals", "override" },
1664  { .func_arg = opt_video_codec },
1665  "alias for -c:v (select encoder/decoder for video streams)", "codec",
1666  .u1.name_canon = "codec", },
1668  { .func_arg = opt_timecode },
1669  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
1671  { .off = OFFSET(pass) },
1672  "select the pass number (1 to 3)", "n" },
1674  { .off = OFFSET(passlogfiles) },
1675  "select two pass log file name prefix", "prefix" },
1676  { "vstats", OPT_TYPE_FUNC, OPT_VIDEO | OPT_EXPERT,
1677  { .func_arg = opt_vstats },
1678  "dump video coding statistics to file" },
1679  { "vstats_file", OPT_TYPE_FUNC, OPT_VIDEO | OPT_FUNC_ARG | OPT_EXPERT,
1680  { .func_arg = opt_vstats_file },
1681  "dump video coding statistics to file", "file" },
1682  { "vstats_version", OPT_TYPE_INT, OPT_VIDEO | OPT_EXPERT,
1683  { &vstats_version },
1684  "Version of the vstats format to use."},
1686  { .func_arg = opt_video_filters },
1687  "alias for -filter:v (apply filters to video streams)", "filter_graph",
1688  .u1.name_canon = "filter", },
1689  { "intra_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1690  { .off = OFFSET(intra_matrices) },
1691  "specify intra matrix coeffs", "matrix" },
1692  { "inter_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1693  { .off = OFFSET(inter_matrices) },
1694  "specify inter matrix coeffs", "matrix" },
1695  { "chroma_intra_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1696  { .off = OFFSET(chroma_intra_matrices) },
1697  "specify intra matrix coeffs", "matrix" },
1699  { .func_arg = opt_old2new },
1700  "force video tag/fourcc", "fourcc/tag",
1701  .u1.name_canon = "tag", },
1703  { .off = OFFSET(fps_mode) },
1704  "set framerate mode for matching video streams; overrides vsync" },
1706  { .off = OFFSET(force_fps) },
1707  "force the selected framerate, disable the best supported framerate selection" },
1709  { .func_arg = opt_streamid },
1710  "set the value of an outfile streamid", "streamIndex:value" },
1711  { "force_key_frames", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1712  { .off = OFFSET(forced_key_frames) },
1713  "force key frames at specified timestamps", "timestamps" },
1715  { .func_arg = opt_bitrate },
1716  "video bitrate (please use -b:v)", "bitrate" },
1718  { .off = OFFSET(hwaccels) },
1719  "use HW accelerated decoding", "hwaccel name" },
1720  { "hwaccel_device", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT,
1721  { .off = OFFSET(hwaccel_devices) },
1722  "select a device for HW acceleration", "devicename" },
1723  { "hwaccel_output_format", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_INPUT,
1724  { .off = OFFSET(hwaccel_output_formats) },
1725  "select output format used with HW accelerated decoding", "format" },
1726  { "hwaccels", OPT_TYPE_FUNC, OPT_EXIT | OPT_EXPERT,
1727  { .func_arg = show_hwaccels },
1728  "show available HW acceleration methods" },
1729  { "autorotate", OPT_TYPE_BOOL, OPT_PERSTREAM | OPT_EXPERT | OPT_INPUT,
1730  { .off = OFFSET(autorotate) },
1731  "automatically insert correct rotate filters" },
1732  { "autoscale", OPT_TYPE_BOOL, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1733  { .off = OFFSET(autoscale) },
1734  "automatically insert a scale filter at the end of the filter graph" },
1735  { "fix_sub_duration_heartbeat", OPT_TYPE_BOOL, OPT_VIDEO | OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1736  { .off = OFFSET(fix_sub_duration_heartbeat) },
1737  "set this video output stream to be a heartbeat stream for "
1738  "fix_sub_duration, according to which subtitles should be split at "
1739  "random access points" },
1740 
1741  /* audio options */
1743  { .func_arg = opt_audio_frames },
1744  "set the number of audio frames to output", "number",
1745  .u1.name_canon = "frames", },
1747  { .func_arg = opt_audio_qscale },
1748  "set audio quality (codec-specific)", "quality", },
1750  { .off = OFFSET(audio_sample_rate) },
1751  "set audio sampling rate (in Hz)", "rate" },
1753  { .off = OFFSET(audio_channels) },
1754  "set number of audio channels", "channels" },
1756  { .off = OFFSET(audio_disable) },
1757  "disable audio" },
1759  { .func_arg = opt_audio_codec },
1760  "alias for -c:a (select encoder/decoder for audio streams)", "codec",
1761  .u1.name_canon = "codec", },
1763  { .func_arg = opt_bitrate },
1764  "alias for -b:a (select bitrate for audio streams)", "bitrate" },
1766  { .func_arg = opt_old2new },
1767  "force audio tag/fourcc", "fourcc/tag",
1768  .u1.name_canon = "tag", },
1770  { .off = OFFSET(sample_fmts) },
1771  "set sample format", "format" },
1773  { .off = OFFSET(audio_ch_layouts) },
1774  "set channel layout", "layout",
1775  .u1.names_alt = alt_channel_layout, },
1777  { .off = OFFSET(audio_ch_layouts) },
1778  "set channel layout", "layout",
1779  .u1.name_canon = "channel_layout", },
1781  { .func_arg = opt_audio_filters },
1782  "alias for -filter:a (apply filters to audio streams)", "filter_graph",
1783  .u1.name_canon = "filter", },
1784  { "guess_layout_max", OPT_TYPE_INT, OPT_AUDIO | OPT_PERSTREAM | OPT_EXPERT | OPT_INPUT,
1785  { .off = OFFSET(guess_layout_max) },
1786  "set the maximum number of channels to try to guess the channel layout" },
1787 
1788  /* subtitle options */
1790  { .off = OFFSET(subtitle_disable) },
1791  "disable subtitle" },
1793  { .func_arg = opt_subtitle_codec },
1794  "alias for -c:s (select encoder/decoder for subtitle streams)", "codec",
1795  .u1.name_canon = "codec", },
1797  { .func_arg = opt_old2new }
1798  , "force subtitle tag/fourcc", "fourcc/tag",
1799  .u1.name_canon = "tag" },
1800  { "fix_sub_duration", OPT_TYPE_BOOL, OPT_EXPERT | OPT_SUBTITLE | OPT_PERSTREAM | OPT_INPUT,
1801  { .off = OFFSET(fix_sub_duration) },
1802  "fix subtitles duration" },
1804  { .off = OFFSET(canvas_sizes) },
1805  "set canvas size (WxH or abbreviation)", "size" },
1806 
1807  /* muxer options */
1808  { "muxdelay", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1809  { .off = OFFSET(mux_max_delay) },
1810  "set the maximum demux-decode delay", "seconds" },
1811  { "muxpreload", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
1812  { .off = OFFSET(mux_preload) },
1813  "set the initial demux-decode delay", "seconds" },
1814  { "sdp_file", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT | OPT_OUTPUT,
1815  { .func_arg = opt_sdp_file },
1816  "specify a file in which to print sdp information", "file" },
1817 
1818  { "time_base", OPT_TYPE_STRING, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1819  { .off = OFFSET(time_bases) },
1820  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
1821  { "enc_time_base", OPT_TYPE_STRING, OPT_EXPERT | OPT_PERSTREAM | OPT_OUTPUT,
1822  { .off = OFFSET(enc_time_bases) },
1823  "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
1824  "two special values are defined - "
1825  "0 = use frame rate (video) or sample rate (audio),"
1826  "-1 = match source time base", "ratio" },
1827 
1829  { .off = OFFSET(bitstream_filters) },
1830  "A comma-separated list of bitstream filters", "bitstream_filters", },
1831 
1833  { .func_arg = opt_preset },
1834  "set the audio options to the indicated preset", "preset",
1835  .u1.name_canon = "pre", },
1837  { .func_arg = opt_preset },
1838  "set the video options to the indicated preset", "preset",
1839  .u1.name_canon = "pre", },
1841  { .func_arg = opt_preset },
1842  "set the subtitle options to the indicated preset", "preset",
1843  .u1.name_canon = "pre", },
1845  { .func_arg = opt_preset },
1846  "set options from indicated preset file", "filename",
1847  .u1.name_canon = "pre", },
1848 
1849  { "max_muxing_queue_size", OPT_TYPE_INT, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1850  { .off = OFFSET(max_muxing_queue_size) },
1851  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
1852  { "muxing_queue_data_threshold", OPT_TYPE_INT, OPT_PERSTREAM | OPT_EXPERT | OPT_OUTPUT,
1853  { .off = OFFSET(muxing_queue_data_threshold) },
1854  "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
1855 
1856  /* data codec support */
1858  { .func_arg = opt_data_codec },
1859  "alias for -c:d (select encoder/decoder for data streams)", "codec",
1860  .u1.name_canon = "codec", },
1862  { .off = OFFSET(data_disable) }, "disable data" },
1863 
1864 #if CONFIG_VAAPI
1865  { "vaapi_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1866  { .func_arg = opt_vaapi_device },
1867  "set VAAPI hardware device (DirectX adapter index, DRM path or X11 display name)", "device" },
1868 #endif
1869 
1870 #if CONFIG_QSV
1871  { "qsv_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1872  { .func_arg = opt_qsv_device },
1873  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
1874 #endif
1875 
1876  { "init_hw_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1877  { .func_arg = opt_init_hw_device },
1878  "initialise hardware device", "args" },
1879  { "filter_hw_device", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1880  { .func_arg = opt_filter_hw_device },
1881  "set hardware device used when filtering", "device" },
1882 
1883  // deprecated options
1884 #if FFMPEG_OPT_ADRIFT_THRESHOLD
1885  { "adrift_threshold", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1886  { .func_arg = opt_adrift_threshold },
1887  "deprecated, does nothing", "threshold" },
1888 #endif
1889 #if FFMPEG_OPT_TOP
1891  { .off = OFFSET(top_field_first) },
1892  "deprecated, use the setfield video filter", "" },
1893 #endif
1894 #if FFMPEG_OPT_QPHIST
1895  { "qphist", OPT_TYPE_FUNC, OPT_VIDEO | OPT_EXPERT,
1896  { .func_arg = opt_qphist },
1897  "deprecated, does nothing" },
1898 #endif
1899 #if FFMPEG_OPT_VSYNC
1900  { "vsync", OPT_TYPE_FUNC, OPT_FUNC_ARG | OPT_EXPERT,
1901  { .func_arg = opt_vsync },
1902  "set video sync method globally; deprecated, use -fps_mode", "" },
1903 #endif
1904 
1905  { NULL, },
1906 };
OPT_EXIT
#define OPT_EXIT
Definition: cmdutils.h:138
show_help_options
void show_help_options(const OptionDef *options, const char *msg, int req_flags, int rej_flags)
Print help for all options matching specified flags.
Definition: cmdutils.c:107
AVCodec
AVCodec.
Definition: codec.h:187
fix_sub_duration_heartbeat
static int fix_sub_duration_heartbeat(DecoderPriv *dp, int64_t signal_pts)
Definition: ffmpeg_dec.c:580
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
InputFile::start_time
int64_t start_time
Definition: ffmpeg.h:450
ignore_unknown_streams
int ignore_unknown_streams
Definition: ffmpeg_opt.c:84
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
OptionsContext::stop_time
int64_t stop_time
Definition: ffmpeg.h:168
StreamMap::file_index
int file_index
Definition: ffmpeg.h:118
show_hwaccels
static int show_hwaccels(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:142
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
opt_abort_on
static int opt_abort_on(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:317
VSYNC_VFR
@ VSYNC_VFR
Definition: ffmpeg.h:69
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:105
opt.h
assert_file_overwrite
int assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:607
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
opt_video_filters
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:983
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:1048
debug_ts
int debug_ts
Definition: ffmpeg_opt.c:69
stats_period
int64_t stats_period
Definition: ffmpeg_opt.c:79
is
The official guide to swscale for confused that is
Definition: swscale.txt:28
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
opt_old2new
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:926
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:814
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
av_asprintf
char * av_asprintf(const char *fmt,...)
Definition: avstring.c:115
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:207
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:197
program_name
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:85
no_file_overwrite
static int no_file_overwrite
Definition: ffmpeg_opt.c:83
opt_default_new
static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:856
OptionsContext::nb_attachments
int nb_attachments
Definition: ffmpeg.h:163
avcodec_find_encoder
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:959
auto_conversion_filters
int auto_conversion_filters
Definition: ffmpeg_opt.c:78
audio_channels
int audio_channels
Definition: rtp.c:40
opt_audio_codec
static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:354
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1323
OptionsContext::mux_max_delay
float mux_max_delay
Definition: ffmpeg.h:171
OPT_FLAG_OFFSET
#define OPT_FLAG_OFFSET
Definition: cmdutils.h:154
OPT_INPUT
#define OPT_INPUT
Definition: cmdutils.h:168
copy_unknown_streams
int copy_unknown_streams
Definition: ffmpeg_opt.c:85
parse_number
int parse_number(const char *context, const char *numstr, enum OptionType type, double min, double max, double *dst)
Parse a string and return its corresponding value as a double.
Definition: cmdutils.c:84
AV_HWDEVICE_TYPE_NONE
@ AV_HWDEVICE_TYPE_NONE
Definition: hwcontext.h:28
AVOption
AVOption.
Definition: opt.h:357
OptionGroupList::groups
OptionGroup * groups
Definition: cmdutils.h:291
OptionGroupList::nb_groups
int nb_groups
Definition: cmdutils.h:292
opt_timelimit
int opt_timelimit(void *optctx, const char *opt, const char *arg)
Limit the execution time.
format_opts
AVDictionary * format_opts
Definition: cmdutils.c:58
filter_hw_device
HWDevice * filter_hw_device
Definition: ffmpeg_opt.c:50
ffmpeg.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
progress_avio
AVIOContext * progress_avio
Definition: ffmpeg.c:102
opt_filter_hw_device
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:537
fg_create
int fg_create(FilterGraph **pfg, char *graph_desc, Scheduler *sch)
Create a new filtergraph in the global filtergraph list.
Definition: ffmpeg_filter.c:1060
show_help_children
void show_help_children(const AVClass *class, int flags)
Show help for all options with given flags in class and all its children.
Definition: cmdutils.c:140
av_hwdevice_iterate_types
enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
Iterate over supported device types.
Definition: hwcontext.c:121
autorotate
static int autorotate
Definition: ffplay.c:348
UNKNOWN
@ UNKNOWN
Definition: ftp.c:39
video_disable
static int video_disable
Definition: ffplay.c:315
mathematics.h
AVDictionary
Definition: dict.c:34
HWDevice
Definition: ffmpeg.h:109
hw_device_init_from_string
int hw_device_init_from_string(const char *arg, HWDevice **dev)
Definition: ffmpeg_hw.c:92
do_benchmark
int do_benchmark
Definition: ffmpeg_opt.c:62
OptionDef
Definition: cmdutils.h:126
subtitle_disable
static int subtitle_disable
Definition: ffplay.c:316
OPT_DATA
#define OPT_DATA
Definition: cmdutils.h:146
OptionsContext::chapters_input_file
int chapters_input_file
Definition: ffmpeg.h:165
opt_filter_threads
static int opt_filter_threads(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:310
do_hex_dump
int do_hex_dump
Definition: ffmpeg_opt.c:64
OptionGroupList
A list of option groups that all have the same group type (e.g.
Definition: cmdutils.h:288
bsf.h
do_pkt_dump
int do_pkt_dump
Definition: ffmpeg_opt.c:65
uninit_options
static void uninit_options(OptionsContext *o)
Definition: ffmpeg_opt.c:88
presets
static const Preset presets[]
Definition: vf_pseudocolor.c:286
opt_timecode
static int opt_timecode(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1003
OptionsContext::g
OptionGroup * g
Definition: ffmpeg.h:124
fail
#define fail()
Definition: checkasm.h:182
StreamMap::disabled
int disabled
Definition: ffmpeg.h:117
opt_data_frames
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:850
ifile_open
int ifile_open(const OptionsContext *o, const char *filename, Scheduler *sch)
Definition: ffmpeg_demux.c:1527
OptionParseContext
Definition: cmdutils.h:295
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
sws_get_class
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:97
OptionsContext
Definition: ffmpeg.h:123
OPT_TYPE_FLOAT
@ OPT_TYPE_FLOAT
Definition: cmdutils.h:86
loop
static int loop
Definition: ffplay.c:335
AVRational::num
int num
Numerator.
Definition: rational.h:59
opt_audio_filters
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:989
InputFile
Definition: ffmpeg.h:436
opt_filter_complex_script
static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1034
OptionGroupDef
Definition: cmdutils.h:256
AV_OPT_FLAG_AUDIO_PARAM
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:285
OptionsContext::recording_time
int64_t recording_time
Definition: ffmpeg.h:167
OPT_PERSTREAM
#define OPT_PERSTREAM
Definition: cmdutils.h:164
OptionsContext::nb_stream_maps
int nb_stream_maps
Definition: ffmpeg.h:161
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:979
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM
#define ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM
Definition: ffmpeg.h:469
OptionGroup::codec_opts
AVDictionary * codec_opts
Definition: cmdutils.h:278
SpecifierOptList::nb_opt
int nb_opt
Definition: cmdutils.h:119
opt_attach
static int opt_attach(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:470
opt_recording_timestamp
static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:551
StreamMap::linklabel
char * linklabel
Definition: ffmpeg.h:120
SpecifierOpt::specifier
char * specifier
stream/chapter/program/...
Definition: cmdutils.h:106
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
SpecifierOptList::type
enum OptionType type
Definition: cmdutils.h:123
s
#define s(width, name)
Definition: cbs_vp9.c:198
split_commandline
int split_commandline(OptionParseContext *octx, int argc, char *argv[], const OptionDef *options, const OptionGroupDef *groups, int nb_groups)
Split the commandline into an intermediate form convenient for further processing.
Definition: cmdutils.c:773
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1267
g
const char * g
Definition: vf_curves.c:128
AVDictionaryEntry::key
char * key
Definition: dict.h:90
OptionsContext::limit_filesize
int64_t limit_filesize
Definition: ffmpeg.h:169
av_strtok
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok().
Definition: avstring.c:178
OPT_TYPE_DOUBLE
@ OPT_TYPE_DOUBLE
Definition: cmdutils.h:87
opt_audio_qscale
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1017
filters
#define filters(fmt, type, inverse, clp, inverset, clip, one, clip_fn, packed)
Definition: af_crystalizer.c:54
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
term_init
void term_init(void)
Definition: ffmpeg.c:201
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
exit_on_error
int exit_on_error
Definition: ffmpeg_opt.c:70
ctx
AVFormatContext * ctx
Definition: movenc.c:49
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
term_exit
void term_exit(void)
Definition: ffmpeg.c:131
av_hwdevice_get_type_name
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:112
do_benchmark_all
int do_benchmark_all
Definition: ffmpeg_opt.c:63
OptionsContext::accurate_seek
int accurate_seek
Definition: ffmpeg.h:147
key
const char * key
Definition: hwcontext_opencl.c:189
opt_video_frames
static int opt_video_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:838
AV_OPT_FLAG_BSF_PARAM
#define AV_OPT_FLAG_BSF_PARAM
A generic parameter which can be set by the user for bit stream filtering.
Definition: opt.h:300
sch_sdp_filename
int sch_sdp_filename(Scheduler *sch, const char *sdp_filename)
Set the file path for the SDP.
Definition: ffmpeg_sched.c:607
arg
const char * arg
Definition: jacosubdec.c:67
if
if(ret)
Definition: filter_design.txt:179
OPT_SPEC
#define OPT_SPEC
Definition: cmdutils.h:160
OptionsContext::start_time
int64_t start_time
Definition: ffmpeg.h:127
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
OptionGroup::format_opts
AVDictionary * format_opts
Definition: cmdutils.h:279
opts
AVDictionary * opts
Definition: movenc.c:51
opt_target
static int opt_target(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:672
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
open_file
static int open_file(AVFormatContext *avf, unsigned fileno)
Definition: concatdec.c:335
opt_profile
static int opt_profile(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:971
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
dec_create
int dec_create(const OptionsContext *o, const char *arg, Scheduler *sch)
Create a standalone decoder.
Definition: ffmpeg_dec.c:1298
strip_specifiers
AVDictionary * strip_specifiers(const AVDictionary *dict)
Definition: ffmpeg_opt.c:155
avcodec_get_class
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:184
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:782
NULL
#define NULL
Definition: coverity.c:32
OPT_HAS_ALT
#define OPT_HAS_ALT
Definition: cmdutils.h:173
OptionParseContext::global_opts
OptionGroup global_opts
Definition: cmdutils.h:296
avcodec_find_decoder_by_name
const AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:992
av_bsf_get_class
const AVClass * av_bsf_get_class(void)
Get the AVClass for AVBSFContext.
Definition: bsf.c:99
OPT_EXPERT
#define OPT_EXPERT
Definition: cmdutils.h:142
swr_get_class
const AVClass * swr_get_class(void)
Get the AVClass for SwrContext.
Definition: options.c:143
InputFile::start_time_effective
int64_t start_time_effective
Effective format start time based on enabled streams.
Definition: ffmpeg.h:447
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
parseutils.h
double
double
Definition: af_crystalizer.c:131
parse_and_set_vsync
int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_idx, int is_global)
Definition: ffmpeg_opt.c:185
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:589
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
OptionsContext::input_sync_ref
int input_sync_ref
Definition: ffmpeg.h:149
OptionGroup
Definition: cmdutils.h:271
correct_input_start_times
static void correct_input_start_times(void)
Definition: ffmpeg_opt.c:221
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
A generic parameter which can be set by the user for muxing or encoding.
Definition: opt.h:280
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
input_files
InputFile ** input_files
Definition: ffmpeg.c:104
Scheduler
Definition: ffmpeg_sched.c:269
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:964
opt_streamid
static int opt_streamid(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:653
file_read
char * file_read(const char *filename)
Definition: cmdutils.c:1125
opt_preset
static int opt_preset(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:876
opt_vstats_file
static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:815
codec_opts
AVDictionary * codec_opts
Definition: cmdutils.c:58
options
const OptionDef options[]
VideoSyncMethod
VideoSyncMethod
Definition: ffmpeg.h:65
opt_bitrate
static int opt_bitrate(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:938
AV_OPT_FLAG_FILTERING_PARAM
#define AV_OPT_FLAG_FILTERING_PARAM
A generic parameter which can be set by the user for filtering.
Definition: opt.h:309
max_error_rate
float max_error_rate
Definition: ffmpeg_opt.c:74
frame_sizes
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
OptionsContext::thread_queue_size
int thread_queue_size
Definition: ffmpeg.h:148
AVMediaType
AVMediaType
Definition: avutil.h:199
OPT_TYPE_INT
@ OPT_TYPE_INT
Definition: cmdutils.h:84
opt_init_hw_device
static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:522
SpecifierOptList
Definition: cmdutils.h:117
OPT_AUDIO
#define OPT_AUDIO
Definition: cmdutils.h:144
opt_map
static int opt_map(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:378
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
start_time
static int64_t start_time
Definition: ffplay.c:326
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1371
get_preset_file
FILE * get_preset_file(char *filename, size_t filename_size, const char *preset_name, int is_path, const char *codec_name)
Get a file corresponding to a preset file.
Definition: cmdutils.c:907
StreamMap
Definition: ffmpeg.h:116
file_overwrite
static int file_overwrite
Definition: ffmpeg_opt.c:82
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
opt_subtitle_codec
static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:366
OptionsContext::streamid
AVDictionary * streamid
Definition: ffmpeg.h:182
PAL
#define PAL
Definition: bktr.c:68
avio_check
int avio_check(const char *url, int flags)
Return AVIO_FLAG_* access flags corresponding to the access permissions of the resource in url,...
Definition: avio.c:664
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
vstats_filename
char * vstats_filename
Definition: ffmpeg_opt.c:52
OPT_TYPE_INT64
@ OPT_TYPE_INT64
Definition: cmdutils.h:85
printf
printf("static const uint8_t my_array[100] = {\n")
show_usage
void show_usage(void)
Definition: ffmpeg_opt.c:1165
opt_sdp_file
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:484
fg_finalise_bindings
int fg_finalise_bindings(void)
Definition: ffmpeg_filter.c:1376
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:165
OPT_FLAG_SPEC
#define OPT_FLAG_SPEC
Definition: cmdutils.h:159
OptionsContext::find_stream_info
int find_stream_info
Definition: ffmpeg.h:150
SpecifierOptList::opt
SpecifierOpt * opt
Definition: cmdutils.h:118
line
Definition: graph2dot.c:48
opt_data_codec
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:372
init_options
static void init_options(OptionsContext *o)
Definition: ffmpeg_opt.c:124
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
NTSC
#define NTSC
Definition: bktr.c:70
OPT_TYPE_FUNC
@ OPT_TYPE_FUNC
Definition: cmdutils.h:81
OPT_DECODER
#define OPT_DECODER
Definition: cmdutils.h:179
OPT_TYPE_BOOL
@ OPT_TYPE_BOOL
Definition: cmdutils.h:82
video_sync_method
enum VideoSyncMethod video_sync_method
Definition: ffmpeg_opt.c:59
OPT_HAS_CANON
#define OPT_HAS_CANON
Definition: cmdutils.h:176
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
start_at_zero
int start_at_zero
Definition: ffmpeg_opt.c:67
apply_sync_offsets
static int apply_sync_offsets(void)
Definition: ffmpeg_opt.c:258
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
StreamMap::stream_index
int stream_index
Definition: ffmpeg.h:119
OPT_TYPE_TIME
@ OPT_TYPE_TIME
Definition: cmdutils.h:88
OptionsContext::codec_names
SpecifierOptList codec_names
Definition: ffmpeg.h:132
OptionsContext::stream_maps
StreamMap * stream_maps
Definition: ffmpeg.h:160
OptionsContext::start_time_eof
int64_t start_time_eof
Definition: ffmpeg.h:128
VSYNC_CFR
@ VSYNC_CFR
Definition: ffmpeg.h:68
OptionsContext::shortest_buf_duration
float shortest_buf_duration
Definition: ffmpeg.h:172
opt_video_codec
static int opt_video_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:360
opt_qscale
static int opt_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:954
stdin_interaction
int stdin_interaction
Definition: ffmpeg_opt.c:73
value
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 value
Definition: writing_filters.txt:86
InputFile::ctx
AVFormatContext * ctx
Definition: ffmpeg.h:441
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:286
OPT_FUNC_ARG
#define OPT_FUNC_ARG
Definition: cmdutils.h:136
opt_vstats
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:822
OPT_OUTPUT
#define OPT_OUTPUT
Definition: cmdutils.h:169
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
dts_error_threshold
float dts_error_threshold
Definition: ffmpeg_opt.c:56
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:306
OPT_OFFSET
#define OPT_OFFSET
Definition: cmdutils.h:155
OptionParseContext::groups
OptionGroupList * groups
Definition: cmdutils.h:298
opt_audio_frames
static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:844
avcodec.h
av_opt_eval_flags
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
find_codec
int find_codec(void *logctx, const char *name, enum AVMediaType type, int encoder, const AVCodec **pcodec)
Definition: ffmpeg_opt.c:574
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:174
read_yesno
int read_yesno(void)
Return a positive value if a line read from standard input starts with [yY], otherwise return 0.
Definition: cmdutils.c:896
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
VSYNC_DROP
@ VSYNC_DROP
Definition: ffmpeg.h:72
uninit_parse_context
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:748
OPT_PERFILE
#define OPT_PERFILE
Definition: cmdutils.h:150
find_stream_info
static int find_stream_info
Definition: ffplay.c:349
avformat.h
CMDUTILS_COMMON_OPTIONS
#define CMDUTILS_COMMON_OPTIONS
Definition: opt_common.h:199
filter_nbthreads
char * filter_nbthreads
Definition: ffmpeg_opt.c:75
OPT_FLAG_PERSTREAM
#define OPT_FLAG_PERSTREAM
Definition: cmdutils.h:163
parse_option
int parse_option(void *optctx, const char *opt, const char *arg, const OptionDef *options)
Parse one given option.
Definition: cmdutils.c:365
OptionsContext::mux_preload
float mux_preload
Definition: ffmpeg.h:170
audio_drift_threshold
float audio_drift_threshold
Definition: ffmpeg_opt.c:54
opt_match_per_type_str
const char * opt_match_per_type_str(const SpecifierOptList *sol, char mediatype)
Definition: ffmpeg_opt.c:172
opt_common.h
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
AVRational::den
int den
Denominator.
Definition: rational.h:60
SpecifierOpt::str
uint8_t * str
Definition: cmdutils.h:108
OPT_SUBTITLE
#define OPT_SUBTITLE
Definition: cmdutils.h:145
avfilter.h
av_get_token
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:143
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
ffmpeg_parse_options
int ffmpeg_parse_options(int argc, char **argv, Scheduler *sch)
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:465
InputFile::ts_offset
int64_t ts_offset
Definition: ffmpeg.h:448
VSYNC_AUTO
@ VSYNC_AUTO
Definition: ffmpeg.h:66
opt_vsync
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:996
parse_optgroup
int parse_optgroup(void *optctx, OptionGroup *g, const OptionDef *defs)
Parse an options group and write results into optctx.
Definition: cmdutils.c:441
AVERROR_DECODER_NOT_FOUND
#define AVERROR_DECODER_NOT_FOUND
Decoder not found.
Definition: error.h:54
opt_default
int opt_default(void *optctx, const char *opt, const char *arg)
Fallback for options that are not explicitly handled, these will be parsed through AVOptions.
Definition: cmdutils.c:582
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:284
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVERROR_ENCODER_NOT_FOUND
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
Definition: error.h:56
avutil.h
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:481
mem.h
copy_tb
int copy_tb
Definition: ffmpeg_opt.c:68
SpecifierOpt::u
union SpecifierOpt::@0 u
opt_stats_period
static int opt_stats_period(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:336
vstats_version
int vstats_version
Definition: ffmpeg_opt.c:77
avio_open2
int avio_open2(AVIOContext **s, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: avio.c:491
of_open
int of_open(const OptionsContext *o, const char *filename, Scheduler *sch)
Definition: ffmpeg_mux_init.c:3192
OptionDef::name
const char * name
Definition: cmdutils.h:127
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
ffmpeg_sched.h
OPT_VIDEO
#define OPT_VIDEO
Definition: cmdutils.h:143
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
OptionsContext::attachments
const char ** attachments
Definition: ffmpeg.h:162
OPT_TYPE_STRING
@ OPT_TYPE_STRING
Definition: cmdutils.h:83
audio_disable
static int audio_disable
Definition: ffplay.c:314
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:237
copy_ts
int copy_ts
Definition: ffmpeg_opt.c:66
cmdutils.h
OFFSET
#define OFFSET(x)
InputFile::input_ts_offset
int64_t input_ts_offset
Definition: ffmpeg.h:442
avio_find_protocol_name
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:657
codec_string
Definition: dashenc.c:209
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Definition: opt.h:244
frame_drop_threshold
float frame_drop_threshold
Definition: ffmpeg_opt.c:61
recast_media
int recast_media
Definition: ffmpeg_opt.c:86
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
print_stats
int print_stats
Definition: ffmpeg_opt.c:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:792
avstring.h
avcodec_descriptor_get_by_name
const AVCodecDescriptor * avcodec_descriptor_get_by_name(const char *name)
Definition: codec_desc.c:3750
InputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:456
hw_device_get_by_name
HWDevice * hw_device_get_by_name(const char *name)
Definition: ffmpeg_hw.c:42
avfilter_get_class
const AVClass * avfilter_get_class(void)
Definition: avfilter.c:1608
dump_attachment
static int dump_attachment(InputStream *ist, const char *filename)
Definition: ffmpeg_demux.c:1460
VSYNC_PASSTHROUGH
@ VSYNC_PASSTHROUGH
Definition: ffmpeg.h:67
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
snprintf
#define snprintf
Definition: snprintf.h:34
ABORT_ON_FLAG_EMPTY_OUTPUT
#define ABORT_ON_FLAG_EMPTY_OUTPUT
Definition: ffmpeg.h:468
opt_filter_complex
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:1023
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
avcodec_find_encoder_by_name
const AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
Definition: allcodecs.c:987
dts_delta_threshold
float dts_delta_threshold
Definition: ffmpeg_opt.c:55
abort_on_flags
int abort_on_flags
Definition: ffmpeg_opt.c:71
filter_complex_nbthreads
int filter_complex_nbthreads
Definition: ffmpeg_opt.c:76