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