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)) !=
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 {
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);
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)) !=
580  printf("\n");
581  exit_program(0);
582  } else {
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  }
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 const 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  const 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) :
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  const AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
776  st->codecpar->codec_id = codec->id;
777  return codec;
778  } else
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 
806 
807  ist->st = st;
808  ist->file_index = nb_input_files;
809  ist->discard = 1;
810  st->discard = AVDISCARD_ALL;
811  ist->nb_samples = 0;
812  ist->min_pts = INT64_MAX;
813  ist->max_pts = INT64_MIN;
814 
815  ist->ts_scale = 1.0;
816  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
817 
818  ist->autorotate = 1;
819  MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
820 
821  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
822  if (codec_tag) {
823  uint32_t tag = strtol(codec_tag, &next, 0);
824  if (*next)
825  tag = AV_RL32(codec_tag);
826  st->codecpar->codec_tag = tag;
827  }
828 
829  ist->dec = choose_decoder(o, ic, st);
830  ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
831 
832  ist->reinit_filters = -1;
833  MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
834 
835  MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
836  ist->user_set_discard = AVDISCARD_NONE;
837 
838  if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
839  (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
840  (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
841  (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
842  ist->user_set_discard = AVDISCARD_ALL;
843 
844  if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
845  av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
846  discard_str);
847  exit_program(1);
848  }
849 
850  ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
851 
852  ist->dec_ctx = avcodec_alloc_context3(ist->dec);
853  if (!ist->dec_ctx) {
854  av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
855  exit_program(1);
856  }
857 
858  ret = avcodec_parameters_to_context(ist->dec_ctx, par);
859  if (ret < 0) {
860  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
861  exit_program(1);
862  }
863 
864  if (o->bitexact)
865  ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
866 
867  switch (par->codec_type) {
868  case AVMEDIA_TYPE_VIDEO:
869  if(!ist->dec)
870  ist->dec = avcodec_find_decoder(par->codec_id);
871 
872  // avformat_find_stream_info() doesn't set this for us anymore.
873  ist->dec_ctx->framerate = st->avg_frame_rate;
874 
875  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
876  if (framerate && av_parse_video_rate(&ist->framerate,
877  framerate) < 0) {
878  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
879  framerate);
880  exit_program(1);
881  }
882 
883  ist->top_field_first = -1;
884  MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
885 
886  MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
887  MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
888  hwaccel_output_format, ic, st);
889 
890  if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
892  "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
893  "with old commandlines. This behaviour is DEPRECATED and will be removed "
894  "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
895  ist->hwaccel_output_format = AV_PIX_FMT_CUDA;
896  } else if (hwaccel_output_format) {
897  ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
898  if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
899  av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
900  "format: %s", hwaccel_output_format);
901  }
902  } else {
903  ist->hwaccel_output_format = AV_PIX_FMT_NONE;
904  }
905 
906  if (hwaccel) {
907  // The NVDEC hwaccels use a CUDA device, so remap the name here.
908  if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
909  hwaccel = "cuda";
910 
911  if (!strcmp(hwaccel, "none"))
912  ist->hwaccel_id = HWACCEL_NONE;
913  else if (!strcmp(hwaccel, "auto"))
914  ist->hwaccel_id = HWACCEL_AUTO;
915  else {
916  enum AVHWDeviceType type;
917  int i;
918  for (i = 0; hwaccels[i].name; i++) {
919  if (!strcmp(hwaccels[i].name, hwaccel)) {
920  ist->hwaccel_id = hwaccels[i].id;
921  break;
922  }
923  }
924 
925  if (!ist->hwaccel_id) {
927  if (type != AV_HWDEVICE_TYPE_NONE) {
928  ist->hwaccel_id = HWACCEL_GENERIC;
929  ist->hwaccel_device_type = type;
930  }
931  }
932 
933  if (!ist->hwaccel_id) {
934  av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
935  hwaccel);
936  av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
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 
955  ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
956 
957  break;
958  case AVMEDIA_TYPE_AUDIO:
959  ist->guess_layout_max = INT_MAX;
960  MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
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;
1071  const AVInputFormat *file_iformat = NULL;
1072  int err, i, ret;
1073  int64_t timestamp;
1074  AVDictionary *unused_opts = NULL;
1075  AVDictionaryEntry *e = NULL;
1076  char * video_codec_name = NULL;
1077  char * audio_codec_name = NULL;
1078  char *subtitle_codec_name = NULL;
1079  char * data_codec_name = NULL;
1080  int scan_all_pmts_set = 0;
1081 
1082  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1083  o->stop_time = INT64_MAX;
1084  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1085  }
1086 
1087  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1088  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1089  if (o->stop_time <= start_time) {
1090  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1091  exit_program(1);
1092  } else {
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  const AVClass *priv_class;
1121  /* because we set audio_channels based on both the "ac" and
1122  * "channel_layout" options, we need to check that the specified
1123  * demuxer actually has the "channels" option before setting it */
1124  if (file_iformat && (priv_class = file_iformat->priv_class) &&
1125  av_opt_find(&priv_class, "channels", NULL, 0,
1127  av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1128  }
1129  }
1130  if (o->nb_frame_rates) {
1131  const AVClass *priv_class;
1132  /* set the format-level framerate option;
1133  * this is important for video grabbers, e.g. x11 */
1134  if (file_iformat && (priv_class = file_iformat->priv_class) &&
1135  av_opt_find(&priv_class, "framerate", NULL, 0,
1137  av_dict_set(&o->g->format_opts, "framerate",
1138  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1139  }
1140  }
1141  if (o->nb_frame_sizes) {
1142  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1143  }
1144  if (o->nb_frame_pix_fmts)
1145  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1146 
1147  MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1148  MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1149  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1150  MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1151 
1152  if (video_codec_name)
1154  if (audio_codec_name)
1156  if (subtitle_codec_name)
1158  if (data_codec_name)
1159  ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1160 
1164  ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1165 
1166  ic->flags |= AVFMT_FLAG_NONBLOCK;
1167  if (o->bitexact)
1168  ic->flags |= AVFMT_FLAG_BITEXACT;
1169  ic->interrupt_callback = int_cb;
1170 
1171  if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1172  av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1173  scan_all_pmts_set = 1;
1174  }
1175  /* open the input file with generic avformat function */
1176  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1177  if (err < 0) {
1178  print_error(filename, err);
1179  if (err == AVERROR_PROTOCOL_NOT_FOUND)
1180  av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1181  exit_program(1);
1182  }
1183  if (scan_all_pmts_set)
1184  av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1187 
1188  /* apply forced codec ids */
1189  for (i = 0; i < ic->nb_streams; i++)
1190  choose_decoder(o, ic, ic->streams[i]);
1191 
1192  if (find_stream_info) {
1194  int orig_nb_streams = ic->nb_streams;
1195 
1196  /* If not enough info to get the stream parameters, we decode the
1197  first frames to get it. (used in mpeg case for example) */
1199 
1200  for (i = 0; i < orig_nb_streams; i++)
1201  av_dict_free(&opts[i]);
1202  av_freep(&opts);
1203 
1204  if (ret < 0) {
1205  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1206  if (ic->nb_streams == 0) {
1207  avformat_close_input(&ic);
1208  exit_program(1);
1209  }
1210  }
1211  }
1212 
1214  av_log(NULL, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss for %s\n", filename);
1216  }
1217 
1218  if (o->start_time_eof != AV_NOPTS_VALUE) {
1219  if (o->start_time_eof >= 0) {
1220  av_log(NULL, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1221  exit_program(1);
1222  }
1223  if (ic->duration > 0) {
1224  o->start_time = o->start_time_eof + ic->duration;
1225  if (o->start_time < 0) {
1226  av_log(NULL, AV_LOG_WARNING, "-sseof value seeks to before start of file %s; ignored\n", filename);
1228  }
1229  } else
1230  av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1231  }
1232  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1233  /* add the stream start time */
1234  if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1235  timestamp += ic->start_time;
1236 
1237  /* if seeking requested, we execute it */
1238  if (o->start_time != AV_NOPTS_VALUE) {
1239  int64_t seek_timestamp = timestamp;
1240 
1241  if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1242  int dts_heuristic = 0;
1243  for (i=0; i<ic->nb_streams; i++) {
1244  const AVCodecParameters *par = ic->streams[i]->codecpar;
1245  if (par->video_delay) {
1246  dts_heuristic = 1;
1247  break;
1248  }
1249  }
1250  if (dts_heuristic) {
1251  seek_timestamp -= 3*AV_TIME_BASE / 23;
1252  }
1253  }
1254  ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1255  if (ret < 0) {
1256  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1257  filename, (double)timestamp / AV_TIME_BASE);
1258  }
1259  }
1260 
1261  /* update the current parameters so that they match the one of the input stream */
1262  add_input_streams(o, ic);
1263 
1264  /* dump the file content */
1265  av_dump_format(ic, nb_input_files, filename, 0);
1266 
1268  f = av_mallocz(sizeof(*f));
1269  if (!f)
1270  exit_program(1);
1271  input_files[nb_input_files - 1] = f;
1272 
1273  f->ctx = ic;
1274  f->ist_index = nb_input_streams - ic->nb_streams;
1275  f->start_time = o->start_time;
1276  f->recording_time = o->recording_time;
1277  f->input_ts_offset = o->input_ts_offset;
1278  f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1279  f->nb_streams = ic->nb_streams;
1280  f->rate_emu = o->rate_emu;
1281  f->accurate_seek = o->accurate_seek;
1282  f->loop = o->loop;
1283  f->duration = 0;
1284  f->time_base = (AVRational){ 1, 1 };
1285  f->pkt = av_packet_alloc();
1286  if (!f->pkt)
1287  exit_program(1);
1288 #if HAVE_THREADS
1289  f->thread_queue_size = o->thread_queue_size;
1290 #endif
1291 
1292  /* check if all codec options have been used */
1293  unused_opts = strip_specifiers(o->g->codec_opts);
1294  for (i = f->ist_index; i < nb_input_streams; i++) {
1295  e = NULL;
1296  while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1298  av_dict_set(&unused_opts, e->key, NULL, 0);
1299  }
1300 
1301  e = NULL;
1302  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1303  const AVClass *class = avcodec_get_class();
1304  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1306  const AVClass *fclass = avformat_get_class();
1307  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1309  if (!option || foption)
1310  continue;
1311 
1312 
1313  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1314  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1315  "input file #%d (%s) is not a decoding option.\n", e->key,
1316  option->help ? option->help : "", nb_input_files - 1,
1317  filename);
1318  exit_program(1);
1319  }
1320 
1321  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1322  "input file #%d (%s) has not been used for any stream. The most "
1323  "likely reason is either wrong type (e.g. a video option with "
1324  "no video streams) or that it is a private option of some decoder "
1325  "which was not actually used for any stream.\n", e->key,
1326  option->help ? option->help : "", nb_input_files - 1, filename);
1327  }
1328  av_dict_free(&unused_opts);
1329 
1330  for (i = 0; i < o->nb_dump_attachment; i++) {
1331  int j;
1332 
1333  for (j = 0; j < ic->nb_streams; j++) {
1334  AVStream *st = ic->streams[j];
1335 
1336  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1338  }
1339  }
1340 
1342 
1343  return 0;
1344 }
1345 
1346 static uint8_t *get_line(AVIOContext *s)
1347 {
1348  AVIOContext *line;
1349  uint8_t *buf;
1350  char c;
1351 
1352  if (avio_open_dyn_buf(&line) < 0) {
1353  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1354  exit_program(1);
1355  }
1356 
1357  while ((c = avio_r8(s)) && c != '\n')
1358  avio_w8(line, c);
1359  avio_w8(line, 0);
1360  avio_close_dyn_buf(line, &buf);
1361 
1362  return buf;
1363 }
1364 
1365 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1366 {
1367  int i, ret = -1;
1368  char filename[1000];
1369  const char *base[3] = { getenv("AVCONV_DATADIR"),
1370  getenv("HOME"),
1371  AVCONV_DATADIR,
1372  };
1373 
1374  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1375  if (!base[i])
1376  continue;
1377  if (codec_name) {
1378  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1379  i != 1 ? "" : "/.avconv", codec_name, preset_name);
1380  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1381  }
1382  if (ret < 0) {
1383  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1384  i != 1 ? "" : "/.avconv", preset_name);
1385  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1386  }
1387  }
1388  return ret;
1389 }
1390 
1392 {
1394  char *codec_name = NULL;
1395 
1397  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1398  if (!codec_name) {
1399  ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->url,
1400  NULL, ost->st->codecpar->codec_type);
1402  if (!ost->enc) {
1403  av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1404  "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1405  "probably disabled. Please choose an encoder manually.\n",
1406  ost->file_index, ost->index, s->oformat->name,
1409  }
1410  } else if (!strcmp(codec_name, "copy"))
1411  ost->stream_copy = 1;
1412  else {
1413  ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1414  ost->st->codecpar->codec_id = ost->enc->id;
1415  }
1417  } else {
1418  /* no encoding supported for other media types */
1419  ost->stream_copy = 1;
1420  ost->encoding_needed = 0;
1421  }
1422 
1423  return 0;
1424 }
1425 
1427 {
1428  OutputStream *ost;
1429  AVStream *st = avformat_new_stream(oc, NULL);
1430  int idx = oc->nb_streams - 1, ret = 0;
1431  const char *bsfs = NULL, *time_base = NULL;
1432  char *next, *codec_tag = NULL;
1433  double qscale = -1;
1434  int i;
1435 
1436  if (!st) {
1437  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1438  exit_program(1);
1439  }
1440 
1441  if (oc->nb_streams - 1 < o->nb_streamid_map)
1442  st->id = o->streamid_map[oc->nb_streams - 1];
1443 
1445  if (!(ost = av_mallocz(sizeof(*ost))))
1446  exit_program(1);
1448 
1450  ost->index = idx;
1451  ost->st = st;
1453  st->codecpar->codec_type = type;
1454 
1455  ret = choose_encoder(o, oc, ost);
1456  if (ret < 0) {
1457  av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1458  "%d:%d\n", ost->file_index, ost->index);
1459  exit_program(1);
1460  }
1461 
1463  if (!ost->enc_ctx) {
1464  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1465  exit_program(1);
1466  }
1467  ost->enc_ctx->codec_type = type;
1468 
1470  if (!ost->ref_par) {
1471  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1472  exit_program(1);
1473  }
1474 
1475  if (ost->enc) {
1476  AVIOContext *s = NULL;
1477  char *buf = NULL, *arg = NULL, *preset = NULL;
1478 
1479  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1480 
1482  ost->autoscale = 1;
1483  MATCH_PER_STREAM_OPT(autoscale, i, ost->autoscale, oc, st);
1484  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1485  do {
1486  buf = get_line(s);
1487  if (!buf[0] || buf[0] == '#') {
1488  av_free(buf);
1489  continue;
1490  }
1491  if (!(arg = strchr(buf, '='))) {
1492  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1493  exit_program(1);
1494  }
1495  *arg++ = 0;
1497  av_free(buf);
1498  } while (!s->eof_reached);
1499  avio_closep(&s);
1500  }
1501  if (ret) {
1503  "Preset %s specified for stream %d:%d, but could not be opened.\n",
1504  preset, ost->file_index, ost->index);
1505  exit_program(1);
1506  }
1507  } else {
1509  }
1510 
1511 
1512  if (o->bitexact)
1514 
1515  MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1516  if (time_base) {
1517  AVRational q;
1518  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1519  q.num <= 0 || q.den <= 0) {
1520  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1521  exit_program(1);
1522  }
1523  st->time_base = q;
1524  }
1525 
1526  MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1527  if (time_base) {
1528  AVRational q;
1529  if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1530  q.den <= 0) {
1531  av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1532  exit_program(1);
1533  }
1534  ost->enc_timebase = q;
1535  }
1536 
1537  ost->max_frames = INT64_MAX;
1538  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1539  for (i = 0; i<o->nb_max_frames; i++) {
1540  char *p = o->max_frames[i].specifier;
1541  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1542  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1543  break;
1544  }
1545  }
1546 
1547  ost->copy_prior_start = -1;
1548  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1549 
1550  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1551  if (bsfs && *bsfs) {
1552  ret = av_bsf_list_parse_str(bsfs, &ost->bsf_ctx);
1553  if (ret < 0) {
1554  av_log(NULL, AV_LOG_ERROR, "Error parsing bitstream filter sequence '%s': %s\n", bsfs, av_err2str(ret));
1555  exit_program(1);
1556  }
1557  }
1558 
1559  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1560  if (codec_tag) {
1561  uint32_t tag = strtol(codec_tag, &next, 0);
1562  if (*next)
1563  tag = AV_RL32(codec_tag);
1564  ost->st->codecpar->codec_tag =
1565  ost->enc_ctx->codec_tag = tag;
1566  }
1567 
1568  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1569  if (qscale >= 0) {
1571  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1572  }
1573 
1574  MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1576 
1577  ost->max_muxing_queue_size = 128;
1578  MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1579  ost->max_muxing_queue_size *= sizeof(ost->pkt);
1580 
1582 
1583  ost->muxing_queue_data_threshold = 50*1024*1024;
1584  MATCH_PER_STREAM_OPT(muxing_queue_data_threshold, i, ost->muxing_queue_data_threshold, oc, st);
1585 
1586  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1588 
1589  av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1590 
1591  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1592  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1593  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1594 
1596 
1597  ost->source_index = source_index;
1598  if (source_index >= 0) {
1599  ost->sync_ist = input_streams[source_index];
1600  input_streams[source_index]->discard = 0;
1601  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1602  }
1604 
1605  ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1606  if (!ost->muxing_queue)
1607  exit_program(1);
1608 
1609  return ost;
1610 }
1611 
1612 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1613 {
1614  int i;
1615  const char *p = str;
1616  for (i = 0;; i++) {
1617  dest[i] = atoi(p);
1618  if (i == 63)
1619  break;
1620  p = strchr(p, ',');
1621  if (!p) {
1622  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1623  exit_program(1);
1624  }
1625  p++;
1626  }
1627 }
1628 
1629 /* read file contents into a string */
1630 static uint8_t *read_file(const char *filename)
1631 {
1632  AVIOContext *pb = NULL;
1633  AVIOContext *dyn_buf = NULL;
1634  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1635  uint8_t buf[1024], *str;
1636 
1637  if (ret < 0) {
1638  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1639  return NULL;
1640  }
1641 
1642  ret = avio_open_dyn_buf(&dyn_buf);
1643  if (ret < 0) {
1644  avio_closep(&pb);
1645  return NULL;
1646  }
1647  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1648  avio_write(dyn_buf, buf, ret);
1649  avio_w8(dyn_buf, 0);
1650  avio_closep(&pb);
1651 
1652  ret = avio_close_dyn_buf(dyn_buf, &str);
1653  if (ret < 0)
1654  return NULL;
1655  return str;
1656 }
1657 
1659  OutputStream *ost)
1660 {
1661  AVStream *st = ost->st;
1662 
1663  if (ost->filters_script && ost->filters) {
1664  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1665  "output stream #%d:%d.\n", nb_output_files, st->index);
1666  exit_program(1);
1667  }
1668 
1669  if (ost->filters_script)
1670  return read_file(ost->filters_script);
1671  else if (ost->filters)
1672  return av_strdup(ost->filters);
1673 
1675  "null" : "anull");
1676 }
1677 
1679  const OutputStream *ost, enum AVMediaType type)
1680 {
1681  if (ost->filters_script || ost->filters) {
1683  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1684  "Filtering and streamcopy cannot be used together.\n",
1685  ost->filters ? "Filtergraph" : "Filtergraph script",
1688  exit_program(1);
1689  }
1690 }
1691 
1693 {
1694  AVStream *st;
1695  OutputStream *ost;
1696  AVCodecContext *video_enc;
1697  char *frame_rate = NULL, *max_frame_rate = NULL, *frame_aspect_ratio = NULL;
1698 
1699  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1700  st = ost->st;
1701  video_enc = ost->enc_ctx;
1702 
1703  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1704  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1705  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1706  exit_program(1);
1707  }
1708 
1709  MATCH_PER_STREAM_OPT(max_frame_rates, str, max_frame_rate, oc, st);
1710  if (max_frame_rate && av_parse_video_rate(&ost->max_frame_rate, max_frame_rate) < 0) {
1711  av_log(NULL, AV_LOG_FATAL, "Invalid maximum framerate value: %s\n", max_frame_rate);
1712  exit_program(1);
1713  }
1714 
1715  if (frame_rate && max_frame_rate) {
1716  av_log(NULL, AV_LOG_ERROR, "Only one of -fpsmax and -r can be set for a stream.\n");
1717  exit_program(1);
1718  }
1719 
1720  if ((frame_rate || max_frame_rate) &&
1722  av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r/-fpsmax can produce invalid output files\n");
1723 
1724  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1725  if (frame_aspect_ratio) {
1726  AVRational q;
1727  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1728  q.num <= 0 || q.den <= 0) {
1729  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1730  exit_program(1);
1731  }
1732  ost->frame_aspect_ratio = q;
1733  }
1734 
1735  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1737 
1738  if (!ost->stream_copy) {
1739  const char *p = NULL;
1740  char *frame_size = NULL;
1741  char *frame_pix_fmt = NULL;
1742  char *intra_matrix = NULL, *inter_matrix = NULL;
1743  char *chroma_intra_matrix = NULL;
1744  int do_pass = 0;
1745  int i;
1746 
1748  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1749  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1750  exit_program(1);
1751  }
1752 
1754  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1755  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1756  ost->keep_pix_fmt = 1;
1757  if (!*++frame_pix_fmt)
1758  frame_pix_fmt = NULL;
1759  }
1760  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1761  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1762  exit_program(1);
1763  }
1764  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1765 
1766  if (intra_only)
1767  video_enc->gop_size = 0;
1768  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1769  if (intra_matrix) {
1770  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1771  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1772  exit_program(1);
1773  }
1774  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1775  }
1776  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1777  if (chroma_intra_matrix) {
1778  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1779  if (!p) {
1780  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1781  exit_program(1);
1782  }
1783  video_enc->chroma_intra_matrix = p;
1784  parse_matrix_coeffs(p, chroma_intra_matrix);
1785  }
1786  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1787  if (inter_matrix) {
1788  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1789  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1790  exit_program(1);
1791  }
1792  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1793  }
1794 
1795  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1796  for (i = 0; p; i++) {
1797  int start, end, q;
1798  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1799  if (e != 3) {
1800  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1801  exit_program(1);
1802  }
1803  video_enc->rc_override =
1804  av_realloc_array(video_enc->rc_override,
1805  i + 1, sizeof(RcOverride));
1806  if (!video_enc->rc_override) {
1807  av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1808  exit_program(1);
1809  }
1810  video_enc->rc_override[i].start_frame = start;
1811  video_enc->rc_override[i].end_frame = end;
1812  if (q > 0) {
1813  video_enc->rc_override[i].qscale = q;
1814  video_enc->rc_override[i].quality_factor = 1.0;
1815  }
1816  else {
1817  video_enc->rc_override[i].qscale = 0;
1818  video_enc->rc_override[i].quality_factor = -q/100.0;
1819  }
1820  p = strchr(p, '/');
1821  if (p) p++;
1822  }
1823  video_enc->rc_override_count = i;
1824 
1825  if (do_psnr)
1826  video_enc->flags|= AV_CODEC_FLAG_PSNR;
1827 
1828  /* two pass mode */
1829  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1830  if (do_pass) {
1831  if (do_pass & 1) {
1832  video_enc->flags |= AV_CODEC_FLAG_PASS1;
1833  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1834  }
1835  if (do_pass & 2) {
1836  video_enc->flags |= AV_CODEC_FLAG_PASS2;
1837  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1838  }
1839  }
1840 
1841  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1842  if (ost->logfile_prefix &&
1844  exit_program(1);
1845 
1846  if (do_pass) {
1847  char logfilename[1024];
1848  FILE *f;
1849 
1850  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1853  i);
1854  if (!strcmp(ost->enc->name, "libx264")) {
1855  av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1856  } else {
1857  if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1858  char *logbuffer = read_file(logfilename);
1859 
1860  if (!logbuffer) {
1861  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1862  logfilename);
1863  exit_program(1);
1864  }
1865  video_enc->stats_in = logbuffer;
1866  }
1867  if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1868  f = av_fopen_utf8(logfilename, "wb");
1869  if (!f) {
1871  "Cannot write log file '%s' for pass-1 encoding: %s\n",
1872  logfilename, strerror(errno));
1873  exit_program(1);
1874  }
1875  ost->logfile = f;
1876  }
1877  }
1878  }
1879 
1880  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1881  if (ost->forced_keyframes)
1883 
1884  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1885 
1886  ost->top_field_first = -1;
1887  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1888 
1889 
1890  ost->avfilter = get_ost_filters(o, oc, ost);
1891  if (!ost->avfilter)
1892  exit_program(1);
1893  } else {
1894  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1895  }
1896 
1897  if (ost->stream_copy)
1899 
1900  return ost;
1901 }
1902 
1904 {
1905  int n;
1906  AVStream *st;
1907  OutputStream *ost;
1908  AVCodecContext *audio_enc;
1909 
1910  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1911  st = ost->st;
1912 
1913  audio_enc = ost->enc_ctx;
1914  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1915 
1916  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1918 
1919  if (!ost->stream_copy) {
1920  char *sample_fmt = NULL;
1921 
1922  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1923 
1924  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1925  if (sample_fmt &&
1926  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1927  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1928  exit_program(1);
1929  }
1930 
1931  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1932 
1933  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1934  ost->apad = av_strdup(ost->apad);
1935 
1936  ost->avfilter = get_ost_filters(o, oc, ost);
1937  if (!ost->avfilter)
1938  exit_program(1);
1939 
1940  /* check for channel mapping for this audio stream */
1941  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1943  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1944  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1945  InputStream *ist;
1946 
1947  if (map->channel_idx == -1) {
1948  ist = NULL;
1949  } else if (ost->source_index < 0) {
1950  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1951  ost->file_index, ost->st->index);
1952  continue;
1953  } else {
1955  }
1956 
1957  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1960  sizeof(*ost->audio_channels_map)
1961  ) < 0 )
1962  exit_program(1);
1963 
1964  ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1965  }
1966  }
1967  }
1968  }
1969 
1970  if (ost->stream_copy)
1972 
1973  return ost;
1974 }
1975 
1977 {
1978  OutputStream *ost;
1979 
1980  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1981  if (!ost->stream_copy) {
1982  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1983  exit_program(1);
1984  }
1985 
1986  return ost;
1987 }
1988 
1990 {
1991  OutputStream *ost;
1992 
1993  ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1994  if (!ost->stream_copy) {
1995  av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1996  exit_program(1);
1997  }
1998 
1999  return ost;
2000 }
2001 
2003 {
2004  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
2005  ost->stream_copy = 1;
2006  ost->finished = 1;
2007  return ost;
2008 }
2009 
2011 {
2012  AVStream *st;
2013  OutputStream *ost;
2014  AVCodecContext *subtitle_enc;
2015 
2016  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
2017  st = ost->st;
2018  subtitle_enc = ost->enc_ctx;
2019 
2020  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
2021 
2022  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
2023 
2024  if (!ost->stream_copy) {
2025  char *frame_size = NULL;
2026 
2028  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
2029  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
2030  exit_program(1);
2031  }
2032  }
2033 
2034  return ost;
2035 }
2036 
2037 /* arg format is "output-stream-index:streamid-value". */
2038 static int opt_streamid(void *optctx, const char *opt, const char *arg)
2039 {
2040  OptionsContext *o = optctx;
2041  int idx;
2042  char *p;
2043  char idx_str[16];
2044 
2045  av_strlcpy(idx_str, arg, sizeof(idx_str));
2046  p = strchr(idx_str, ':');
2047  if (!p) {
2049  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
2050  arg, opt);
2051  exit_program(1);
2052  }
2053  *p++ = '\0';
2054  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
2055  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
2056  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
2057  return 0;
2058 }
2059 
2061 {
2062  AVFormatContext *is = ifile->ctx;
2063  AVFormatContext *os = ofile->ctx;
2064  AVChapter **tmp;
2065  int i;
2066 
2067  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
2068  if (!tmp)
2069  return AVERROR(ENOMEM);
2070  os->chapters = tmp;
2071 
2072  for (i = 0; i < is->nb_chapters; i++) {
2073  AVChapter *in_ch = is->chapters[i], *out_ch;
2074  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
2075  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
2076  AV_TIME_BASE_Q, in_ch->time_base);
2077  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
2078  av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
2079 
2080 
2081  if (in_ch->end < ts_off)
2082  continue;
2083  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
2084  break;
2085 
2086  out_ch = av_mallocz(sizeof(AVChapter));
2087  if (!out_ch)
2088  return AVERROR(ENOMEM);
2089 
2090  out_ch->id = in_ch->id;
2091  out_ch->time_base = in_ch->time_base;
2092  out_ch->start = FFMAX(0, in_ch->start - ts_off);
2093  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
2094 
2095  if (copy_metadata)
2096  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
2097 
2098  os->chapters[os->nb_chapters++] = out_ch;
2099  }
2100  return 0;
2101 }
2102 
2104  AVFormatContext *oc)
2105 {
2106  OutputStream *ost;
2107 
2108  switch (ofilter->type) {
2109  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2110  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2111  default:
2112  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2113  "currently.\n");
2114  exit_program(1);
2115  }
2116 
2117  ost->source_index = -1;
2118  ost->filter = ofilter;
2119 
2120  ofilter->ost = ost;
2121  ofilter->format = -1;
2122 
2123  if (ost->stream_copy) {
2124  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2125  "which is fed from a complex filtergraph. Filtering and streamcopy "
2126  "cannot be used together.\n", ost->file_index, ost->index);
2127  exit_program(1);
2128  }
2129 
2130  if (ost->avfilter && (ost->filters || ost->filters_script)) {
2131  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2133  "%s '%s' was specified through the %s option "
2134  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2135  "%s and -filter_complex cannot be used together for the same stream.\n",
2136  ost->filters ? "Filtergraph" : "Filtergraph script",
2138  opt, ost->file_index, ost->index, opt);
2139  exit_program(1);
2140  }
2141 
2142  avfilter_inout_free(&ofilter->out_tmp);
2143 }
2144 
2145 static int init_complex_filters(void)
2146 {
2147  int i, ret = 0;
2148 
2149  for (i = 0; i < nb_filtergraphs; i++) {
2151  if (ret < 0)
2152  return ret;
2153  }
2154  return 0;
2155 }
2156 
2157 static int open_output_file(OptionsContext *o, const char *filename)
2158 {
2159  AVFormatContext *oc;
2160  int i, j, err;
2161  OutputFile *of;
2162  OutputStream *ost;
2163  InputStream *ist;
2164  AVDictionary *unused_opts = NULL;
2165  AVDictionaryEntry *e = NULL;
2166  int format_flags = 0;
2167 
2168  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2169  o->stop_time = INT64_MAX;
2170  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2171  }
2172 
2173  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2174  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2175  if (o->stop_time <= start_time) {
2176  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2177  exit_program(1);
2178  } else {
2180  }
2181  }
2182 
2184  of = av_mallocz(sizeof(*of));
2185  if (!of)
2186  exit_program(1);
2187  output_files[nb_output_files - 1] = of;
2188 
2190  of->recording_time = o->recording_time;
2191  of->start_time = o->start_time;
2192  of->limit_filesize = o->limit_filesize;
2193  of->shortest = o->shortest;
2194  av_dict_copy(&of->opts, o->g->format_opts, 0);
2195 
2196  if (!strcmp(filename, "-"))
2197  filename = "pipe:";
2198 
2199  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2200  if (!oc) {
2201  print_error(filename, err);
2202  exit_program(1);
2203  }
2204 
2205  of->ctx = oc;
2206  if (o->recording_time != INT64_MAX)
2207  oc->duration = o->recording_time;
2208 
2209  oc->interrupt_callback = int_cb;
2210 
2211  e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2212  if (e) {
2213  const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2214  av_opt_eval_flags(oc, o, e->value, &format_flags);
2215  }
2216  if (o->bitexact) {
2217  format_flags |= AVFMT_FLAG_BITEXACT;
2218  oc->flags |= AVFMT_FLAG_BITEXACT;
2219  }
2220 
2221  /* create streams for all unlabeled output pads */
2222  for (i = 0; i < nb_filtergraphs; i++) {
2223  FilterGraph *fg = filtergraphs[i];
2224  for (j = 0; j < fg->nb_outputs; j++) {
2225  OutputFilter *ofilter = fg->outputs[j];
2226 
2227  if (!ofilter->out_tmp || ofilter->out_tmp->name)
2228  continue;
2229 
2230  switch (ofilter->type) {
2231  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2232  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2233  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2234  }
2235  init_output_filter(ofilter, o, oc);
2236  }
2237  }
2238 
2239  if (!o->nb_stream_maps) {
2240  char *subtitle_codec_name = NULL;
2241  /* pick the "best" stream of each type */
2242 
2243  /* video: highest resolution */
2245  int best_score = 0, idx = -1;
2246  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2247  for (i = 0; i < nb_input_streams; i++) {
2248  int score;
2249  ist = input_streams[i];
2250  score = ist->st->codecpar->width * ist->st->codecpar->height
2251  + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
2252  + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2253  if (ist->user_set_discard == AVDISCARD_ALL)
2254  continue;
2255  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2256  score = 1;
2257  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2258  score > best_score) {
2259  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2260  continue;
2261  best_score = score;
2262  idx = i;
2263  }
2264  }
2265  if (idx >= 0)
2266  new_video_stream(o, oc, idx);
2267  }
2268 
2269  /* audio: most channels */
2271  int best_score = 0, idx = -1;
2272  for (i = 0; i < nb_input_streams; i++) {
2273  int score;
2274  ist = input_streams[i];
2275  score = ist->st->codecpar->channels
2276  + 100000000 * !!(ist->st->event_flags & AVSTREAM_EVENT_FLAG_NEW_PACKETS)
2277  + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2278  if (ist->user_set_discard == AVDISCARD_ALL)
2279  continue;
2280  if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2281  score > best_score) {
2282  best_score = score;
2283  idx = i;
2284  }
2285  }
2286  if (idx >= 0)
2287  new_audio_stream(o, oc, idx);
2288  }
2289 
2290  /* subtitles: pick first */
2291  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2293  for (i = 0; i < nb_input_streams; i++)
2294  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2295  AVCodecDescriptor const *input_descriptor =
2296  avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2297  AVCodecDescriptor const *output_descriptor = NULL;
2298  AVCodec const *output_codec =
2300  int input_props = 0, output_props = 0;
2301  if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2302  continue;
2303  if (output_codec)
2304  output_descriptor = avcodec_descriptor_get(output_codec->id);
2305  if (input_descriptor)
2306  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2307  if (output_descriptor)
2308  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2309  if (subtitle_codec_name ||
2310  input_props & output_props ||
2311  // Map dvb teletext which has neither property to any output subtitle encoder
2312  input_descriptor && output_descriptor &&
2313  (!input_descriptor->props ||
2314  !output_descriptor->props)) {
2315  new_subtitle_stream(o, oc, i);
2316  break;
2317  }
2318  }
2319  }
2320  /* Data only if codec id match */
2321  if (!o->data_disable ) {
2323  for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2324  if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2325  continue;
2326  if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2328  new_data_stream(o, oc, i);
2329  }
2330  }
2331  } else {
2332  for (i = 0; i < o->nb_stream_maps; i++) {
2333  StreamMap *map = &o->stream_maps[i];
2334 
2335  if (map->disabled)
2336  continue;
2337 
2338  if (map->linklabel) {
2339  FilterGraph *fg;
2340  OutputFilter *ofilter = NULL;
2341  int j, k;
2342 
2343  for (j = 0; j < nb_filtergraphs; j++) {
2344  fg = filtergraphs[j];
2345  for (k = 0; k < fg->nb_outputs; k++) {
2346  AVFilterInOut *out = fg->outputs[k]->out_tmp;
2347  if (out && !strcmp(out->name, map->linklabel)) {
2348  ofilter = fg->outputs[k];
2349  goto loop_end;
2350  }
2351  }
2352  }
2353 loop_end:
2354  if (!ofilter) {
2355  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2356  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2357  exit_program(1);
2358  }
2359  init_output_filter(ofilter, o, oc);
2360  } else {
2361  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2362 
2363  ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2364  if (ist->user_set_discard == AVDISCARD_ALL) {
2365  av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2366  map->file_index, map->stream_index);
2367  exit_program(1);
2368  }
2369  if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2370  continue;
2371  if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2372  continue;
2373  if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2374  continue;
2375  if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2376  continue;
2377 
2378  ost = NULL;
2379  switch (ist->st->codecpar->codec_type) {
2380  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2381  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2382  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2383  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2384  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2385  case AVMEDIA_TYPE_UNKNOWN:
2386  if (copy_unknown_streams) {
2387  ost = new_unknown_stream (o, oc, src_idx);
2388  break;
2389  }
2390  default:
2392  "Cannot map stream #%d:%d - unsupported type.\n",
2393  map->file_index, map->stream_index);
2394  if (!ignore_unknown_streams) {
2396  "If you want unsupported types ignored instead "
2397  "of failing, please use the -ignore_unknown option\n"
2398  "If you want them copied, please use -copy_unknown\n");
2399  exit_program(1);
2400  }
2401  }
2402  if (ost)
2403  ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2404  + map->sync_stream_index];
2405  }
2406  }
2407  }
2408 
2409  /* handle attached files */
2410  for (i = 0; i < o->nb_attachments; i++) {
2411  AVIOContext *pb;
2412  uint8_t *attachment;
2413  const char *p;
2414  int64_t len;
2415 
2416  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2417  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2418  o->attachments[i]);
2419  exit_program(1);
2420  }
2421  if ((len = avio_size(pb)) <= 0) {
2422  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2423  o->attachments[i]);
2424  exit_program(1);
2425  }
2426  if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2427  !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2428  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2429  o->attachments[i]);
2430  exit_program(1);
2431  }
2432  avio_read(pb, attachment, len);
2433  memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2434 
2435  ost = new_attachment_stream(o, oc, -1);
2436  ost->stream_copy = 0;
2438  ost->st->codecpar->extradata = attachment;
2440 
2441  p = strrchr(o->attachments[i], '/');
2442  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2443  avio_closep(&pb);
2444  }
2445 
2446  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2447  av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2448  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2449  exit_program(1);
2450  }
2451 
2452  /* check if all codec options have been used */
2453  unused_opts = strip_specifiers(o->g->codec_opts);
2454  for (i = of->ost_index; i < nb_output_streams; i++) {
2455  e = NULL;
2456  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2458  av_dict_set(&unused_opts, e->key, NULL, 0);
2459  }
2460 
2461  e = NULL;
2462  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2463  const AVClass *class = avcodec_get_class();
2464  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2466  const AVClass *fclass = avformat_get_class();
2467  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2469  if (!option || foption)
2470  continue;
2471 
2472 
2473  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2474  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2475  "output file #%d (%s) is not an encoding option.\n", e->key,
2476  option->help ? option->help : "", nb_output_files - 1,
2477  filename);
2478  exit_program(1);
2479  }
2480 
2481  // gop_timecode is injected by generic code but not always used
2482  if (!strcmp(e->key, "gop_timecode"))
2483  continue;
2484 
2485  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2486  "output file #%d (%s) has not been used for any stream. The most "
2487  "likely reason is either wrong type (e.g. a video option with "
2488  "no video streams) or that it is a private option of some encoder "
2489  "which was not actually used for any stream.\n", e->key,
2490  option->help ? option->help : "", nb_output_files - 1, filename);
2491  }
2492  av_dict_free(&unused_opts);
2493 
2494  /* set the decoding_needed flags and create simple filtergraphs */
2495  for (i = of->ost_index; i < nb_output_streams; i++) {
2497 
2498  if (ost->encoding_needed && ost->source_index >= 0) {
2500  ist->decoding_needed |= DECODING_FOR_OST;
2501 
2505  if (err < 0) {
2507  "Error initializing a simple filtergraph between streams "
2508  "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2509  nb_output_files - 1, ost->st->index);
2510  exit_program(1);
2511  }
2512  }
2513  }
2514 
2515  /* set the filter output constraints */
2516  if (ost->filter) {
2517  OutputFilter *f = ost->filter;
2518  int count;
2519  switch (ost->enc_ctx->codec_type) {
2520  case AVMEDIA_TYPE_VIDEO:
2521  f->frame_rate = ost->frame_rate;
2522  f->width = ost->enc_ctx->width;
2523  f->height = ost->enc_ctx->height;
2524  if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2525  f->format = ost->enc_ctx->pix_fmt;
2526  } else if (ost->enc->pix_fmts) {
2527  count = 0;
2528  while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2529  count++;
2530  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2531  if (!f->formats)
2532  exit_program(1);
2533  memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2534  }
2535  break;
2536  case AVMEDIA_TYPE_AUDIO:
2538  f->format = ost->enc_ctx->sample_fmt;
2539  } else if (ost->enc->sample_fmts) {
2540  count = 0;
2541  while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2542  count++;
2543  f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2544  if (!f->formats)
2545  exit_program(1);
2546  memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2547  }
2548  if (ost->enc_ctx->sample_rate) {
2549  f->sample_rate = ost->enc_ctx->sample_rate;
2550  } else if (ost->enc->supported_samplerates) {
2551  count = 0;
2552  while (ost->enc->supported_samplerates[count])
2553  count++;
2554  f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2555  if (!f->sample_rates)
2556  exit_program(1);
2557  memcpy(f->sample_rates, ost->enc->supported_samplerates,
2558  (count + 1) * sizeof(*f->sample_rates));
2559  }
2560  if (ost->enc_ctx->channels) {
2561  f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2562  } else if (ost->enc->channel_layouts) {
2563  count = 0;
2564  while (ost->enc->channel_layouts[count])
2565  count++;
2566  f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2567  if (!f->channel_layouts)
2568  exit_program(1);
2569  memcpy(f->channel_layouts, ost->enc->channel_layouts,
2570  (count + 1) * sizeof(*f->channel_layouts));
2571  }
2572  break;
2573  }
2574  }
2575  }
2576 
2577  /* check filename in case of an image number is expected */
2578  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2579  if (!av_filename_number_test(oc->url)) {
2580  print_error(oc->url, AVERROR(EINVAL));
2581  exit_program(1);
2582  }
2583  }
2584 
2587  "No input streams but output needs an input stream\n");
2588  exit_program(1);
2589  }
2590 
2591  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2592  /* test if it already exists to avoid losing precious files */
2593  assert_file_overwrite(filename);
2594 
2595  /* open the file */
2596  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2597  &oc->interrupt_callback,
2598  &of->opts)) < 0) {
2599  print_error(filename, err);
2600  exit_program(1);
2601  }
2602  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2603  assert_file_overwrite(filename);
2604 
2605  if (o->mux_preload) {
2606  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2607  }
2608  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2609 
2610  /* copy metadata */
2611  for (i = 0; i < o->nb_metadata_map; i++) {
2612  char *p;
2613  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2614 
2615  if (in_file_index >= nb_input_files) {
2616  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2617  exit_program(1);
2618  }
2619  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2620  in_file_index >= 0 ?
2621  input_files[in_file_index]->ctx : NULL, o);
2622  }
2623 
2624  /* copy chapters */
2625  if (o->chapters_input_file >= nb_input_files) {
2626  if (o->chapters_input_file == INT_MAX) {
2627  /* copy chapters from the first input file that has them*/
2628  o->chapters_input_file = -1;
2629  for (i = 0; i < nb_input_files; i++)
2630  if (input_files[i]->ctx->nb_chapters) {
2631  o->chapters_input_file = i;
2632  break;
2633  }
2634  } else {
2635  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2636  o->chapters_input_file);
2637  exit_program(1);
2638  }
2639  }
2640  if (o->chapters_input_file >= 0)
2643 
2644  /* copy global metadata by default */
2648  if(o->recording_time != INT64_MAX)
2649  av_dict_set(&oc->metadata, "duration", NULL, 0);
2650  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2651  av_dict_set(&oc->metadata, "company_name", NULL, 0);
2652  av_dict_set(&oc->metadata, "product_name", NULL, 0);
2653  av_dict_set(&oc->metadata, "product_version", NULL, 0);
2654  }
2655  if (!o->metadata_streams_manual)
2656  for (i = of->ost_index; i < nb_output_streams; i++) {
2657  InputStream *ist;
2658  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2659  continue;
2662  if (!output_streams[i]->stream_copy) {
2663  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2664  }
2665  }
2666 
2667  /* process manually set programs */
2668  for (i = 0; i < o->nb_program; i++) {
2669  const char *p = o->program[i].u.str;
2670  int progid = i+1;
2671  AVProgram *program;
2672 
2673  while(*p) {
2674  const char *p2 = av_get_token(&p, ":");
2675  const char *to_dealloc = p2;
2676  char *key;
2677  if (!p2)
2678  break;
2679 
2680  if(*p) p++;
2681 
2682  key = av_get_token(&p2, "=");
2683  if (!key || !*p2) {
2684  av_freep(&to_dealloc);
2685  av_freep(&key);
2686  break;
2687  }
2688  p2++;
2689 
2690  if (!strcmp(key, "program_num"))
2691  progid = strtol(p2, NULL, 0);
2692  av_freep(&to_dealloc);
2693  av_freep(&key);
2694  }
2695 
2696  program = av_new_program(oc, progid);
2697 
2698  p = o->program[i].u.str;
2699  while(*p) {
2700  const char *p2 = av_get_token(&p, ":");
2701  const char *to_dealloc = p2;
2702  char *key;
2703  if (!p2)
2704  break;
2705  if(*p) p++;
2706 
2707  key = av_get_token(&p2, "=");
2708  if (!key) {
2710  "No '=' character in program string %s.\n",
2711  p2);
2712  exit_program(1);
2713  }
2714  if (!*p2)
2715  exit_program(1);
2716  p2++;
2717 
2718  if (!strcmp(key, "title")) {
2719  av_dict_set(&program->metadata, "title", p2, 0);
2720  } else if (!strcmp(key, "program_num")) {
2721  } else if (!strcmp(key, "st")) {
2722  int st_num = strtol(p2, NULL, 0);
2723  av_program_add_stream_index(oc, progid, st_num);
2724  } else {
2725  av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2726  exit_program(1);
2727  }
2728  av_freep(&to_dealloc);
2729  av_freep(&key);
2730  }
2731  }
2732 
2733  /* process manually set metadata */
2734  for (i = 0; i < o->nb_metadata; i++) {
2735  AVDictionary **m;
2736  char type, *val;
2737  const char *stream_spec;
2738  int index = 0, j, ret = 0;
2739 
2740  val = strchr(o->metadata[i].u.str, '=');
2741  if (!val) {
2742  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2743  o->metadata[i].u.str);
2744  exit_program(1);
2745  }
2746  *val++ = 0;
2747 
2748  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2749  if (type == 's') {
2750  for (j = 0; j < oc->nb_streams; j++) {
2752  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2753  if (!strcmp(o->metadata[i].u.str, "rotate")) {
2754  char *tail;
2755  double theta = av_strtod(val, &tail);
2756  if (!*tail) {
2757  ost->rotate_overridden = 1;
2758  ost->rotate_override_value = theta;
2759  }
2760  } else {
2761  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2762  }
2763  } else if (ret < 0)
2764  exit_program(1);
2765  }
2766  }
2767  else {
2768  switch (type) {
2769  case 'g':
2770  m = &oc->metadata;
2771  break;
2772  case 'c':
2773  if (index < 0 || index >= oc->nb_chapters) {
2774  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2775  exit_program(1);
2776  }
2777  m = &oc->chapters[index]->metadata;
2778  break;
2779  case 'p':
2780  if (index < 0 || index >= oc->nb_programs) {
2781  av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2782  exit_program(1);
2783  }
2784  m = &oc->programs[index]->metadata;
2785  break;
2786  default:
2787  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2788  exit_program(1);
2789  }
2790  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2791  }
2792  }
2793 
2794  return 0;
2795 }
2796 
2797 static int opt_target(void *optctx, const char *opt, const char *arg)
2798 {
2799  OptionsContext *o = optctx;
2800  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2801  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2802 
2803  if (!strncmp(arg, "pal-", 4)) {
2804  norm = PAL;
2805  arg += 4;
2806  } else if (!strncmp(arg, "ntsc-", 5)) {
2807  norm = NTSC;
2808  arg += 5;
2809  } else if (!strncmp(arg, "film-", 5)) {
2810  norm = FILM;
2811  arg += 5;
2812  } else {
2813  /* Try to determine PAL/NTSC by peeking in the input files */
2814  if (nb_input_files) {
2815  int i, j;
2816  for (j = 0; j < nb_input_files; j++) {
2817  for (i = 0; i < input_files[j]->nb_streams; i++) {
2818  AVStream *st = input_files[j]->ctx->streams[i];
2819  int64_t fr;
2821  continue;
2822  fr = st->time_base.den * 1000LL / st->time_base.num;
2823  if (fr == 25000) {
2824  norm = PAL;
2825  break;
2826  } else if ((fr == 29970) || (fr == 23976)) {
2827  norm = NTSC;
2828  break;
2829  }
2830  }
2831  if (norm != UNKNOWN)
2832  break;
2833  }
2834  }
2835  if (norm != UNKNOWN)
2836  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2837  }
2838 
2839  if (norm == UNKNOWN) {
2840  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2841  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2842  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2843  exit_program(1);
2844  }
2845 
2846  if (!strcmp(arg, "vcd")) {
2847  opt_video_codec(o, "c:v", "mpeg1video");
2848  opt_audio_codec(o, "c:a", "mp2");
2849  parse_option(o, "f", "vcd", options);
2850 
2851  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2852  parse_option(o, "r", frame_rates[norm], options);
2853  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2854 
2855  opt_default(NULL, "b:v", "1150000");
2856  opt_default(NULL, "maxrate:v", "1150000");
2857  opt_default(NULL, "minrate:v", "1150000");
2858  opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2859 
2860  opt_default(NULL, "b:a", "224000");
2861  parse_option(o, "ar", "44100", options);
2862  parse_option(o, "ac", "2", options);
2863 
2864  opt_default(NULL, "packetsize", "2324");
2865  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2866 
2867  /* We have to offset the PTS, so that it is consistent with the SCR.
2868  SCR starts at 36000, but the first two packs contain only padding
2869  and the first pack from the other stream, respectively, may also have
2870  been written before.
2871  So the real data starts at SCR 36000+3*1200. */
2872  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2873  } else if (!strcmp(arg, "svcd")) {
2874 
2875  opt_video_codec(o, "c:v", "mpeg2video");
2876  opt_audio_codec(o, "c:a", "mp2");
2877  parse_option(o, "f", "svcd", options);
2878 
2879  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2880  parse_option(o, "r", frame_rates[norm], options);
2881  parse_option(o, "pix_fmt", "yuv420p", options);
2882  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2883 
2884  opt_default(NULL, "b:v", "2040000");
2885  opt_default(NULL, "maxrate:v", "2516000");
2886  opt_default(NULL, "minrate:v", "0"); // 1145000;
2887  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2888  opt_default(NULL, "scan_offset", "1");
2889 
2890  opt_default(NULL, "b:a", "224000");
2891  parse_option(o, "ar", "44100", options);
2892 
2893  opt_default(NULL, "packetsize", "2324");
2894 
2895  } else if (!strcmp(arg, "dvd")) {
2896 
2897  opt_video_codec(o, "c:v", "mpeg2video");
2898  opt_audio_codec(o, "c:a", "ac3");
2899  parse_option(o, "f", "dvd", options);
2900 
2901  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2902  parse_option(o, "r", frame_rates[norm], options);
2903  parse_option(o, "pix_fmt", "yuv420p", options);
2904  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2905 
2906  opt_default(NULL, "b:v", "6000000");
2907  opt_default(NULL, "maxrate:v", "9000000");
2908  opt_default(NULL, "minrate:v", "0"); // 1500000;
2909  opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2910 
2911  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2912  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2913 
2914  opt_default(NULL, "b:a", "448000");
2915  parse_option(o, "ar", "48000", options);
2916 
2917  } else if (!strncmp(arg, "dv", 2)) {
2918 
2919  parse_option(o, "f", "dv", options);
2920 
2921  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2922  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2923  norm == PAL ? "yuv420p" : "yuv411p", options);
2924  parse_option(o, "r", frame_rates[norm], options);
2925 
2926  parse_option(o, "ar", "48000", options);
2927  parse_option(o, "ac", "2", options);
2928 
2929  } else {
2930  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2931  return AVERROR(EINVAL);
2932  }
2933 
2936 
2937  return 0;
2938 }
2939 
2940 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2941 {
2944  return 0;
2945 }
2946 
2947 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2948 {
2949  char filename[40];
2950  time_t today2 = time(NULL);
2951  struct tm *today = localtime(&today2);
2952 
2953  if (!today) { // maybe tomorrow
2954  av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2955  exit_program(1);
2956  }
2957 
2958  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2959  today->tm_sec);
2960  return opt_vstats_file(NULL, opt, filename);
2961 }
2962 
2963 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2964 {
2965  OptionsContext *o = optctx;
2966  return parse_option(o, "frames:v", arg, options);
2967 }
2968 
2969 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2970 {
2971  OptionsContext *o = optctx;
2972  return parse_option(o, "frames:a", arg, options);
2973 }
2974 
2975 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2976 {
2977  OptionsContext *o = optctx;
2978  return parse_option(o, "frames:d", arg, options);
2979 }
2980 
2981 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2982 {
2983  int ret;
2984  AVDictionary *cbak = codec_opts;
2985  AVDictionary *fbak = format_opts;
2986  codec_opts = NULL;
2987  format_opts = NULL;
2988 
2989  ret = opt_default(NULL, opt, arg);
2990 
2991  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2995  codec_opts = cbak;
2996  format_opts = fbak;
2997 
2998  return ret;
2999 }
3000 
3001 static int opt_preset(void *optctx, const char *opt, const char *arg)
3002 {
3003  OptionsContext *o = optctx;
3004  FILE *f=NULL;
3005  char filename[1000], line[1000], tmp_line[1000];
3006  const char *codec_name = NULL;
3007 
3008  tmp_line[0] = *opt;
3009  tmp_line[1] = 0;
3010  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
3011 
3012  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
3013  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
3014  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
3015  }else
3016  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3017  exit_program(1);
3018  }
3019 
3020  while (fgets(line, sizeof(line), f)) {
3021  char *key = tmp_line, *value, *endptr;
3022 
3023  if (strcspn(line, "#\n\r") == 0)
3024  continue;
3025  av_strlcpy(tmp_line, line, sizeof(tmp_line));
3026  if (!av_strtok(key, "=", &value) ||
3027  !av_strtok(value, "\r\n", &endptr)) {
3028  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3029  exit_program(1);
3030  }
3031  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3032 
3033  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3034  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3035  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3036  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3037  else if (opt_default_new(o, key, value) < 0) {
3038  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3039  filename, line, key, value);
3040  exit_program(1);
3041  }
3042  }
3043 
3044  fclose(f);
3045 
3046  return 0;
3047 }
3048 
3049 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3050 {
3051  OptionsContext *o = optctx;
3052  int ret;
3053  char *s = av_asprintf("%s:%c", opt + 1, *opt);
3054  if (!s)
3055  return AVERROR(ENOMEM);
3056  ret = parse_option(o, s, arg, options);
3057  av_free(s);
3058  return ret;
3059 }
3060 
3061 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3062 {
3063  OptionsContext *o = optctx;
3064 
3065  if(!strcmp(opt, "ab")){
3066  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3067  return 0;
3068  } else if(!strcmp(opt, "b")){
3069  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3070  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3071  return 0;
3072  }
3073  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3074  return 0;
3075 }
3076 
3077 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3078 {
3079  OptionsContext *o = optctx;
3080  char *s;
3081  int ret;
3082  if(!strcmp(opt, "qscale")){
3083  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3084  return parse_option(o, "q:v", arg, options);
3085  }
3086  s = av_asprintf("q%s", opt + 6);
3087  if (!s)
3088  return AVERROR(ENOMEM);
3089  ret = parse_option(o, s, arg, options);
3090  av_free(s);
3091  return ret;
3092 }
3093 
3094 static int opt_profile(void *optctx, const char *opt, const char *arg)
3095 {
3096  OptionsContext *o = optctx;
3097  if(!strcmp(opt, "profile")){
3098  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3099  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3100  return 0;
3101  }
3102  av_dict_set(&o->g->codec_opts, opt, arg, 0);
3103  return 0;
3104 }
3105 
3106 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3107 {
3108  OptionsContext *o = optctx;
3109  return parse_option(o, "filter:v", arg, options);
3110 }
3111 
3112 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3113 {
3114  OptionsContext *o = optctx;
3115  return parse_option(o, "filter:a", arg, options);
3116 }
3117 
3118 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3119 {
3120  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3121  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3122  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3123  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3124 
3127  return 0;
3128 }
3129 
3130 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3131 {
3132  OptionsContext *o = optctx;
3133  int ret;
3134  char *tcr = av_asprintf("timecode=%s", arg);
3135  if (!tcr)
3136  return AVERROR(ENOMEM);
3137  ret = parse_option(o, "metadata:g", tcr, options);
3138  if (ret >= 0)
3139  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3140  av_free(tcr);
3141  return ret;
3142 }
3143 
3144 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3145 {
3146  OptionsContext *o = optctx;
3147  char layout_str[32];
3148  char *stream_str;
3149  char *ac_str;
3150  int ret, channels, ac_str_size;
3151  uint64_t layout;
3152 
3154  if (!layout) {
3155  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3156  return AVERROR(EINVAL);
3157  }
3158  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3159  ret = opt_default_new(o, opt, layout_str);
3160  if (ret < 0)
3161  return ret;
3162 
3163  /* set 'ac' option based on channel layout */
3165  snprintf(layout_str, sizeof(layout_str), "%d", channels);
3166  stream_str = strchr(opt, ':');
3167  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3168  ac_str = av_mallocz(ac_str_size);
3169  if (!ac_str)
3170  return AVERROR(ENOMEM);
3171  av_strlcpy(ac_str, "ac", 3);
3172  if (stream_str)
3173  av_strlcat(ac_str, stream_str, ac_str_size);
3174  ret = parse_option(o, ac_str, layout_str, options);
3175  av_free(ac_str);
3176 
3177  return ret;
3178 }
3179 
3180 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3181 {
3182  OptionsContext *o = optctx;
3183  return parse_option(o, "q:a", arg, options);
3184 }
3185 
3186 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3187 {
3189  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3190  return AVERROR(ENOMEM);
3193  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3194  return AVERROR(ENOMEM);
3195 
3197 
3198  return 0;
3199 }
3200 
3201 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3202 {
3203  uint8_t *graph_desc = read_file(arg);
3204  if (!graph_desc)
3205  return AVERROR(EINVAL);
3206 
3208  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3209  return AVERROR(ENOMEM);
3211  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3212 
3214 
3215  return 0;
3216 }
3217 
3218 void show_help_default(const char *opt, const char *arg)
3219 {
3220  /* per-file options have at least one of those set */
3221  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3222  int show_advanced = 0, show_avoptions = 0;
3223 
3224  if (opt && *opt) {
3225  if (!strcmp(opt, "long"))
3226  show_advanced = 1;
3227  else if (!strcmp(opt, "full"))
3228  show_advanced = show_avoptions = 1;
3229  else
3230  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3231  }
3232 
3233  show_usage();
3234 
3235  printf("Getting help:\n"
3236  " -h -- print basic options\n"
3237  " -h long -- print more options\n"
3238  " -h full -- print all options (including all format and codec specific options, very long)\n"
3239  " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3240  " See man %s for detailed description of the options.\n"
3241  "\n", program_name);
3242 
3243  show_help_options(options, "Print help / information / capabilities:",
3244  OPT_EXIT, 0, 0);
3245 
3246  show_help_options(options, "Global options (affect whole program "
3247  "instead of just one file):",
3248  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3249  if (show_advanced)
3250  show_help_options(options, "Advanced global options:", OPT_EXPERT,
3251  per_file | OPT_EXIT, 0);
3252 
3253  show_help_options(options, "Per-file main options:", 0,
3255  OPT_EXIT, per_file);
3256  if (show_advanced)
3257  show_help_options(options, "Advanced per-file options:",
3258  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3259 
3260  show_help_options(options, "Video options:",
3262  if (show_advanced)
3263  show_help_options(options, "Advanced Video options:",
3265 
3266  show_help_options(options, "Audio options:",
3268  if (show_advanced)
3269  show_help_options(options, "Advanced Audio options:",
3271  show_help_options(options, "Subtitle options:",
3272  OPT_SUBTITLE, 0, 0);
3273  printf("\n");
3274 
3275  if (show_avoptions) {
3279 #if CONFIG_SWSCALE
3281 #endif
3282 #if CONFIG_SWRESAMPLE
3284 #endif
3287  }
3288 }
3289 
3290 void show_usage(void)
3291 {
3292  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3293  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3294  av_log(NULL, AV_LOG_INFO, "\n");
3295 }
3296 
3297 enum OptGroup {
3298  GROUP_OUTFILE,
3299  GROUP_INFILE,
3300 };
3301 
3302 static const OptionGroupDef groups[] = {
3303  [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3304  [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3305 };
3306 
3307 static int open_files(OptionGroupList *l, const char *inout,
3308  int (*open_file)(OptionsContext*, const char*))
3309 {
3310  int i, ret;
3311 
3312  for (i = 0; i < l->nb_groups; i++) {
3313  OptionGroup *g = &l->groups[i];
3314  OptionsContext o;
3315 
3316  init_options(&o);
3317  o.g = g;
3318 
3319  ret = parse_optgroup(&o, g);
3320  if (ret < 0) {
3321  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3322  "%s.\n", inout, g->arg);
3323  uninit_options(&o);
3324  return ret;
3325  }
3326 
3327  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3328  ret = open_file(&o, g->arg);
3329  uninit_options(&o);
3330  if (ret < 0) {
3331  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3332  inout, g->arg);
3333  return ret;
3334  }
3335  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3336  }
3337 
3338  return 0;
3339 }
3340 
3341 int ffmpeg_parse_options(int argc, char **argv)
3342 {
3343  OptionParseContext octx;
3344  uint8_t error[128];
3345  int ret;
3346 
3347  memset(&octx, 0, sizeof(octx));
3348 
3349  /* split the commandline into an internal representation */
3350  ret = split_commandline(&octx, argc, argv, options, groups,
3351  FF_ARRAY_ELEMS(groups));
3352  if (ret < 0) {
3353  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3354  goto fail;
3355  }
3356 
3357  /* apply global options */
3358  ret = parse_optgroup(NULL, &octx.global_opts);
3359  if (ret < 0) {
3360  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3361  goto fail;
3362  }
3363 
3364  /* configure terminal and setup signal handlers */
3365  term_init();
3366 
3367  /* open input files */
3368  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3369  if (ret < 0) {
3370  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3371  goto fail;
3372  }
3373 
3374  /* create the complex filtergraphs */
3376  if (ret < 0) {
3377  av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3378  goto fail;
3379  }
3380 
3381  /* open output files */
3382  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3383  if (ret < 0) {
3384  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3385  goto fail;
3386  }
3387 
3389 
3390 fail:
3391  uninit_parse_context(&octx);
3392  if (ret < 0) {
3393  av_strerror(ret, error, sizeof(error));
3394  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3395  }
3396  return ret;
3397 }
3398 
3399 static int opt_progress(void *optctx, const char *opt, const char *arg)
3400 {
3401  AVIOContext *avio = NULL;
3402  int ret;
3403 
3404  if (!strcmp(arg, "-"))
3405  arg = "pipe:";
3406  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3407  if (ret < 0) {
3408  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3409  arg, av_err2str(ret));
3410  return ret;
3411  }
3412  progress_avio = avio;
3413  return 0;
3414 }
3415 
3416 #define OFFSET(x) offsetof(OptionsContext, x)
3417 const OptionDef options[] = {
3418  /* main options */
3420  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3421  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3422  "force format", "fmt" },
3423  { "y", OPT_BOOL, { &file_overwrite },
3424  "overwrite output files" },
3425  { "n", OPT_BOOL, { &no_file_overwrite },
3426  "never overwrite output files" },
3427  { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3428  "Ignore unknown stream types" },
3429  { "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3430  "Copy unknown stream types" },
3431  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3432  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3433  "codec name", "codec" },
3434  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3435  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3436  "codec name", "codec" },
3437  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3438  OPT_OUTPUT, { .off = OFFSET(presets) },
3439  "preset name", "preset" },
3440  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3441  OPT_OUTPUT, { .func_arg = opt_map },
3442  "set input stream mapping",
3443  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3444  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3445  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3446  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3447  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3448  "set metadata information of outfile from infile",
3449  "outfile[,metadata]:infile[,metadata]" },
3450  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3451  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3452  "set chapters mapping", "input_file_index" },
3453  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3454  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3455  "record or transcode \"duration\" seconds of audio/video",
3456  "duration" },
3457  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3458  "record or transcode stop time", "time_stop" },
3459  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3460  "set the limit file size in bytes", "limit_size" },
3461  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3462  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3463  "set the start time offset", "time_off" },
3464  { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3465  OPT_INPUT, { .off = OFFSET(start_time_eof) },
3466  "set the start time offset relative to EOF", "time_off" },
3467  { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3468  OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3469  "enable/disable seeking by timestamp with -ss" },
3470  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3471  OPT_INPUT, { .off = OFFSET(accurate_seek) },
3472  "enable/disable accurate seeking with -ss" },
3473  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3474  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3475  "set the input ts offset", "time_off" },
3476  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3477  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3478  "set the input ts scale", "scale" },
3479  { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3480  "set the recording timestamp ('now' to set the current time)", "time" },
3481  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3482  "add metadata", "string=string" },
3483  { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3484  "add program with specified streams", "title=string:st=number..." },
3485  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3486  OPT_OUTPUT, { .func_arg = opt_data_frames },
3487  "set the number of data frames to output", "number" },
3488  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3489  "add timings for benchmarking" },
3490  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3491  "add timings for each task" },
3492  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3493  "write program-readable progress information", "url" },
3494  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3495  "enable or disable interaction on standard input" },
3496  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3497  "set max runtime in seconds in CPU user time", "limit" },
3498  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3499  "dump each input packet" },
3500  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3501  "when dumping packets, also dump the payload" },
3502  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3503  OPT_INPUT, { .off = OFFSET(rate_emu) },
3504  "read input at native frame rate", "" },
3505  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3506  "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3507  "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3508  { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3509  "video sync method", "" },
3510  { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3511  "frame drop threshold", "" },
3512  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3513  "audio sync method", "" },
3514  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3515  "audio drift threshold", "threshold" },
3516  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3517  "copy timestamps" },
3518  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3519  "shift input timestamps to start at 0 when using copyts" },
3520  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3521  "copy input stream time base when stream copying", "mode" },
3522  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3523  OPT_OUTPUT, { .off = OFFSET(shortest) },
3524  "finish encoding within shortest input" },
3525  { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3526  OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3527  "bitexact mode" },
3528  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3529  OPT_OUTPUT, { .off = OFFSET(apad) },
3530  "audio pad", "" },
3531  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3532  "timestamp discontinuity delta threshold", "threshold" },
3533  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3534  "timestamp error delta threshold", "threshold" },
3535  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3536  "exit on error", "error" },
3537  { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3538  "abort on the specified condition flags", "flags" },
3539  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3540  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3541  "copy initial non-keyframes" },
3542  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3543  "copy or discard frames before start time" },
3544  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3545  "set the number of frames to output", "number" },
3546  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3547  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3548  "force codec tag/fourcc", "fourcc/tag" },
3549  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3550  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3551  "use fixed quality scale (VBR)", "q" },
3552  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3553  OPT_OUTPUT, { .func_arg = opt_qscale },
3554  "use fixed quality scale (VBR)", "q" },
3555  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3556  "set profile", "profile" },
3557  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3558  "set stream filtergraph", "filter_graph" },
3559  { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3560  "number of non-complex filter threads" },
3561  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3562  "read stream filtergraph description from a file", "filename" },
3563  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3564  "reinit filtergraph on input parameter changes", "" },
3565  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3566  "create a complex filtergraph", "graph_description" },
3567  { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3568  "number of threads for -filter_complex" },
3569  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3570  "create a complex filtergraph", "graph_description" },
3571  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3572  "read complex filtergraph description from a file", "filename" },
3573  { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT, { &auto_conversion_filters },
3574  "enable automatic conversion filters globally" },
3575  { "stats", OPT_BOOL, { &print_stats },
3576  "print progress report during encoding", },
3577  { "stats_period", HAS_ARG | OPT_EXPERT, { .func_arg = opt_stats_period },
3578  "set the period at which ffmpeg updates stats and -progress output", "time" },
3579  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3580  OPT_OUTPUT, { .func_arg = opt_attach },
3581  "add an attachment to the output file", "filename" },
3582  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3583  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3584  "extract an attachment into a file", "filename" },
3585  { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3586  OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3587  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3588  "print timestamp debugging info" },
3589  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3590  "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3591  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3592  OPT_INPUT, { .off = OFFSET(discard) },
3593  "discard", "" },
3594  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3595  OPT_OUTPUT, { .off = OFFSET(disposition) },
3596  "disposition", "" },
3597  { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3598  { .off = OFFSET(thread_queue_size) },
3599  "set the maximum number of queued packets from the demuxer" },
3600  { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3601  "read and decode the streams to fill missing information with heuristics" },
3602 
3603  /* video options */
3604  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3605  "set the number of video frames to output", "number" },
3606  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3607  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3608  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3609  { "fpsmax", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3610  OPT_OUTPUT, { .off = OFFSET(max_frame_rates) },
3611  "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
3613  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3614  "set frame size (WxH or abbreviation)", "size" },
3615  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3616  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3617  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3618  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3619  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3620  "set pixel format", "format" },
3621  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3622  "set the number of bits per raw sample", "number" },
3623  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3624  "deprecated use -g 1" },
3626  "disable video" },
3627  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3628  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3629  "rate control override for specific intervals", "override" },
3630  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3631  OPT_OUTPUT, { .func_arg = opt_video_codec },
3632  "force video codec ('copy' to copy stream)", "codec" },
3633  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3634  "Removed" },
3635  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3636  "Removed" },
3637  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3638  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3639  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3640  "select the pass number (1 to 3)", "n" },
3641  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3642  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3643  "select two pass log file name prefix", "prefix" },
3644  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3645  "this option is deprecated, use the yadif filter instead" },
3646  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3647  "calculate PSNR of compressed frames" },
3648  { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3649  "dump video coding statistics to file" },
3650  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3651  "dump video coding statistics to file", "file" },
3652  { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3653  "Version of the vstats format to use."},
3654  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3655  "set video filters", "filter_graph" },
3656  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3657  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3658  "specify intra matrix coeffs", "matrix" },
3659  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3660  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3661  "specify inter matrix coeffs", "matrix" },
3662  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3663  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3664  "specify intra matrix coeffs", "matrix" },
3665  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3666  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3667  "top=1/bottom=0/auto=-1 field first", "" },
3668  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3669  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3670  "force video tag/fourcc", "fourcc/tag" },
3671  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3672  "show QP histogram" },
3673  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3674  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3675  "force the selected framerate, disable the best supported framerate selection" },
3676  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3677  OPT_OUTPUT, { .func_arg = opt_streamid },
3678  "set the value of an outfile streamid", "streamIndex:value" },
3679  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3680  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3681  "force key frames at specified timestamps", "timestamps" },
3682  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3683  "audio bitrate (please use -b:a)", "bitrate" },
3684  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3685  "video bitrate (please use -b:v)", "bitrate" },
3686  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3687  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3688  "use HW accelerated decoding", "hwaccel name" },
3689  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3690  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3691  "select a device for HW acceleration", "devicename" },
3692  { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3693  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3694  "select output format used with HW accelerated decoding", "format" },
3695 #if CONFIG_VIDEOTOOLBOX
3696  { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3697 #endif
3698  { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3699  "show available HW acceleration methods" },
3700  { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3701  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3702  "automatically insert correct rotate filters" },
3703  { "autoscale", HAS_ARG | OPT_BOOL | OPT_SPEC |
3704  OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) },
3705  "automatically insert a scale filter at the end of the filter graph" },
3706 
3707  /* audio options */
3708  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3709  "set the number of audio frames to output", "number" },
3710  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3711  "set audio quality (codec-specific)", "quality", },
3712  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3713  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3714  "set audio sampling rate (in Hz)", "rate" },
3715  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3716  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3717  "set number of audio channels", "channels" },
3719  "disable audio" },
3720  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3721  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3722  "force audio codec ('copy' to copy stream)", "codec" },
3723  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3724  OPT_OUTPUT, { .func_arg = opt_old2new },
3725  "force audio tag/fourcc", "fourcc/tag" },
3726  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3727  "change audio volume (256=normal)" , "volume" },
3728  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3730  "set sample format", "format" },
3731  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3732  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3733  "set channel layout", "layout" },
3734  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3735  "set audio filters", "filter_graph" },
3736  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3737  "set the maximum number of channels to try to guess the channel layout" },
3738 
3739  /* subtitle options */
3741  "disable subtitle" },
3742  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3743  "force subtitle codec ('copy' to copy stream)", "codec" },
3744  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3745  , "force subtitle tag/fourcc", "fourcc/tag" },
3746  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3747  "fix subtitles duration" },
3748  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3749  "set canvas size (WxH or abbreviation)", "size" },
3750 
3751  /* grab options */
3752  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3753  "deprecated, use -channel", "channel" },
3754  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3755  "deprecated, use -standard", "standard" },
3756  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3757 
3758  /* muxer options */
3759  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3760  "set the maximum demux-decode delay", "seconds" },
3761  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3762  "set the initial demux-decode delay", "seconds" },
3763  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3764  "specify a file in which to print sdp information", "file" },
3765 
3766  { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3767  "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3768  { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3769  "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3770  "two special values are defined - "
3771  "0 = use frame rate (video) or sample rate (audio),"
3772  "-1 = match source time base", "ratio" },
3773 
3774  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3775  "A comma-separated list of bitstream filters", "bitstream_filters" },
3776  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3777  "deprecated", "audio bitstream_filters" },
3778  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3779  "deprecated", "video bitstream_filters" },
3780 
3781  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3782  "set the audio options to the indicated preset", "preset" },
3783  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3784  "set the video options to the indicated preset", "preset" },
3785  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3786  "set the subtitle options to the indicated preset", "preset" },
3787  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3788  "set options from indicated preset file", "filename" },
3789 
3790  { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3791  "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3792  { "muxing_queue_data_threshold", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) },
3793  "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
3794 
3795  /* data codec support */
3796  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3797  "force data codec ('copy' to copy stream)", "codec" },
3798  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3799  "disable data" },
3800 
3801 #if CONFIG_VAAPI
3802  { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3803  "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3804 #endif
3805 
3806 #if CONFIG_QSV
3807  { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3808  "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3809 #endif
3810 
3811  { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3812  "initialise hardware device", "args" },
3813  { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3814  "set hardware device used when filtering", "device" },
3815 
3816  { NULL, },
3817 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:30
OPT_FLOAT
#define OPT_FLOAT
Definition: cmdutils.h:168
OPT_EXIT
#define OPT_EXIT
Definition: cmdutils.h:171
AVCodec
AVCodec.
Definition: codec.h:197
OptionsContext::input_ts_offset
int64_t input_ts_offset
Definition: ffmpeg.h:119
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:187
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:225
ignore_unknown_streams
static int ignore_unknown_streams
Definition: ffmpeg_opt.c:187
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
OptionsContext::stop_time
int64_t stop_time
Definition: ffmpeg.h:152
StreamMap::file_index
int file_index
Definition: ffmpeg.h:82
new_output_stream
static OutputStream * new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
Definition: ffmpeg_opt.c:1426
show_hwaccels
static int show_hwaccels(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:238
program
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C program
Definition: undefined.txt:6
opt_abort_on
static int opt_abort_on(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:268
AVOutputFormat::name
const char * name
Definition: avformat.h:491
AVChapter::metadata
AVDictionary * metadata
Definition: avformat.h:1067
OptionsContext::dump_attachment
SpecifierOpt * dump_attachment
Definition: ffmpeg.h:127
VSYNC_PASSTHROUGH
#define VSYNC_PASSTHROUGH
Definition: ffmpeg.h:50
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
nb_input_files
int nb_input_files
Definition: ffmpeg.c:151
opt.h
OutputStream::attachment_filename
const char * attachment_filename
Definition: ffmpeg.h:535
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4374
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:281
OptionsContext::nb_audio_sample_rate
int nb_audio_sample_rate
Definition: ffmpeg.h:108
OutputStream::enc
AVCodecContext * enc
Definition: muxing.c:55
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AudioChannelMap::ofile_idx
int ofile_idx
Definition: ffmpeg.h:91
dump_attachment
static void dump_attachment(AVStream *st, const char *filename)
Definition: ffmpeg_opt.c:1035
OptionDef::off
size_t off
Definition: cmdutils.h:183
opt_video_filters
static int opt_video_filters(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3106
show_help_default
void show_help_default(const char *opt, const char *arg)
Per-fftool specific help handler.
Definition: ffmpeg_opt.c:3218
debug_ts
int debug_ts
Definition: ffmpeg_opt.c:166
stats_period
int64_t stats_period
Definition: ffmpeg_opt.c:178
SET_DICT
#define SET_DICT(type, meta, context, index)
AVSTREAM_EVENT_FLAG_NEW_PACKETS
#define AVSTREAM_EVENT_FLAG_NEW_PACKETS
Definition: avformat.h:958
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1152
out
FILE * out
Definition: movenc.c:54
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1098
av_get_token
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:151
is
The official guide to swscale for confused that is
Definition: swscale.txt:28
FilterGraph::graph_desc
const char * graph_desc
Definition: ffmpeg.h:289
AVFormatContext::nb_chapters
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1318
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
OutputStream::enc_ctx
AVCodecContext * enc_ctx
Definition: ffmpeg.h:474
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:953
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:800
MAX_STREAMS
#define MAX_STREAMS
Definition: ffmpeg.h:56
opt_old2new
static int opt_old2new(void *optctx, const char *opt, const char *arg)
Definition: ffmpeg_opt.c:3049