FFmpeg
ffmpeg_opt.c
Go to the documentation of this file.
1 
2 /*
3  * ffmpeg option parsing
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdint.h>
23 
24 #include "ffmpeg.h"
25 #include "cmdutils.h"
26 
27 #include "libavformat/avformat.h"
28 
29 #include "libavcodec/avcodec.h"
30 
31 #include "libavfilter/avfilter.h"
32 
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
44 
45 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 
47 #define SPECIFIER_OPT_FMT_str "%s"
48 #define SPECIFIER_OPT_FMT_i "%i"
49 #define SPECIFIER_OPT_FMT_i64 "%"PRId64
50 #define SPECIFIER_OPT_FMT_ui64 "%"PRIu64
51 #define SPECIFIER_OPT_FMT_f "%f"
52 #define SPECIFIER_OPT_FMT_dbl "%lf"
53 
54 static const char *opt_name_codec_names[] = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL};
55 static const char *opt_name_audio_channels[] = {"ac", NULL};
56 static const char *opt_name_audio_sample_rate[] = {"ar", NULL};
57 static const char *opt_name_frame_rates[] = {"r", NULL};
58 static const char *opt_name_frame_sizes[] = {"s", NULL};
59 static const char *opt_name_frame_pix_fmts[] = {"pix_fmt", NULL};
60 static const char *opt_name_ts_scale[] = {"itsscale", NULL};
61 static const char *opt_name_hwaccels[] = {"hwaccel", NULL};
62 static const char *opt_name_hwaccel_devices[] = {"hwaccel_device", NULL};
63 static const char *opt_name_hwaccel_output_formats[] = {"hwaccel_output_format", NULL};
64 static const char *opt_name_autorotate[] = {"autorotate", NULL};
65 static const char *opt_name_autoscale[] = {"autoscale", NULL};
66 static const char *opt_name_max_frames[] = {"frames", "aframes", "vframes", "dframes", NULL};
67 static const char *opt_name_bitstream_filters[] = {"bsf", "absf", "vbsf", NULL};
68 static const char *opt_name_codec_tags[] = {"tag", "atag", "vtag", "stag", NULL};
69 static const char *opt_name_sample_fmts[] = {"sample_fmt", NULL};
70 static const char *opt_name_qscale[] = {"q", "qscale", NULL};
71 static const char *opt_name_forced_key_frames[] = {"forced_key_frames", NULL};
72 static const char *opt_name_force_fps[] = {"force_fps", NULL};
73 static const char *opt_name_frame_aspect_ratios[] = {"aspect", NULL};
74 static const char *opt_name_rc_overrides[] = {"rc_override", NULL};
75 static const char *opt_name_intra_matrices[] = {"intra_matrix", NULL};
76 static const char *opt_name_inter_matrices[] = {"inter_matrix", NULL};
77 static const char *opt_name_chroma_intra_matrices[] = {"chroma_intra_matrix", NULL};
78 static const char *opt_name_top_field_first[] = {"top", NULL};
79 static const char *opt_name_presets[] = {"pre", "apre", "vpre", "spre", NULL};
80 static const char *opt_name_copy_initial_nonkeyframes[] = {"copyinkfr", NULL};
81 static const char *opt_name_copy_prior_start[] = {"copypriorss", NULL};
82 static const char *opt_name_filters[] = {"filter", "af", "vf", NULL};
83 static const char *opt_name_filter_scripts[] = {"filter_script", NULL};
84 static const char *opt_name_reinit_filters[] = {"reinit_filter", NULL};
85 static const char *opt_name_fix_sub_duration[] = {"fix_sub_duration", NULL};
86 static const char *opt_name_canvas_sizes[] = {"canvas_size", NULL};
87 static const char *opt_name_pass[] = {"pass", NULL};
88 static const char *opt_name_passlogfiles[] = {"passlogfile", NULL};
89 static const char *opt_name_max_muxing_queue_size[] = {"max_muxing_queue_size", NULL};
90 static const char *opt_name_guess_layout_max[] = {"guess_layout_max", NULL};
91 static const char *opt_name_apad[] = {"apad", NULL};
92 static const char *opt_name_discard[] = {"discard", NULL};
93 static const char *opt_name_disposition[] = {"disposition", NULL};
94 static const char *opt_name_time_bases[] = {"time_base", NULL};
95 static const char *opt_name_enc_time_bases[] = {"enc_time_base", NULL};
96 
97 #define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
98 {\
99  char namestr[128] = "";\
100  const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
101  for (i = 0; opt_name_##name[i]; i++)\
102  av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
103  av_log(NULL, AV_LOG_WARNING, "Multiple %s options specified for stream %d, only the last option '-%s%s%s "SPECIFIER_OPT_FMT_##type"' will be used.\n",\
104  namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
105 }
106 
107 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
108 {\
109  int i, ret, matches = 0;\
110  SpecifierOpt *so;\
111  for (i = 0; i < o->nb_ ## name; i++) {\
112  char *spec = o->name[i].specifier;\
113  if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0) {\
114  outvar = o->name[i].u.type;\
115  so = &o->name[i];\
116  matches++;\
117  } else if (ret < 0)\
118  exit_program(1);\
119  }\
120  if (matches > 1)\
121  WARN_MULTIPLE_OPT_USAGE(name, type, so, st);\
122 }
123 
124 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
125 {\
126  int i;\
127  for (i = 0; i < o->nb_ ## name; i++) {\
128  char *spec = o->name[i].specifier;\
129  if (!strcmp(spec, mediatype))\
130  outvar = o->name[i].u.type;\
131  }\
132 }
133 
134 const HWAccel hwaccels[] = {
135 #if CONFIG_VIDEOTOOLBOX
137 #endif
138 #if CONFIG_LIBMFX
139  { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
140 #endif
141  { 0 },
142 };
144 
147 
150 float dts_error_threshold = 3600*30;
151 
152 int audio_volume = 256;
157 int do_benchmark = 0;
159 int do_hex_dump = 0;
160 int do_pkt_dump = 0;
161 int copy_ts = 0;
163 int copy_tb = -1;
164 int debug_ts = 0;
167 int print_stats = -1;
168 int qp_hist = 0;
171 float max_error_rate = 2.0/3;
175 
176 
177 static int intra_only = 0;
178 static int file_overwrite = 0;
179 static int no_file_overwrite = 0;
180 static int do_psnr = 0;
181 static int input_sync;
183 static int ignore_unknown_streams = 0;
184 static int copy_unknown_streams = 0;
185 static int find_stream_info = 1;
186 
188 {
189  const OptionDef *po = options;
190  int i;
191 
192  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
193  while (po->name) {
194  void *dst = (uint8_t*)o + po->u.off;
195 
196  if (po->flags & OPT_SPEC) {
197  SpecifierOpt **so = dst;
198  int i, *count = (int*)(so + 1);
199  for (i = 0; i < *count; i++) {
200  av_freep(&(*so)[i].specifier);
201  if (po->flags & OPT_STRING)
202  av_freep(&(*so)[i].u.str);
203  }
204  av_freep(so);
205  *count = 0;
206  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
207  av_freep(dst);
208  po++;
209  }
210 
211  for (i = 0; i < o->nb_stream_maps; i++)
213  av_freep(&o->stream_maps);
215  av_freep(&o->streamid_map);
216  av_freep(&o->attachments);
217 }
218 
220 {
221  memset(o, 0, sizeof(*o));
222 
223  o->stop_time = INT64_MAX;
224  o->mux_max_delay = 0.7;
227  o->recording_time = INT64_MAX;
228  o->limit_filesize = UINT64_MAX;
229  o->chapters_input_file = INT_MAX;
230  o->accurate_seek = 1;
231 }
232 
233 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
234 {
236 
237  printf("Hardware acceleration methods:\n");
238  while ((type = av_hwdevice_iterate_types(type)) !=
240  printf("%s\n", av_hwdevice_get_type_name(type));
241  printf("\n");
242  return 0;
243 }
244 
245 /* return a copy of the input with the stream specifiers removed from the keys */
247 {
248  AVDictionaryEntry *e = NULL;
249  AVDictionary *ret = NULL;
250 
251  while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
252  char *p = strchr(e->key, ':');
253 
254  if (p)
255  *p = 0;
256  av_dict_set(&ret, e->key, e->value, 0);
257  if (p)
258  *p = ':';
259  }
260  return ret;
261 }
262 
263 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
264 {
265  static const AVOption opts[] = {
266  { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
267  { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
268  { "empty_output_stream", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT_STREAM }, .unit = "flags" },
269  { NULL },
270  };
271  static const AVClass class = {
272  .class_name = "",
273  .item_name = av_default_item_name,
274  .option = opts,
275  .version = LIBAVUTIL_VERSION_INT,
276  };
277  const AVClass *pclass = &class;
278 
279  return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
280 }
281 
282 static int opt_sameq(void *optctx, const char *opt, const char *arg)
283 {
284  av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
285  "If you are looking for an option to preserve the quality (which is not "
286  "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
287  opt, opt);
288  return AVERROR(EINVAL);
289 }
290 
291 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
292 {
293  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
294  return opt_default(optctx, "channel", arg);
295 }
296 
297 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
298 {
299  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
300  return opt_default(optctx, "standard", arg);
301 }
302 
303 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
304 {
305  OptionsContext *o = optctx;
306  return parse_option(o, "codec:a", arg, options);
307 }
308 
309 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
310 {
311  OptionsContext *o = optctx;
312  return parse_option(o, "codec:v", arg, options);
313 }
314 
315 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
316 {
317  OptionsContext *o = optctx;
318  return parse_option(o, "codec:s", arg, options);
319 }
320 
321 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
322 {
323  OptionsContext *o = optctx;
324  return parse_option(o, "codec:d", arg, options);
325 }
326 
327 static int opt_map(void *optctx, const char *opt, const char *arg)
328 {
329  OptionsContext *o = optctx;
330  StreamMap *m = NULL;
331  int i, negative = 0, file_idx, disabled = 0;
332  int sync_file_idx = -1, sync_stream_idx = 0;
333  char *p, *sync;
334  char *map;
335  char *allow_unused;
336 
337  if (*arg == '-') {
338  negative = 1;
339  arg++;
340  }
341  map = av_strdup(arg);
342  if (!map)
343  return AVERROR(ENOMEM);
344 
345  /* parse sync stream first, just pick first matching stream */
346  if (sync = strchr(map, ',')) {
347  *sync = 0;
348  sync_file_idx = strtol(sync + 1, &sync, 0);
349  if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
350  av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
351  exit_program(1);
352  }
353  if (*sync)
354  sync++;
355  for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
356  if (check_stream_specifier(input_files[sync_file_idx]->ctx,
357  input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
358  sync_stream_idx = i;
359  break;
360  }
361  if (i == input_files[sync_file_idx]->nb_streams) {
362  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
363  "match any streams.\n", arg);
364  exit_program(1);
365  }
366  if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
367  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
368  "stream.\n", arg);
369  exit_program(1);
370  }
371  }
372 
373 
374  if (map[0] == '[') {
375  /* this mapping refers to lavfi output */
376  const char *c = map + 1;
378  m = &o->stream_maps[o->nb_stream_maps - 1];
379  m->linklabel = av_get_token(&c, "]");
380  if (!m->linklabel) {
381  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
382  exit_program(1);
383  }
384  } else {
385  if (allow_unused = strchr(map, '?'))
386  *allow_unused = 0;
387  file_idx = strtol(map, &p, 0);
388  if (file_idx >= nb_input_files || file_idx < 0) {
389  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
390  exit_program(1);
391  }
392  if (negative)
393  /* disable some already defined maps */
394  for (i = 0; i < o->nb_stream_maps; i++) {
395  m = &o->stream_maps[i];
396  if (file_idx == m->file_index &&
399  *p == ':' ? p + 1 : p) > 0)
400  m->disabled = 1;
401  }
402  else
403  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
404  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
405  *p == ':' ? p + 1 : p) <= 0)
406  continue;
407  if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
408  disabled = 1;
409  continue;
410  }
412  m = &o->stream_maps[o->nb_stream_maps - 1];
413 
414  m->file_index = file_idx;
415  m->stream_index = i;
416 
417  if (sync_file_idx >= 0) {
418  m->sync_file_index = sync_file_idx;
419  m->sync_stream_index = sync_stream_idx;
420  } else {
421  m->sync_file_index = file_idx;
422  m->sync_stream_index = i;
423  }
424  }
425  }
426 
427  if (!m) {
428  if (allow_unused) {
429  av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
430  } else if (disabled) {
431  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
432  "To ignore this, add a trailing '?' to the map.\n", arg);
433  exit_program(1);
434  } else {
435  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
436  "To ignore this, add a trailing '?' to the map.\n", arg);
437  exit_program(1);
438  }
439  }
440 
441  av_freep(&map);
442  return 0;
443 }
444 
445 static int opt_attach(void *optctx, const char *opt, const char *arg)
446 {
447  OptionsContext *o = optctx;
449  o->attachments[o->nb_attachments - 1] = arg;
450  return 0;
451 }
452 
453 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
454 {
455  OptionsContext *o = optctx;
456  int n;
457  AVStream *st;
458  AudioChannelMap *m;
459  char *allow_unused;
460  char *mapchan;
461  mapchan = av_strdup(arg);
462  if (!mapchan)
463  return AVERROR(ENOMEM);
464 
467 
468  /* muted channel syntax */
469  n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
470  if ((n == 1 || n == 3) && m->channel_idx == -1) {
471  m->file_idx = m->stream_idx = -1;
472  if (n == 1)
473  m->ofile_idx = m->ostream_idx = -1;
474  av_free(mapchan);
475  return 0;
476  }
477 
478  /* normal syntax */
479  n = sscanf(arg, "%d.%d.%d:%d.%d",
480  &m->file_idx, &m->stream_idx, &m->channel_idx,
481  &m->ofile_idx, &m->ostream_idx);
482 
483  if (n != 3 && n != 5) {
484  av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
485  "[file.stream.channel|-1][:syncfile:syncstream]\n");
486  exit_program(1);
487  }
488 
489  if (n != 5) // only file.stream.channel specified
490  m->ofile_idx = m->ostream_idx = -1;
491 
492  /* check input */
493  if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
494  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
495  m->file_idx);
496  exit_program(1);
497  }
498  if (m->stream_idx < 0 ||
500  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
501  m->file_idx, m->stream_idx);
502  exit_program(1);
503  }
504  st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
505  if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
506  av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
507  m->file_idx, m->stream_idx);
508  exit_program(1);
509  }
510  /* allow trailing ? to map_channel */
511  if (allow_unused = strchr(mapchan, '?'))
512  *allow_unused = 0;
513  if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
515  if (allow_unused) {
516  av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
517  m->file_idx, m->stream_idx, m->channel_idx);
518  } else {
519  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
520  "To ignore this, add a trailing '?' to the map_channel.\n",
521  m->file_idx, m->stream_idx, m->channel_idx);
522  exit_program(1);
523  }
524 
525  }
526  av_free(mapchan);
527  return 0;
528 }
529 
530 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
531 {
533  sdp_filename = av_strdup(arg);
534  return 0;
535 }
536 
537 #if CONFIG_VAAPI
538 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
539 {
540  const char *prefix = "vaapi:";
541  char *tmp;
542  int err;
543  tmp = av_asprintf("%s%s", prefix, arg);
544  if (!tmp)
545  return AVERROR(ENOMEM);
546  err = hw_device_init_from_string(tmp, NULL);
547  av_free(tmp);
548  return err;
549 }
550 #endif
551 
552 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
553 {
554  if (!strcmp(arg, "list")) {
556  printf("Supported hardware device types:\n");
557  while ((type = av_hwdevice_iterate_types(type)) !=
559  printf("%s\n", av_hwdevice_get_type_name(type));
560  printf("\n");
561  exit_program(0);
562  } else {
563  return hw_device_init_from_string(arg, NULL);
564  }
565 }
566 
567 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
568 {
569  if (filter_hw_device) {
570  av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
571  return AVERROR(EINVAL);
572  }
573  filter_hw_device = hw_device_get_by_name(arg);
574  if (!filter_hw_device) {
575  av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
576  return AVERROR(EINVAL);
577  }
578  return 0;
579 }
580 
581 /**
582  * Parse a metadata specifier passed as 'arg' parameter.
583  * @param arg metadata string to parse
584  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
585  * @param index for type c/p, chapter/program index is written here
586  * @param stream_spec for type s, the stream specifier is written here
587  */
588 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
589 {
590  if (*arg) {
591  *type = *arg;
592  switch (*arg) {
593  case 'g':
594  break;
595  case 's':
596  if (*(++arg) && *arg != ':') {
597  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
598  exit_program(1);
599  }
600  *stream_spec = *arg == ':' ? arg + 1 : "";
601  break;
602  case 'c':
603  case 'p':
604  if (*(++arg) == ':')
605  *index = strtol(++arg, NULL, 0);
606  break;
607  default:
608  av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
609  exit_program(1);
610  }
611  } else
612  *type = 'g';
613 }
614 
615 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
616 {
617  AVDictionary **meta_in = NULL;
618  AVDictionary **meta_out = NULL;
619  int i, ret = 0;
620  char type_in, type_out;
621  const char *istream_spec = NULL, *ostream_spec = NULL;
622  int idx_in = 0, idx_out = 0;
623 
624  parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
625  parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
626 
627  if (!ic) {
628  if (type_out == 'g' || !*outspec)
629  o->metadata_global_manual = 1;
630  if (type_out == 's' || !*outspec)
632  if (type_out == 'c' || !*outspec)
634  return 0;
635  }
636 
637  if (type_in == 'g' || type_out == 'g')
638  o->metadata_global_manual = 1;
639  if (type_in == 's' || type_out == 's')
641  if (type_in == 'c' || type_out == 'c')
643 
644  /* ic is NULL when just disabling automatic mappings */
645  if (!ic)
646  return 0;
647 
648 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
649  if ((index) < 0 || (index) >= (nb_elems)) {\
650  av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
651  (desc), (index));\
652  exit_program(1);\
653  }
654 
655 #define SET_DICT(type, meta, context, index)\
656  switch (type) {\
657  case 'g':\
658  meta = &context->metadata;\
659  break;\
660  case 'c':\
661  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
662  meta = &context->chapters[index]->metadata;\
663  break;\
664  case 'p':\
665  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
666  meta = &context->programs[index]->metadata;\
667  break;\
668  case 's':\
669  break; /* handled separately below */ \
670  default: av_assert0(0);\
671  }\
672 
673  SET_DICT(type_in, meta_in, ic, idx_in);
674  SET_DICT(type_out, meta_out, oc, idx_out);
675 
676  /* for input streams choose first matching stream */
677  if (type_in == 's') {
678  for (i = 0; i < ic->nb_streams; i++) {
679  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
680  meta_in = &ic->streams[i]->metadata;
681  break;
682  } else if (ret < 0)
683  exit_program(1);
684  }
685  if (!meta_in) {
686  av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
687  exit_program(1);
688  }
689  }
690 
691  if (type_out == 's') {
692  for (i = 0; i < oc->nb_streams; i++) {
693  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
694  meta_out = &oc->streams[i]->metadata;
695  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
696  } else if (ret < 0)
697  exit_program(1);
698  }
699  } else
700  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
701 
702  return 0;
703 }
704 
705 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
706 {
707  OptionsContext *o = optctx;
708  char buf[128];
709  int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
710  struct tm time = *gmtime((time_t*)&recording_timestamp);
711  if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
712  return -1;
713  parse_option(o, "metadata", buf, options);
714 
715  av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
716  "tag instead.\n", opt);
717  return 0;
718 }
719 
720 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
721 {
722  const AVCodecDescriptor *desc;
723  const char *codec_string = encoder ? "encoder" : "decoder";
724  AVCodec *codec;
725 
726  codec = encoder ?
729 
730  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
731  codec = encoder ? avcodec_find_encoder(desc->id) :
732  avcodec_find_decoder(desc->id);
733  if (codec)
734  av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
735  codec_string, codec->name, desc->name);
736  }
737 
738  if (!codec) {
739  av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
740  exit_program(1);
741  }
742  if (codec->type != type) {
743  av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
744  exit_program(1);
745  }
746  return codec;
747 }
748 
750 {
751  char *codec_name = NULL;
752 
753  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
754  if (codec_name) {
755  AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
756  st->codecpar->codec_id = codec->id;
757  return codec;
758  } else
760 }
761 
762 /* Add all the streams from the given input file to the global
763  * list of input streams. */
765 {
766  int i, ret;
767 
768  for (i = 0; i < ic->nb_streams; i++) {
769  AVStream *st = ic->streams[i];
770  AVCodecParameters *par = st->codecpar;
771  InputStream *ist = av_mallocz(sizeof(*ist));
772  char *framerate = NULL, *hwaccel_device = NULL;
773  const char *hwaccel = NULL;
774  char *hwaccel_output_format = NULL;
775  char *codec_tag = NULL;
776  char *next;
777  char *discard_str = NULL;
778  const AVClass *cc = avcodec_get_class();
779  const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
780 
781  if (!ist)
782  exit_program(1);
783 
785  input_streams[nb_input_streams - 1] = ist;
786 
787  ist->st = st;
788  ist->file_index = nb_input_files;
789  ist->discard = 1;
790  st->discard = AVDISCARD_ALL;
791  ist->nb_samples = 0;
792  ist->min_pts = INT64_MAX;
793  ist->max_pts = INT64_MIN;
794 
795  ist->ts_scale = 1.0;
796  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
797 
798  ist->autorotate = 1;
799  MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
800 
801  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
802  if (codec_tag) {
803  uint32_t tag = strtol(codec_tag, &next, 0);
804  if (*next)
805  tag = AV_RL32(codec_tag);
806  st->codecpar->codec_tag = tag;
807  }
808 
809  ist->dec = choose_decoder(o, ic, st);
810  ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
811 
812  ist->reinit_filters = -1;
813  MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
814 
815  MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
817 
818  if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
823 
824  if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
825  av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
826  discard_str);
827  exit_program(1);
828  }
829 
831 
832  ist->dec_ctx = avcodec_alloc_context3(ist->dec);
833  if (!ist->dec_ctx) {
834  av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
835  exit_program(1);
836  }
837 
838  ret = avcodec_parameters_to_context(ist->dec_ctx, par);
839  if (ret < 0) {
840  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
841  exit_program(1);
842  }
843 
844  if (o->bitexact)
846 
847  switch (par->codec_type) {
848  case AVMEDIA_TYPE_VIDEO:
849  if(!ist->dec)
850  ist->dec = avcodec_find_decoder(par->codec_id);
851 #if FF_API_LOWRES
852  if (st->codec->lowres) {
853  ist->dec_ctx->lowres = st->codec->lowres;
854  ist->dec_ctx->width = st->codec->width;
855  ist->dec_ctx->height = st->codec->height;
856  ist->dec_ctx->coded_width = st->codec->coded_width;
857  ist->dec_ctx->coded_height = st->codec->coded_height;
858  }
859 #endif
860 
861  // avformat_find_stream_info() doesn't set this for us anymore.
862  ist->dec_ctx->framerate = st->avg_frame_rate;
863 
864  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
865  if (framerate && av_parse_video_rate(&ist->framerate,
866  framerate) < 0) {
867  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
868  framerate);
869  exit_program(1);
870  }
871 
872  ist->top_field_first = -1;
873  MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
874 
875  MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
876  MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
877  hwaccel_output_format, ic, st);
878 
879  if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
881  "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
882  "with old commandlines. This behaviour is DEPRECATED and will be removed "
883  "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
885  } else if (hwaccel_output_format) {
886  ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
888  av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
889  "format: %s", hwaccel_output_format);
890  }
891  } else {
893  }
894 
895  if (hwaccel) {
896  // The NVDEC hwaccels use a CUDA device, so remap the name here.
897  if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
898  hwaccel = "cuda";
899 
900  if (!strcmp(hwaccel, "none"))
901  ist->hwaccel_id = HWACCEL_NONE;
902  else if (!strcmp(hwaccel, "auto"))
903  ist->hwaccel_id = HWACCEL_AUTO;
904  else {
905  enum AVHWDeviceType type;
906  int i;
907  for (i = 0; hwaccels[i].name; i++) {
908  if (!strcmp(hwaccels[i].name, hwaccel)) {
909  ist->hwaccel_id = hwaccels[i].id;
910  break;
911  }
912  }
913 
914  if (!ist->hwaccel_id) {
915  type = av_hwdevice_find_type_by_name(hwaccel);
916  if (type != AV_HWDEVICE_TYPE_NONE) {
918  ist->hwaccel_device_type = type;
919  }
920  }
921 
922  if (!ist->hwaccel_id) {
923  av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
924  hwaccel);
925  av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
926  type = AV_HWDEVICE_TYPE_NONE;
927  while ((type = av_hwdevice_iterate_types(type)) !=
929  av_log(NULL, AV_LOG_FATAL, "%s ",
931  av_log(NULL, AV_LOG_FATAL, "\n");
932  exit_program(1);
933  }
934  }
935  }
936 
937  MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
938  if (hwaccel_device) {
939  ist->hwaccel_device = av_strdup(hwaccel_device);
940  if (!ist->hwaccel_device)
941  exit_program(1);
942  }
943 
945 
946  break;
947  case AVMEDIA_TYPE_AUDIO:
948  ist->guess_layout_max = INT_MAX;
949  MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
951  break;
952  case AVMEDIA_TYPE_DATA:
953  case AVMEDIA_TYPE_SUBTITLE: {
954  char *canvas_size = NULL;
955  if(!ist->dec)
956  ist->dec = avcodec_find_decoder(par->codec_id);
957  MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
958  MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
959  if (canvas_size &&
960  av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
961  av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
962  exit_program(1);
963  }
964  break;
965  }
968  break;
969  default:
970  abort();
971  }
972 
973  ret = avcodec_parameters_from_context(par, ist->dec_ctx);
974  if (ret < 0) {
975  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
976  exit_program(1);
977  }
978  }
979 }
980 
981 static void assert_file_overwrite(const char *filename)
982 {
983  const char *proto_name = avio_find_protocol_name(filename);
984 
986  fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
987  exit_program(1);
988  }
989 
990  if (!file_overwrite) {
991  if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
993  fprintf(stderr,"File '%s' already exists. Overwrite? [y/N] ", filename);
994  fflush(stderr);
995  term_exit();
996  signal(SIGINT, SIG_DFL);
997  if (!read_yesno()) {
998  av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
999  exit_program(1);
1000  }
1001  term_init();
1002  }
1003  else {
1004  av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
1005  exit_program(1);
1006  }
1007  }
1008  }
1009 
1010  if (proto_name && !strcmp(proto_name, "file")) {
1011  for (int i = 0; i < nb_input_files; i++) {
1012  InputFile *file = input_files[i];
1013  if (file->ctx->iformat->flags & AVFMT_NOFILE)
1014  continue;
1015  if (!strcmp(filename, file->ctx->url)) {
1016  av_log(NULL, AV_LOG_FATAL, "Output %s same as Input #%d - exiting\n", filename, i);
1017  av_log(NULL, AV_LOG_WARNING, "FFmpeg cannot edit existing files in-place.\n");
1018  exit_program(1);
1019  }
1020  }
1021  }
1022 }
1023 
1024 static void dump_attachment(AVStream *st, const char *filename)
1025 {
1026  int ret;
1027  AVIOContext *out = NULL;
1028  AVDictionaryEntry *e;
1029 
1030  if (!st->codecpar->extradata_size) {
1031  av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
1032  nb_input_files - 1, st->index);
1033  return;
1034  }
1035  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1036  filename = e->value;
1037  if (!*filename) {
1038  av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
1039  "in stream #%d:%d.\n", nb_input_files - 1, st->index);
1040  exit_program(1);
1041  }
1042 
1043  assert_file_overwrite(filename);
1044 
1045  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1046  av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1047  filename);
1048  exit_program(1);
1049  }
1050 
1052  avio_flush(out);
1053  avio_close(out);
1054 }
1055 
1056 static int open_input_file(OptionsContext *o, const char *filename)
1057 {
1058  InputFile *f;
1059  AVFormatContext *ic;
1061  int err, i, ret;
1062  int64_t timestamp;
1063  AVDictionary *unused_opts = NULL;
1064  AVDictionaryEntry *e = NULL;
1065  char * video_codec_name = NULL;
1066  char * audio_codec_name = NULL;
1067  char *subtitle_codec_name = NULL;
1068  char * data_codec_name = NULL;
1069  int scan_all_pmts_set = 0;
1070 
1071  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1072  o->stop_time = INT64_MAX;
1073  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1074  }
1075 
1076  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1077  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1078  if (o->stop_time <= start_time) {
1079  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1080  exit_program(1);
1081  } else {
1083  }
1084  }
1085 
1086  if (o->format) {
1087  if (!(file_iformat = av_find_input_format(o->format))) {
1088  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1089  exit_program(1);
1090  }
1091  }
1092 
1093  if (!strcmp(filename, "-"))
1094  filename = "pipe:";
1095 
1096  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1097  strcmp(filename, "/dev/stdin");
1098 
1099  /* get default parameters from command line */
1100  ic = avformat_alloc_context();
1101  if (!ic) {
1102  print_error(filename, AVERROR(ENOMEM));
1103  exit_program(1);
1104  }
1105  if (o->nb_audio_sample_rate) {
1106  av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1107  }
1108  if (o->nb_audio_channels) {
1109  /* because we set audio_channels based on both the "ac" and
1110  * "channel_layout" options, we need to check that the specified
1111  * demuxer actually has the "channels" option before setting it */
1112  if (file_iformat && file_iformat->priv_class &&
1113  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1115  av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1116  }
1117  }
1118  if (o->nb_frame_rates) {
1119  /* set the format-level framerate option;
1120  * this is important for video grabbers, e.g. x11 */
1121  if (file_iformat && file_iformat->priv_class &&
1122  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1124  av_dict_set(&o->g->format_opts, "framerate",
1125  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1126  }
1127  }
1128  if (o->nb_frame_sizes) {
1129  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1130  }
1131  if (o->nb_frame_pix_fmts)
1132  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1133 
1134  MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1135  MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1136  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1137  MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1138 
1139  if (video_codec_name)
1140  ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1141  if (audio_codec_name)
1142  ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1143  if (subtitle_codec_name)
1144  ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1145  if (data_codec_name)
1146  ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1147 
1148  ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1149  ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1150  ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1151  ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1152 
1153  ic->flags |= AVFMT_FLAG_NONBLOCK;
1154  if (o->bitexact)
1155  ic->flags |= AVFMT_FLAG_BITEXACT;
1156  ic->interrupt_callback = int_cb;
1157 
1158  if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1159  av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1160  scan_all_pmts_set = 1;
1161  }
1162  /* open the input file with generic avformat function */
1163  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1164  if (err < 0) {
1165  print_error(filename, err);
1166  if (err == AVERROR_PROTOCOL_NOT_FOUND)
1167  av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1168  exit_program(1);
1169  }
1170  if (scan_all_pmts_set)
1171  av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1174 
1175  /* apply forced codec ids */
1176  for (i = 0; i < ic->nb_streams; i++)
1177  choose_decoder(o, ic, ic->streams[i]);
1178 
1179  if (find_stream_info) {
1181  int orig_nb_streams = ic->nb_streams;
1182 
1183  /* If not enough info to get the stream parameters, we decode the
1184  first frames to get it. (used in mpeg case for example) */
1185  ret = avformat_find_stream_info(ic, opts);
1186 
1187  for (i = 0; i < orig_nb_streams; i++)
1188  av_dict_free(&opts[i]);
1189  av_freep(&opts);
1190 
1191  if (ret < 0) {
1192  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1193  if (ic->nb_streams == 0) {
1194  avformat_close_input(&ic);
1195  exit_program(1);
1196  }
1197  }
1198  }
1199 
1201  av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1203  }
1204 
1205  if (o->start_time_eof != AV_NOPTS_VALUE) {
1206  if (o->start_time_eof >= 0) {
1207  av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1208  exit_program(1);
1209  }
1210  if (ic->duration > 0) {
1211  o->start_time = o->start_time_eof + ic->duration;
1212  if (o->start_time < 0) {
1213  av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1215  }
1216  } else
1217  av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1218  }
1219  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1220  /* add the stream start time */
1221  if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1222  timestamp += ic->start_time;
1223 
1224  /* if seeking requested, we execute it */
1225  if (o->start_time != AV_NOPTS_VALUE) {
1226  int64_t seek_timestamp = timestamp;
1227 
1228  if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1229  int dts_heuristic = 0;
1230  for (i=0; i<ic->nb_streams; i++) {
1231  const AVCodecParameters *par = ic->streams[i]->codecpar;
1232  if (par->video_delay) {
1233  dts_heuristic = 1;
1234  break;
1235  }
1236  }
1237  if (dts_heuristic) {
1238  seek_timestamp -= 3*AV_TIME_BASE / 23;
1239  }
1240  }
1241  ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1242  if (ret < 0) {
1243  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1244  filename, (double)timestamp / AV_TIME_BASE);
1245  }
1246  }
1247 
1248  /* update the current parameters so that they match the one of the input stream */
1249  add_input_streams(o, ic);
1250 
1251  /* dump the file content */
1252  av_dump_format(ic, nb_input_files, filename, 0);
1253 
1255  f = av_mallocz(sizeof(*f));
1256  if (!f)
1257  exit_program(1);
1258  input_files[nb_input_files - 1] = f;
1259 
1260  f->ctx = ic;
1262  f->start_time = o->start_time;
1265  f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1266  f->nb_streams = ic->nb_streams;
1267  f->rate_emu = o->rate_emu;
1268  f->accurate_seek = o->accurate_seek;
1269  f->loop = o->loop;
1270  f->duration = 0;
1271  f->time_base = (AVRational){ 1, 1 };
1272 #if HAVE_THREADS
1273  f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1274 #endif
1275 
1276  /* check if all codec options have been used */
1277  unused_opts = strip_specifiers(o->g->codec_opts);
1278  for (i = f->ist_index; i < nb_input_streams; i++) {
1279  e = NULL;
1280  while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1282  av_dict_set(&unused_opts, e->key, NULL, 0);
1283  }
1284 
1285  e = NULL;
1286  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1287  const AVClass *class = avcodec_get_class();
1288  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1290  const AVClass *fclass = avformat_get_class();
1291  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1293  if (!option || foption)
1294  continue;
1295 
1296 
1297  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1298  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1299  "input file #%d (%s) is not a decoding option.\n", e->key,
1300  option->help ? option->help : "", nb_input_files - 1,
1301  filename);
1302  exit_program(1);
1303  }
1304 
1305  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1306  "input file #%d (%s) has not been used for any stream. The most "
1307  "likely reason is either wrong type (e.g. a video option with "
1308  "no video streams) or that it is a private option of some decoder "
1309  "which was not actually used for any stream.\n", e->key,
1310  option->help ? option->help : "", nb_input_files - 1, filename);
1311  }
1312  av_dict_free(&unused_opts);
1313 
1314  for (i = 0; i < o->nb_dump_attachment; i++) {
1315  int j;
1316 
1317  for (j = 0; j < ic->nb_streams; j++) {
1318  AVStream *st = ic->streams[j];
1319 
1320  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1321  dump_attachment(st, o->dump_attachment[i].u.str);
1322  }
1323  }
1324 
1326 
1327  return 0;
1328 }
1329 
1331 {
1332  AVIOContext *line;
1333  uint8_t *buf;
1334  char c;
1335 
1336  if (avio_open_dyn_buf(&line) < 0) {
1337  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1338  exit_program(1);
1339  }
1340 
1341  while ((c = avio_r8(s)) && c != '\n')
1342  avio_w8(line, c);
1343  avio_w8(line, 0);
1344  avio_close_dyn_buf(line, &buf);
1345 
1346  return buf;
1347 }
1348 
1349 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1350 {
1351  int i, ret = -1;
1352  char filename[1000];
1353  const char *base[3] = { getenv("AVCONV_DATADIR"),
1354  getenv("HOME"),
1355  AVCONV_DATADIR,
1356  };
1357 
1358  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1359  if (!base[i])
1360  continue;
1361  if (codec_name) {
1362  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1363  i != 1 ? "" : "/.avconv", codec_name, preset_name);
1364  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1365  }
1366  if (ret < 0) {
1367  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1368  i != 1 ? "" : "/.avconv", preset_name);
1369  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1370  }
1371  }
1372  return ret;
1373 }
1374 
1376 {
1377  enum AVMediaType type = ost->st->codecpar->codec_type;
1378  char *codec_name = NULL;
1379 
1380  if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1381  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1382  if (!codec_name) {
1383  ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1384  NULL, ost->st->codecpar->codec_type);
1385  ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1386  if (!ost->enc) {
1387  av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1388  "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1389  "probably disabled. Please choose an encoder manually.\n",
1390  ost->file_index, ost->index, s->oformat->name,
1393  }
1394  } else if (!strcmp(codec_name, "copy"))
1395  ost->stream_copy = 1;
1396  else {
1397  ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1398  ost->st->codecpar->codec_id = ost->enc->id;
1399  }
1400  ost->encoding_needed = !ost->stream_copy;
1401  } else {
1402  /* no encoding supported for other media types */
1403  ost->stream_copy = 1;
1404  ost->encoding_needed = 0;
1405  }
1406 
1407  return 0;
1408 }
1409 
1411 {
1412  OutputStream *ost;
1413  AVStream *st = avformat_new_stream(oc, NULL);
1414  int idx = oc->nb_streams - 1, ret = 0;
1415  const char *bsfs = NULL, *time_base = NULL;
1416  char *next, *codec_tag = NULL;
1417  double qscale = -1;
1418  int i;
1419 
1420  if (!st) {
1421  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1422  exit_program(1);
1423  }
1424 
1425  if (oc->nb_streams - 1 < o->nb_streamid_map)
1426  st->id = o->streamid_map[oc->nb_streams - 1];
1427 
1429  if (!(ost = av_mallocz(sizeof(*ost))))
1430  exit_program(1);
1432 
1433  ost->file_index = nb_output_files - 1;
1434  ost->index = idx;
1435  ost->st = st;
1437  st->codecpar->codec_type = type;
1438 
1439  ret = choose_encoder(o, oc, ost);
1440  if (ret < 0) {
1441  av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1442  "%d:%d\n", ost->file_index, ost->index);
1443  exit_program(1);
1444  }
1445 
1446  ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1447  if (!ost->enc_ctx) {
1448  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1449  exit_program(1);
1450  }
1451  ost->enc_ctx->codec_type = type;
1452 
1454  if (!ost->ref_par) {
1455  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1456  exit_program(1);
1457  }
1458 
1459  if (ost->enc) {
1460  AVIOContext *s = NULL;
1461  char *buf = NULL, *arg = NULL, *preset = NULL;
1462 
1463  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1464 
1465  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1466  ost->autoscale = 1;
1467  MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1468  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1469  do {
1470  buf = get_line(s);
1471  if (!buf[0] || buf[0] == '#') {
1472  av_free(buf);
1473  continue;
1474  }
1475  if (!(arg = strchr(buf, '='))) {
1476  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1477  exit_program(1);
1478  }
1479  *arg++ = 0;
1481  av_free(buf);
1482  } while (!s->eof_reached);
1483  avio_closep(&s);
1484  }
1485  if (ret) {
1487  "Preset %s specified for stream %d:%d, but could not be opened.\n",
1488  preset, ost->file_index, ost->index);
1489  exit_program(1);
1490  }
1491  } else {
1493  }
1494 
1495 
1496  if (o->bitexact)
1498 
1499  MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1500  if (time_base) {
1501  AVRational q;
1502  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1503  q.num <= 0 || q.den <= 0) {
1504  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1505  exit_program(1);
1506  }
1507  st->time_base = q;
1508  }
1509 
1510  MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1511  if (time_base) {
1512  AVRational q;
1513  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1514  q.den <= 0) {
1515  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1516  exit_program(1);
1517  }
1518  ost->enc_timebase = q;
1519  }
1520 
1521  ost->max_frames = INT64_MAX;
1522  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1523  for (i = 0; i<o->nb_max_frames; i++) {
1524  char *p = o->max_frames[i].specifier;
1525  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1526  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1527  break;
1528  }
1529  }
1530 
1531  ost->copy_prior_start = -1;
1532  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1533 
1534  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1535  if (bsfs && *bsfs) {
1536  ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1537  if (ret < 0) {
1538  av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1539  exit_program(1);
1540  }
1541  }
1542 
1543  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1544  if (codec_tag) {
1545  uint32_t tag = strtol(codec_tag, &next, 0);
1546  if (*next)
1547  tag = AV_RL32(codec_tag);
1548  ost->st->codecpar->codec_tag =
1549  ost->enc_ctx->codec_tag = tag;
1550  }
1551 
1552  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1553  if (qscale >= 0) {
1555  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1556  }
1557 
1558  MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1559  ost->disposition = av_strdup(ost->disposition);
1560 
1561  ost->max_muxing_queue_size = 128;
1562  MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1563  ost->max_muxing_queue_size *= sizeof(AVPacket);
1564 
1565  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1567 
1568  av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1569 
1570  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1571  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1572  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1573 
1574  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1575 
1576  ost->source_index = source_index;
1577  if (source_index >= 0) {
1578  ost->sync_ist = input_streams[source_index];
1579  input_streams[source_index]->discard = 0;
1580  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1581  }
1583 
1584  ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1585  if (!ost->muxing_queue)
1586  exit_program(1);
1587 
1588  return ost;
1589 }
1590 
1591 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1592 {
1593  int i;
1594  const char *p = str;
1595  for (i = 0;; i++) {
1596  dest[i] = atoi(p);
1597  if (i == 63)
1598  break;
1599  p = strchr(p, ',');
1600  if (!p) {
1601  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1602  exit_program(1);
1603  }
1604  p++;
1605  }
1606 }
1607 
1608 /* read file contents into a string */
1609 static uint8_t *read_file(const char *filename)
1610 {
1611  AVIOContext *pb = NULL;
1612  AVIOContext *dyn_buf = NULL;
1613  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1614  uint8_t buf[1024], *str;
1615 
1616  if (ret < 0) {
1617  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1618  return NULL;
1619  }
1620 
1621  ret = avio_open_dyn_buf(&dyn_buf);
1622  if (ret < 0) {
1623  avio_closep(&pb);
1624  return NULL;
1625  }
1626  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1627  avio_write(dyn_buf, buf, ret);
1628  avio_w8(dyn_buf, 0);
1629  avio_closep(&pb);
1630 
1631  ret = avio_close_dyn_buf(dyn_buf, &str);
1632  if (ret < 0)
1633  return NULL;
1634  return str;
1635 }
1636 
1638  OutputStream *ost)
1639 {
1640  AVStream *st = ost->st;
1641 
1642  if (ost->filters_script && ost->filters) {
1643  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1644  "output stream #%d:%d.\n", nb_output_files, st->index);
1645  exit_program(1);
1646  }
1647 
1648  if (ost->filters_script)
1649  return read_file(ost->filters_script);
1650  else if (ost->filters)
1651  return av_strdup(ost->filters);
1652 
1654  "null" : "anull");
1655 }
1656 
1658  const OutputStream *ost, enum AVMediaType type)
1659 {
1660  if (ost->filters_script || ost->filters) {
1662  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1663  "Filtering and streamcopy cannot be used together.\n",
1664  ost->filters ? "Filtergraph" : "Filtergraph script",
1665  ost->filters ? ost->filters : ost->filters_script,
1666  av_get_media_type_string(type), ost->file_index, ost->index);
1667  exit_program(1);
1668  }
1669 }
1670 
1672 {
1673  AVStream *st;
1674  OutputStream *ost;
1675  AVCodecContext *video_enc;
1676  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1677 
1678  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1679  st = ost->st;
1680  video_enc = ost->enc_ctx;
1681 
1682  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1683  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1684  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1685  exit_program(1);
1686  }
1687  if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1688  av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1689 
1690  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1691  if (frame_aspect_ratio) {
1692  AVRational q;
1693  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1694  q.num <= 0 || q.den <= 0) {
1695  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1696  exit_program(1);
1697  }
1698  ost->frame_aspect_ratio = q;
1699  }
1700 
1701  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1702  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1703 
1704  if (!ost->stream_copy) {
1705  const char *p = NULL;
1706  char *frame_size = NULL;
1707  char *frame_pix_fmt = NULL;
1708  char *intra_matrix = NULL, *inter_matrix = NULL;
1709  char *chroma_intra_matrix = NULL;
1710  int do_pass = 0;
1711  int i;
1712 
1713  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1714  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1715  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1716  exit_program(1);
1717  }
1718 
1720  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1721  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1722  ost->keep_pix_fmt = 1;
1723  if (!*++frame_pix_fmt)
1724  frame_pix_fmt = NULL;
1725  }
1726  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1727  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1728  exit_program(1);
1729  }
1730  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1731 
1732  if (intra_only)
1733  video_enc->gop_size = 0;
1734  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1735  if (intra_matrix) {
1736  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1737  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1738  exit_program(1);
1739  }
1740  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1741  }
1742  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1743  if (chroma_intra_matrix) {
1744  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1745  if (!p) {
1746  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1747  exit_program(1);
1748  }
1749  video_enc->chroma_intra_matrix = p;
1750  parse_matrix_coeffs(p, chroma_intra_matrix);
1751  }
1752  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1753  if (inter_matrix) {
1754  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1755  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1756  exit_program(1);
1757  }
1758  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1759  }
1760 
1761  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1762  for (i = 0; p; i++) {
1763  int start, end, q;
1764  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1765  if (e != 3) {
1766  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1767  exit_program(1);
1768  }
1769  video_enc->rc_override =
1770  av_realloc_array(video_enc->rc_override,
1771  i + 1, sizeof(RcOverride));
1772  if (!video_enc->rc_override) {
1773  av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1774  exit_program(1);
1775  }
1776  video_enc->rc_override[i].start_frame = start;
1777  video_enc->rc_override[i].end_frame = end;
1778  if (q > 0) {
1779  video_enc->rc_override[i].qscale = q;
1780  video_enc->rc_override[i].quality_factor = 1.0;
1781  }
1782  else {
1783  video_enc->rc_override[i].qscale = 0;
1784  video_enc->rc_override[i].quality_factor = -q/100.0;
1785  }
1786  p = strchr(p, '/');
1787  if (p) p++;
1788  }
1789  video_enc->rc_override_count = i;
1790 
1791  if (do_psnr)
1792  video_enc->flags|= AV_CODEC_FLAG_PSNR;
1793 
1794  /* two pass mode */
1795  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1796  if (do_pass) {
1797  if (do_pass & 1) {
1798  video_enc->flags |= AV_CODEC_FLAG_PASS1;
1799  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1800  }
1801  if (do_pass & 2) {
1802  video_enc->flags |= AV_CODEC_FLAG_PASS2;
1803  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1804  }
1805  }
1806 
1807  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1808  if (ost->logfile_prefix &&
1809  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1810  exit_program(1);
1811 
1812  if (do_pass) {
1813  char logfilename[1024];
1814  FILE *f;
1815 
1816  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1817  ost->logfile_prefix ? ost->logfile_prefix :
1819  i);
1820  if (!strcmp(ost->enc->name, "libx264")) {
1821  av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1822  } else {
1823  if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1824  char *logbuffer = read_file(logfilename);
1825 
1826  if (!logbuffer) {
1827  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1828  logfilename);
1829  exit_program(1);
1830  }
1831  video_enc->stats_in = logbuffer;
1832  }
1833  if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1834  f = av_fopen_utf8(logfilename, "wb");
1835  if (!f) {
1837  "Cannot write log file '%s' for pass-1 encoding: %s\n",
1838  logfilename, strerror(errno));
1839  exit_program(1);
1840  }
1841  ost->logfile = f;
1842  }
1843  }
1844  }
1845 
1846  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1847  if (ost->forced_keyframes)
1849 
1850  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1851 
1852  ost->top_field_first = -1;
1853  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1854 
1855 
1856  ost->avfilter = get_ost_filters(o, oc, ost);
1857  if (!ost->avfilter)
1858  exit_program(1);
1859  } else {
1860  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1861  }
1862 
1863  if (ost->stream_copy)
1865 
1866  return ost;
1867 }
1868 
1870 {
1871  int n;
1872  AVStream *st;
1873  OutputStream *ost;
1874  AVCodecContext *audio_enc;
1875 
1876  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1877  st = ost->st;
1878 
1879  audio_enc = ost->enc_ctx;
1880  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1881 
1882  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1883  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1884 
1885  if (!ost->stream_copy) {
1886  char *sample_fmt = NULL;
1887 
1888  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1889 
1890  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1891  if (sample_fmt &&
1892  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1893  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1894  exit_program(1);
1895  }
1896 
1897  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1898 
1899  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1900  ost->apad = av_strdup(ost->apad);
1901 
1902  ost->avfilter = get_ost_filters(o, oc, ost);
1903  if (!ost->avfilter)
1904  exit_program(1);
1905 
1906  /* check for channel mapping for this audio stream */
1907  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1909  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1910  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1911  InputStream *ist;
1912 
1913  if (map->channel_idx == -1) {
1914  ist = NULL;
1915  } else if (ost->source_index < 0) {
1916  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1917  ost->file_index, ost->st->index);
1918  continue;
1919  } else {
1920  ist = input_streams[ost->source_index];
1921  }
1922 
1923  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1925  ost->audio_channels_mapped + 1,
1926  sizeof(*ost->audio_channels_map)
1927  ) < 0 )
1928  exit_program(1);
1929 
1931  }
1932  }
1933  }
1934  }
1935 
1936  if (ost->stream_copy)
1938 
1939  return ost;
1940 }
1941 
1943 {
1944  OutputStream *ost;
1945 
1946  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1947  if (!ost->stream_copy) {
1948  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1949  exit_program(1);
1950  }
1951 
1952  return ost;
1953 }
1954 
1956 {
1957  OutputStream *ost;
1958 
1959  ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1960  if (!ost->stream_copy) {
1961  av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1962  exit_program(1);
1963  }
1964 
1965  return ost;
1966 }
1967 
1969 {
1970  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1971  ost->stream_copy = 1;
1972  ost->finished = 1;
1973  return ost;
1974 }
1975 
1977 {
1978  AVStream *st;
1979  OutputStream *ost;
1980  AVCodecContext *subtitle_enc;
1981 
1982  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1983  st = ost->st;
1984  subtitle_enc = ost->enc_ctx;
1985 
1986  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1987 
1988  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1989 
1990  if (!ost->stream_copy) {
1991  char *frame_size = NULL;
1992 
1993  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1994  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1995  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1996  exit_program(1);
1997  }
1998  }
1999 
2000  return ost;
2001 }
2002 
2003 /* arg format is "output-stream-index:streamid-value". */
2004 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2005 {
2006  OptionsContext *o = optctx;
2007  int idx;
2008  char *p;
2009  char idx_str[16];
2010 
2011  av_strlcpy(idx_str, arg, sizeof(idx_str));
2012  p = strchr(idx_str, ':');
2013  if (!p) {
2015  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2016  arg, opt);
2017  exit_program(1);
2018  }
2019  *p++ = '\0';
2020  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2021  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2022  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2023  return 0;
2024 }
2025 
2027 {
2028  AVFormatContext *is = ifile->ctx;
2029  AVFormatContext *os = ofile->ctx;
2030  AVChapter **tmp;
2031  int i;
2032 
2033  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2034  if (!tmp)
2035  return AVERROR(ENOMEM);
2036  os->chapters = tmp;
2037 
2038  for (i = 0; i < is->nb_chapters; i++) {
2039  AVChapter *in_ch = is->chapters[i], *out_ch;
2040  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2041  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2042  AV_TIME_BASE_Q, in_ch->time_base);
2043  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2045 
2046 
2047  if (in_ch->end < ts_off)
2048  continue;
2049  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2050  break;
2051 
2052  out_ch = av_mallocz(sizeof(AVChapter));
2053  if (!out_ch)
2054  return AVERROR(ENOMEM);
2055 
2056  out_ch->id = in_ch->id;
2057  out_ch->time_base = in_ch->time_base;
2058  out_ch->start = FFMAX(0, in_ch->start - ts_off);
2059  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2060 
2061  if (copy_metadata)
2062  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2063 
2064  os->chapters[os->nb_chapters++] = out_ch;
2065  }
2066  return 0;
2067 }
2068 
2070  AVFormatContext *oc)
2071 {
2072  OutputStream *ost;
2073 
2074  switch (ofilter->type) {
2075  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2076  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2077  default:
2078  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2079  "currently.\n");
2080  exit_program(1);
2081  }
2082 
2083  ost->source_index = -1;
2084  ost->filter = ofilter;
2085 
2086  ofilter->ost = ost;
2087  ofilter->format = -1;
2088 
2089  if (ost->stream_copy) {
2090  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2091  "which is fed from a complex filtergraph. Filtering and streamcopy "
2092  "cannot be used together.\n", ost->file_index, ost->index);
2093  exit_program(1);
2094  }
2095 
2096  if (ost->avfilter && (ost->filters || ost->filters_script)) {
2097  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2099  "%s '%s' was specified through the %s option "
2100  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2101  "%s and -filter_complex cannot be used together for the same stream.\n",
2102  ost->filters ? "Filtergraph" : "Filtergraph script",
2103  ost->filters ? ost->filters : ost->filters_script,
2104  opt, ost->file_index, ost->index, opt);
2105  exit_program(1);
2106  }
2107 
2108  avfilter_inout_free(&ofilter->out_tmp);
2109 }
2110 
2111 static int init_complex_filters(void)
2112 {
2113  int i, ret = 0;
2114 
2115  for (i = 0; i < nb_filtergraphs; i++) {
2117  if (ret < 0)
2118  return ret;
2119  }
2120  return 0;
2121 }
2122 
2123 static int open_output_file(OptionsContext *o, const char *filename)
2124 {
2125  AVFormatContext *oc;
2126  int i, j, err;
2127  OutputFile *of;
2128  OutputStream *ost;
2129  InputStream *ist;
2130  AVDictionary *unused_opts = NULL;
2131  AVDictionaryEntry *e = NULL;
2132  int format_flags = 0;
2133 
2134  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2135  o->stop_time = INT64_MAX;
2136  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2137  }
2138 
2139  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2140  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2141  if (o->stop_time <= start_time) {
2142  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2143  exit_program(1);
2144  } else {
2146  }
2147  }
2148 
2150  of = av_mallocz(sizeof(*of));
2151  if (!of)
2152  exit_program(1);
2153  output_files[nb_output_files - 1] = of;
2154 
2156  of->recording_time = o->recording_time;
2157  of->start_time = o->start_time;
2158  of->limit_filesize = o->limit_filesize;
2159  of->shortest = o->shortest;
2160  av_dict_copy(&of->opts, o->g->format_opts, 0);
2161 
2162  if (!strcmp(filename, "-"))
2163  filename = "pipe:";
2164 
2165  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2166  if (!oc) {
2167  print_error(filename, err);
2168  exit_program(1);
2169  }
2170 
2171  of->ctx = oc;
2172  if (o->recording_time != INT64_MAX)
2173  oc->duration = o->recording_time;
2174 
2175  oc->interrupt_callback = int_cb;
2176 
2177  e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2178  if (e) {
2179  const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2180  av_opt_eval_flags(oc, o, e->value, &format_flags);
2181  }
2182  if (o->bitexact) {
2183  format_flags |= AVFMT_FLAG_BITEXACT;
2184  oc->flags |= AVFMT_FLAG_BITEXACT;
2185  }
2186 
2187  /* create streams for all unlabeled output pads */
2188  for (i = 0; i < nb_filtergraphs; i++) {
2189  FilterGraph *fg = filtergraphs[i];
2190  for (j = 0; j < fg->nb_outputs; j++) {
2191  OutputFilter *ofilter = fg->outputs[j];
2192 
2193  if (!ofilter->out_tmp || ofilter->out_tmp->name)
2194  continue;
2195 
2196  switch (ofilter->type) {
2197  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2198  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2199  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2200  }
2201  init_output_filter(ofilter, o, oc);
2202  }
2203  }
2204 
2205  if (!o->nb_stream_maps) {
2206  char *subtitle_codec_name = NULL;
2207  /* pick the "best" stream of each type */
2208 
2209  /* video: highest resolution */
2211  int area = 0, idx = -1;
2212  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2213  for (i = 0; i < nb_input_streams; i++) {
2214  int new_area;
2215  ist = input_streams[i];
2216  new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2217  + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2218  if (ist->user_set_discard == AVDISCARD_ALL)
2219  continue;
2220  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2221  new_area = 1;
2222  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2223  new_area > area) {
2224  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2225  continue;
2226  area = new_area;
2227  idx = i;
2228  }
2229  }
2230  if (idx >= 0)
2231  new_video_stream(o, oc, idx);
2232  }
2233 
2234  /* audio: most channels */
2236  int best_score = 0, idx = -1;
2237  for (i = 0; i < nb_input_streams; i++) {
2238  int score;
2239  ist = input_streams[i];
2240  score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2241  + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2242  if (ist->user_set_discard == AVDISCARD_ALL)
2243  continue;
2244  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2245  score > best_score) {
2246  best_score = score;
2247  idx = i;
2248  }
2249  }
2250  if (idx >= 0)
2251  new_audio_stream(o, oc, idx);
2252  }
2253 
2254  /* subtitles: pick first */
2255  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2256  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2257  for (i = 0; i < nb_input_streams; i++)
2258  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2259  AVCodecDescriptor const *input_descriptor =
2260  avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2261  AVCodecDescriptor const *output_descriptor = NULL;
2262  AVCodec const *output_codec =
2264  int input_props = 0, output_props = 0;
2265  if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2266  continue;
2267  if (output_codec)
2268  output_descriptor = avcodec_descriptor_get(output_codec->id);
2269  if (input_descriptor)
2270  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2271  if (output_descriptor)
2272  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2273  if (subtitle_codec_name ||
2274  input_props & output_props ||
2275  // Map dvb teletext which has neither property to any output subtitle encoder
2276  input_descriptor && output_descriptor &&
2277  (!input_descriptor->props ||
2278  !output_descriptor->props)) {
2279  new_subtitle_stream(o, oc, i);
2280  break;
2281  }
2282  }
2283  }
2284  /* Data only if codec id match */
2285  if (!o->data_disable ) {
2287  for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2288  if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2289  continue;
2290  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2291  && input_streams[i]->st->codecpar->codec_id == codec_id )
2292  new_data_stream(o, oc, i);
2293  }
2294  }
2295  } else {
2296  for (i = 0; i < o->nb_stream_maps; i++) {
2297  StreamMap *map = &o->stream_maps[i];
2298 
2299  if (map->disabled)
2300  continue;
2301 
2302  if (map->linklabel) {
2303  FilterGraph *fg;
2304  OutputFilter *ofilter = NULL;
2305  int j, k;
2306 
2307  for (j = 0; j < nb_filtergraphs; j++) {
2308  fg = filtergraphs[j];
2309  for (k = 0; k < fg->nb_outputs; k++) {
2310  AVFilterInOut *out = fg->outputs[k]->out_tmp;
2311  if (out && !strcmp(out->name, map->linklabel)) {
2312  ofilter = fg->outputs[k];
2313  goto loop_end;
2314  }
2315  }
2316  }
2317 loop_end:
2318  if (!ofilter) {
2319  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2320  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2321  exit_program(1);
2322  }
2323  init_output_filter(ofilter, o, oc);
2324  } else {
2325  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2326 
2328  if (ist->user_set_discard == AVDISCARD_ALL) {
2329  av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2330  map->file_index, map->stream_index);
2331  exit_program(1);
2332  }
2334  continue;
2336  continue;
2338  continue;
2339  if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2340  continue;
2341 
2342  ost = NULL;
2343  switch (ist->st->codecpar->codec_type) {
2344  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2345  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2346  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2347  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2348  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2349  case AVMEDIA_TYPE_UNKNOWN:
2350  if (copy_unknown_streams) {
2351  ost = new_unknown_stream (o, oc, src_idx);
2352  break;
2353  }
2354  default:
2356  "Cannot map stream #%d:%d - unsupported type.\n",
2357  map->file_index, map->stream_index);
2358  if (!ignore_unknown_streams) {
2359  av_log(NULL, AV_LOG_FATAL,
2360  "If you want unsupported types ignored instead "
2361  "of failing, please use the -ignore_unknown option\n"
2362  "If you want them copied, please use -copy_unknown\n");
2363  exit_program(1);
2364  }
2365  }
2366  if (ost)
2367  ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2368  + map->sync_stream_index];
2369  }
2370  }
2371  }
2372 
2373  /* handle attached files */
2374  for (i = 0; i < o->nb_attachments; i++) {
2375  AVIOContext *pb;
2376  uint8_t *attachment;
2377  const char *p;
2378  int64_t len;
2379 
2380  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2381  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2382  o->attachments[i]);
2383  exit_program(1);
2384  }
2385  if ((len = avio_size(pb)) <= 0) {
2386  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2387  o->attachments[i]);
2388  exit_program(1);
2389  }
2390  if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2391  !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2392  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2393  o->attachments[i]);
2394  exit_program(1);
2395  }
2396  avio_read(pb, attachment, len);
2397  memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2398 
2399  ost = new_attachment_stream(o, oc, -1);
2400  ost->stream_copy = 0;
2401  ost->attachment_filename = o->attachments[i];
2402  ost->st->codecpar->extradata = attachment;
2403  ost->st->codecpar->extradata_size = len;
2404 
2405  p = strrchr(o->attachments[i], '/');
2406  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2407  avio_closep(&pb);
2408  }
2409 
2410 #if FF_API_LAVF_AVCTX
2411  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2412  AVDictionaryEntry *e;
2413  ost = output_streams[i];
2414 
2415  if ((ost->stream_copy || ost->attachment_filename)
2416  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2417  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2418  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2419  exit_program(1);
2420  }
2421 #endif
2422 
2423  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2424  av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2425  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2426  exit_program(1);
2427  }
2428 
2429  /* check if all codec options have been used */
2430  unused_opts = strip_specifiers(o->g->codec_opts);
2431  for (i = of->ost_index; i < nb_output_streams; i++) {
2432  e = NULL;
2433  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2435  av_dict_set(&unused_opts, e->key, NULL, 0);
2436  }
2437 
2438  e = NULL;
2439  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2440  const AVClass *class = avcodec_get_class();
2441  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2443  const AVClass *fclass = avformat_get_class();
2444  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2446  if (!option || foption)
2447  continue;
2448 
2449 
2450  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2451  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2452  "output file #%d (%s) is not an encoding option.\n", e->key,
2453  option->help ? option->help : "", nb_output_files - 1,
2454  filename);
2455  exit_program(1);
2456  }
2457 
2458  // gop_timecode is injected by generic code but not always used
2459  if (!strcmp(e->key, "gop_timecode"))
2460  continue;
2461 
2462  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2463  "output file #%d (%s) has not been used for any stream. The most "
2464  "likely reason is either wrong type (e.g. a video option with "
2465  "no video streams) or that it is a private option of some encoder "
2466  "which was not actually used for any stream.\n", e->key,
2467  option->help ? option->help : "", nb_output_files - 1, filename);
2468  }
2469  av_dict_free(&unused_opts);
2470 
2471  /* set the decoding_needed flags and create simple filtergraphs */
2472  for (i = of->ost_index; i < nb_output_streams; i++) {
2473  OutputStream *ost = output_streams[i];
2474 
2475  if (ost->encoding_needed && ost->source_index >= 0) {
2476  InputStream *ist = input_streams[ost->source_index];
2478 
2479  if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2481  err = init_simple_filtergraph(ist, ost);
2482  if (err < 0) {
2484  "Error initializing a simple filtergraph between streams "
2485  "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2486  nb_output_files - 1, ost->st->index);
2487  exit_program(1);
2488  }
2489  }
2490  }
2491 
2492  /* set the filter output constraints */
2493  if (ost->filter) {
2494  OutputFilter *f = ost->filter;
2495  int count;
2496  switch (ost->enc_ctx->codec_type) {
2497  case AVMEDIA_TYPE_VIDEO:
2498  f->frame_rate = ost->frame_rate;
2499  f->width = ost->enc_ctx->width;
2500  f->height = ost->enc_ctx->height;
2501  if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2502  f->format = ost->enc_ctx->pix_fmt;
2503  } else if (ost->enc->pix_fmts) {
2504  count = 0;
2505  while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2506  count++;
2507  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2508  if (!f->formats)
2509  exit_program(1);
2510  memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2511  }
2512  break;
2513  case AVMEDIA_TYPE_AUDIO:
2514  if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2515  f->format = ost->enc_ctx->sample_fmt;
2516  } else if (ost->enc->sample_fmts) {
2517  count = 0;
2518  while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2519  count++;
2520  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2521  if (!f->formats)
2522  exit_program(1);
2523  memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2524  }
2525  if (ost->enc_ctx->sample_rate) {
2526  f->sample_rate = ost->enc_ctx->sample_rate;
2527  } else if (ost->enc->supported_samplerates) {
2528  count = 0;
2529  while (ost->enc->supported_samplerates[count])
2530  count++;
2531  f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2532  if (!f->sample_rates)
2533  exit_program(1);
2534  memcpy(f->sample_rates, ost->enc->supported_samplerates,
2535  (count + 1) * sizeof(*f->sample_rates));
2536  }
2537  if (ost->enc_ctx->channels) {
2539  } else if (ost->enc->channel_layouts) {
2540  count = 0;
2541  while (ost->enc->channel_layouts[count])
2542  count++;
2543  f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2544  if (!f->channel_layouts)
2545  exit_program(1);
2546  memcpy(f->channel_layouts, ost->enc->channel_layouts,
2547  (count + 1) * sizeof(*f->channel_layouts));
2548  }
2549  break;
2550  }
2551  }
2552  }
2553 
2554  /* check filename in case of an image number is expected */
2555  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2556  if (!av_filename_number_test(oc->url)) {
2557  print_error(oc->url, AVERROR(EINVAL));
2558  exit_program(1);
2559  }
2560  }
2561 
2564  "No input streams but output needs an input stream\n");
2565  exit_program(1);
2566  }
2567 
2568  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2569  /* test if it already exists to avoid losing precious files */
2570  assert_file_overwrite(filename);
2571 
2572  /* open the file */
2573  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2574  &oc->interrupt_callback,
2575  &of->opts)) < 0) {
2576  print_error(filename, err);
2577  exit_program(1);
2578  }
2579  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2580  assert_file_overwrite(filename);
2581 
2582  if (o->mux_preload) {
2583  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2584  }
2585  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2586 
2587  /* copy metadata */
2588  for (i = 0; i < o->nb_metadata_map; i++) {
2589  char *p;
2590  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2591 
2592  if (in_file_index >= nb_input_files) {
2593  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2594  exit_program(1);
2595  }
2596  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2597  in_file_index >= 0 ?
2598  input_files[in_file_index]->ctx : NULL, o);
2599  }
2600 
2601  /* copy chapters */
2602  if (o->chapters_input_file >= nb_input_files) {
2603  if (o->chapters_input_file == INT_MAX) {
2604  /* copy chapters from the first input file that has them*/
2605  o->chapters_input_file = -1;
2606  for (i = 0; i < nb_input_files; i++)
2607  if (input_files[i]->ctx->nb_chapters) {
2608  o->chapters_input_file = i;
2609  break;
2610  }
2611  } else {
2612  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2613  o->chapters_input_file);
2614  exit_program(1);
2615  }
2616  }
2617  if (o->chapters_input_file >= 0)
2620 
2621  /* copy global metadata by default */
2625  if(o->recording_time != INT64_MAX)
2626  av_dict_set(&oc->metadata, "duration", NULL, 0);
2627  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2628  }
2629  if (!o->metadata_streams_manual)
2630  for (i = of->ost_index; i < nb_output_streams; i++) {
2631  InputStream *ist;
2632  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2633  continue;
2635  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2636  if (!output_streams[i]->stream_copy) {
2637  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2638  }
2639  }
2640 
2641  /* process manually set programs */
2642  for (i = 0; i < o->nb_program; i++) {
2643  const char *p = o->program[i].u.str;
2644  int progid = i+1;
2645  AVProgram *program;
2646 
2647  while(*p) {
2648  const char *p2 = av_get_token(&p, ":");
2649  const char *to_dealloc = p2;
2650  char *key;
2651  if (!p2)
2652  break;
2653 
2654  if(*p) p++;
2655 
2656  key = av_get_token(&p2, "=");
2657  if (!key || !*p2) {
2658  av_freep(&to_dealloc);
2659  av_freep(&key);
2660  break;
2661  }
2662  p2++;
2663 
2664  if (!strcmp(key, "program_num"))
2665  progid = strtol(p2, NULL, 0);
2666  av_freep(&to_dealloc);
2667  av_freep(&key);
2668  }
2669 
2670  program = av_new_program(oc, progid);
2671 
2672  p = o->program[i].u.str;
2673  while(*p) {
2674  const char *p2 = av_get_token(&p, ":");
2675  const char *to_dealloc = p2;
2676  char *key;
2677  if (!p2)
2678  break;
2679  if(*p) p++;
2680 
2681  key = av_get_token(&p2, "=");
2682  if (!key) {
2684  "No '=' character in program string %s.\n",
2685  p2);
2686  exit_program(1);
2687  }
2688  if (!*p2)
2689  exit_program(1);
2690  p2++;
2691 
2692  if (!strcmp(key, "title")) {
2693  av_dict_set(&program->metadata, "title", p2, 0);
2694  } else if (!strcmp(key, "program_num")) {
2695  } else if (!strcmp(key, "st")) {
2696  int st_num = strtol(p2, NULL, 0);
2697  av_program_add_stream_index(oc, progid, st_num);
2698  } else {
2699  av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2700  exit_program(1);
2701  }
2702  av_freep(&to_dealloc);
2703  av_freep(&key);
2704  }
2705  }
2706 
2707  /* process manually set metadata */
2708  for (i = 0; i < o->nb_metadata; i++) {
2709  AVDictionary **m;
2710  char type, *val;
2711  const char *stream_spec;
2712  int index = 0, j, ret = 0;
2713 
2714  val = strchr(o->metadata[i].u.str, '=');
2715  if (!val) {
2716  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2717  o->metadata[i].u.str);
2718  exit_program(1);
2719  }
2720  *val++ = 0;
2721 
2722  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2723  if (type == 's') {
2724  for (j = 0; j < oc->nb_streams; j++) {
2725  ost = output_streams[nb_output_streams - oc->nb_streams + j];
2726  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2727  if (!strcmp(o->metadata[i].u.str, "rotate")) {
2728  char *tail;
2729  double theta = av_strtod(val, &tail);
2730  if (!*tail) {
2731  ost->rotate_overridden = 1;
2732  ost->rotate_override_value = theta;
2733  }
2734  } else {
2735  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2736  }
2737  } else if (ret < 0)
2738  exit_program(1);
2739  }
2740  }
2741  else {
2742  switch (type) {
2743  case 'g':
2744  m = &oc->metadata;
2745  break;
2746  case 'c':
2747  if (index < 0 || index >= oc->nb_chapters) {
2748  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2749  exit_program(1);
2750  }
2751  m = &oc->chapters[index]->metadata;
2752  break;
2753  case 'p':
2754  if (index < 0 || index >= oc->nb_programs) {
2755  av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2756  exit_program(1);
2757  }
2758  m = &oc->programs[index]->metadata;
2759  break;
2760  default:
2761  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2762  exit_program(1);
2763  }
2764  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2765  }
2766  }
2767 
2768  return 0;
2769 }
2770 
2771 static int opt_target(void *optctx, const char *opt, const char *arg)
2772 {
2773  OptionsContext *o = optctx;
2774  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2775  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2776 
2777  if (!strncmp(arg, "pal-", 4)) {
2778  norm = PAL;
2779  arg += 4;
2780  } else if (!strncmp(arg, "ntsc-", 5)) {
2781  norm = NTSC;
2782  arg += 5;
2783  } else if (!strncmp(arg, "film-", 5)) {
2784  norm = FILM;
2785  arg += 5;
2786  } else {
2787  /* Try to determine PAL/NTSC by peeking in the input files */
2788  if (nb_input_files) {
2789  int i, j;
2790  for (j = 0; j < nb_input_files; j++) {
2791  for (i = 0; i < input_files[j]->nb_streams; i++) {
2792  AVStream *st = input_files[j]->ctx->streams[i];
2793  int64_t fr;
2795  continue;
2796  fr = st->time_base.den * 1000LL / st->time_base.num;
2797  if (fr == 25000) {
2798  norm = PAL;
2799  break;
2800  } else if ((fr == 29970) || (fr == 23976)) {
2801  norm = NTSC;
2802  break;
2803  }
2804  }
2805  if (norm != UNKNOWN)
2806  break;
2807  }
2808  }
2809  if (norm != UNKNOWN)
2810  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2811  }
2812 
2813  if (norm == UNKNOWN) {
2814  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2815  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2816  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2817  exit_program(1);
2818  }
2819 
2820  if (!strcmp(arg, "vcd")) {
2821  opt_video_codec(o, "c:v", "mpeg1video");
2822  opt_audio_codec(o, "c:a", "mp2");
2823  parse_option(o, "f", "vcd", options);
2824 
2825  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2826  parse_option(o, "r", frame_rates[norm], options);
2827  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2828 
2829  opt_default(NULL, "b:v", "1150000");
2830  opt_default(NULL, "maxrate:v", "1150000");
2831  opt_default(NULL, "minrate:v", "1150000");
2832  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2833 
2834  opt_default(NULL, "b:a", "224000");
2835  parse_option(o, "ar", "44100", options);
2836  parse_option(o, "ac", "2", options);
2837 
2838  opt_default(NULL, "packetsize", "2324");
2839  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2840 
2841  /* We have to offset the PTS, so that it is consistent with the SCR.
2842  SCR starts at 36000, but the first two packs contain only padding
2843  and the first pack from the other stream, respectively, may also have
2844  been written before.
2845  So the real data starts at SCR 36000+3*1200. */
2846  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2847  } else if (!strcmp(arg, "svcd")) {
2848 
2849  opt_video_codec(o, "c:v", "mpeg2video");
2850  opt_audio_codec(o, "c:a", "mp2");
2851  parse_option(o, "f", "svcd", options);
2852 
2853  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2854  parse_option(o, "r", frame_rates[norm], options);
2855  parse_option(o, "pix_fmt", "yuv420p", options);
2856  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2857 
2858  opt_default(NULL, "b:v", "2040000");
2859  opt_default(NULL, "maxrate:v", "2516000");
2860  opt_default(NULL, "minrate:v", "0"); // 1145000;
2861  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2862  opt_default(NULL, "scan_offset", "1");
2863 
2864  opt_default(NULL, "b:a", "224000");
2865  parse_option(o, "ar", "44100", options);
2866 
2867  opt_default(NULL, "packetsize", "2324");
2868 
2869  } else if (!strcmp(arg, "dvd")) {
2870 
2871  opt_video_codec(o, "c:v", "mpeg2video");
2872  opt_audio_codec(o, "c:a", "ac3");
2873  parse_option(o, "f", "dvd", options);
2874 
2875  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2876  parse_option(o, "r", frame_rates[norm], options);
2877  parse_option(o, "pix_fmt", "yuv420p", options);
2878  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2879 
2880  opt_default(NULL, "b:v", "6000000");
2881  opt_default(NULL, "maxrate:v", "9000000");
2882  opt_default(NULL, "minrate:v", "0"); // 1500000;
2883  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2884 
2885  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2886  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2887 
2888  opt_default(NULL, "b:a", "448000");
2889  parse_option(o, "ar", "48000", options);
2890 
2891  } else if (!strncmp(arg, "dv", 2)) {
2892 
2893  parse_option(o, "f", "dv", options);
2894 
2895  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2896  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2897  norm == PAL ? "yuv420p" : "yuv411p", options);
2898  parse_option(o, "r", frame_rates[norm], options);
2899 
2900  parse_option(o, "ar", "48000", options);
2901  parse_option(o, "ac", "2", options);
2902 
2903  } else {
2904  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2905  return AVERROR(EINVAL);
2906  }
2907 
2910 
2911  return 0;
2912 }
2913 
2914 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2915 {
2917  vstats_filename = av_strdup (arg);
2918  return 0;
2919 }
2920 
2921 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2922 {
2923  char filename[40];
2924  time_t today2 = time(NULL);
2925  struct tm *today = localtime(&today2);
2926 
2927  if (!today) { // maybe tomorrow
2928  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2929  exit_program(1);
2930  }
2931 
2932  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2933  today->tm_sec);
2934  return opt_vstats_file(NULL, opt, filename);
2935 }
2936 
2937 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2938 {
2939  OptionsContext *o = optctx;
2940  return parse_option(o, "frames:v", arg, options);
2941 }
2942 
2943 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2944 {
2945  OptionsContext *o = optctx;
2946  return parse_option(o, "frames:a", arg, options);
2947 }
2948 
2949 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2950 {
2951  OptionsContext *o = optctx;
2952  return parse_option(o, "frames:d", arg, options);
2953 }
2954 
2955 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2956 {
2957  int ret;
2958  AVDictionary *cbak = codec_opts;
2959  AVDictionary *fbak = format_opts;
2960  codec_opts = NULL;
2961  format_opts = NULL;
2962 
2963  ret = opt_default(NULL, opt, arg);
2964 
2965  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2969  codec_opts = cbak;
2970  format_opts = fbak;
2971 
2972  return ret;
2973 }
2974 
2975 static int opt_preset(void *optctx, const char *opt, const char *arg)
2976 {
2977  OptionsContext *o = optctx;
2978  FILE *f=NULL;
2979  char filename[1000], line[1000], tmp_line[1000];
2980  const char *codec_name = NULL;
2981 
2982  tmp_line[0] = *opt;
2983  tmp_line[1] = 0;
2984  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2985 
2986  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2987  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2988  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2989  }else
2990  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2991  exit_program(1);
2992  }
2993 
2994  while (fgets(line, sizeof(line), f)) {
2995  char *key = tmp_line, *value, *endptr;
2996 
2997  if (strcspn(line, "#\n\r") == 0)
2998  continue;
2999  av_strlcpy(tmp_line, line, sizeof(tmp_line));
3000  if (!av_strtok(key, "=", &value) ||
3001  !av_strtok(value, "\r\n", &endptr)) {
3002  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3003  exit_program(1);
3004  }
3005  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3006 
3007  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3008  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3009  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3010  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3011  else if (opt_default_new(o, key, value) < 0) {
3012  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3013  filename, line, key, value);
3014  exit_program(1);
3015  }
3016  }
3017 
3018  fclose(f);
3019 
3020  return 0;
3021 }
3022 
3023 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3024 {
3025  OptionsContext *o = optctx;
3026  int ret;
3027  char *s = av_asprintf("%s:%c", opt + 1, *opt);
3028  if (!s)
3029  return AVERROR(ENOMEM);
3030  ret = parse_option(o, s, arg, options);
3031  av_free(s);
3032  return ret;
3033 }
3034 
3035 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3036 {
3037  OptionsContext *o = optctx;
3038 
3039  if(!strcmp(opt, "ab")){
3040  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3041  return 0;
3042  } else if(!strcmp(opt, "b")){
3043  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3044  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3045  return 0;
3046  }
3047  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3048  return 0;
3049 }
3050 
3051 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3052 {
3053  OptionsContext *o = optctx;
3054  char *s;
3055  int ret;
3056  if(!strcmp(opt, "qscale")){
3057  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3058  return parse_option(o, "q:v", arg, options);
3059  }
3060  s = av_asprintf("q%s", opt + 6);
3061  if (!s)
3062  return AVERROR(ENOMEM);
3063  ret = parse_option(o, s, arg, options);
3064  av_free(s);
3065  return ret;
3066 }
3067 
3068 static int opt_profile(void *optctx, const char *opt, const char *arg)
3069 {
3070  OptionsContext *o = optctx;
3071  if(!strcmp(opt, "profile")){
3072  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3073  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3074  return 0;
3075  }
3076  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3077  return 0;
3078 }
3079 
3080 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3081 {
3082  OptionsContext *o = optctx;
3083  return parse_option(o, "filter:v", arg, options);
3084 }
3085 
3086 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3087 {
3088  OptionsContext *o = optctx;
3089  return parse_option(o, "filter:a", arg, options);
3090 }
3091 
3092 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3093 {
3094  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3095  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3096  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3097  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3098 
3101  return 0;
3102 }
3103 
3104 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3105 {
3106  OptionsContext *o = optctx;
3107  int ret;
3108  char *tcr = av_asprintf("timecode=%s", arg);
3109  if (!tcr)
3110  return AVERROR(ENOMEM);
3111  ret = parse_option(o, "metadata:g", tcr, options);
3112  if (ret >= 0)
3113  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3114  av_free(tcr);
3115  return ret;
3116 }
3117 
3118 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3119 {
3120  OptionsContext *o = optctx;
3121  char layout_str[32];
3122  char *stream_str;
3123  char *ac_str;
3124  int ret, channels, ac_str_size;
3125  uint64_t layout;
3126 
3127  layout = av_get_channel_layout(arg);
3128  if (!layout) {
3129  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3130  return AVERROR(EINVAL);
3131  }
3132  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3133  ret = opt_default_new(o, opt, layout_str);
3134  if (ret < 0)
3135  return ret;
3136 
3137  /* set 'ac' option based on channel layout */
3138  channels = av_get_channel_layout_nb_channels(layout);
3139  snprintf(layout_str, sizeof(layout_str), "%d", channels);
3140  stream_str = strchr(opt, ':');
3141  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3142  ac_str = av_mallocz(ac_str_size);
3143  if (!ac_str)
3144  return AVERROR(ENOMEM);
3145  av_strlcpy(ac_str, "ac", 3);
3146  if (stream_str)
3147  av_strlcat(ac_str, stream_str, ac_str_size);
3148  ret = parse_option(o, ac_str, layout_str, options);
3149  av_free(ac_str);
3150 
3151  return ret;
3152 }
3153 
3154 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3155 {
3156  OptionsContext *o = optctx;
3157  return parse_option(o, "q:a", arg, options);
3158 }
3159 
3160 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3161 {
3163  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3164  return AVERROR(ENOMEM);
3167  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3168  return AVERROR(ENOMEM);
3169 
3171 
3172  return 0;
3173 }
3174 
3175 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3176 {
3177  uint8_t *graph_desc = read_file(arg);
3178  if (!graph_desc)
3179  return AVERROR(EINVAL);
3180 
3182  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3183  return AVERROR(ENOMEM);
3185  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3186 
3188 
3189  return 0;
3190 }
3191 
3192 void show_help_default(const char *opt, const char *arg)
3193 {
3194  /* per-file options have at least one of those set */
3195  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3196  int show_advanced = 0, show_avoptions = 0;
3197 
3198  if (opt && *opt) {
3199  if (!strcmp(opt, "long"))
3200  show_advanced = 1;
3201  else if (!strcmp(opt, "full"))
3202  show_advanced = show_avoptions = 1;
3203  else
3204  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3205  }
3206 
3207  show_usage();
3208 
3209  printf("Getting help:\n"
3210  " -h -- print basic options\n"
3211  " -h long -- print more options\n"
3212  " -h full -- print all options (including all format and codec specific options, very long)\n"
3213  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3214  " See man %s for detailed description of the options.\n"
3215  "\n", program_name);
3216 
3217  show_help_options(options, "Print help / information / capabilities:",
3218  OPT_EXIT, 0, 0);
3219 
3220  show_help_options(options, "Global options (affect whole program "
3221  "instead of just one file):",
3222  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3223  if (show_advanced)
3224  show_help_options(options, "Advanced global options:", OPT_EXPERT,
3225  per_file | OPT_EXIT, 0);
3226 
3227  show_help_options(options, "Per-file main options:", 0,
3229  OPT_EXIT, per_file);
3230  if (show_advanced)
3231  show_help_options(options, "Advanced per-file options:",
3232  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3233 
3234  show_help_options(options, "Video options:",
3236  if (show_advanced)
3237  show_help_options(options, "Advanced Video options:",
3239 
3240  show_help_options(options, "Audio options:",
3242  if (show_advanced)
3243  show_help_options(options, "Advanced Audio options:",
3245  show_help_options(options, "Subtitle options:",
3246  OPT_SUBTITLE, 0, 0);
3247  printf("\n");
3248 
3249  if (show_avoptions) {
3253 #if CONFIG_SWSCALE
3255 #endif
3256 #if CONFIG_SWRESAMPLE
3258 #endif
3261  }
3262 }
3263 
3264 void show_usage(void)
3265 {
3266  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3267  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3268  av_log(NULL, AV_LOG_INFO, "\n");
3269 }
3270 
3271 enum OptGroup {
3274 };
3275 
3276 static const OptionGroupDef groups[] = {
3277  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3278  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3279 };
3280 
3281 static int open_files(OptionGroupList *l, const char *inout,
3282  int (*open_file)(OptionsContext*, const char*))
3283 {
3284  int i, ret;
3285 
3286  for (i = 0; i < l->nb_groups; i++) {
3287  OptionGroup *g = &l->groups[i];
3288  OptionsContext o;
3289 
3290  init_options(&o);
3291  o.g = g;
3292 
3293  ret = parse_optgroup(&o, g);
3294  if (ret < 0) {
3295  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3296  "%s.\n", inout, g->arg);
3297  uninit_options(&o);
3298  return ret;
3299  }
3300 
3301  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3302  ret = open_file(&o, g->arg);
3303  uninit_options(&o);
3304  if (ret < 0) {
3305  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3306  inout, g->arg);
3307  return ret;
3308  }
3309  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3310  }
3311 
3312  return 0;
3313 }
3314 
3315 int ffmpeg_parse_options(int argc, char **argv)
3316 {
3317  OptionParseContext octx;
3318  uint8_t error[128];
3319  int ret;
3320 
3321  memset(&octx, 0, sizeof(octx));
3322 
3323  /* split the commandline into an internal representation */
3324  ret = split_commandline(&octx, argc, argv, options, groups,
3325  FF_ARRAY_ELEMS(groups));
3326  if (ret < 0) {
3327  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3328  goto fail;
3329  }
3330 
3331  /* apply global options */
3332  ret = parse_optgroup(NULL, &octx.global_opts);
3333  if (ret < 0) {
3334  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3335  goto fail;
3336  }
3337 
3338  /* configure terminal and setup signal handlers */
3339  term_init();
3340 
3341  /* open input files */
3342  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3343  if (ret < 0) {
3344  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3345  goto fail;
3346  }
3347 
3348  /* create the complex filtergraphs */
3349  ret = init_complex_filters();
3350  if (ret < 0) {
3351  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3352  goto fail;
3353  }
3354 
3355  /* open output files */
3356  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3357  if (ret < 0) {
3358  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3359  goto fail;
3360  }
3361 
3363 
3364 fail:
3365  uninit_parse_context(&octx);
3366  if (ret < 0) {
3367  av_strerror(ret, error, sizeof(error));
3368  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3369  }
3370  return ret;
3371 }
3372 
3373 static int opt_progress(void *optctx, const char *opt, const char *arg)
3374 {
3375  AVIOContext *avio = NULL;
3376  int ret;
3377 
3378  if (!strcmp(arg, "-"))
3379  arg = "pipe:";
3380  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3381  if (ret < 0) {
3382  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3383  arg, av_err2str(ret));
3384  return ret;
3385  }
3386  progress_avio = avio;
3387  return 0;
3388 }
3389 
3390 #define OFFSET(x) offsetof(OptionsContext, x)
3391 const OptionDef options[] = {
3392  /* main options */
3394  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3395  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3396  "force format", "fmt" },
3397  { "y", OPT_BOOL, { &file_overwrite },
3398  "overwrite output files" },
3399  { "n", OPT_BOOL, { &no_file_overwrite },
3400  "never overwrite output files" },
3401  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3402  "Ignore unknown stream types" },
3403  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3404  "Copy unknown stream types" },
3405  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3406  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3407  "codec name", "codec" },
3408  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3409  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3410  "codec name", "codec" },
3411  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3412  OPT_OUTPUT, { .off = OFFSET(presets) },
3413  "preset name", "preset" },
3414  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3415  OPT_OUTPUT, { .func_arg = opt_map },
3416  "set input stream mapping",
3417  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3418  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3419  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3420  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3421  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3422  "set metadata information of outfile from infile",
3423  "outfile[,metadata]:infile[,metadata]" },
3424  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3425  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3426  "set chapters mapping", "input_file_index" },
3427  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3428  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3429  "record or transcode \"duration\" seconds of audio/video",
3430  "duration" },
3431  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3432  "record or transcode stop time", "time_stop" },
3433  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3434  "set the limit file size in bytes", "limit_size" },
3435  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3436  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3437  "set the start time offset", "time_off" },
3438  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3439  OPT_INPUT, { .off = OFFSET(start_time_eof) },
3440  "set the start time offset relative to EOF", "time_off" },
3441  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3442  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3443  "enable/disable seeking by timestamp with -ss" },
3444  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3445  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3446  "enable/disable accurate seeking with -ss" },
3447  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3448  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3449  "set the input ts offset", "time_off" },
3450  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3451  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3452  "set the input ts scale", "scale" },
3453  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3454  "set the recording timestamp ('now' to set the current time)", "time" },
3455  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3456  "add metadata", "string=string" },
3457  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3458  "add program with specified streams", "title=string:st=number..." },
3459  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3460  OPT_OUTPUT, { .func_arg = opt_data_frames },
3461  "set the number of data frames to output", "number" },
3462  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3463  "add timings for benchmarking" },
3464  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3465  "add timings for each task" },
3466  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3467  "write program-readable progress information", "url" },
3468  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3469  "enable or disable interaction on standard input" },
3470  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3471  "set max runtime in seconds in CPU user time", "limit" },
3472  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3473  "dump each input packet" },
3474  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3475  "when dumping packets, also dump the payload" },
3476  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3477  OPT_INPUT, { .off = OFFSET(rate_emu) },
3478  "read input at native frame rate", "" },
3479  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3480  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3481  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3482  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3483  "video sync method", "" },
3484  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3485  "frame drop threshold", "" },
3486  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3487  "audio sync method", "" },
3488  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3489  "audio drift threshold", "threshold" },
3490  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3491  "copy timestamps" },
3492  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3493  "shift input timestamps to start at 0 when using copyts" },
3494  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3495  "copy input stream time base when stream copying", "mode" },
3496  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3497  OPT_OUTPUT, { .off = OFFSET(shortest) },
3498  "finish encoding within shortest input" },
3499  { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3500  OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3501  "bitexact mode" },
3502  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3503  OPT_OUTPUT, { .off = OFFSET(apad) },
3504  "audio pad", "" },
3505  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3506  "timestamp discontinuity delta threshold", "threshold" },
3507  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3508  "timestamp error delta threshold", "threshold" },
3509  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3510  "exit on error", "error" },
3511  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3512  "abort on the specified condition flags", "flags" },
3513  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3514  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3515  "copy initial non-keyframes" },
3516  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3517  "copy or discard frames before start time" },
3518  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3519  "set the number of frames to output", "number" },
3520  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3521  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3522  "force codec tag/fourcc", "fourcc/tag" },
3523  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3524  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3525  "use fixed quality scale (VBR)", "q" },
3526  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3527  OPT_OUTPUT, { .func_arg = opt_qscale },
3528  "use fixed quality scale (VBR)", "q" },
3529  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3530  "set profile", "profile" },
3531  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3532  "set stream filtergraph", "filter_graph" },
3533  { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3534  "number of non-complex filter threads" },
3535  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3536  "read stream filtergraph description from a file", "filename" },
3537  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3538  "reinit filtergraph on input parameter changes", "" },
3539  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3540  "create a complex filtergraph", "graph_description" },
3541  { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3542  "number of threads for -filter_complex" },
3543  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3544  "create a complex filtergraph", "graph_description" },
3545  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3546  "read complex filtergraph description from a file", "filename" },
3547  { "stats", OPT_BOOL, { &print_stats },
3548  "print progress report during encoding", },
3549  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3550  OPT_OUTPUT, { .func_arg = opt_attach },
3551  "add an attachment to the output file", "filename" },
3552  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3553  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3554  "extract an attachment into a file", "filename" },
3555  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3556  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3557  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3558  "print timestamp debugging info" },
3559  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3560  "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3561  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3562  OPT_INPUT, { .off = OFFSET(discard) },
3563  "discard", "" },
3564  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3565  OPT_OUTPUT, { .off = OFFSET(disposition) },
3566  "disposition", "" },
3567  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3568  { .off = OFFSET(thread_queue_size) },
3569  "set the maximum number of queued packets from the demuxer" },
3570  { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3571  "read and decode the streams to fill missing information with heuristics" },
3572 
3573  /* video options */
3574  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3575  "set the number of video frames to output", "number" },
3576  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3577  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3578  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3580  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3581  "set frame size (WxH or abbreviation)", "size" },
3582  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3583  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3584  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3585  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3586  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3587  "set pixel format", "format" },
3588  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3589  "set the number of bits per raw sample", "number" },
3590  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3591  "deprecated use -g 1" },
3593  "disable video" },
3594  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3595  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3596  "rate control override for specific intervals", "override" },
3597  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3598  OPT_OUTPUT, { .func_arg = opt_video_codec },
3599  "force video codec ('copy' to copy stream)", "codec" },
3600  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3601  "Removed" },
3602  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3603  "Removed" },
3604  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3605  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3606  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3607  "select the pass number (1 to 3)", "n" },
3608  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3609  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3610  "select two pass log file name prefix", "prefix" },
3611  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3612  "this option is deprecated, use the yadif filter instead" },
3613  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3614  "calculate PSNR of compressed frames" },
3615  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3616  "dump video coding statistics to file" },
3617  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3618  "dump video coding statistics to file", "file" },
3619  { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3620  "Version of the vstats format to use."},
3621  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3622  "set video filters", "filter_graph" },
3623  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3624  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3625  "specify intra matrix coeffs", "matrix" },
3626  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3627  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3628  "specify inter matrix coeffs", "matrix" },
3629  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3630  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3631  "specify intra matrix coeffs", "matrix" },
3632  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3633  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3634  "top=1/bottom=0/auto=-1 field first", "" },
3635  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3636  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3637  "force video tag/fourcc", "fourcc/tag" },
3638  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3639  "show QP histogram" },
3640  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3641  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3642  "force the selected framerate, disable the best supported framerate selection" },
3643  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3644  OPT_OUTPUT, { .func_arg = opt_streamid },
3645  "set the value of an outfile streamid", "streamIndex:value" },
3646  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3647  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3648  "force key frames at specified timestamps", "timestamps" },
3649  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3650  "audio bitrate (please use -b:a)", "bitrate" },
3651  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3652  "video bitrate (please use -b:v)", "bitrate" },
3653  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3654  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3655  "use HW accelerated decoding", "hwaccel name" },
3656  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3657  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3658  "select a device for HW acceleration", "devicename" },
3659  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3660  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3661  "select output format used with HW accelerated decoding", "format" },
3662 #if CONFIG_VIDEOTOOLBOX
3663  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3664 #endif
3665  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3666  "show available HW acceleration methods" },
3667  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3668  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3669  "automatically insert correct rotate filters" },
3670  { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC |
3671  OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) },
3672  "automatically insert a scale filter at the end of the filter graph" },
3673 
3674  /* audio options */
3675  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3676  "set the number of audio frames to output", "number" },
3677  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3678  "set audio quality (codec-specific)", "quality", },
3679  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3680  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3681  "set audio sampling rate (in Hz)", "rate" },
3682  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3683  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3684  "set number of audio channels", "channels" },
3686  "disable audio" },
3687  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3688  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3689  "force audio codec ('copy' to copy stream)", "codec" },
3690  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3691  OPT_OUTPUT, { .func_arg = opt_old2new },
3692  "force audio tag/fourcc", "fourcc/tag" },
3693  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3694  "change audio volume (256=normal)" , "volume" },
3695  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3697  "set sample format", "format" },
3698  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3699  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3700  "set channel layout", "layout" },
3701  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3702  "set audio filters", "filter_graph" },
3703  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3704  "set the maximum number of channels to try to guess the channel layout" },
3705 
3706  /* subtitle options */
3708  "disable subtitle" },
3709  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3710  "force subtitle codec ('copy' to copy stream)", "codec" },
3711  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3712  , "force subtitle tag/fourcc", "fourcc/tag" },
3713  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3714  "fix subtitles duration" },
3715  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3716  "set canvas size (WxH or abbreviation)", "size" },
3717 
3718  /* grab options */
3719  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3720  "deprecated, use -channel", "channel" },
3721  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3722  "deprecated, use -standard", "standard" },
3723  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3724 
3725  /* muxer options */
3726  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3727  "set the maximum demux-decode delay", "seconds" },
3728  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3729  "set the initial demux-decode delay", "seconds" },
3730  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3731  "specify a file in which to print sdp information", "file" },
3732 
3733  { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3734  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3735  { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3736  "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3737  "two special values are defined - "
3738  "0 = use frame rate (video) or sample rate (audio),"
3739  "-1 = match source time base", "ratio" },
3740 
3741  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3742  "A comma-separated list of bitstream filters", "bitstream_filters" },
3743  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3744  "deprecated", "audio bitstream_filters" },
3745  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3746  "deprecated", "video bitstream_filters" },
3747 
3748  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3749  "set the audio options to the indicated preset", "preset" },
3750  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3751  "set the video options to the indicated preset", "preset" },
3752  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3753  "set the subtitle options to the indicated preset", "preset" },
3754  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3755  "set options from indicated preset file", "filename" },
3756 
3757  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3758  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3759 
3760  /* data codec support */
3761  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3762  "force data codec ('copy' to copy stream)", "codec" },
3763  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3764  "disable data" },
3765 
3766 #if CONFIG_VAAPI
3767  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3768  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3769 #endif
3770 
3771 #if CONFIG_QSV
3772  { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3773  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3774 #endif
3775 
3776  { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3777  "initialise hardware device", "args" },
3778  { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3779  "set hardware device used when filtering", "device" },
3780 
3781  { NULL, },
3782 };
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1580
#define AVERROR_ENCODER_NOT_FOUND
Encoder not found.
Definition: error.h:54
int avio_open(AVIOContext **s, const char *url, int flags)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1127
int parse_optgroup(void *optctx, OptionGroup *g)
Parse an options group and write results into optctx.
Definition: cmdutils.c:412
AVRational enc_timebase
Definition: ffmpeg.h:463
char * vstats_filename
Definition: ffmpeg_opt.c:145
int av_parse_ratio(AVRational *q, const char *str, int max, int log_offset, void *log_ctx)
Parse str and store the parsed ratio in q.
Definition: parseutils.c:45
int nb_dump_attachment
Definition: ffmpeg.h:126
int guess_input_channel_layout(InputStream *ist)
Definition: ffmpeg.c:2056
void show_usage(void)
Definition: ffmpeg_opt.c:3264
int nb_metadata
Definition: ffmpeg.h:167
int nb_streamid_map
Definition: ffmpeg.h:164
#define NULL
Definition: coverity.c:32
int width
Definition: ffmpeg.h:271
AVRational framerate
Definition: avcodec.h:2069
int audio_sync_method
Definition: ffmpeg_opt.c:153
AVDictionary * resample_opts
Definition: cmdutils.h:320
int keep_pix_fmt
Definition: ffmpeg.h:531
Bytestream IO Context.
Definition: avio.h:161
float mux_preload
Definition: ffmpeg.h:152
static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:567
static const char * opt_name_frame_sizes[]
Definition: ffmpeg_opt.c:58
#define OPT_EXPERT
Definition: cmdutils.h:163
int start_at_zero
Definition: ffmpeg_opt.c:162
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:561
void term_init(void)
Definition: ffmpeg.c:395
static const char * opt_name_copy_initial_nonkeyframes[]
Definition: ffmpeg_opt.c:80
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:346
int nb_outputs
Definition: ffmpeg.h:293
int copy_tb
Definition: ffmpeg_opt.c:163
char * qsv_device
Definition: ffmpeg_qsv.c:32
AVDictionary * swr_opts
Definition: ffmpeg.h:512
int qp_hist
Definition: ffmpeg_opt.c:168
AVDictionary * swr_opts
Definition: cmdutils.h:322
static const char * opt_name_apad[]
Definition: ffmpeg_opt.c:91
#define av_realloc_f(p, o, n)
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:179
void term_exit(void)
Definition: ffmpeg.c:336
int stream_copy
Definition: ffmpeg.h:517
static int opt_data_frames(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2949
int do_benchmark
Definition: ffmpeg_opt.c:157
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1629
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1414
AVOption.
Definition: opt.h:248
AVRational frame_rate
Definition: ffmpeg.h:479
int audio_channels
Definition: rtp.c:40
static const char * opt_name_passlogfiles[]
Definition: ffmpeg_opt.c:88
int64_t start_time_eof
Definition: ffmpeg.h:99
static const char * opt_name_frame_rates[]
Definition: ffmpeg_opt.c:57
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
Definition: parseutils.c:148
static void init_output_filter(OutputFilter *ofilter, OptionsContext *o, AVFormatContext *oc)
Definition: ffmpeg_opt.c:2069
char * filters
filtergraph associated to the -filter option
Definition: ffmpeg.h:507
static AVInputFormat * file_iformat
Definition: ffplay.c:311
#define OPT_VIDEO
Definition: cmdutils.h:165
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
int data_disable
Definition: ffmpeg.h:160
float mux_max_delay
Definition: ffmpeg.h:153
int accurate_seek
Definition: ffmpeg.h:415
int64_t forced_kf_ref_pts
Definition: ffmpeg.h:490
int * streamid_map
Definition: ffmpeg.h:163
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int video_sync_method
Definition: ffmpeg_opt.c:154
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Main libavfilter public API header.
int nb_stream_maps
Definition: ffmpeg.h:138
static void assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:981
static const char * opt_name_bitstream_filters[]
Definition: ffmpeg_opt.c:67
int ostream_idx
Definition: ffmpeg.h:91
#define AV_DICT_DONT_OVERWRITE
Don&#39;t overwrite existing entries.
Definition: dict.h:79
static int input_sync
Definition: ffmpeg_opt.c:181
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
Look up an AVHWDeviceType by name.
Definition: hwcontext.c:82
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:87
hardware decoding through Videotoolbox
Definition: pixfmt.h:282
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:751
AVRational framerate
Definition: ffmpeg.h:334
void avfilter_inout_free(AVFilterInOut **inout)
Free the supplied list of AVFilterInOut and set *inout to NULL.
Definition: graphparser.c:203
enum AVCodecID video_codec
default video codec
Definition: avformat.h:511
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:2097
#define OPT_AUDIO
Definition: cmdutils.h:166
int64_t max_pts
Definition: ffmpeg.h:323
FILE * av_fopen_utf8(const char *path, const char *mode)
Open a file using a UTF-8 filename.
Definition: file_open.c:158
static const char * opt_name_top_field_first[]
Definition: ffmpeg_opt.c:78
AVFilterInOut * out_tmp
Definition: ffmpeg.h:267
static const char * opt_name_force_fps[]
Definition: ffmpeg_opt.c:72
int bitexact
Definition: ffmpeg.h:155
int decoding_needed
Definition: ffmpeg.h:301
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int qscale
Definition: avcodec.h:258
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:938
int num
Numerator.
Definition: rational.h:59
#define AV_OPT_FLAG_AUDIO_PARAM
Definition: opt.h:280
int rotate_overridden
Definition: ffmpeg.h:483
int index
stream index in AVFormatContext
Definition: avformat.h:877
int max_muxing_queue_size
Definition: ffmpeg.h:545
int nb_frame_pix_fmts
Definition: ffmpeg.h:114
#define AVIO_FLAG_READ
read-only
Definition: avio.h:674
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int do_deinterlace
Definition: ffmpeg_opt.c:156
static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3086
static OutputStream * new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
Definition: ffmpeg_opt.c:1955
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:675
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:905
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: codec_desc.h:102
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
Convenience header that includes libavutil&#39;s core.
const char * arg
Definition: cmdutils.h:313
static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3160
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
GLint GLenum type
Definition: opengl_enc.c:104
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:533
#define OPT_DATA
Definition: cmdutils.h:172
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1553
static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
Definition: ffmpeg_opt.c:2026
enum AVMediaType type
Definition: codec.h:203
int nb_program
Definition: ffmpeg.h:227
const char * key
static const char * opt_name_discard[]
Definition: ffmpeg_opt.c:92
static int file_overwrite
Definition: ffmpeg_opt.c:178
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static OutputStream * new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
Definition: ffmpeg_opt.c:1410
discard all
Definition: avcodec.h:236
static const char * opt_name_enc_time_bases[]
Definition: ffmpeg_opt.c:95
static int find_stream_info
Definition: ffmpeg_opt.c:185
int64_t input_ts_offset
Definition: ffmpeg.h:404
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:95
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1757
int nb_input_streams
Definition: ffmpeg.c:148
static const char * opt_name_max_frames[]
Definition: ffmpeg_opt.c:66
static int audio_disable
Definition: ffplay.c:320
static void error(const char *err)
const char * name
Definition: ffmpeg.h:67
AVDictionary * metadata
Definition: avformat.h:1312
static const char * audio_codec_name
Definition: ffplay.c:345
static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
Definition: ffmpeg_opt.c:1375
static const char * opt_name_autoscale[]
Definition: ffmpeg_opt.c:65
#define OPT_DOUBLE
Definition: cmdutils.h:180
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1549
#define OPT_FLOAT
Definition: cmdutils.h:168
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
AVCodec.
Definition: codec.h:190
int framerate
Definition: h264_levels.c:65
#define VSYNC_VFR
Definition: ffmpeg.h:52
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1369
#define CMDUTILS_COMMON_OPTIONS
Definition: cmdutils.h:215
AVDictionary * filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, AVCodec *codec)
Filter out options for given codec.
Definition: cmdutils.c:2105
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:562
int index
Definition: ffmpeg.h:284
static int opt_preset(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2975
Definition: ftp.c:37
SpecifierOpt * frame_pix_fmts
Definition: ffmpeg.h:113
uint8_t base
Definition: vp3data.h:202
static int opt_data_codec(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:321
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
Definition: ffmpeg_opt.c:107
void uninit_parse_context(OptionParseContext *octx)
Free all allocated memory in an OptionParseContext.
Definition: cmdutils.c:725
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
Definition: allcodecs.c:948
int encoding_needed
Definition: ffmpeg.h:450
static const char * opt_name_ts_scale[]
Definition: ffmpeg_opt.c:60
static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3154
Format I/O context.
Definition: avformat.h:1351
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:310
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:482
enum HWAccelID id
Definition: ffmpeg.h:69
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
static const char * opt_name_canvas_sizes[]
Definition: ffmpeg_opt.c:86
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:72
static const uint8_t frame_sizes[]
Definition: rtpdec_qcelp.c:24
static int do_psnr
Definition: ffmpeg_opt.c:180
char * logfile_prefix
Definition: ffmpeg.h:502
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1485
int user_set_discard
Definition: ffmpeg.h:300
static int ignore_unknown_streams
Definition: ffmpeg_opt.c:183
static int64_t start_time
Definition: ffplay.c:332
static const char * opt_name_audio_sample_rate[]
Definition: ffmpeg_opt.c:56
int copy_initial_nonkeyframes
Definition: ffmpeg.h:527
int filter_nbthreads
Definition: ffmpeg_opt.c:172
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1194
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:519
uint8_t
static int nb_streams
Definition: ffprobe.c:282
#define av_malloc(s)
AVDictionary * sws_dict
Definition: ffmpeg.h:511
Opaque data information usually continuous.
Definition: avutil.h:203
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:543
static const char * opt_name_max_muxing_queue_size[]
Definition: ffmpeg_opt.c:89
#define OPT_OUTPUT
Definition: cmdutils.h:182
int width
Video only.
Definition: codec_par.h:126
static const char * opt_name_rc_overrides[]
Definition: ffmpeg_opt.c:74
AVOptions.
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:664
#define HAS_ARG
Definition: cmdutils.h:161
static int open_input_file(OptionsContext *o, const char *filename)
Definition: ffmpeg_opt.c:1056
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3276
FILE * logfile
Definition: ffmpeg.h:503
static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:530
#define f(width, name)
Definition: cbs_vp9.c:255
AVDictionary * opts
Definition: ffmpeg.h:559
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint16_t * chroma_intra_matrix
custom intra quantization matrix
Definition: avcodec.h:2168
int id
unique ID to identify the chapter
Definition: avformat.h:1309
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
static int opt_vsync(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3092
int id
Format-specific stream ID.
Definition: avformat.h:883
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
#define OPT_OFFSET
Definition: cmdutils.h:175
int vstats_version
Definition: ffmpeg_opt.c:174
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4519
int nb_max_frames
Definition: ffmpeg.h:169
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
int shortest
Definition: ffmpeg.h:565
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
static int opt_vstats(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:2921
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2148
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:208
int channel_idx
Definition: ffmpeg.h:90
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:63
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:675
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
int nb_streams
Definition: ffmpeg.h:411
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1482
int sync_file_index
Definition: ffmpeg.h:84
static const char * opt_name_chroma_intra_matrices[]
Definition: ffmpeg_opt.c:77
AVProgram * av_new_program(AVFormatContext *s, int id)
Definition: utils.c:4618
AVDictionary * resample_opts
Definition: ffmpeg.h:513
int seek_timestamp
Definition: ffmpeg.h:100
uint32_t tag
Definition: movenc.c:1532
int * formats
Definition: ffmpeg.h:278
#define OPT_SPEC
Definition: