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