FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ffmpeg_opt.c
Go to the documentation of this file.
1 /*
2  * ffmpeg option parsing
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdint.h>
22 
23 #include "ffmpeg.h"
24 #include "cmdutils.h"
25 
26 #include "libavformat/avformat.h"
27 
28 #include "libavcodec/avcodec.h"
29 
30 #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 MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
46 {\
47  int i, ret;\
48  for (i = 0; i < o->nb_ ## name; i++) {\
49  char *spec = o->name[i].specifier;\
50  if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51  outvar = o->name[i].u.type;\
52  else if (ret < 0)\
53  exit(1);\
54  }\
55 }
56 
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
58 {\
59  int i;\
60  for (i = 0; i < o->nb_ ## name; i++) {\
61  char *spec = o->name[i].specifier;\
62  if (!strcmp(spec, mediatype))\
63  outvar = o->name[i].u.type;\
64  }\
65 }
67 
70 float dts_error_threshold = 3600*30;
71 
72 int audio_volume = 256;
76 int do_benchmark = 0;
78 int do_hex_dump = 0;
79 int do_pkt_dump = 0;
80 int copy_ts = 0;
81 int copy_tb = -1;
82 int debug_ts = 0;
83 int exit_on_error = 0;
84 int print_stats = -1;
85 int qp_hist = 0;
88 
89 
90 static int intra_only = 0;
91 static int file_overwrite = 0;
92 static int no_file_overwrite = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int do_psnr = 0;
96 static int input_sync;
97 
98 static int64_t recording_time = INT64_MAX;
99 
100 static void uninit_options(OptionsContext *o, int is_input)
101 {
102  const OptionDef *po = options;
103  int i;
104 
105  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
106  while (po->name) {
107  void *dst = (uint8_t*)o + po->u.off;
108 
109  if (po->flags & OPT_SPEC) {
110  SpecifierOpt **so = dst;
111  int i, *count = (int*)(so + 1);
112  for (i = 0; i < *count; i++) {
113  av_freep(&(*so)[i].specifier);
114  if (po->flags & OPT_STRING)
115  av_freep(&(*so)[i].u.str);
116  }
117  av_freep(so);
118  *count = 0;
119  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
120  av_freep(dst);
121  po++;
122  }
123 
124  for (i = 0; i < o->nb_stream_maps; i++)
126  av_freep(&o->stream_maps);
128  av_freep(&o->streamid_map);
129  av_freep(&o->attachments);
130 
131  if (is_input)
133  else
134  recording_time = INT64_MAX;
135 }
136 
137 static void init_options(OptionsContext *o, int is_input)
138 {
139  memset(o, 0, sizeof(*o));
140 
141  if (!is_input && recording_time != INT64_MAX) {
144  "-t is not an input option, keeping it for the next output;"
145  " consider fixing your command line.\n");
146  } else
147  o->recording_time = INT64_MAX;
148  o->stop_time = INT64_MAX;
149  o->mux_max_delay = 0.7;
150  o->limit_filesize = UINT64_MAX;
151  o->chapters_input_file = INT_MAX;
152 }
153 
154 static int opt_sameq(void *optctx, const char *opt, const char *arg)
155 {
156  av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
157  "If you are looking for an option to preserve the quality (which is not "
158  "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
159  opt, opt);
160  return AVERROR(EINVAL);
161 }
162 
163 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
164 {
165  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
166  return opt_default(optctx, "channel", arg);
167 }
168 
169 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
170 {
171  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
172  return opt_default(optctx, "standard", arg);
173 }
174 
175 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
176 {
177  OptionsContext *o = optctx;
178  return parse_option(o, "codec:a", arg, options);
179 }
180 
181 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
182 {
183  OptionsContext *o = optctx;
184  return parse_option(o, "codec:v", arg, options);
185 }
186 
187 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
188 {
189  OptionsContext *o = optctx;
190  return parse_option(o, "codec:s", arg, options);
191 }
192 
193 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
194 {
195  OptionsContext *o = optctx;
196  return parse_option(o, "codec:d", arg, options);
197 }
198 
199 static int opt_map(void *optctx, const char *opt, const char *arg)
200 {
201  OptionsContext *o = optctx;
202  StreamMap *m = NULL;
203  int i, negative = 0, file_idx;
204  int sync_file_idx = -1, sync_stream_idx = 0;
205  char *p, *sync;
206  char *map;
207 
208  if (*arg == '-') {
209  negative = 1;
210  arg++;
211  }
212  map = av_strdup(arg);
213 
214  /* parse sync stream first, just pick first matching stream */
215  if (sync = strchr(map, ',')) {
216  *sync = 0;
217  sync_file_idx = strtol(sync + 1, &sync, 0);
218  if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
219  av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
220  exit(1);
221  }
222  if (*sync)
223  sync++;
224  for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
225  if (check_stream_specifier(input_files[sync_file_idx]->ctx,
226  input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
227  sync_stream_idx = i;
228  break;
229  }
230  if (i == input_files[sync_file_idx]->nb_streams) {
231  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
232  "match any streams.\n", arg);
233  exit(1);
234  }
235  }
236 
237 
238  if (map[0] == '[') {
239  /* this mapping refers to lavfi output */
240  const char *c = map + 1;
242  m = &o->stream_maps[o->nb_stream_maps - 1];
243  m->linklabel = av_get_token(&c, "]");
244  if (!m->linklabel) {
245  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
246  exit(1);
247  }
248  } else {
249  file_idx = strtol(map, &p, 0);
250  if (file_idx >= nb_input_files || file_idx < 0) {
251  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
252  exit(1);
253  }
254  if (negative)
255  /* disable some already defined maps */
256  for (i = 0; i < o->nb_stream_maps; i++) {
257  m = &o->stream_maps[i];
258  if (file_idx == m->file_index &&
261  *p == ':' ? p + 1 : p) > 0)
262  m->disabled = 1;
263  }
264  else
265  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
266  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
267  *p == ':' ? p + 1 : p) <= 0)
268  continue;
270  m = &o->stream_maps[o->nb_stream_maps - 1];
271 
272  m->file_index = file_idx;
273  m->stream_index = i;
274 
275  if (sync_file_idx >= 0) {
276  m->sync_file_index = sync_file_idx;
277  m->sync_stream_index = sync_stream_idx;
278  } else {
279  m->sync_file_index = file_idx;
280  m->sync_stream_index = i;
281  }
282  }
283  }
284 
285  if (!m) {
286  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
287  exit(1);
288  }
289 
290  av_freep(&map);
291  return 0;
292 }
293 
294 static int opt_attach(void *optctx, const char *opt, const char *arg)
295 {
296  OptionsContext *o = optctx;
298  o->attachments[o->nb_attachments - 1] = arg;
299  return 0;
300 }
301 
302 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
303 {
304  OptionsContext *o = optctx;
305  int n;
306  AVStream *st;
308 
311 
312  /* muted channel syntax */
313  n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
314  if ((n == 1 || n == 3) && m->channel_idx == -1) {
315  m->file_idx = m->stream_idx = -1;
316  if (n == 1)
317  m->ofile_idx = m->ostream_idx = -1;
318  return 0;
319  }
320 
321  /* normal syntax */
322  n = sscanf(arg, "%d.%d.%d:%d.%d",
323  &m->file_idx, &m->stream_idx, &m->channel_idx,
324  &m->ofile_idx, &m->ostream_idx);
325 
326  if (n != 3 && n != 5) {
327  av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
328  "[file.stream.channel|-1][:syncfile:syncstream]\n");
329  exit(1);
330  }
331 
332  if (n != 5) // only file.stream.channel specified
333  m->ofile_idx = m->ostream_idx = -1;
334 
335  /* check input */
336  if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
337  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
338  m->file_idx);
339  exit(1);
340  }
341  if (m->stream_idx < 0 ||
343  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
344  m->file_idx, m->stream_idx);
345  exit(1);
346  }
347  st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
348  if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
349  av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
350  m->file_idx, m->stream_idx);
351  exit(1);
352  }
353  if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
354  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
355  m->file_idx, m->stream_idx, m->channel_idx);
356  exit(1);
357  }
358  return 0;
359 }
360 
361 /**
362  * Parse a metadata specifier passed as 'arg' parameter.
363  * @param arg metadata string to parse
364  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
365  * @param index for type c/p, chapter/program index is written here
366  * @param stream_spec for type s, the stream specifier is written here
367  */
368 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
369 {
370  if (*arg) {
371  *type = *arg;
372  switch (*arg) {
373  case 'g':
374  break;
375  case 's':
376  if (*(++arg) && *arg != ':') {
377  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
378  exit(1);
379  }
380  *stream_spec = *arg == ':' ? arg + 1 : "";
381  break;
382  case 'c':
383  case 'p':
384  if (*(++arg) == ':')
385  *index = strtol(++arg, NULL, 0);
386  break;
387  default:
388  av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
389  exit(1);
390  }
391  } else
392  *type = 'g';
393 }
394 
395 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
396 {
397  AVDictionary **meta_in = NULL;
398  AVDictionary **meta_out = NULL;
399  int i, ret = 0;
400  char type_in, type_out;
401  const char *istream_spec = NULL, *ostream_spec = NULL;
402  int idx_in = 0, idx_out = 0;
403 
404  parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
405  parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
406 
407  if (!ic) {
408  if (type_out == 'g' || !*outspec)
409  o->metadata_global_manual = 1;
410  if (type_out == 's' || !*outspec)
412  if (type_out == 'c' || !*outspec)
414  return 0;
415  }
416 
417  if (type_in == 'g' || type_out == 'g')
418  o->metadata_global_manual = 1;
419  if (type_in == 's' || type_out == 's')
421  if (type_in == 'c' || type_out == 'c')
423 
424  /* ic is NULL when just disabling automatic mappings */
425  if (!ic)
426  return 0;
427 
428 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
429  if ((index) < 0 || (index) >= (nb_elems)) {\
430  av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
431  (desc), (index));\
432  exit(1);\
433  }
434 
435 #define SET_DICT(type, meta, context, index)\
436  switch (type) {\
437  case 'g':\
438  meta = &context->metadata;\
439  break;\
440  case 'c':\
441  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
442  meta = &context->chapters[index]->metadata;\
443  break;\
444  case 'p':\
445  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
446  meta = &context->programs[index]->metadata;\
447  break;\
448  case 's':\
449  break; /* handled separately below */ \
450  default: av_assert0(0);\
451  }\
452 
453  SET_DICT(type_in, meta_in, ic, idx_in);
454  SET_DICT(type_out, meta_out, oc, idx_out);
455 
456  /* for input streams choose first matching stream */
457  if (type_in == 's') {
458  for (i = 0; i < ic->nb_streams; i++) {
459  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
460  meta_in = &ic->streams[i]->metadata;
461  break;
462  } else if (ret < 0)
463  exit(1);
464  }
465  if (!meta_in) {
466  av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
467  exit(1);
468  }
469  }
470 
471  if (type_out == 's') {
472  for (i = 0; i < oc->nb_streams; i++) {
473  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
474  meta_out = &oc->streams[i]->metadata;
475  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
476  } else if (ret < 0)
477  exit(1);
478  }
479  } else
480  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
481 
482  return 0;
483 }
484 
485 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
486 {
487  OptionsContext *o = optctx;
488  char buf[128];
489  int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
490  struct tm time = *gmtime((time_t*)&recording_timestamp);
491  strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
492  parse_option(o, "metadata", buf, options);
493 
494  av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
495  "tag instead.\n", opt);
496  return 0;
497 }
498 
499 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
500 {
501  const AVCodecDescriptor *desc;
502  const char *codec_string = encoder ? "encoder" : "decoder";
503  AVCodec *codec;
504 
505  codec = encoder ?
508 
509  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
510  codec = encoder ? avcodec_find_encoder(desc->id) :
511  avcodec_find_decoder(desc->id);
512  if (codec)
513  av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
514  codec_string, codec->name, desc->name);
515  }
516 
517  if (!codec) {
518  av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
519  exit(1);
520  }
521  if (codec->type != type) {
522  av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
523  exit(1);
524  }
525  return codec;
526 }
527 
529 {
530  char *codec_name = NULL;
531 
532  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
533  if (codec_name) {
534  AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
535  st->codec->codec_id = codec->id;
536  return codec;
537  } else
538  return avcodec_find_decoder(st->codec->codec_id);
539 }
540 
541 /* Add all the streams from the given input file to the global
542  * list of input streams. */
544 {
545  int i;
546  char *next, *codec_tag = NULL;
547 
548  for (i = 0; i < ic->nb_streams; i++) {
549  AVStream *st = ic->streams[i];
550  AVCodecContext *dec = st->codec;
551  InputStream *ist = av_mallocz(sizeof(*ist));
552  char *framerate = NULL;
553 
554  if (!ist)
555  exit(1);
556 
558  input_streams[nb_input_streams - 1] = ist;
559 
560  ist->st = st;
561  ist->file_index = nb_input_files;
562  ist->discard = 1;
563  st->discard = AVDISCARD_ALL;
564 
565  ist->ts_scale = 1.0;
566  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
567 
568  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
569  if (codec_tag) {
570  uint32_t tag = strtol(codec_tag, &next, 0);
571  if (*next)
572  tag = AV_RL32(codec_tag);
573  st->codec->codec_tag = tag;
574  }
575 
576  ist->dec = choose_decoder(o, ic, st);
577  ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
578 
579  ist->reinit_filters = -1;
580  MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
581 
583 
584  switch (dec->codec_type) {
585  case AVMEDIA_TYPE_VIDEO:
586  if(!ist->dec)
587  ist->dec = avcodec_find_decoder(dec->codec_id);
588  if (dec->lowres) {
589  dec->flags |= CODEC_FLAG_EMU_EDGE;
590  }
591 
592  ist->resample_height = dec->height;
593  ist->resample_width = dec->width;
594  ist->resample_pix_fmt = dec->pix_fmt;
595 
596  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
597  if (framerate && av_parse_video_rate(&ist->framerate,
598  framerate) < 0) {
599  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
600  framerate);
601  exit(1);
602  }
603 
604  ist->top_field_first = -1;
605  MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
606 
607  break;
608  case AVMEDIA_TYPE_AUDIO:
609  ist->guess_layout_max = INT_MAX;
610  MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
612 
613  ist->resample_sample_fmt = dec->sample_fmt;
614  ist->resample_sample_rate = dec->sample_rate;
615  ist->resample_channels = dec->channels;
617 
618  break;
619  case AVMEDIA_TYPE_DATA:
621  if(!ist->dec)
622  ist->dec = avcodec_find_decoder(dec->codec_id);
623  MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
624  break;
627  break;
628  default:
629  abort();
630  }
631  }
632 }
633 
634 static void assert_file_overwrite(const char *filename)
635 {
636  if ((!file_overwrite || no_file_overwrite) &&
637  (strchr(filename, ':') == NULL || filename[1] == ':' ||
638  av_strstart(filename, "file:", NULL))) {
639  if (avio_check(filename, 0) == 0) {
641  fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
642  fflush(stderr);
643  term_exit();
644  signal(SIGINT, SIG_DFL);
645  if (!read_yesno()) {
646  av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
647  exit(1);
648  }
649  term_init();
650  }
651  else {
652  av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
653  exit(1);
654  }
655  }
656  }
657 }
658 
659 static void dump_attachment(AVStream *st, const char *filename)
660 {
661  int ret;
662  AVIOContext *out = NULL;
664 
665  if (!st->codec->extradata_size) {
666  av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
667  nb_input_files - 1, st->index);
668  return;
669  }
670  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
671  filename = e->value;
672  if (!*filename) {
673  av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
674  "in stream #%d:%d.\n", nb_input_files - 1, st->index);
675  exit(1);
676  }
677 
678  assert_file_overwrite(filename);
679 
680  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
681  av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
682  filename);
683  exit(1);
684  }
685 
686  avio_write(out, st->codec->extradata, st->codec->extradata_size);
687  avio_flush(out);
688  avio_close(out);
689 }
690 
691 static int open_input_file(OptionsContext *o, const char *filename)
692 {
693  AVFormatContext *ic;
695  int err, i, ret;
696  int64_t timestamp;
697  uint8_t buf[128];
698  AVDictionary **opts;
699  int orig_nb_streams; // number of streams before avformat_find_stream_info
700  char * video_codec_name = NULL;
701  char * audio_codec_name = NULL;
702  char *subtitle_codec_name = NULL;
703 
704  if (o->format) {
705  if (!(file_iformat = av_find_input_format(o->format))) {
706  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
707  exit(1);
708  }
709  }
710 
711  if (!strcmp(filename, "-"))
712  filename = "pipe:";
713 
714  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
715  strcmp(filename, "/dev/stdin");
716 
717  /* get default parameters from command line */
718  ic = avformat_alloc_context();
719  if (!ic) {
720  print_error(filename, AVERROR(ENOMEM));
721  exit(1);
722  }
723  if (o->nb_audio_sample_rate) {
724  snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
725  av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
726  }
727  if (o->nb_audio_channels) {
728  /* because we set audio_channels based on both the "ac" and
729  * "channel_layout" options, we need to check that the specified
730  * demuxer actually has the "channels" option before setting it */
731  if (file_iformat && file_iformat->priv_class &&
732  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
734  snprintf(buf, sizeof(buf), "%d",
735  o->audio_channels[o->nb_audio_channels - 1].u.i);
736  av_dict_set(&o->g->format_opts, "channels", buf, 0);
737  }
738  }
739  if (o->nb_frame_rates) {
740  /* set the format-level framerate option;
741  * this is important for video grabbers, e.g. x11 */
742  if (file_iformat && file_iformat->priv_class &&
743  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
745  av_dict_set(&o->g->format_opts, "framerate",
746  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
747  }
748  }
749  if (o->nb_frame_sizes) {
750  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
751  }
752  if (o->nb_frame_pix_fmts)
753  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
754 
755  MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
756  MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
757  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
758 
759  ic->video_codec_id = video_codec_name ?
760  find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
761  ic->audio_codec_id = audio_codec_name ?
762  find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
763  ic->subtitle_codec_id= subtitle_codec_name ?
764  find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
765  ic->flags |= AVFMT_FLAG_NONBLOCK;
767 
768  /* open the input file with generic avformat function */
769  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
770  if (err < 0) {
771  print_error(filename, err);
772  exit(1);
773  }
775 
776  /* apply forced codec ids */
777  for (i = 0; i < ic->nb_streams; i++)
778  choose_decoder(o, ic, ic->streams[i]);
779 
780  /* Set AVCodecContext options for avformat_find_stream_info */
781  opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
782  orig_nb_streams = ic->nb_streams;
783 
784  /* If not enough info to get the stream parameters, we decode the
785  first frames to get it. (used in mpeg case for example) */
786  ret = avformat_find_stream_info(ic, opts);
787  if (ret < 0) {
788  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
790  exit(1);
791  }
792 
793  timestamp = o->start_time;
794  /* add the stream start time */
795  if (ic->start_time != AV_NOPTS_VALUE)
796  timestamp += ic->start_time;
797 
798  /* if seeking requested, we execute it */
799  if (o->start_time != 0) {
800  ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
801  if (ret < 0) {
802  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
803  filename, (double)timestamp / AV_TIME_BASE);
804  }
805  }
806 
807  /* update the current parameters so that they match the one of the input stream */
808  add_input_streams(o, ic);
809 
810  /* dump the file content */
811  av_dump_format(ic, nb_input_files, filename, 0);
812 
814  if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
815  exit(1);
816 
817  input_files[nb_input_files - 1]->ctx = ic;
819  input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
822 
823  for (i = 0; i < o->nb_dump_attachment; i++) {
824  int j;
825 
826  for (j = 0; j < ic->nb_streams; j++) {
827  AVStream *st = ic->streams[j];
828 
829  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
831  }
832  }
833 
834  for (i = 0; i < orig_nb_streams; i++)
835  av_dict_free(&opts[i]);
836  av_freep(&opts);
837 
838  return 0;
839 }
840 
842 {
843  AVIOContext *line;
844  uint8_t *buf;
845  char c;
846 
847  if (avio_open_dyn_buf(&line) < 0) {
848  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
849  exit(1);
850  }
851 
852  while ((c = avio_r8(s)) && c != '\n')
853  avio_w8(line, c);
854  avio_w8(line, 0);
855  avio_close_dyn_buf(line, &buf);
856 
857  return buf;
858 }
859 
860 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
861 {
862  int i, ret = 1;
863  char filename[1000];
864  const char *base[3] = { getenv("AVCONV_DATADIR"),
865  getenv("HOME"),
866  AVCONV_DATADIR,
867  };
868 
869  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
870  if (!base[i])
871  continue;
872  if (codec_name) {
873  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
874  i != 1 ? "" : "/.avconv", codec_name, preset_name);
875  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
876  }
877  if (ret) {
878  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
879  i != 1 ? "" : "/.avconv", preset_name);
880  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
881  }
882  }
883  return ret;
884 }
885 
887 {
888  char *codec_name = NULL;
889 
890  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
891  if (!codec_name) {
893  NULL, ost->st->codec->codec_type);
894  ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
895  } else if (!strcmp(codec_name, "copy"))
896  ost->stream_copy = 1;
897  else {
898  ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
899  ost->st->codec->codec_id = ost->enc->id;
900  }
901 }
902 
903 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
904 {
905  OutputStream *ost;
906  AVStream *st = avformat_new_stream(oc, NULL);
907  int idx = oc->nb_streams - 1, ret = 0;
908  char *bsf = NULL, *next, *codec_tag = NULL;
909  AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
910  double qscale = -1;
911 
912  if (!st) {
913  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
914  exit(1);
915  }
916 
917  if (oc->nb_streams - 1 < o->nb_streamid_map)
918  st->id = o->streamid_map[oc->nb_streams - 1];
919 
921  if (!(ost = av_mallocz(sizeof(*ost))))
922  exit(1);
924 
926  ost->index = idx;
927  ost->st = st;
928  st->codec->codec_type = type;
929  choose_encoder(o, oc, ost);
930  if (ost->enc) {
931  AVIOContext *s = NULL;
932  char *buf = NULL, *arg = NULL, *preset = NULL;
933 
934  ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
935 
936  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
937  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
938  do {
939  buf = get_line(s);
940  if (!buf[0] || buf[0] == '#') {
941  av_free(buf);
942  continue;
943  }
944  if (!(arg = strchr(buf, '='))) {
945  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
946  exit(1);
947  }
948  *arg++ = 0;
949  av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
950  av_free(buf);
951  } while (!s->eof_reached);
952  avio_close(s);
953  }
954  if (ret) {
956  "Preset %s specified for stream %d:%d, but could not be opened.\n",
957  preset, ost->file_index, ost->index);
958  exit(1);
959  }
960  } else {
961  ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
962  }
963 
965  st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
966 
967  ost->max_frames = INT64_MAX;
968  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
969 
970  ost->copy_prior_start = -1;
971  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
972 
973  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
974  while (bsf) {
975  if (next = strchr(bsf, ','))
976  *next++ = 0;
977  if (!(bsfc = av_bitstream_filter_init(bsf))) {
978  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
979  exit(1);
980  }
981  if (bsfc_prev)
982  bsfc_prev->next = bsfc;
983  else
984  ost->bitstream_filters = bsfc;
985 
986  bsfc_prev = bsfc;
987  bsf = next;
988  }
989 
990  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
991  if (codec_tag) {
992  uint32_t tag = strtol(codec_tag, &next, 0);
993  if (*next)
994  tag = AV_RL32(codec_tag);
995  st->codec->codec_tag = tag;
996  }
997 
998  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
999  if (qscale >= 0) {
1000  st->codec->flags |= CODEC_FLAG_QSCALE;
1001  st->codec->global_quality = FF_QP2LAMBDA * qscale;
1002  }
1003 
1004  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1006 
1007  av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1008 
1009  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1010  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1011  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1012 
1013  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1014 
1015  ost->source_index = source_index;
1016  if (source_index >= 0) {
1017  ost->sync_ist = input_streams[source_index];
1018  input_streams[source_index]->discard = 0;
1019  input_streams[source_index]->st->discard = AVDISCARD_NONE;
1020  }
1021 
1022  return ost;
1023 }
1024 
1025 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1026 {
1027  int i;
1028  const char *p = str;
1029  for (i = 0;; i++) {
1030  dest[i] = atoi(p);
1031  if (i == 63)
1032  break;
1033  p = strchr(p, ',');
1034  if (!p) {
1035  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1036  exit(1);
1037  }
1038  p++;
1039  }
1040 }
1041 
1043 {
1044  AVStream *st;
1045  OutputStream *ost;
1046  AVCodecContext *video_enc;
1047  char *frame_rate = NULL;
1048 
1049  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1050  st = ost->st;
1051  video_enc = st->codec;
1052 
1053  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1054  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1055  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1056  exit(1);
1057  }
1058 
1059  if (!ost->stream_copy) {
1060  const char *p = NULL;
1061  char *frame_size = NULL;
1062  char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1063  char *intra_matrix = NULL, *inter_matrix = NULL;
1064  const char *filters = "null";
1065  int do_pass = 0;
1066  int i;
1067 
1068  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1069  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1070  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1071  exit(1);
1072  }
1073 
1074  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1075  if (frame_aspect_ratio) {
1076  AVRational q;
1077  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1078  q.num <= 0 || q.den <= 0) {
1079  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1080  exit(1);
1081  }
1082  ost->frame_aspect_ratio = av_q2d(q);
1083  }
1084 
1086  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1087  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1088  ost->keep_pix_fmt = 1;
1089  if (!*++frame_pix_fmt)
1090  frame_pix_fmt = NULL;
1091  }
1092  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1093  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1094  exit(1);
1095  }
1096  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1097 
1098  if (intra_only)
1099  video_enc->gop_size = 0;
1100  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1101  if (intra_matrix) {
1102  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1103  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1104  exit(1);
1105  }
1106  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1107  }
1108  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1109  if (inter_matrix) {
1110  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1111  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1112  exit(1);
1113  }
1114  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1115  }
1116 
1117  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1118  for (i = 0; p; i++) {
1119  int start, end, q;
1120  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1121  if (e != 3) {
1122  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1123  exit(1);
1124  }
1125  /* FIXME realloc failure */
1126  video_enc->rc_override =
1127  av_realloc(video_enc->rc_override,
1128  sizeof(RcOverride) * (i + 1));
1129  video_enc->rc_override[i].start_frame = start;
1130  video_enc->rc_override[i].end_frame = end;
1131  if (q > 0) {
1132  video_enc->rc_override[i].qscale = q;
1133  video_enc->rc_override[i].quality_factor = 1.0;
1134  }
1135  else {
1136  video_enc->rc_override[i].qscale = 0;
1137  video_enc->rc_override[i].quality_factor = -q/100.0;
1138  }
1139  p = strchr(p, '/');
1140  if (p) p++;
1141  }
1142  video_enc->rc_override_count = i;
1143  video_enc->intra_dc_precision = intra_dc_precision - 8;
1144 
1145  if (do_psnr)
1146  video_enc->flags|= CODEC_FLAG_PSNR;
1147 
1148  /* two pass mode */
1149  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1150  if (do_pass) {
1151  if (do_pass & 1) {
1152  video_enc->flags |= CODEC_FLAG_PASS1;
1153  av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1154  }
1155  if (do_pass & 2) {
1156  video_enc->flags |= CODEC_FLAG_PASS2;
1157  av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1158  }
1159  }
1160 
1161  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1162  if (ost->logfile_prefix &&
1163  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1164  exit(1);
1165 
1166  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1167  if (ost->forced_keyframes)
1169 
1170  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1171 
1172  ost->top_field_first = -1;
1173  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1174 
1175  MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1176  ost->avfilter = av_strdup(filters);
1177  } else {
1178  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1179  }
1180 
1181  return ost;
1182 }
1183 
1185 {
1186  int n;
1187  AVStream *st;
1188  OutputStream *ost;
1189  AVCodecContext *audio_enc;
1190 
1191  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1192  st = ost->st;
1193 
1194  audio_enc = st->codec;
1195  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1196 
1197  if (!ost->stream_copy) {
1198  char *sample_fmt = NULL;
1199  const char *filters = "anull";
1200 
1201  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1202 
1203  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1204  if (sample_fmt &&
1205  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1206  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1207  exit(1);
1208  }
1209 
1210  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1211 
1212  MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1213 
1214  av_assert1(filters);
1215  ost->avfilter = av_strdup(filters);
1216 
1217  /* check for channel mapping for this audio stream */
1218  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1219  AudioChannelMap *map = &o->audio_channel_maps[n];
1220  InputStream *ist = input_streams[ost->source_index];
1221  if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1222  (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1223  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1226  else
1227  av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1228  ost->file_index, ost->st->index);
1229  }
1230  }
1231  }
1232 
1233  return ost;
1234 }
1235 
1237 {
1238  OutputStream *ost;
1239 
1240  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1241  if (!ost->stream_copy) {
1242  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1243  exit(1);
1244  }
1245 
1246  return ost;
1247 }
1248 
1250 {
1251  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1252  ost->stream_copy = 1;
1253  return ost;
1254 }
1255 
1257 {
1258  AVStream *st;
1259  OutputStream *ost;
1260  AVCodecContext *subtitle_enc;
1261 
1262  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1263  st = ost->st;
1264  subtitle_enc = st->codec;
1265 
1266  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1267 
1268  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1269 
1270  if (!ost->stream_copy) {
1271  char *frame_size = NULL;
1272 
1273  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1274  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1275  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1276  exit(1);
1277  }
1278  }
1279 
1280  return ost;
1281 }
1282 
1283 /* arg format is "output-stream-index:streamid-value". */
1284 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1285 {
1286  OptionsContext *o = optctx;
1287  int idx;
1288  char *p;
1289  char idx_str[16];
1290 
1291  av_strlcpy(idx_str, arg, sizeof(idx_str));
1292  p = strchr(idx_str, ':');
1293  if (!p) {
1295  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1296  arg, opt);
1297  exit(1);
1298  }
1299  *p++ = '\0';
1300  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1301  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1302  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1303  return 0;
1304 }
1305 
1306 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1307 {
1308  AVFormatContext *is = ifile->ctx;
1309  AVFormatContext *os = ofile->ctx;
1310  AVChapter **tmp;
1311  int i;
1312 
1313  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1314  if (!tmp)
1315  return AVERROR(ENOMEM);
1316  os->chapters = tmp;
1317 
1318  for (i = 0; i < is->nb_chapters; i++) {
1319  AVChapter *in_ch = is->chapters[i], *out_ch;
1320  int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1321  AV_TIME_BASE_Q, in_ch->time_base);
1322  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1324 
1325 
1326  if (in_ch->end < ts_off)
1327  continue;
1328  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1329  break;
1330 
1331  out_ch = av_mallocz(sizeof(AVChapter));
1332  if (!out_ch)
1333  return AVERROR(ENOMEM);
1334 
1335  out_ch->id = in_ch->id;
1336  out_ch->time_base = in_ch->time_base;
1337  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1338  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1339 
1340  if (copy_metadata)
1341  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1342 
1343  os->chapters[os->nb_chapters++] = out_ch;
1344  }
1345  return 0;
1346 }
1347 
1348 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1349 {
1350  int i, err;
1352 
1353  ic->interrupt_callback = int_cb;
1354  err = avformat_open_input(&ic, filename, NULL, NULL);
1355  if (err < 0)
1356  return err;
1357  /* copy stream format */
1358  for(i=0;i<ic->nb_streams;i++) {
1359  AVStream *st;
1360  OutputStream *ost;
1361  AVCodec *codec;
1362  AVCodecContext *avctx;
1363 
1364  codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1365  ost = new_output_stream(o, s, codec->type, -1);
1366  st = ost->st;
1367  avctx = st->codec;
1368  ost->enc = codec;
1369 
1370  // FIXME: a more elegant solution is needed
1371  memcpy(st, ic->streams[i], sizeof(AVStream));
1372  st->cur_dts = 0;
1373  st->info = av_malloc(sizeof(*st->info));
1374  memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1375  st->codec= avctx;
1376  avcodec_copy_context(st->codec, ic->streams[i]->codec);
1377 
1378  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1379  choose_sample_fmt(st, codec);
1380  else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1381  choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1382  }
1383 
1384  /* ffserver seeking with date=... needs a date reference */
1385  err = parse_option(o, "metadata", "creation_time=now", options);
1386 
1387  avformat_close_input(&ic);
1388  return err;
1389 }
1390 
1392  AVFormatContext *oc)
1393 {
1394  OutputStream *ost;
1395 
1397  ofilter->out_tmp->pad_idx)) {
1398  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1399  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1400  default:
1401  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1402  "currently.\n");
1403  exit(1);
1404  }
1405 
1406  ost->source_index = -1;
1407  ost->filter = ofilter;
1408 
1409  ofilter->ost = ost;
1410 
1411  if (ost->stream_copy) {
1412  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1413  "which is fed from a complex filtergraph. Filtering and streamcopy "
1414  "cannot be used together.\n", ost->file_index, ost->index);
1415  exit(1);
1416  }
1417 
1418  if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1419  av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1420  exit(1);
1421  }
1422  avfilter_inout_free(&ofilter->out_tmp);
1423 }
1424 
1426 {
1427  int i, ret = 0;
1428 
1429  for (i = 0; i < nb_filtergraphs; i++)
1430  if (!filtergraphs[i]->graph &&
1431  (ret = configure_filtergraph(filtergraphs[i])) < 0)
1432  return ret;
1433  return 0;
1434 }
1435 
1436 static int open_output_file(OptionsContext *o, const char *filename)
1437 {
1438  AVFormatContext *oc;
1439  int i, j, err;
1440  AVOutputFormat *file_oformat;
1441  OutputStream *ost;
1442  InputStream *ist;
1443 
1444  if (configure_complex_filters() < 0) {
1445  av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1446  exit(1);
1447  }
1448 
1449  if (!strcmp(filename, "-"))
1450  filename = "pipe:";
1451 
1452  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1453  if (!oc) {
1454  print_error(filename, err);
1455  exit(1);
1456  }
1457  file_oformat= oc->oformat;
1458  oc->interrupt_callback = int_cb;
1459 
1460  /* create streams for all unlabeled output pads */
1461  for (i = 0; i < nb_filtergraphs; i++) {
1462  FilterGraph *fg = filtergraphs[i];
1463  for (j = 0; j < fg->nb_outputs; j++) {
1464  OutputFilter *ofilter = fg->outputs[j];
1465 
1466  if (!ofilter->out_tmp || ofilter->out_tmp->name)
1467  continue;
1468 
1470  ofilter->out_tmp->pad_idx)) {
1471  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1472  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1473  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1474  }
1475  init_output_filter(ofilter, o, oc);
1476  }
1477  }
1478 
1479  if (!strcmp(file_oformat->name, "ffm") &&
1480  av_strstart(filename, "http:", NULL)) {
1481  int j;
1482  /* special case for files sent to ffserver: we get the stream
1483  parameters from ffserver */
1484  int err = read_ffserver_streams(o, oc, filename);
1485  if (err < 0) {
1486  print_error(filename, err);
1487  exit(1);
1488  }
1489  for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1490  ost = output_streams[j];
1491  for (i = 0; i < nb_input_streams; i++) {
1492  ist = input_streams[i];
1493  if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1494  ost->sync_ist= ist;
1495  ost->source_index= i;
1496  if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1497  if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1498  ist->discard = 0;
1499  ist->st->discard = AVDISCARD_NONE;
1500  break;
1501  }
1502  }
1503  if(!ost->sync_ist){
1504  av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1505  exit(1);
1506  }
1507  }
1508  } else if (!o->nb_stream_maps) {
1509  char *subtitle_codec_name = NULL;
1510  /* pick the "best" stream of each type */
1511 
1512  /* video: highest resolution */
1513  if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1514  int area = 0, idx = -1;
1515  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1516  for (i = 0; i < nb_input_streams; i++) {
1517  int new_area;
1518  ist = input_streams[i];
1519  new_area = ist->st->codec->width * ist->st->codec->height;
1520  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1521  new_area = 1;
1522  if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1523  new_area > area) {
1524  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1525  continue;
1526  area = new_area;
1527  idx = i;
1528  }
1529  }
1530  if (idx >= 0)
1531  new_video_stream(o, oc, idx);
1532  }
1533 
1534  /* audio: most channels */
1535  if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1536  int channels = 0, idx = -1;
1537  for (i = 0; i < nb_input_streams; i++) {
1538  ist = input_streams[i];
1539  if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1540  ist->st->codec->channels > channels) {
1541  channels = ist->st->codec->channels;
1542  idx = i;
1543  }
1544  }
1545  if (idx >= 0)
1546  new_audio_stream(o, oc, idx);
1547  }
1548 
1549  /* subtitles: pick first */
1550  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1551  if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1552  for (i = 0; i < nb_input_streams; i++)
1553  if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1554  new_subtitle_stream(o, oc, i);
1555  break;
1556  }
1557  }
1558  /* do something with data? */
1559  } else {
1560  for (i = 0; i < o->nb_stream_maps; i++) {
1561  StreamMap *map = &o->stream_maps[i];
1562  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1563 
1564  if (map->disabled)
1565  continue;
1566 
1567  if (map->linklabel) {
1568  FilterGraph *fg;
1569  OutputFilter *ofilter = NULL;
1570  int j, k;
1571 
1572  for (j = 0; j < nb_filtergraphs; j++) {
1573  fg = filtergraphs[j];
1574  for (k = 0; k < fg->nb_outputs; k++) {
1575  AVFilterInOut *out = fg->outputs[k]->out_tmp;
1576  if (out && !strcmp(out->name, map->linklabel)) {
1577  ofilter = fg->outputs[k];
1578  goto loop_end;
1579  }
1580  }
1581  }
1582 loop_end:
1583  if (!ofilter) {
1584  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1585  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1586  exit(1);
1587  }
1588  init_output_filter(ofilter, o, oc);
1589  } else {
1592  continue;
1593  if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1594  continue;
1595  if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1596  continue;
1597  if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1598  continue;
1599 
1600  switch (ist->st->codec->codec_type) {
1601  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1602  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1603  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1604  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1605  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1606  default:
1607  av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1608  map->file_index, map->stream_index);
1609  exit(1);
1610  }
1611  }
1612  }
1613  }
1614 
1615  /* handle attached files */
1616  for (i = 0; i < o->nb_attachments; i++) {
1617  AVIOContext *pb;
1618  uint8_t *attachment;
1619  const char *p;
1620  int64_t len;
1621 
1622  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1623  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1624  o->attachments[i]);
1625  exit(1);
1626  }
1627  if ((len = avio_size(pb)) <= 0) {
1628  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1629  o->attachments[i]);
1630  exit(1);
1631  }
1632  if (!(attachment = av_malloc(len))) {
1633  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1634  o->attachments[i]);
1635  exit(1);
1636  }
1637  avio_read(pb, attachment, len);
1638 
1639  ost = new_attachment_stream(o, oc, -1);
1640  ost->stream_copy = 0;
1641  ost->attachment_filename = o->attachments[i];
1642  ost->finished = 1;
1643  ost->st->codec->extradata = attachment;
1644  ost->st->codec->extradata_size = len;
1645 
1646  p = strrchr(o->attachments[i], '/');
1647  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1648  avio_close(pb);
1649  }
1650 
1651  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1652  AVDictionaryEntry *e;
1653  ost = output_streams[i];
1654 
1655  if ((ost->stream_copy || ost->attachment_filename)
1656  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1657  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1658  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1659  exit(1);
1660  }
1661 
1662  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1663  o->stop_time = INT64_MAX;
1664  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1665  }
1666 
1667  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1668  if (o->stop_time <= o->start_time) {
1669  av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1670  o->stop_time = INT64_MAX;
1671  } else {
1672  o->recording_time = o->stop_time - o->start_time;
1673  }
1674  }
1675 
1677  if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1678  exit(1);
1679 
1680  output_files[nb_output_files - 1]->ctx = oc;
1683  if (o->recording_time != INT64_MAX)
1684  oc->duration = o->recording_time;
1688  av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1689 
1690  /* check filename in case of an image number is expected */
1691  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1692  if (!av_filename_number_test(oc->filename)) {
1693  print_error(oc->filename, AVERROR(EINVAL));
1694  exit(1);
1695  }
1696  }
1697 
1698  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1699  /* test if it already exists to avoid losing precious files */
1700  assert_file_overwrite(filename);
1701 
1702  /* open the file */
1703  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1704  &oc->interrupt_callback,
1705  &output_files[nb_output_files - 1]->opts)) < 0) {
1706  print_error(filename, err);
1707  exit(1);
1708  }
1709  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1710  assert_file_overwrite(filename);
1711 
1712  if (o->mux_preload) {
1713  uint8_t buf[64];
1714  snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1715  av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1716  }
1717  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1718 
1719  /* copy metadata */
1720  for (i = 0; i < o->nb_metadata_map; i++) {
1721  char *p;
1722  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1723 
1724  if (in_file_index >= nb_input_files) {
1725  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1726  exit(1);
1727  }
1728  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1729  in_file_index >= 0 ?
1730  input_files[in_file_index]->ctx : NULL, o);
1731  }
1732 
1733  /* copy chapters */
1734  if (o->chapters_input_file >= nb_input_files) {
1735  if (o->chapters_input_file == INT_MAX) {
1736  /* copy chapters from the first input file that has them*/
1737  o->chapters_input_file = -1;
1738  for (i = 0; i < nb_input_files; i++)
1739  if (input_files[i]->ctx->nb_chapters) {
1740  o->chapters_input_file = i;
1741  break;
1742  }
1743  } else {
1744  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1745  o->chapters_input_file);
1746  exit(1);
1747  }
1748  }
1749  if (o->chapters_input_file >= 0)
1752 
1753  /* copy global metadata by default */
1757  if(o->recording_time != INT64_MAX)
1758  av_dict_set(&oc->metadata, "duration", NULL, 0);
1759  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1760  }
1761  if (!o->metadata_streams_manual)
1762  for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1763  InputStream *ist;
1764  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1765  continue;
1767  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1768  }
1769 
1770  /* process manually set metadata */
1771  for (i = 0; i < o->nb_metadata; i++) {
1772  AVDictionary **m;
1773  char type, *val;
1774  const char *stream_spec;
1775  int index = 0, j, ret = 0;
1776 
1777  val = strchr(o->metadata[i].u.str, '=');
1778  if (!val) {
1779  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1780  o->metadata[i].u.str);
1781  exit(1);
1782  }
1783  *val++ = 0;
1784 
1785  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1786  if (type == 's') {
1787  for (j = 0; j < oc->nb_streams; j++) {
1788  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1789  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1790  } else if (ret < 0)
1791  exit(1);
1792  }
1793  }
1794  else {
1795  switch (type) {
1796  case 'g':
1797  m = &oc->metadata;
1798  break;
1799  case 'c':
1800  if (index < 0 || index >= oc->nb_chapters) {
1801  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1802  exit(1);
1803  }
1804  m = &oc->chapters[index]->metadata;
1805  break;
1806  default:
1807  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1808  exit(1);
1809  }
1810  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1811  }
1812  }
1813 
1814  return 0;
1815 }
1816 
1817 static int opt_target(void *optctx, const char *opt, const char *arg)
1818 {
1819  OptionsContext *o = optctx;
1820  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1821  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1822 
1823  if (!strncmp(arg, "pal-", 4)) {
1824  norm = PAL;
1825  arg += 4;
1826  } else if (!strncmp(arg, "ntsc-", 5)) {
1827  norm = NTSC;
1828  arg += 5;
1829  } else if (!strncmp(arg, "film-", 5)) {
1830  norm = FILM;
1831  arg += 5;
1832  } else {
1833  /* Try to determine PAL/NTSC by peeking in the input files */
1834  if (nb_input_files) {
1835  int i, j, fr;
1836  for (j = 0; j < nb_input_files; j++) {
1837  for (i = 0; i < input_files[j]->nb_streams; i++) {
1839  if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1840  continue;
1841  fr = c->time_base.den * 1000 / c->time_base.num;
1842  if (fr == 25000) {
1843  norm = PAL;
1844  break;
1845  } else if ((fr == 29970) || (fr == 23976)) {
1846  norm = NTSC;
1847  break;
1848  }
1849  }
1850  if (norm != UNKNOWN)
1851  break;
1852  }
1853  }
1854  if (norm != UNKNOWN)
1855  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1856  }
1857 
1858  if (norm == UNKNOWN) {
1859  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1860  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1861  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1862  exit(1);
1863  }
1864 
1865  if (!strcmp(arg, "vcd")) {
1866  opt_video_codec(o, "c:v", "mpeg1video");
1867  opt_audio_codec(o, "c:a", "mp2");
1868  parse_option(o, "f", "vcd", options);
1869  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1870 
1871  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1872  parse_option(o, "r", frame_rates[norm], options);
1873  av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1874 
1875  av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1876  av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1877  av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1878  av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1879 
1880  av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1881  parse_option(o, "ar", "44100", options);
1882  parse_option(o, "ac", "2", options);
1883 
1884  av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1885  av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1886 
1887  /* We have to offset the PTS, so that it is consistent with the SCR.
1888  SCR starts at 36000, but the first two packs contain only padding
1889  and the first pack from the other stream, respectively, may also have
1890  been written before.
1891  So the real data starts at SCR 36000+3*1200. */
1892  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1893  } else if (!strcmp(arg, "svcd")) {
1894 
1895  opt_video_codec(o, "c:v", "mpeg2video");
1896  opt_audio_codec(o, "c:a", "mp2");
1897  parse_option(o, "f", "svcd", options);
1898 
1899  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1900  parse_option(o, "r", frame_rates[norm], options);
1901  parse_option(o, "pix_fmt", "yuv420p", options);
1902  av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1903 
1904  av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1905  av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1906  av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1907  av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1908  av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1909 
1910  av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1911  parse_option(o, "ar", "44100", options);
1912 
1913  av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1914 
1915  } else if (!strcmp(arg, "dvd")) {
1916 
1917  opt_video_codec(o, "c:v", "mpeg2video");
1918  opt_audio_codec(o, "c:a", "ac3");
1919  parse_option(o, "f", "dvd", options);
1920 
1921  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1922  parse_option(o, "r", frame_rates[norm], options);
1923  parse_option(o, "pix_fmt", "yuv420p", options);
1924  av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1925 
1926  av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1927  av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1928  av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1929  av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1930 
1931  av_dict_set(&o->g->format_opts, "packetsize", "2048", 0); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1932  av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1933 
1934  av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1935  parse_option(o, "ar", "48000", options);
1936 
1937  } else if (!strncmp(arg, "dv", 2)) {
1938 
1939  parse_option(o, "f", "dv", options);
1940 
1941  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1942  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1943  norm == PAL ? "yuv420p" : "yuv411p", options);
1944  parse_option(o, "r", frame_rates[norm], options);
1945 
1946  parse_option(o, "ar", "48000", options);
1947  parse_option(o, "ac", "2", options);
1948 
1949  } else {
1950  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1951  return AVERROR(EINVAL);
1952  }
1953  return 0;
1954 }
1955 
1956 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1957 {
1959  vstats_filename = av_strdup (arg);
1960  return 0;
1961 }
1962 
1963 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1964 {
1965  char filename[40];
1966  time_t today2 = time(NULL);
1967  struct tm *today = localtime(&today2);
1968 
1969  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1970  today->tm_sec);
1971  return opt_vstats_file(NULL, opt, filename);
1972 }
1973 
1974 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1975 {
1976  OptionsContext *o = optctx;
1977  return parse_option(o, "frames:v", arg, options);
1978 }
1979 
1980 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1981 {
1982  OptionsContext *o = optctx;
1983  return parse_option(o, "frames:a", arg, options);
1984 }
1985 
1986 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1987 {
1988  OptionsContext *o = optctx;
1989  return parse_option(o, "frames:d", arg, options);
1990 }
1991 
1992 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1993 {
1994  int ret;
1995  AVDictionary *cbak = codec_opts;
1996  AVDictionary *fbak = format_opts;
1997  codec_opts = NULL;
1998  format_opts = NULL;
1999 
2000  ret = opt_default(NULL, opt, arg);
2001 
2002  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2006  codec_opts = cbak;
2007  format_opts = fbak;
2008 
2009  return ret;
2010 }
2011 
2012 static int opt_preset(void *optctx, const char *opt, const char *arg)
2013 {
2014  OptionsContext *o = optctx;
2015  FILE *f=NULL;
2016  char filename[1000], line[1000], tmp_line[1000];
2017  const char *codec_name = NULL;
2018 
2019  tmp_line[0] = *opt;
2020  tmp_line[1] = 0;
2021  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2022 
2023  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2024  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2025  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2026  }else
2027  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2028  exit(1);
2029  }
2030 
2031  while (fgets(line, sizeof(line), f)) {
2032  char *key = tmp_line, *value, *endptr;
2033 
2034  if (strcspn(line, "#\n\r") == 0)
2035  continue;
2036  strcpy(tmp_line, line);
2037  if (!av_strtok(key, "=", &value) ||
2038  !av_strtok(value, "\r\n", &endptr)) {
2039  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2040  exit(1);
2041  }
2042  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2043 
2044  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2045  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2046  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2047  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2048  else if (opt_default_new(o, key, value) < 0) {
2049  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2050  filename, line, key, value);
2051  exit(1);
2052  }
2053  }
2054 
2055  fclose(f);
2056 
2057  return 0;
2058 }
2059 
2060 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2061 {
2062  OptionsContext *o = optctx;
2063  char *s = av_asprintf("%s:%c", opt + 1, *opt);
2064  int ret = parse_option(o, s, arg, options);
2065  av_free(s);
2066  return ret;
2067 }
2068 
2069 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2070 {
2071  OptionsContext *o = optctx;
2072  if(!strcmp(opt, "b")){
2073  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2074  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2075  return 0;
2076  }
2077  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2078  return 0;
2079 }
2080 
2081 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2082 {
2083  OptionsContext *o = optctx;
2084  char *s;
2085  int ret;
2086  if(!strcmp(opt, "qscale")){
2087  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2088  return parse_option(o, "q:v", arg, options);
2089  }
2090  s = av_asprintf("q%s", opt + 6);
2091  ret = parse_option(o, s, arg, options);
2092  av_free(s);
2093  return ret;
2094 }
2095 
2096 static int opt_profile(void *optctx, const char *opt, const char *arg)
2097 {
2098  OptionsContext *o = optctx;
2099  if(!strcmp(opt, "profile")){
2100  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2101  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2102  return 0;
2103  }
2104  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2105  return 0;
2106 }
2107 
2108 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2109 {
2110  OptionsContext *o = optctx;
2111  return parse_option(o, "filter:v", arg, options);
2112 }
2113 
2114 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2115 {
2116  OptionsContext *o = optctx;
2117  return parse_option(o, "filter:a", arg, options);
2118 }
2119 
2120 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2121 {
2122  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2123  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2124  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2125  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2126 
2129  return 0;
2130 }
2131 
2132 #if FF_API_DEINTERLACE
2133 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2134 {
2135  av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2136  do_deinterlace = 1;
2137  return 0;
2138 }
2139 #endif
2140 
2141 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2142 {
2143  OptionsContext *o = optctx;
2144  char *tcr = av_asprintf("timecode=%s", arg);
2145  int ret = parse_option(o, "metadata:g", tcr, options);
2146  if (ret >= 0)
2147  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2148  av_free(tcr);
2149  return 0;
2150 }
2151 
2152 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2153 {
2154  OptionsContext *o = optctx;
2155  char layout_str[32];
2156  char *stream_str;
2157  char *ac_str;
2158  int ret, channels, ac_str_size;
2159  uint64_t layout;
2160 
2161  layout = av_get_channel_layout(arg);
2162  if (!layout) {
2163  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2164  return AVERROR(EINVAL);
2165  }
2166  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2167  ret = opt_default_new(o, opt, layout_str);
2168  if (ret < 0)
2169  return ret;
2170 
2171  /* set 'ac' option based on channel layout */
2172  channels = av_get_channel_layout_nb_channels(layout);
2173  snprintf(layout_str, sizeof(layout_str), "%d", channels);
2174  stream_str = strchr(opt, ':');
2175  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2176  ac_str = av_mallocz(ac_str_size);
2177  if (!ac_str)
2178  return AVERROR(ENOMEM);
2179  av_strlcpy(ac_str, "ac", 3);
2180  if (stream_str)
2181  av_strlcat(ac_str, stream_str, ac_str_size);
2182  ret = parse_option(o, ac_str, layout_str, options);
2183  av_free(ac_str);
2184 
2185  return ret;
2186 }
2187 
2188 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2189 {
2190  OptionsContext *o = optctx;
2191  return parse_option(o, "q:a", arg, options);
2192 }
2193 
2194 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2195 {
2197  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2198  return AVERROR(ENOMEM);
2201  return 0;
2202 }
2203 
2204 void show_help_default(const char *opt, const char *arg)
2205 {
2206  /* per-file options have at least one of those set */
2207  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2208  int show_advanced = 0, show_avoptions = 0;
2209 
2210  if (opt && *opt) {
2211  if (!strcmp(opt, "long"))
2212  show_advanced = 1;
2213  else if (!strcmp(opt, "full"))
2214  show_advanced = show_avoptions = 1;
2215  else
2216  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2217  }
2218 
2219  show_usage();
2220 
2221  printf("Getting help:\n"
2222  " -h -- print basic options\n"
2223  " -h long -- print more options\n"
2224  " -h full -- print all options (including all format and codec specific options, very long)\n"
2225  " See man %s for detailed description of the options.\n"
2226  "\n", program_name);
2227 
2228  show_help_options(options, "Print help / information / capabilities:",
2229  OPT_EXIT, 0, 0);
2230 
2231  show_help_options(options, "Global options (affect whole program "
2232  "instead of just one file:",
2233  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2234  if (show_advanced)
2235  show_help_options(options, "Advanced global options:", OPT_EXPERT,
2236  per_file | OPT_EXIT, 0);
2237 
2238  show_help_options(options, "Per-file main options:", 0,
2240  OPT_EXIT, per_file);
2241  if (show_advanced)
2242  show_help_options(options, "Advanced per-file options:",
2243  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2244 
2245  show_help_options(options, "Video options:",
2247  if (show_advanced)
2248  show_help_options(options, "Advanced Video options:",
2250 
2251  show_help_options(options, "Audio options:",
2253  if (show_advanced)
2254  show_help_options(options, "Advanced Audio options:",
2256  show_help_options(options, "Subtitle options:",
2257  OPT_SUBTITLE, 0, 0);
2258  printf("\n");
2259 
2260  if (show_avoptions) {
2267  }
2268 }
2269 
2270 void show_usage(void)
2271 {
2272  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2273  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2274  av_log(NULL, AV_LOG_INFO, "\n");
2275 }
2276 
2277 enum OptGroup {
2280 };
2281 
2282 static const OptionGroupDef groups[] = {
2283  [GROUP_OUTFILE] = { "output file", NULL },
2284  [GROUP_INFILE] = { "input file", "i" },
2285 };
2286 
2287 static int open_files(OptionGroupList *l, const char *inout,
2288  int (*open_file)(OptionsContext*, const char*))
2289 {
2290  int i, ret;
2291 
2292  for (i = 0; i < l->nb_groups; i++) {
2293  OptionGroup *g = &l->groups[i];
2294  OptionsContext o;
2295 
2296  init_options(&o, !strcmp(inout, "input"));
2297  o.g = g;
2298 
2299  ret = parse_optgroup(&o, g);
2300  if (ret < 0) {
2301  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2302  "%s.\n", inout, g->arg);
2303  return ret;
2304  }
2305 
2306  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2307  ret = open_file(&o, g->arg);
2308  uninit_options(&o, !strcmp(inout, "input"));
2309  if (ret < 0) {
2310  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2311  inout, g->arg);
2312  return ret;
2313  }
2314  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2315  }
2316 
2317  return 0;
2318 }
2319 
2320 int ffmpeg_parse_options(int argc, char **argv)
2321 {
2322  OptionParseContext octx;
2323  uint8_t error[128];
2324  int ret;
2325 
2326  memset(&octx, 0, sizeof(octx));
2327 
2328  /* split the commandline into an internal representation */
2329  ret = split_commandline(&octx, argc, argv, options, groups,
2330  FF_ARRAY_ELEMS(groups));
2331  if (ret < 0) {
2332  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2333  goto fail;
2334  }
2335 
2336  /* apply global options */
2337  ret = parse_optgroup(NULL, &octx.global_opts);
2338  if (ret < 0) {
2339  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2340  goto fail;
2341  }
2342 
2343  /* open input files */
2344  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2345  if (ret < 0) {
2346  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2347  goto fail;
2348  }
2349 
2350  /* open output files */
2351  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2352  if (ret < 0) {
2353  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2354  goto fail;
2355  }
2356 
2357 fail:
2358  uninit_parse_context(&octx);
2359  if (ret < 0) {
2360  av_strerror(ret, error, sizeof(error));
2361  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2362  }
2363  return ret;
2364 }
2365 
2366 static int opt_progress(void *optctx, const char *opt, const char *arg)
2367 {
2368  AVIOContext *avio = NULL;
2369  int ret;
2370 
2371  if (!strcmp(arg, "-"))
2372  arg = "pipe:";
2373  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2374  if (ret < 0) {
2375  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2376  arg, av_err2str(ret));
2377  return ret;
2378  }
2379  progress_avio = avio;
2380  return 0;
2381 }
2382 
2383 #define OFFSET(x) offsetof(OptionsContext, x)
2384 const OptionDef options[] = {
2385  /* main options */
2386 #include "cmdutils_common_opts.h"
2387  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2388  "force format", "fmt" },
2389  { "y", OPT_BOOL, { &file_overwrite },
2390  "overwrite output files" },
2391  { "n", OPT_BOOL, { &no_file_overwrite },
2392  "do not overwrite output files" },
2393  { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2394  "codec name", "codec" },
2395  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2396  "codec name", "codec" },
2397  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2398  "preset name", "preset" },
2399  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2400  "set input stream mapping",
2401  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2402  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2403  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2404  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2405  "set metadata information of outfile from infile",
2406  "outfile[,metadata]:infile[,metadata]" },
2407  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2408  "set chapters mapping", "input_file_index" },
2409  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2410  "record or transcode \"duration\" seconds of audio/video",
2411  "duration" },
2412  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(stop_time) },
2413  "record or transcode stop time", "time_stop" },
2414  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2415  "set the limit file size in bytes", "limit_size" },
2416  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2417  "set the start time offset", "time_off" },
2418  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2419  "set the input ts offset", "time_off" },
2420  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2421  "set the input ts scale", "scale" },
2422  { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2423  "set the recording timestamp ('now' to set the current time)", "time" },
2424  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2425  "add metadata", "string=string" },
2426  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2427  "set the number of data frames to record", "number" },
2428  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2429  "add timings for benchmarking" },
2430  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2431  "add timings for each task" },
2432  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2433  "write program-readable progress information", "url" },
2434  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2435  "enable or disable interaction on standard input" },
2436  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2437  "set max runtime in seconds", "limit" },
2438  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2439  "dump each input packet" },
2440  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2441  "when dumping packets, also dump the payload" },
2442  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2443  "read input at native frame rate", "" },
2444  { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2445  "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2446  " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2447  { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2448  "video sync method", "" },
2449  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2450  "audio sync method", "" },
2451  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2452  "audio drift threshold", "threshold" },
2453  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2454  "copy timestamps" },
2455  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
2456  "copy input stream time base when stream copying", "mode" },
2457  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2458  "finish encoding within shortest input" },
2459  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2460  "timestamp discontinuity delta threshold", "threshold" },
2461  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2462  "timestamp error delta threshold", "threshold" },
2463  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2464  "exit on error", "error" },
2465  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2466  "copy initial non-keyframes" },
2467  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2468  "copy or discard frames before start time" },
2469  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2470  "set the number of frames to record", "number" },
2471  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2472  "force codec tag/fourcc", "fourcc/tag" },
2473  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2474  "use fixed quality scale (VBR)", "q" },
2475  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2476  "use fixed quality scale (VBR)", "q" },
2477  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2478  "set profile", "profile" },
2479  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2480  "set stream filtergraph", "filter_graph" },
2481  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2482  "reinit filtergraph on input parameter changes", "" },
2483  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2484  "create a complex filtergraph", "graph_description" },
2485  { "stats", OPT_BOOL, { &print_stats },
2486  "print progress report during encoding", },
2487  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2488  "add an attachment to the output file", "filename" },
2489  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2490  "extract an attachment into a file", "filename" },
2491  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2492  "print timestamp debugging info" },
2493 
2494  /* video options */
2495  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2496  "set the number of video frames to record", "number" },
2497  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2498  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2499  { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2500  "set frame size (WxH or abbreviation)", "size" },
2501  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2502  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2503  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2504  "set pixel format", "format" },
2505  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2506  "set the number of bits per raw sample", "number" },
2507  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2508  "deprecated use -g 1" },
2509  { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2510  "disable video" },
2511  { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2512  "discard threshold", "n" },
2513  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2514  "rate control override for specific intervals", "override" },
2515  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2516  "force video codec ('copy' to copy stream)", "codec" },
2517  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2518  "Removed" },
2519  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2520  "Removed" },
2521  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2522  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2523  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2524  "select the pass number (1 to 3)", "n" },
2525  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2526  "select two pass log file name prefix", "prefix" },
2527 #if FF_API_DEINTERLACE
2528  { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2529  "this option is deprecated, use the yadif filter instead" },
2530 #endif
2531  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2532  "calculate PSNR of compressed frames" },
2533  { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2534  "dump video coding statistics to file" },
2535  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2536  "dump video coding statistics to file", "file" },
2537  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2538  "set video filters", "filter_graph" },
2539  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2540  "specify intra matrix coeffs", "matrix" },
2541  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2542  "specify inter matrix coeffs", "matrix" },
2543  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2544  "top=1/bottom=0/auto=-1 field first", "" },
2545  { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2546  "intra_dc_precision", "precision" },
2547  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2548  "force video tag/fourcc", "fourcc/tag" },
2549  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2550  "show QP histogram" },
2551  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2552  "force the selected framerate, disable the best supported framerate selection" },
2553  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2554  "set the value of an outfile streamid", "streamIndex:value" },
2555  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2556  { .off = OFFSET(forced_key_frames) },
2557  "force key frames at specified timestamps", "timestamps" },
2558  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2559  "video bitrate (please use -b:v)", "bitrate" },
2560 
2561  /* audio options */
2562  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2563  "set the number of audio frames to record", "number" },
2564  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2565  "set audio quality (codec-specific)", "quality", },
2566  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2567  "set audio sampling rate (in Hz)", "rate" },
2568  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2569  "set number of audio channels", "channels" },
2570  { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2571  "disable audio" },
2572  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2573  "force audio codec ('copy' to copy stream)", "codec" },
2574  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2575  "force audio tag/fourcc", "fourcc/tag" },
2576  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2577  "change audio volume (256=normal)" , "volume" },
2578  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2579  "set sample format", "format" },
2580  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2581  "set channel layout", "layout" },
2582  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2583  "set audio filters", "filter_graph" },
2584  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(guess_layout_max) },
2585  "set the maximum number of channels to try to guess the channel layout" },
2586 
2587  /* subtitle options */
2588  { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2589  "disable subtitle" },
2590  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2591  "force subtitle codec ('copy' to copy stream)", "codec" },
2592  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2593  , "force subtitle tag/fourcc", "fourcc/tag" },
2594  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2595  "fix subtitles duration" },
2596 
2597  /* grab options */
2598  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2599  "deprecated, use -channel", "channel" },
2600  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2601  "deprecated, use -standard", "standard" },
2602  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2603 
2604  /* muxer options */
2605  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2606  "set the maximum demux-decode delay", "seconds" },
2607  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2608  "set the initial demux-decode delay", "seconds" },
2609 
2610  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2611  "A comma-separated list of bitstream filters", "bitstream_filters" },
2612  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2613  "deprecated", "audio bitstream_filters" },
2614  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2615  "deprecated", "video bitstream_filters" },
2616 
2617  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2618  "set the audio options to the indicated preset", "preset" },
2619  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2620  "set the video options to the indicated preset", "preset" },
2621  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2622  "set the subtitle options to the indicated preset", "preset" },
2623  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2624  "set options from indicated preset file", "filename" },
2625  /* data codec support */
2626  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2627  "force data codec ('copy' to copy stream)", "codec" },
2628  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2629  "disable data" },
2630 
2631  { NULL, },
2632 };