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