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