FFmpeg
 All Data Structures Namespaces 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"
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43 
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
45 {\
46  int i, ret;\
47  for (i = 0; i < o->nb_ ## name; i++) {\
48  char *spec = o->name[i].specifier;\
49  if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50  outvar = o->name[i].u.type;\
51  else if (ret < 0)\
52  exit_program(1);\
53  }\
54 }
55 
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
57 {\
58  int i;\
59  for (i = 0; i < o->nb_ ## name; i++) {\
60  char *spec = o->name[i].specifier;\
61  if (!strcmp(spec, mediatype))\
62  outvar = o->name[i].u.type;\
63  }\
64 }
65 
66 const HWAccel hwaccels[] = {
67 #if HAVE_VDPAU_X11
69 #endif
70 #if HAVE_DXVA2_LIB
72 #endif
73 #if CONFIG_VDA
74  { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
75 #endif
76  { 0 },
77 };
78 
81 
84 float dts_error_threshold = 3600*30;
85 
86 int audio_volume = 256;
90 int do_benchmark = 0;
92 int do_hex_dump = 0;
93 int do_pkt_dump = 0;
94 int copy_ts = 0;
95 int start_at_zero = 0;
96 int copy_tb = -1;
97 int debug_ts = 0;
98 int exit_on_error = 0;
99 int print_stats = -1;
100 int qp_hist = 0;
103 float max_error_rate = 2.0/3;
104 
105 
106 static int intra_only = 0;
107 static int file_overwrite = 0;
108 static int no_file_overwrite = 0;
109 static int do_psnr = 0;
110 static int input_sync;
111 static int override_ffserver = 0;
112 
114 {
115  const OptionDef *po = options;
116  int i;
117 
118  /* all OPT_SPEC and OPT_STRING can be freed in generic way */
119  while (po->name) {
120  void *dst = (uint8_t*)o + po->u.off;
121 
122  if (po->flags & OPT_SPEC) {
123  SpecifierOpt **so = dst;
124  int i, *count = (int*)(so + 1);
125  for (i = 0; i < *count; i++) {
126  av_freep(&(*so)[i].specifier);
127  if (po->flags & OPT_STRING)
128  av_freep(&(*so)[i].u.str);
129  }
130  av_freep(so);
131  *count = 0;
132  } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
133  av_freep(dst);
134  po++;
135  }
136 
137  for (i = 0; i < o->nb_stream_maps; i++)
139  av_freep(&o->stream_maps);
141  av_freep(&o->streamid_map);
142  av_freep(&o->attachments);
143 }
144 
146 {
147  memset(o, 0, sizeof(*o));
148 
149  o->stop_time = INT64_MAX;
150  o->mux_max_delay = 0.7;
152  o->recording_time = INT64_MAX;
153  o->limit_filesize = UINT64_MAX;
154  o->chapters_input_file = INT_MAX;
155  o->accurate_seek = 1;
156 }
157 
158 /* return a copy of the input with the stream specifiers removed from the keys */
160 {
161  AVDictionaryEntry *e = NULL;
162  AVDictionary *ret = NULL;
163 
164  while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
165  char *p = strchr(e->key, ':');
166 
167  if (p)
168  *p = 0;
169  av_dict_set(&ret, e->key, e->value, 0);
170  if (p)
171  *p = ':';
172  }
173  return ret;
174 }
175 
176 static int opt_sameq(void *optctx, const char *opt, const char *arg)
177 {
178  av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
179  "If you are looking for an option to preserve the quality (which is not "
180  "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
181  opt, opt);
182  return AVERROR(EINVAL);
183 }
184 
185 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
186 {
187  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
188  return opt_default(optctx, "channel", arg);
189 }
190 
191 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
192 {
193  av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
194  return opt_default(optctx, "standard", arg);
195 }
196 
197 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
198 {
199  OptionsContext *o = optctx;
200  return parse_option(o, "codec:a", arg, options);
201 }
202 
203 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
204 {
205  OptionsContext *o = optctx;
206  return parse_option(o, "codec:v", arg, options);
207 }
208 
209 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
210 {
211  OptionsContext *o = optctx;
212  return parse_option(o, "codec:s", arg, options);
213 }
214 
215 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
216 {
217  OptionsContext *o = optctx;
218  return parse_option(o, "codec:d", arg, options);
219 }
220 
221 static int opt_map(void *optctx, const char *opt, const char *arg)
222 {
223  OptionsContext *o = optctx;
224  StreamMap *m = NULL;
225  int i, negative = 0, file_idx;
226  int sync_file_idx = -1, sync_stream_idx = 0;
227  char *p, *sync;
228  char *map;
229 
230  if (*arg == '-') {
231  negative = 1;
232  arg++;
233  }
234  map = av_strdup(arg);
235  if (!map)
236  return AVERROR(ENOMEM);
237 
238  /* parse sync stream first, just pick first matching stream */
239  if (sync = strchr(map, ',')) {
240  *sync = 0;
241  sync_file_idx = strtol(sync + 1, &sync, 0);
242  if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
243  av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
244  exit_program(1);
245  }
246  if (*sync)
247  sync++;
248  for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
249  if (check_stream_specifier(input_files[sync_file_idx]->ctx,
250  input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
251  sync_stream_idx = i;
252  break;
253  }
254  if (i == input_files[sync_file_idx]->nb_streams) {
255  av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
256  "match any streams.\n", arg);
257  exit_program(1);
258  }
259  }
260 
261 
262  if (map[0] == '[') {
263  /* this mapping refers to lavfi output */
264  const char *c = map + 1;
266  m = &o->stream_maps[o->nb_stream_maps - 1];
267  m->linklabel = av_get_token(&c, "]");
268  if (!m->linklabel) {
269  av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
270  exit_program(1);
271  }
272  } else {
273  file_idx = strtol(map, &p, 0);
274  if (file_idx >= nb_input_files || file_idx < 0) {
275  av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
276  exit_program(1);
277  }
278  if (negative)
279  /* disable some already defined maps */
280  for (i = 0; i < o->nb_stream_maps; i++) {
281  m = &o->stream_maps[i];
282  if (file_idx == m->file_index &&
285  *p == ':' ? p + 1 : p) > 0)
286  m->disabled = 1;
287  }
288  else
289  for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
290  if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
291  *p == ':' ? p + 1 : p) <= 0)
292  continue;
294  m = &o->stream_maps[o->nb_stream_maps - 1];
295 
296  m->file_index = file_idx;
297  m->stream_index = i;
298 
299  if (sync_file_idx >= 0) {
300  m->sync_file_index = sync_file_idx;
301  m->sync_stream_index = sync_stream_idx;
302  } else {
303  m->sync_file_index = file_idx;
304  m->sync_stream_index = i;
305  }
306  }
307  }
308 
309  if (!m) {
310  av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
311  exit_program(1);
312  }
313 
314  av_freep(&map);
315  return 0;
316 }
317 
318 static int opt_attach(void *optctx, const char *opt, const char *arg)
319 {
320  OptionsContext *o = optctx;
322  o->attachments[o->nb_attachments - 1] = arg;
323  return 0;
324 }
325 
326 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
327 {
328  OptionsContext *o = optctx;
329  int n;
330  AVStream *st;
332 
335 
336  /* muted channel syntax */
337  n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
338  if ((n == 1 || n == 3) && m->channel_idx == -1) {
339  m->file_idx = m->stream_idx = -1;
340  if (n == 1)
341  m->ofile_idx = m->ostream_idx = -1;
342  return 0;
343  }
344 
345  /* normal syntax */
346  n = sscanf(arg, "%d.%d.%d:%d.%d",
347  &m->file_idx, &m->stream_idx, &m->channel_idx,
348  &m->ofile_idx, &m->ostream_idx);
349 
350  if (n != 3 && n != 5) {
351  av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
352  "[file.stream.channel|-1][:syncfile:syncstream]\n");
353  exit_program(1);
354  }
355 
356  if (n != 5) // only file.stream.channel specified
357  m->ofile_idx = m->ostream_idx = -1;
358 
359  /* check input */
360  if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
361  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
362  m->file_idx);
363  exit_program(1);
364  }
365  if (m->stream_idx < 0 ||
367  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
368  m->file_idx, m->stream_idx);
369  exit_program(1);
370  }
371  st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
372  if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
373  av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
374  m->file_idx, m->stream_idx);
375  exit_program(1);
376  }
377  if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
378  av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
379  m->file_idx, m->stream_idx, m->channel_idx);
380  exit_program(1);
381  }
382  return 0;
383 }
384 
385 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
386 {
388  sdp_filename = av_strdup(arg);
389  return 0;
390 }
391 
392 /**
393  * Parse a metadata specifier passed as 'arg' parameter.
394  * @param arg metadata string to parse
395  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
396  * @param index for type c/p, chapter/program index is written here
397  * @param stream_spec for type s, the stream specifier is written here
398  */
399 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
400 {
401  if (*arg) {
402  *type = *arg;
403  switch (*arg) {
404  case 'g':
405  break;
406  case 's':
407  if (*(++arg) && *arg != ':') {
408  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
409  exit_program(1);
410  }
411  *stream_spec = *arg == ':' ? arg + 1 : "";
412  break;
413  case 'c':
414  case 'p':
415  if (*(++arg) == ':')
416  *index = strtol(++arg, NULL, 0);
417  break;
418  default:
419  av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
420  exit_program(1);
421  }
422  } else
423  *type = 'g';
424 }
425 
426 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
427 {
428  AVDictionary **meta_in = NULL;
429  AVDictionary **meta_out = NULL;
430  int i, ret = 0;
431  char type_in, type_out;
432  const char *istream_spec = NULL, *ostream_spec = NULL;
433  int idx_in = 0, idx_out = 0;
434 
435  parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
436  parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
437 
438  if (!ic) {
439  if (type_out == 'g' || !*outspec)
440  o->metadata_global_manual = 1;
441  if (type_out == 's' || !*outspec)
443  if (type_out == 'c' || !*outspec)
445  return 0;
446  }
447 
448  if (type_in == 'g' || type_out == 'g')
449  o->metadata_global_manual = 1;
450  if (type_in == 's' || type_out == 's')
452  if (type_in == 'c' || type_out == 'c')
454 
455  /* ic is NULL when just disabling automatic mappings */
456  if (!ic)
457  return 0;
458 
459 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
460  if ((index) < 0 || (index) >= (nb_elems)) {\
461  av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
462  (desc), (index));\
463  exit_program(1);\
464  }
465 
466 #define SET_DICT(type, meta, context, index)\
467  switch (type) {\
468  case 'g':\
469  meta = &context->metadata;\
470  break;\
471  case 'c':\
472  METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
473  meta = &context->chapters[index]->metadata;\
474  break;\
475  case 'p':\
476  METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
477  meta = &context->programs[index]->metadata;\
478  break;\
479  case 's':\
480  break; /* handled separately below */ \
481  default: av_assert0(0);\
482  }\
483 
484  SET_DICT(type_in, meta_in, ic, idx_in);
485  SET_DICT(type_out, meta_out, oc, idx_out);
486 
487  /* for input streams choose first matching stream */
488  if (type_in == 's') {
489  for (i = 0; i < ic->nb_streams; i++) {
490  if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
491  meta_in = &ic->streams[i]->metadata;
492  break;
493  } else if (ret < 0)
494  exit_program(1);
495  }
496  if (!meta_in) {
497  av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
498  exit_program(1);
499  }
500  }
501 
502  if (type_out == 's') {
503  for (i = 0; i < oc->nb_streams; i++) {
504  if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
505  meta_out = &oc->streams[i]->metadata;
506  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
507  } else if (ret < 0)
508  exit_program(1);
509  }
510  } else
511  av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
512 
513  return 0;
514 }
515 
516 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
517 {
518  OptionsContext *o = optctx;
519  char buf[128];
520  int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
521  struct tm time = *gmtime((time_t*)&recording_timestamp);
522  if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
523  return -1;
524  parse_option(o, "metadata", buf, options);
525 
526  av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
527  "tag instead.\n", opt);
528  return 0;
529 }
530 
531 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
532 {
533  const AVCodecDescriptor *desc;
534  const char *codec_string = encoder ? "encoder" : "decoder";
535  AVCodec *codec;
536 
537  codec = encoder ?
540 
541  if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
542  codec = encoder ? avcodec_find_encoder(desc->id) :
543  avcodec_find_decoder(desc->id);
544  if (codec)
545  av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
546  codec_string, codec->name, desc->name);
547  }
548 
549  if (!codec) {
550  av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
551  exit_program(1);
552  }
553  if (codec->type != type) {
554  av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
555  exit_program(1);
556  }
557  return codec;
558 }
559 
561 {
562  char *codec_name = NULL;
563 
564  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
565  if (codec_name) {
566  AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
567  st->codec->codec_id = codec->id;
568  return codec;
569  } else
570  return avcodec_find_decoder(st->codec->codec_id);
571 }
572 
573 /* Add all the streams from the given input file to the global
574  * list of input streams. */
576 {
577  int i, ret;
578 
579  for (i = 0; i < ic->nb_streams; i++) {
580  AVStream *st = ic->streams[i];
581  AVCodecContext *dec = st->codec;
582  InputStream *ist = av_mallocz(sizeof(*ist));
583  char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
584  char *codec_tag = NULL;
585  char *next;
586  char *discard_str = NULL;
587  const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
588 
589  if (!ist)
590  exit_program(1);
591 
593  input_streams[nb_input_streams - 1] = ist;
594 
595  ist->st = st;
596  ist->file_index = nb_input_files;
597  ist->discard = 1;
598  st->discard = AVDISCARD_ALL;
599 
600  ist->ts_scale = 1.0;
601  MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
602 
603  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
604  if (codec_tag) {
605  uint32_t tag = strtol(codec_tag, &next, 0);
606  if (*next)
607  tag = AV_RL32(codec_tag);
608  st->codec->codec_tag = tag;
609  }
610 
611  ist->dec = choose_decoder(o, ic, st);
612  ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
613 
614  ist->reinit_filters = -1;
615  MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
616 
617  MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
619  if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
620  av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
621  discard_str);
622  exit_program(1);
623  }
624 
626 
627  ist->dec_ctx = avcodec_alloc_context3(ist->dec);
628  if (!ist->dec_ctx) {
629  av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
630  exit_program(1);
631  }
632 
633  ret = avcodec_copy_context(ist->dec_ctx, dec);
634  if (ret < 0) {
635  av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
636  exit_program(1);
637  }
638 
639  switch (dec->codec_type) {
640  case AVMEDIA_TYPE_VIDEO:
641  if(!ist->dec)
642  ist->dec = avcodec_find_decoder(dec->codec_id);
643  if (av_codec_get_lowres(dec)) {
644  dec->flags |= CODEC_FLAG_EMU_EDGE;
645  }
646 
647  ist->resample_height = ist->dec_ctx->height;
648  ist->resample_width = ist->dec_ctx->width;
649  ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
650 
651  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
652  if (framerate && av_parse_video_rate(&ist->framerate,
653  framerate) < 0) {
654  av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
655  framerate);
656  exit_program(1);
657  }
658 
659  ist->top_field_first = -1;
660  MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
661 
662  MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
663  if (hwaccel) {
664  if (!strcmp(hwaccel, "none"))
665  ist->hwaccel_id = HWACCEL_NONE;
666  else if (!strcmp(hwaccel, "auto"))
667  ist->hwaccel_id = HWACCEL_AUTO;
668  else {
669  int i;
670  for (i = 0; hwaccels[i].name; i++) {
671  if (!strcmp(hwaccels[i].name, hwaccel)) {
672  ist->hwaccel_id = hwaccels[i].id;
673  break;
674  }
675  }
676 
677  if (!ist->hwaccel_id) {
678  av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
679  hwaccel);
680  av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
681  for (i = 0; hwaccels[i].name; i++)
682  av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
683  av_log(NULL, AV_LOG_FATAL, "\n");
684  exit_program(1);
685  }
686  }
687  }
688 
689  MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
690  if (hwaccel_device) {
691  ist->hwaccel_device = av_strdup(hwaccel_device);
692  if (!ist->hwaccel_device)
693  exit_program(1);
694  }
696 
697  break;
698  case AVMEDIA_TYPE_AUDIO:
699  ist->guess_layout_max = INT_MAX;
700  MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
702 
705  ist->resample_channels = ist->dec_ctx->channels;
707 
708  break;
709  case AVMEDIA_TYPE_DATA:
710  case AVMEDIA_TYPE_SUBTITLE: {
711  char *canvas_size = NULL;
712  if(!ist->dec)
713  ist->dec = avcodec_find_decoder(dec->codec_id);
714  MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
715  MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
716  if (canvas_size &&
717  av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
718  av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
719  exit_program(1);
720  }
721  break;
722  }
725  break;
726  default:
727  abort();
728  }
729  }
730 }
731 
732 static void assert_file_overwrite(const char *filename)
733 {
735  fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
736  exit_program(1);
737  }
738 
739  if (!file_overwrite) {
740  const char *proto_name = avio_find_protocol_name(filename);
741  if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
743  fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
744  fflush(stderr);
745  term_exit();
746  signal(SIGINT, SIG_DFL);
747  if (!read_yesno()) {
748  av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
749  exit_program(1);
750  }
751  term_init();
752  }
753  else {
754  av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
755  exit_program(1);
756  }
757  }
758  }
759 }
760 
761 static void dump_attachment(AVStream *st, const char *filename)
762 {
763  int ret;
764  AVIOContext *out = NULL;
766 
767  if (!st->codec->extradata_size) {
768  av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
769  nb_input_files - 1, st->index);
770  return;
771  }
772  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
773  filename = e->value;
774  if (!*filename) {
775  av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
776  "in stream #%d:%d.\n", nb_input_files - 1, st->index);
777  exit_program(1);
778  }
779 
780  assert_file_overwrite(filename);
781 
782  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
783  av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
784  filename);
785  exit_program(1);
786  }
787 
788  avio_write(out, st->codec->extradata, st->codec->extradata_size);
789  avio_flush(out);
790  avio_close(out);
791 }
792 
793 static int open_input_file(OptionsContext *o, const char *filename)
794 {
795  InputFile *f;
796  AVFormatContext *ic;
797  AVInputFormat *file_iformat = NULL;
798  int err, i, ret;
799  int64_t timestamp;
800  AVDictionary **opts;
801  AVDictionary *unused_opts = NULL;
802  AVDictionaryEntry *e = NULL;
803  int orig_nb_streams; // number of streams before avformat_find_stream_info
804  char * video_codec_name = NULL;
805  char * audio_codec_name = NULL;
806  char *subtitle_codec_name = NULL;
807  char * data_codec_name = NULL;
808  int scan_all_pmts_set = 0;
809 
810  if (o->format) {
811  if (!(file_iformat = av_find_input_format(o->format))) {
812  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
813  exit_program(1);
814  }
815  }
816 
817  if (!strcmp(filename, "-"))
818  filename = "pipe:";
819 
820  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
821  strcmp(filename, "/dev/stdin");
822 
823  /* get default parameters from command line */
824  ic = avformat_alloc_context();
825  if (!ic) {
826  print_error(filename, AVERROR(ENOMEM));
827  exit_program(1);
828  }
829  if (o->nb_audio_sample_rate) {
830  av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
831  }
832  if (o->nb_audio_channels) {
833  /* because we set audio_channels based on both the "ac" and
834  * "channel_layout" options, we need to check that the specified
835  * demuxer actually has the "channels" option before setting it */
836  if (file_iformat && file_iformat->priv_class &&
837  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
839  av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
840  }
841  }
842  if (o->nb_frame_rates) {
843  /* set the format-level framerate option;
844  * this is important for video grabbers, e.g. x11 */
845  if (file_iformat && file_iformat->priv_class &&
846  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
848  av_dict_set(&o->g->format_opts, "framerate",
849  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
850  }
851  }
852  if (o->nb_frame_sizes) {
853  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
854  }
855  if (o->nb_frame_pix_fmts)
856  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
857 
858  MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
859  MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
860  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
861 
862  ic->video_codec_id = video_codec_name ?
863  find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
864  ic->audio_codec_id = audio_codec_name ?
865  find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
866  ic->subtitle_codec_id= subtitle_codec_name ?
867  find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
868  ic->data_codec_id = data_codec_name ?
869  find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
870 
871  if (video_codec_name)
872  av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
873  if (audio_codec_name)
874  av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
875  if (subtitle_codec_name)
877  if (data_codec_name)
879 
880  ic->flags |= AVFMT_FLAG_NONBLOCK;
882 
883  if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
884  av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
885  scan_all_pmts_set = 1;
886  }
887  /* open the input file with generic avformat function */
888  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
889  if (err < 0) {
890  print_error(filename, err);
891  exit_program(1);
892  }
893  if (scan_all_pmts_set)
894  av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
897 
898  /* apply forced codec ids */
899  for (i = 0; i < ic->nb_streams; i++)
900  choose_decoder(o, ic, ic->streams[i]);
901 
902  /* Set AVCodecContext options for avformat_find_stream_info */
903  opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
904  orig_nb_streams = ic->nb_streams;
905 
906  /* If not enough info to get the stream parameters, we decode the
907  first frames to get it. (used in mpeg case for example) */
908  ret = avformat_find_stream_info(ic, opts);
909  if (ret < 0) {
910  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
911  if (ic->nb_streams == 0) {
913  exit_program(1);
914  }
915  }
916 
917  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
918  /* add the stream start time */
919  if (ic->start_time != AV_NOPTS_VALUE)
920  timestamp += ic->start_time;
921 
922  /* if seeking requested, we execute it */
923  if (o->start_time != AV_NOPTS_VALUE) {
924  ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
925  if (ret < 0) {
926  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
927  filename, (double)timestamp / AV_TIME_BASE);
928  }
929  }
930 
931  /* update the current parameters so that they match the one of the input stream */
932  add_input_streams(o, ic);
933 
934  /* dump the file content */
935  av_dump_format(ic, nb_input_files, filename, 0);
936 
938  f = av_mallocz(sizeof(*f));
939  if (!f)
940  exit_program(1);
941  input_files[nb_input_files - 1] = f;
942 
943  f->ctx = ic;
945  f->start_time = o->start_time;
948  f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
949  f->nb_streams = ic->nb_streams;
950  f->rate_emu = o->rate_emu;
952 
953  /* check if all codec options have been used */
954  unused_opts = strip_specifiers(o->g->codec_opts);
955  for (i = f->ist_index; i < nb_input_streams; i++) {
956  e = NULL;
957  while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
959  av_dict_set(&unused_opts, e->key, NULL, 0);
960  }
961 
962  e = NULL;
963  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
964  const AVClass *class = avcodec_get_class();
965  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
967  const AVClass *fclass = avformat_get_class();
968  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
970  if (!option || foption)
971  continue;
972 
973 
974  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
975  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
976  "input file #%d (%s) is not a decoding option.\n", e->key,
977  option->help ? option->help : "", nb_input_files - 1,
978  filename);
979  exit_program(1);
980  }
981 
982  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
983  "input file #%d (%s) has not been used for any stream. The most "
984  "likely reason is either wrong type (e.g. a video option with "
985  "no video streams) or that it is a private option of some decoder "
986  "which was not actually used for any stream.\n", e->key,
987  option->help ? option->help : "", nb_input_files - 1, filename);
988  }
989  av_dict_free(&unused_opts);
990 
991  for (i = 0; i < o->nb_dump_attachment; i++) {
992  int j;
993 
994  for (j = 0; j < ic->nb_streams; j++) {
995  AVStream *st = ic->streams[j];
996 
997  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
999  }
1000  }
1001 
1002  for (i = 0; i < orig_nb_streams; i++)
1003  av_dict_free(&opts[i]);
1004  av_freep(&opts);
1005 
1006  return 0;
1007 }
1008 
1010 {
1011  AVIOContext *line;
1012  uint8_t *buf;
1013  char c;
1014 
1015  if (avio_open_dyn_buf(&line) < 0) {
1016  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1017  exit_program(1);
1018  }
1019 
1020  while ((c = avio_r8(s)) && c != '\n')
1021  avio_w8(line, c);
1022  avio_w8(line, 0);
1023  avio_close_dyn_buf(line, &buf);
1024 
1025  return buf;
1026 }
1027 
1028 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1029 {
1030  int i, ret = -1;
1031  char filename[1000];
1032  const char *base[3] = { getenv("AVCONV_DATADIR"),
1033  getenv("HOME"),
1034  AVCONV_DATADIR,
1035  };
1036 
1037  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1038  if (!base[i])
1039  continue;
1040  if (codec_name) {
1041  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1042  i != 1 ? "" : "/.avconv", codec_name, preset_name);
1043  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1044  }
1045  if (ret < 0) {
1046  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1047  i != 1 ? "" : "/.avconv", preset_name);
1048  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1049  }
1050  }
1051  return ret;
1052 }
1053 
1055 {
1056  char *codec_name = NULL;
1057 
1058  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1059  if (!codec_name) {
1060  ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1061  NULL, ost->st->codec->codec_type);
1062  ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1063  } else if (!strcmp(codec_name, "copy"))
1064  ost->stream_copy = 1;
1065  else {
1066  ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1067  ost->st->codec->codec_id = ost->enc->id;
1068  }
1069 }
1070 
1072 {
1073  OutputStream *ost;
1074  AVStream *st = avformat_new_stream(oc, NULL);
1075  int idx = oc->nb_streams - 1, ret = 0;
1076  char *bsf = NULL, *next, *codec_tag = NULL;
1077  AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1078  double qscale = -1;
1079  int i;
1080 
1081  if (!st) {
1082  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1083  exit_program(1);
1084  }
1085 
1086  if (oc->nb_streams - 1 < o->nb_streamid_map)
1087  st->id = o->streamid_map[oc->nb_streams - 1];
1088 
1090  if (!(ost = av_mallocz(sizeof(*ost))))
1091  exit_program(1);
1092  output_streams[nb_output_streams - 1] = ost;
1093 
1094  ost->file_index = nb_output_files - 1;
1095  ost->index = idx;
1096  ost->st = st;
1097  st->codec->codec_type = type;
1098  choose_encoder(o, oc, ost);
1099 
1100  ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1101  if (!ost->enc_ctx) {
1102  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1103  exit_program(1);
1104  }
1105  ost->enc_ctx->codec_type = type;
1106 
1107  if (ost->enc) {
1108  AVIOContext *s = NULL;
1109  char *buf = NULL, *arg = NULL, *preset = NULL;
1110 
1111  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1112 
1113  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1114  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1115  do {
1116  buf = get_line(s);
1117  if (!buf[0] || buf[0] == '#') {
1118  av_free(buf);
1119  continue;
1120  }
1121  if (!(arg = strchr(buf, '='))) {
1122  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1123  exit_program(1);
1124  }
1125  *arg++ = 0;
1127  av_free(buf);
1128  } while (!s->eof_reached);
1129  avio_closep(&s);
1130  }
1131  if (ret) {
1132  av_log(NULL, AV_LOG_FATAL,
1133  "Preset %s specified for stream %d:%d, but could not be opened.\n",
1134  preset, ost->file_index, ost->index);
1135  exit_program(1);
1136  }
1137  } else {
1138  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1139  }
1140 
1141  ost->max_frames = INT64_MAX;
1142  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1143  for (i = 0; i<o->nb_max_frames; i++) {
1144  char *p = o->max_frames[i].specifier;
1145  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1146  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1147  break;
1148  }
1149  }
1150 
1151  ost->copy_prior_start = -1;
1152  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1153 
1154  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1155  while (bsf) {
1156  char *arg = NULL;
1157  if (next = strchr(bsf, ','))
1158  *next++ = 0;
1159  if (arg = strchr(bsf, '='))
1160  *arg++ = 0;
1161  if (!(bsfc = av_bitstream_filter_init(bsf))) {
1162  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1163  exit_program(1);
1164  }
1165  if (bsfc_prev)
1166  bsfc_prev->next = bsfc;
1167  else
1168  ost->bitstream_filters = bsfc;
1169  av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1170 
1171  bsfc_prev = bsfc;
1172  bsf = next;
1173  }
1174 
1175  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1176  if (codec_tag) {
1177  uint32_t tag = strtol(codec_tag, &next, 0);
1178  if (*next)
1179  tag = AV_RL32(codec_tag);
1180  ost->enc_ctx->codec_tag = tag;
1181  }
1182 
1183  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1184  if (qscale >= 0) {
1185  ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1186  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1187  }
1188 
1189  MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1190  ost->disposition = av_strdup(ost->disposition);
1191 
1192  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1194 
1195  av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1196 
1197  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1198  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1199  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1200 
1201  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1202 
1203  ost->source_index = source_index;
1204  if (source_index >= 0) {
1205  ost->sync_ist = input_streams[source_index];
1206  input_streams[source_index]->discard = 0;
1207  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1208  }
1210 
1211  return ost;
1212 }
1213 
1214 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1215 {
1216  int i;
1217  const char *p = str;
1218  for (i = 0;; i++) {
1219  dest[i] = atoi(p);
1220  if (i == 63)
1221  break;
1222  p = strchr(p, ',');
1223  if (!p) {
1224  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1225  exit_program(1);
1226  }
1227  p++;
1228  }
1229 }
1230 
1231 /* read file contents into a string */
1232 static uint8_t *read_file(const char *filename)
1233 {
1234  AVIOContext *pb = NULL;
1235  AVIOContext *dyn_buf = NULL;
1236  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1237  uint8_t buf[1024], *str;
1238 
1239  if (ret < 0) {
1240  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1241  return NULL;
1242  }
1243 
1244  ret = avio_open_dyn_buf(&dyn_buf);
1245  if (ret < 0) {
1246  avio_closep(&pb);
1247  return NULL;
1248  }
1249  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1250  avio_write(dyn_buf, buf, ret);
1251  avio_w8(dyn_buf, 0);
1252  avio_closep(&pb);
1253 
1254  ret = avio_close_dyn_buf(dyn_buf, &str);
1255  if (ret < 0)
1256  return NULL;
1257  return str;
1258 }
1259 
1261  OutputStream *ost)
1262 {
1263  AVStream *st = ost->st;
1264 
1265  if (ost->filters_script && ost->filters) {
1266  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1267  "output stream #%d:%d.\n", nb_output_files, st->index);
1268  exit_program(1);
1269  }
1270 
1271  if (ost->filters_script)
1272  return read_file(ost->filters_script);
1273  else if (ost->filters)
1274  return av_strdup(ost->filters);
1275 
1276  return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1277  "null" : "anull");
1278 }
1279 
1281  const OutputStream *ost, enum AVMediaType type)
1282 {
1283  if (ost->filters_script || ost->filters) {
1284  av_log(NULL, AV_LOG_ERROR,
1285  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1286  "Filtering and streamcopy cannot be used together.\n",
1287  ost->filters ? "Filtergraph" : "Filtergraph script",
1288  ost->filters ? ost->filters : ost->filters_script,
1289  av_get_media_type_string(type), ost->file_index, ost->index);
1290  exit_program(1);
1291  }
1292 }
1293 
1295 {
1296  AVStream *st;
1297  OutputStream *ost;
1298  AVCodecContext *video_enc;
1299  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1300 
1301  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1302  st = ost->st;
1303  video_enc = ost->enc_ctx;
1304 
1305  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1306  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1307  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1308  exit_program(1);
1309  }
1310  if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1311  av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1312 
1313  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1314  if (frame_aspect_ratio) {
1315  AVRational q;
1316  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1317  q.num <= 0 || q.den <= 0) {
1318  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1319  exit_program(1);
1320  }
1321  ost->frame_aspect_ratio = q;
1322  }
1323 
1324  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1325  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1326 
1327  if (!ost->stream_copy) {
1328  const char *p = NULL;
1329  char *frame_size = NULL;
1330  char *frame_pix_fmt = NULL;
1331  char *intra_matrix = NULL, *inter_matrix = NULL;
1332  char *chroma_intra_matrix = NULL;
1333  int do_pass = 0;
1334  int i;
1335 
1336  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1337  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1338  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1339  exit_program(1);
1340  }
1341 
1343  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1344  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1345  ost->keep_pix_fmt = 1;
1346  if (!*++frame_pix_fmt)
1347  frame_pix_fmt = NULL;
1348  }
1349  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1350  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1351  exit_program(1);
1352  }
1353  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1354 
1355  if (intra_only)
1356  video_enc->gop_size = 0;
1357  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1358  if (intra_matrix) {
1359  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1360  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1361  exit_program(1);
1362  }
1363  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1364  }
1365  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1366  if (chroma_intra_matrix) {
1367  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1368  if (!p) {
1369  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1370  exit_program(1);
1371  }
1372  av_codec_set_chroma_intra_matrix(video_enc, p);
1373  parse_matrix_coeffs(p, chroma_intra_matrix);
1374  }
1375  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1376  if (inter_matrix) {
1377  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1378  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1379  exit_program(1);
1380  }
1381  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1382  }
1383 
1384  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1385  for (i = 0; p; i++) {
1386  int start, end, q;
1387  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1388  if (e != 3) {
1389  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1390  exit_program(1);
1391  }
1392  video_enc->rc_override =
1393  av_realloc_array(video_enc->rc_override,
1394  i + 1, sizeof(RcOverride));
1395  if (!video_enc->rc_override)
1396  exit_program(1);
1397  video_enc->rc_override[i].start_frame = start;
1398  video_enc->rc_override[i].end_frame = end;
1399  if (q > 0) {
1400  video_enc->rc_override[i].qscale = q;
1401  video_enc->rc_override[i].quality_factor = 1.0;
1402  }
1403  else {
1404  video_enc->rc_override[i].qscale = 0;
1405  video_enc->rc_override[i].quality_factor = -q/100.0;
1406  }
1407  p = strchr(p, '/');
1408  if (p) p++;
1409  }
1410  video_enc->rc_override_count = i;
1411 
1412  if (do_psnr)
1413  video_enc->flags|= CODEC_FLAG_PSNR;
1414 
1415  /* two pass mode */
1416  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1417  if (do_pass) {
1418  if (do_pass & 1) {
1419  video_enc->flags |= CODEC_FLAG_PASS1;
1420  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1421  }
1422  if (do_pass & 2) {
1423  video_enc->flags |= CODEC_FLAG_PASS2;
1424  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1425  }
1426  }
1427 
1428  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1429  if (ost->logfile_prefix &&
1430  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1431  exit_program(1);
1432 
1433  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1434  if (ost->forced_keyframes)
1436 
1437  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1438 
1439  ost->top_field_first = -1;
1440  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1441 
1442 
1443  ost->avfilter = get_ost_filters(o, oc, ost);
1444  if (!ost->avfilter)
1445  exit_program(1);
1446  } else {
1447  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1448  }
1449 
1450  if (ost->stream_copy)
1452 
1453  return ost;
1454 }
1455 
1457 {
1458  int n;
1459  AVStream *st;
1460  OutputStream *ost;
1461  AVCodecContext *audio_enc;
1462 
1463  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1464  st = ost->st;
1465 
1466  audio_enc = ost->enc_ctx;
1467  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1468 
1469  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1470  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1471 
1472  if (!ost->stream_copy) {
1473  char *sample_fmt = NULL;
1474 
1475  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1476 
1477  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1478  if (sample_fmt &&
1479  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1480  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1481  exit_program(1);
1482  }
1483 
1484  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1485 
1486  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1487  ost->apad = av_strdup(ost->apad);
1488 
1489  ost->avfilter = get_ost_filters(o, oc, ost);
1490  if (!ost->avfilter)
1491  exit_program(1);
1492 
1493  /* check for channel mapping for this audio stream */
1494  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1495  AudioChannelMap *map = &o->audio_channel_maps[n];
1496  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1497  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1498  InputStream *ist;
1499 
1500  if (map->channel_idx == -1) {
1501  ist = NULL;
1502  } else if (ost->source_index < 0) {
1503  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1504  ost->file_index, ost->st->index);
1505  continue;
1506  } else {
1507  ist = input_streams[ost->source_index];
1508  }
1509 
1510  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1512  ost->audio_channels_mapped + 1,
1513  sizeof(*ost->audio_channels_map)
1514  ) < 0 )
1515  exit_program(1);
1516 
1518  }
1519  }
1520  }
1521  }
1522 
1523  if (ost->stream_copy)
1525 
1526  return ost;
1527 }
1528 
1530 {
1531  OutputStream *ost;
1532 
1533  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1534  if (!ost->stream_copy) {
1535  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1536  exit_program(1);
1537  }
1538 
1539  return ost;
1540 }
1541 
1543 {
1544  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1545  ost->stream_copy = 1;
1546  ost->finished = 1;
1547  return ost;
1548 }
1549 
1551 {
1552  AVStream *st;
1553  OutputStream *ost;
1554  AVCodecContext *subtitle_enc;
1555 
1556  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1557  st = ost->st;
1558  subtitle_enc = ost->enc_ctx;
1559 
1560  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1561 
1562  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1563 
1564  if (!ost->stream_copy) {
1565  char *frame_size = NULL;
1566 
1567  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1568  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1569  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1570  exit_program(1);
1571  }
1572  }
1573 
1574  return ost;
1575 }
1576 
1577 /* arg format is "output-stream-index:streamid-value". */
1578 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1579 {
1580  OptionsContext *o = optctx;
1581  int idx;
1582  char *p;
1583  char idx_str[16];
1584 
1585  av_strlcpy(idx_str, arg, sizeof(idx_str));
1586  p = strchr(idx_str, ':');
1587  if (!p) {
1588  av_log(NULL, AV_LOG_FATAL,
1589  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1590  arg, opt);
1591  exit_program(1);
1592  }
1593  *p++ = '\0';
1594  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1595  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1596  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1597  return 0;
1598 }
1599 
1601 {
1602  AVFormatContext *is = ifile->ctx;
1603  AVFormatContext *os = ofile->ctx;
1604  AVChapter **tmp;
1605  int i;
1606 
1607  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1608  if (!tmp)
1609  return AVERROR(ENOMEM);
1610  os->chapters = tmp;
1611 
1612  for (i = 0; i < is->nb_chapters; i++) {
1613  AVChapter *in_ch = is->chapters[i], *out_ch;
1614  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1615  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1616  AV_TIME_BASE_Q, in_ch->time_base);
1617  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1619 
1620 
1621  if (in_ch->end < ts_off)
1622  continue;
1623  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1624  break;
1625 
1626  out_ch = av_mallocz(sizeof(AVChapter));
1627  if (!out_ch)
1628  return AVERROR(ENOMEM);
1629 
1630  out_ch->id = in_ch->id;
1631  out_ch->time_base = in_ch->time_base;
1632  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1633  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1634 
1635  if (copy_metadata)
1636  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1637 
1638  os->chapters[os->nb_chapters++] = out_ch;
1639  }
1640  return 0;
1641 }
1642 
1643 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1644 {
1645  int i, err;
1647 
1648  ic->interrupt_callback = int_cb;
1649  err = avformat_open_input(&ic, filename, NULL, NULL);
1650  if (err < 0)
1651  return err;
1652  /* copy stream format */
1653  for(i=0;i<ic->nb_streams;i++) {
1654  AVStream *st;
1655  OutputStream *ost;
1656  AVCodec *codec;
1657  const char *enc_config;
1658 
1659  codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1660  if (!codec) {
1661  av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1662  return AVERROR(EINVAL);
1663  }
1664  if (codec->type == AVMEDIA_TYPE_AUDIO)
1665  opt_audio_codec(o, "c:a", codec->name);
1666  else if (codec->type == AVMEDIA_TYPE_VIDEO)
1667  opt_video_codec(o, "c:v", codec->name);
1668  ost = new_output_stream(o, s, codec->type, -1);
1669  st = ost->st;
1670 
1673  if (enc_config) {
1674  AVDictionary *opts = NULL;
1675  av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1677  av_dict_free(&opts);
1678  }
1679 
1680  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1681  choose_sample_fmt(st, codec);
1682  else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1683  choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1684  avcodec_copy_context(ost->enc_ctx, st->codec);
1685  if (enc_config)
1686  av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1687  }
1688 
1689  avformat_close_input(&ic);
1690  return err;
1691 }
1692 
1694  AVFormatContext *oc)
1695 {
1696  OutputStream *ost;
1697 
1699  ofilter->out_tmp->pad_idx)) {
1700  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1701  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1702  default:
1703  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1704  "currently.\n");
1705  exit_program(1);
1706  }
1707 
1708  ost->source_index = -1;
1709  ost->filter = ofilter;
1710 
1711  ofilter->ost = ost;
1712 
1713  if (ost->stream_copy) {
1714  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1715  "which is fed from a complex filtergraph. Filtering and streamcopy "
1716  "cannot be used together.\n", ost->file_index, ost->index);
1717  exit_program(1);
1718  }
1719 
1720  if (ost->avfilter && (ost->filters || ost->filters_script)) {
1721  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1722  av_log(NULL, AV_LOG_ERROR,
1723  "%s '%s' was specified through the %s option "
1724  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1725  "%s and -filter_complex cannot be used together for the same stream.\n",
1726  ost->filters ? "Filtergraph" : "Filtergraph script",
1727  ost->filters ? ost->filters : ost->filters_script,
1728  opt, ost->file_index, ost->index, opt);
1729  exit_program(1);
1730  }
1731 
1732  if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1733  av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1734  exit_program(1);
1735  }
1736  avfilter_inout_free(&ofilter->out_tmp);
1737 }
1738 
1740 {
1741  int i, ret = 0;
1742 
1743  for (i = 0; i < nb_filtergraphs; i++)
1744  if (!filtergraphs[i]->graph &&
1745  (ret = configure_filtergraph(filtergraphs[i])) < 0)
1746  return ret;
1747  return 0;
1748 }
1749 
1750 static int open_output_file(OptionsContext *o, const char *filename)
1751 {
1752  AVFormatContext *oc;
1753  int i, j, err;
1754  AVOutputFormat *file_oformat;
1755  OutputFile *of;
1756  OutputStream *ost;
1757  InputStream *ist;
1758  AVDictionary *unused_opts = NULL;
1759  AVDictionaryEntry *e = NULL;
1760 
1761  if (configure_complex_filters() < 0) {
1762  av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1763  exit_program(1);
1764  }
1765 
1766  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1767  o->stop_time = INT64_MAX;
1768  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1769  }
1770 
1771  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1772  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1773  if (o->stop_time <= start_time) {
1774  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1775  exit_program(1);
1776  } else {
1778  }
1779  }
1780 
1782  of = av_mallocz(sizeof(*of));
1783  if (!of)
1784  exit_program(1);
1785  output_files[nb_output_files - 1] = of;
1786 
1788  of->recording_time = o->recording_time;
1789  of->start_time = o->start_time;
1790  of->limit_filesize = o->limit_filesize;
1791  of->shortest = o->shortest;
1792  av_dict_copy(&of->opts, o->g->format_opts, 0);
1793 
1794  if (!strcmp(filename, "-"))
1795  filename = "pipe:";
1796 
1797  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1798  if (!oc) {
1799  print_error(filename, err);
1800  exit_program(1);
1801  }
1802 
1803  of->ctx = oc;
1804  if (o->recording_time != INT64_MAX)
1805  oc->duration = o->recording_time;
1806 
1807  file_oformat= oc->oformat;
1808  oc->interrupt_callback = int_cb;
1809 
1810  /* create streams for all unlabeled output pads */
1811  for (i = 0; i < nb_filtergraphs; i++) {
1812  FilterGraph *fg = filtergraphs[i];
1813  for (j = 0; j < fg->nb_outputs; j++) {
1814  OutputFilter *ofilter = fg->outputs[j];
1815 
1816  if (!ofilter->out_tmp || ofilter->out_tmp->name)
1817  continue;
1818 
1820  ofilter->out_tmp->pad_idx)) {
1821  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1822  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1823  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1824  }
1825  init_output_filter(ofilter, o, oc);
1826  }
1827  }
1828 
1829  /* ffserver seeking with date=... needs a date reference */
1830  if (!strcmp(file_oformat->name, "ffm") &&
1831  av_strstart(filename, "http:", NULL)) {
1832  int err = parse_option(o, "metadata", "creation_time=now", options);
1833  if (err < 0) {
1834  print_error(filename, err);
1835  exit_program(1);
1836  }
1837  }
1838 
1839  if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1840  av_strstart(filename, "http:", NULL)) {
1841  int j;
1842  /* special case for files sent to ffserver: we get the stream
1843  parameters from ffserver */
1844  int err = read_ffserver_streams(o, oc, filename);
1845  if (err < 0) {
1846  print_error(filename, err);
1847  exit_program(1);
1848  }
1849  for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1850  ost = output_streams[j];
1851  for (i = 0; i < nb_input_streams; i++) {
1852  ist = input_streams[i];
1853  if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1854  ost->sync_ist= ist;
1855  ost->source_index= i;
1856  if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1857  if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1858  ist->discard = 0;
1859  ist->st->discard = ist->user_set_discard;
1860  break;
1861  }
1862  }
1863  if(!ost->sync_ist){
1864  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));
1865  exit_program(1);
1866  }
1867  }
1868  } else if (!o->nb_stream_maps) {
1869  char *subtitle_codec_name = NULL;
1870  /* pick the "best" stream of each type */
1871 
1872  /* video: highest resolution */
1873  if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1874  int area = 0, idx = -1;
1875  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1876  for (i = 0; i < nb_input_streams; i++) {
1877  int new_area;
1878  ist = input_streams[i];
1879  new_area = ist->st->codec->width * ist->st->codec->height;
1880  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1881  new_area = 1;
1882  if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1883  new_area > area) {
1884  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1885  continue;
1886  area = new_area;
1887  idx = i;
1888  }
1889  }
1890  if (idx >= 0)
1891  new_video_stream(o, oc, idx);
1892  }
1893 
1894  /* audio: most channels */
1895  if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1896  int channels = 0, idx = -1;
1897  for (i = 0; i < nb_input_streams; i++) {
1898  ist = input_streams[i];
1899  if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1900  ist->st->codec->channels > channels) {
1901  channels = ist->st->codec->channels;
1902  idx = i;
1903  }
1904  }
1905  if (idx >= 0)
1906  new_audio_stream(o, oc, idx);
1907  }
1908 
1909  /* subtitles: pick first */
1910  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1911  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1912  for (i = 0; i < nb_input_streams; i++)
1913  if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1914  AVCodecDescriptor const *input_descriptor =
1915  avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1916  AVCodecDescriptor const *output_descriptor = NULL;
1917  AVCodec const *output_codec =
1919  int input_props = 0, output_props = 0;
1920  if (output_codec)
1921  output_descriptor = avcodec_descriptor_get(output_codec->id);
1922  if (input_descriptor)
1923  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1924  if (output_descriptor)
1925  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1926  if (subtitle_codec_name ||
1927  input_props & output_props ||
1928  // Map dvb teletext which has neither property to any output subtitle encoder
1929  input_descriptor && output_descriptor &&
1930  (!input_descriptor->props ||
1931  !output_descriptor->props)) {
1932  new_subtitle_stream(o, oc, i);
1933  break;
1934  }
1935  }
1936  }
1937  /* do something with data? */
1938  } else {
1939  for (i = 0; i < o->nb_stream_maps; i++) {
1940  StreamMap *map = &o->stream_maps[i];
1941 
1942  if (map->disabled)
1943  continue;
1944 
1945  if (map->linklabel) {
1946  FilterGraph *fg;
1947  OutputFilter *ofilter = NULL;
1948  int j, k;
1949 
1950  for (j = 0; j < nb_filtergraphs; j++) {
1951  fg = filtergraphs[j];
1952  for (k = 0; k < fg->nb_outputs; k++) {
1953  AVFilterInOut *out = fg->outputs[k]->out_tmp;
1954  if (out && !strcmp(out->name, map->linklabel)) {
1955  ofilter = fg->outputs[k];
1956  goto loop_end;
1957  }
1958  }
1959  }
1960 loop_end:
1961  if (!ofilter) {
1962  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1963  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1964  exit_program(1);
1965  }
1966  init_output_filter(ofilter, o, oc);
1967  } else {
1968  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1969 
1972  continue;
1973  if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1974  continue;
1975  if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1976  continue;
1977  if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1978  continue;
1979 
1980  switch (ist->st->codec->codec_type) {
1981  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1982  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1983  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1984  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1985  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1986  default:
1987  av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1988  map->file_index, map->stream_index);
1989  exit_program(1);
1990  }
1991  }
1992  }
1993  }
1994 
1995  /* handle attached files */
1996  for (i = 0; i < o->nb_attachments; i++) {
1997  AVIOContext *pb;
1998  uint8_t *attachment;
1999  const char *p;
2000  int64_t len;
2001 
2002  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2003  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2004  o->attachments[i]);
2005  exit_program(1);
2006  }
2007  if ((len = avio_size(pb)) <= 0) {
2008  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2009  o->attachments[i]);
2010  exit_program(1);
2011  }
2012  if (!(attachment = av_malloc(len))) {
2013  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2014  o->attachments[i]);
2015  exit_program(1);
2016  }
2017  avio_read(pb, attachment, len);
2018 
2019  ost = new_attachment_stream(o, oc, -1);
2020  ost->stream_copy = 0;
2021  ost->attachment_filename = o->attachments[i];
2022  ost->finished = 1;
2023  ost->enc_ctx->extradata = attachment;
2024  ost->enc_ctx->extradata_size = len;
2025 
2026  p = strrchr(o->attachments[i], '/');
2027  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2028  avio_closep(&pb);
2029  }
2030 
2031  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2032  AVDictionaryEntry *e;
2033  ost = output_streams[i];
2034 
2035  if ((ost->stream_copy || ost->attachment_filename)
2036  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2037  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2038  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2039  exit_program(1);
2040  }
2041 
2042  /* check if all codec options have been used */
2043  unused_opts = strip_specifiers(o->g->codec_opts);
2044  for (i = of->ost_index; i < nb_output_streams; i++) {
2045  e = NULL;
2046  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2048  av_dict_set(&unused_opts, e->key, NULL, 0);
2049  }
2050 
2051  e = NULL;
2052  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2053  const AVClass *class = avcodec_get_class();
2054  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2056  const AVClass *fclass = avformat_get_class();
2057  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2059  if (!option || foption)
2060  continue;
2061 
2062 
2063  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2064  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2065  "output file #%d (%s) is not an encoding option.\n", e->key,
2066  option->help ? option->help : "", nb_output_files - 1,
2067  filename);
2068  exit_program(1);
2069  }
2070 
2071  // gop_timecode is injected by generic code but not always used
2072  if (!strcmp(e->key, "gop_timecode"))
2073  continue;
2074 
2075  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2076  "output file #%d (%s) has not been used for any stream. The most "
2077  "likely reason is either wrong type (e.g. a video option with "
2078  "no video streams) or that it is a private option of some encoder "
2079  "which was not actually used for any stream.\n", e->key,
2080  option->help ? option->help : "", nb_output_files - 1, filename);
2081  }
2082  av_dict_free(&unused_opts);
2083 
2084  /* check filename in case of an image number is expected */
2085  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2086  if (!av_filename_number_test(oc->filename)) {
2087  print_error(oc->filename, AVERROR(EINVAL));
2088  exit_program(1);
2089  }
2090  }
2091 
2092  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2093  /* test if it already exists to avoid losing precious files */
2094  assert_file_overwrite(filename);
2095 
2096  /* open the file */
2097  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2098  &oc->interrupt_callback,
2099  &of->opts)) < 0) {
2100  print_error(filename, err);
2101  exit_program(1);
2102  }
2103  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2104  assert_file_overwrite(filename);
2105 
2106  if (o->mux_preload) {
2107  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2108  }
2109  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2110 
2111  /* copy metadata */
2112  for (i = 0; i < o->nb_metadata_map; i++) {
2113  char *p;
2114  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2115 
2116  if (in_file_index >= nb_input_files) {
2117  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2118  exit_program(1);
2119  }
2120  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2121  in_file_index >= 0 ?
2122  input_files[in_file_index]->ctx : NULL, o);
2123  }
2124 
2125  /* copy chapters */
2126  if (o->chapters_input_file >= nb_input_files) {
2127  if (o->chapters_input_file == INT_MAX) {
2128  /* copy chapters from the first input file that has them*/
2129  o->chapters_input_file = -1;
2130  for (i = 0; i < nb_input_files; i++)
2131  if (input_files[i]->ctx->nb_chapters) {
2132  o->chapters_input_file = i;
2133  break;
2134  }
2135  } else {
2136  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2137  o->chapters_input_file);
2138  exit_program(1);
2139  }
2140  }
2141  if (o->chapters_input_file >= 0)
2144 
2145  /* copy global metadata by default */
2149  if(o->recording_time != INT64_MAX)
2150  av_dict_set(&oc->metadata, "duration", NULL, 0);
2151  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2152  }
2153  if (!o->metadata_streams_manual)
2154  for (i = of->ost_index; i < nb_output_streams; i++) {
2155  InputStream *ist;
2156  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2157  continue;
2159  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2160  if (!output_streams[i]->stream_copy)
2161  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2162  }
2163 
2164  /* process manually set metadata */
2165  for (i = 0; i < o->nb_metadata; i++) {
2166  AVDictionary **m;
2167  char type, *val;
2168  const char *stream_spec;
2169  int index = 0, j, ret = 0;
2170 
2171  val = strchr(o->metadata[i].u.str, '=');
2172  if (!val) {
2173  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2174  o->metadata[i].u.str);
2175  exit_program(1);
2176  }
2177  *val++ = 0;
2178 
2179  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2180  if (type == 's') {
2181  for (j = 0; j < oc->nb_streams; j++) {
2182  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2183  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2184  } else if (ret < 0)
2185  exit_program(1);
2186  }
2187  }
2188  else {
2189  switch (type) {
2190  case 'g':
2191  m = &oc->metadata;
2192  break;
2193  case 'c':
2194  if (index < 0 || index >= oc->nb_chapters) {
2195  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2196  exit_program(1);
2197  }
2198  m = &oc->chapters[index]->metadata;
2199  break;
2200  default:
2201  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2202  exit_program(1);
2203  }
2204  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2205  }
2206  }
2207 
2208  return 0;
2209 }
2210 
2211 static int opt_target(void *optctx, const char *opt, const char *arg)
2212 {
2213  OptionsContext *o = optctx;
2214  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2215  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2216 
2217  if (!strncmp(arg, "pal-", 4)) {
2218  norm = PAL;
2219  arg += 4;
2220  } else if (!strncmp(arg, "ntsc-", 5)) {
2221  norm = NTSC;
2222  arg += 5;
2223  } else if (!strncmp(arg, "film-", 5)) {
2224  norm = FILM;
2225  arg += 5;
2226  } else {
2227  /* Try to determine PAL/NTSC by peeking in the input files */
2228  if (nb_input_files) {
2229  int i, j, fr;
2230  for (j = 0; j < nb_input_files; j++) {
2231  for (i = 0; i < input_files[j]->nb_streams; i++) {
2233  if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2234  !c->time_base.num)
2235  continue;
2236  fr = c->time_base.den * 1000 / c->time_base.num;
2237  if (fr == 25000) {
2238  norm = PAL;
2239  break;
2240  } else if ((fr == 29970) || (fr == 23976)) {
2241  norm = NTSC;
2242  break;
2243  }
2244  }
2245  if (norm != UNKNOWN)
2246  break;
2247  }
2248  }
2249  if (norm != UNKNOWN)
2250  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2251  }
2252 
2253  if (norm == UNKNOWN) {
2254  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2255  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2256  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2257  exit_program(1);
2258  }
2259 
2260  if (!strcmp(arg, "vcd")) {
2261  opt_video_codec(o, "c:v", "mpeg1video");
2262  opt_audio_codec(o, "c:a", "mp2");
2263  parse_option(o, "f", "vcd", options);
2264 
2265  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2266  parse_option(o, "r", frame_rates[norm], options);
2267  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2268 
2269  opt_default(NULL, "b:v", "1150000");
2270  opt_default(NULL, "maxrate", "1150000");
2271  opt_default(NULL, "minrate", "1150000");
2272  opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2273 
2274  opt_default(NULL, "b:a", "224000");
2275  parse_option(o, "ar", "44100", options);
2276  parse_option(o, "ac", "2", options);
2277 
2278  opt_default(NULL, "packetsize", "2324");
2279  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2280 
2281  /* We have to offset the PTS, so that it is consistent with the SCR.
2282  SCR starts at 36000, but the first two packs contain only padding
2283  and the first pack from the other stream, respectively, may also have
2284  been written before.
2285  So the real data starts at SCR 36000+3*1200. */
2286  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2287  } else if (!strcmp(arg, "svcd")) {
2288 
2289  opt_video_codec(o, "c:v", "mpeg2video");
2290  opt_audio_codec(o, "c:a", "mp2");
2291  parse_option(o, "f", "svcd", options);
2292 
2293  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2294  parse_option(o, "r", frame_rates[norm], options);
2295  parse_option(o, "pix_fmt", "yuv420p", options);
2296  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2297 
2298  opt_default(NULL, "b:v", "2040000");
2299  opt_default(NULL, "maxrate", "2516000");
2300  opt_default(NULL, "minrate", "0"); // 1145000;
2301  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2302  opt_default(NULL, "scan_offset", "1");
2303 
2304  opt_default(NULL, "b:a", "224000");
2305  parse_option(o, "ar", "44100", options);
2306 
2307  opt_default(NULL, "packetsize", "2324");
2308 
2309  } else if (!strcmp(arg, "dvd")) {
2310 
2311  opt_video_codec(o, "c:v", "mpeg2video");
2312  opt_audio_codec(o, "c:a", "ac3");
2313  parse_option(o, "f", "dvd", options);
2314 
2315  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2316  parse_option(o, "r", frame_rates[norm], options);
2317  parse_option(o, "pix_fmt", "yuv420p", options);
2318  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2319 
2320  opt_default(NULL, "b:v", "6000000");
2321  opt_default(NULL, "maxrate", "9000000");
2322  opt_default(NULL, "minrate", "0"); // 1500000;
2323  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2324 
2325  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2326  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2327 
2328  opt_default(NULL, "b:a", "448000");
2329  parse_option(o, "ar", "48000", options);
2330 
2331  } else if (!strncmp(arg, "dv", 2)) {
2332 
2333  parse_option(o, "f", "dv", options);
2334 
2335  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2336  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2337  norm == PAL ? "yuv420p" : "yuv411p", options);
2338  parse_option(o, "r", frame_rates[norm], options);
2339 
2340  parse_option(o, "ar", "48000", options);
2341  parse_option(o, "ac", "2", options);
2342 
2343  } else {
2344  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2345  return AVERROR(EINVAL);
2346  }
2347 
2350 
2351  return 0;
2352 }
2353 
2354 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2355 {
2357  vstats_filename = av_strdup (arg);
2358  return 0;
2359 }
2360 
2361 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2362 {
2363  char filename[40];
2364  time_t today2 = time(NULL);
2365  struct tm *today = localtime(&today2);
2366 
2367  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2368  today->tm_sec);
2369  return opt_vstats_file(NULL, opt, filename);
2370 }
2371 
2372 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2373 {
2374  OptionsContext *o = optctx;
2375  return parse_option(o, "frames:v", arg, options);
2376 }
2377 
2378 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2379 {
2380  OptionsContext *o = optctx;
2381  return parse_option(o, "frames:a", arg, options);
2382 }
2383 
2384 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2385 {
2386  OptionsContext *o = optctx;
2387  return parse_option(o, "frames:d", arg, options);
2388 }
2389 
2390 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2391 {
2392  int ret;
2393  AVDictionary *cbak = codec_opts;
2394  AVDictionary *fbak = format_opts;
2395  codec_opts = NULL;
2396  format_opts = NULL;
2397 
2398  ret = opt_default(NULL, opt, arg);
2399 
2400  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2404  codec_opts = cbak;
2405  format_opts = fbak;
2406 
2407  return ret;
2408 }
2409 
2410 static int opt_preset(void *optctx, const char *opt, const char *arg)
2411 {
2412  OptionsContext *o = optctx;
2413  FILE *f=NULL;
2414  char filename[1000], line[1000], tmp_line[1000];
2415  const char *codec_name = NULL;
2416 
2417  tmp_line[0] = *opt;
2418  tmp_line[1] = 0;
2419  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2420 
2421  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2422  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2423  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2424  }else
2425  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2426  exit_program(1);
2427  }
2428 
2429  while (fgets(line, sizeof(line), f)) {
2430  char *key = tmp_line, *value, *endptr;
2431 
2432  if (strcspn(line, "#\n\r") == 0)
2433  continue;
2434  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2435  if (!av_strtok(key, "=", &value) ||
2436  !av_strtok(value, "\r\n", &endptr)) {
2437  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2438  exit_program(1);
2439  }
2440  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2441 
2442  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2443  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2444  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2445  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2446  else if (opt_default_new(o, key, value) < 0) {
2447  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2448  filename, line, key, value);
2449  exit_program(1);
2450  }
2451  }
2452 
2453  fclose(f);
2454 
2455  return 0;
2456 }
2457 
2458 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2459 {
2460  OptionsContext *o = optctx;
2461  char *s = av_asprintf("%s:%c", opt + 1, *opt);
2462  int ret = parse_option(o, s, arg, options);
2463  av_free(s);
2464  return ret;
2465 }
2466 
2467 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2468 {
2469  OptionsContext *o = optctx;
2470 
2471  if(!strcmp(opt, "ab")){
2472  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2473  return 0;
2474  } else if(!strcmp(opt, "b")){
2475  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2476  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2477  return 0;
2478  }
2479  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2480  return 0;
2481 }
2482 
2483 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2484 {
2485  OptionsContext *o = optctx;
2486  char *s;
2487  int ret;
2488  if(!strcmp(opt, "qscale")){
2489  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2490  return parse_option(o, "q:v", arg, options);
2491  }
2492  s = av_asprintf("q%s", opt + 6);
2493  ret = parse_option(o, s, arg, options);
2494  av_free(s);
2495  return ret;
2496 }
2497 
2498 static int opt_profile(void *optctx, const char *opt, const char *arg)
2499 {
2500  OptionsContext *o = optctx;
2501  if(!strcmp(opt, "profile")){
2502  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2503  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2504  return 0;
2505  }
2506  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2507  return 0;
2508 }
2509 
2510 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2511 {
2512  OptionsContext *o = optctx;
2513  return parse_option(o, "filter:v", arg, options);
2514 }
2515 
2516 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2517 {
2518  OptionsContext *o = optctx;
2519  return parse_option(o, "filter:a", arg, options);
2520 }
2521 
2522 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2523 {
2524  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2525  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2526  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2527  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2528 
2531  return 0;
2532 }
2533 
2534 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2535 {
2536  OptionsContext *o = optctx;
2537  char *tcr = av_asprintf("timecode=%s", arg);
2538  int ret = parse_option(o, "metadata:g", tcr, options);
2539  if (ret >= 0)
2540  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2541  av_free(tcr);
2542  return 0;
2543 }
2544 
2545 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2546 {
2547  OptionsContext *o = optctx;
2548  char layout_str[32];
2549  char *stream_str;
2550  char *ac_str;
2551  int ret, channels, ac_str_size;
2552  uint64_t layout;
2553 
2554  layout = av_get_channel_layout(arg);
2555  if (!layout) {
2556  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2557  return AVERROR(EINVAL);
2558  }
2559  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2560  ret = opt_default_new(o, opt, layout_str);
2561  if (ret < 0)
2562  return ret;
2563 
2564  /* set 'ac' option based on channel layout */
2565  channels = av_get_channel_layout_nb_channels(layout);
2566  snprintf(layout_str, sizeof(layout_str), "%d", channels);
2567  stream_str = strchr(opt, ':');
2568  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2569  ac_str = av_mallocz(ac_str_size);
2570  if (!ac_str)
2571  return AVERROR(ENOMEM);
2572  av_strlcpy(ac_str, "ac", 3);
2573  if (stream_str)
2574  av_strlcat(ac_str, stream_str, ac_str_size);
2575  ret = parse_option(o, ac_str, layout_str, options);
2576  av_free(ac_str);
2577 
2578  return ret;
2579 }
2580 
2581 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2582 {
2583  OptionsContext *o = optctx;
2584  return parse_option(o, "q:a", arg, options);
2585 }
2586 
2587 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2588 {
2590  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2591  return AVERROR(ENOMEM);
2594  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2595  return AVERROR(ENOMEM);
2596  return 0;
2597 }
2598 
2599 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2600 {
2601  uint8_t *graph_desc = read_file(arg);
2602  if (!graph_desc)
2603  return AVERROR(EINVAL);
2604 
2606  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2607  return AVERROR(ENOMEM);
2609  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2610  return 0;
2611 }
2612 
2613 void show_help_default(const char *opt, const char *arg)
2614 {
2615  /* per-file options have at least one of those set */
2616  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2617  int show_advanced = 0, show_avoptions = 0;
2618 
2619  if (opt && *opt) {
2620  if (!strcmp(opt, "long"))
2621  show_advanced = 1;
2622  else if (!strcmp(opt, "full"))
2623  show_advanced = show_avoptions = 1;
2624  else
2625  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2626  }
2627 
2628  show_usage();
2629 
2630  printf("Getting help:\n"
2631  " -h -- print basic options\n"
2632  " -h long -- print more options\n"
2633  " -h full -- print all options (including all format and codec specific options, very long)\n"
2634  " See man %s for detailed description of the options.\n"
2635  "\n", program_name);
2636 
2637  show_help_options(options, "Print help / information / capabilities:",
2638  OPT_EXIT, 0, 0);
2639 
2640  show_help_options(options, "Global options (affect whole program "
2641  "instead of just one file:",
2642  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2643  if (show_advanced)
2644  show_help_options(options, "Advanced global options:", OPT_EXPERT,
2645  per_file | OPT_EXIT, 0);
2646 
2647  show_help_options(options, "Per-file main options:", 0,
2649  OPT_EXIT, per_file);
2650  if (show_advanced)
2651  show_help_options(options, "Advanced per-file options:",
2652  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2653 
2654  show_help_options(options, "Video options:",
2656  if (show_advanced)
2657  show_help_options(options, "Advanced Video options:",
2659 
2660  show_help_options(options, "Audio options:",
2662  if (show_advanced)
2663  show_help_options(options, "Advanced Audio options:",
2665  show_help_options(options, "Subtitle options:",
2666  OPT_SUBTITLE, 0, 0);
2667  printf("\n");
2668 
2669  if (show_avoptions) {
2673 #if CONFIG_SWSCALE
2675 #endif
2678  }
2679 }
2680 
2681 void show_usage(void)
2682 {
2683  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2684  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2685  av_log(NULL, AV_LOG_INFO, "\n");
2686 }
2687 
2688 enum OptGroup {
2691 };
2692 
2693 static const OptionGroupDef groups[] = {
2694  [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2695  [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2696 };
2697 
2698 static int open_files(OptionGroupList *l, const char *inout,
2699  int (*open_file)(OptionsContext*, const char*))
2700 {
2701  int i, ret;
2702 
2703  for (i = 0; i < l->nb_groups; i++) {
2704  OptionGroup *g = &l->groups[i];
2705  OptionsContext o;
2706 
2707  init_options(&o);
2708  o.g = g;
2709 
2710  ret = parse_optgroup(&o, g);
2711  if (ret < 0) {
2712  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2713  "%s.\n", inout, g->arg);
2714  return ret;
2715  }
2716 
2717  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2718  ret = open_file(&o, g->arg);
2719  uninit_options(&o);
2720  if (ret < 0) {
2721  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2722  inout, g->arg);
2723  return ret;
2724  }
2725  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2726  }
2727 
2728  return 0;
2729 }
2730 
2731 int ffmpeg_parse_options(int argc, char **argv)
2732 {
2733  OptionParseContext octx;
2734  uint8_t error[128];
2735  int ret;
2736 
2737  memset(&octx, 0, sizeof(octx));
2738 
2739  /* split the commandline into an internal representation */
2740  ret = split_commandline(&octx, argc, argv, options, groups,
2741  FF_ARRAY_ELEMS(groups));
2742  if (ret < 0) {
2743  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2744  goto fail;
2745  }
2746 
2747  /* apply global options */
2748  ret = parse_optgroup(NULL, &octx.global_opts);
2749  if (ret < 0) {
2750  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2751  goto fail;
2752  }
2753 
2754  /* open input files */
2755  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2756  if (ret < 0) {
2757  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2758  goto fail;
2759  }
2760 
2761  /* open output files */
2762  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2763  if (ret < 0) {
2764  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2765  goto fail;
2766  }
2767 
2768 fail:
2769  uninit_parse_context(&octx);
2770  if (ret < 0) {
2771  av_strerror(ret, error, sizeof(error));
2772  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2773  }
2774  return ret;
2775 }
2776 
2777 static int opt_progress(void *optctx, const char *opt, const char *arg)
2778 {
2779  AVIOContext *avio = NULL;
2780  int ret;
2781 
2782  if (!strcmp(arg, "-"))
2783  arg = "pipe:";
2784  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2785  if (ret < 0) {
2786  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2787  arg, av_err2str(ret));
2788  return ret;
2789  }
2790  progress_avio = avio;
2791  return 0;
2792 }
2793 
2794 #define OFFSET(x) offsetof(OptionsContext, x)
2795 const OptionDef options[] = {
2796  /* main options */
2797 #include "cmdutils_common_opts.h"
2798  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2799  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2800  "force format", "fmt" },
2801  { "y", OPT_BOOL, { &file_overwrite },
2802  "overwrite output files" },
2803  { "n", OPT_BOOL, { &no_file_overwrite },
2804  "never overwrite output files" },
2805  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2806  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2807  "codec name", "codec" },
2808  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2809  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2810  "codec name", "codec" },
2811  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2812  OPT_OUTPUT, { .off = OFFSET(presets) },
2813  "preset name", "preset" },
2814  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2815  OPT_OUTPUT, { .func_arg = opt_map },
2816  "set input stream mapping",
2817  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2818  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2819  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2820  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2821  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2822  "set metadata information of outfile from infile",
2823  "outfile[,metadata]:infile[,metadata]" },
2824  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2825  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2826  "set chapters mapping", "input_file_index" },
2827  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2828  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2829  "record or transcode \"duration\" seconds of audio/video",
2830  "duration" },
2831  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2832  "record or transcode stop time", "time_stop" },
2833  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2834  "set the limit file size in bytes", "limit_size" },
2835  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2836  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2837  "set the start time offset", "time_off" },
2838  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2839  OPT_INPUT, { .off = OFFSET(accurate_seek) },
2840  "enable/disable accurate seeking with -ss" },
2841  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2842  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2843  "set the input ts offset", "time_off" },
2844  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2845  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2846  "set the input ts scale", "scale" },
2847  { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2848  "set the recording timestamp ('now' to set the current time)", "time" },
2849  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2850  "add metadata", "string=string" },
2851  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2852  OPT_OUTPUT, { .func_arg = opt_data_frames },
2853  "set the number of data frames to output", "number" },
2854  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2855  "add timings for benchmarking" },
2856  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2857  "add timings for each task" },
2858  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2859  "write program-readable progress information", "url" },
2860  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2861  "enable or disable interaction on standard input" },
2862  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2863  "set max runtime in seconds", "limit" },
2864  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2865  "dump each input packet" },
2866  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2867  "when dumping packets, also dump the payload" },
2868  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2869  OPT_INPUT, { .off = OFFSET(rate_emu) },
2870  "read input at native frame rate", "" },
2871  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2872  "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2873  " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2874  { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2875  "video sync method", "" },
2876  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2877  "audio sync method", "" },
2878  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2879  "audio drift threshold", "threshold" },
2880  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2881  "copy timestamps" },
2882  { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2883  "shift input timestamps to start at 0 when using copyts" },
2884  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
2885  "copy input stream time base when stream copying", "mode" },
2886  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2887  OPT_OUTPUT, { .off = OFFSET(shortest) },
2888  "finish encoding within shortest input" },
2889  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2890  OPT_OUTPUT, { .off = OFFSET(apad) },
2891  "audio pad", "" },
2892  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2893  "timestamp discontinuity delta threshold", "threshold" },
2894  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2895  "timestamp error delta threshold", "threshold" },
2896  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2897  "exit on error", "error" },
2898  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2899  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2900  "copy initial non-keyframes" },
2901  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2902  "copy or discard frames before start time" },
2903  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2904  "set the number of frames to output", "number" },
2905  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2906  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2907  "force codec tag/fourcc", "fourcc/tag" },
2908  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2909  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2910  "use fixed quality scale (VBR)", "q" },
2911  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2912  OPT_OUTPUT, { .func_arg = opt_qscale },
2913  "use fixed quality scale (VBR)", "q" },
2914  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2915  "set profile", "profile" },
2916  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2917  "set stream filtergraph", "filter_graph" },
2918  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2919  "read stream filtergraph description from a file", "filename" },
2920  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2921  "reinit filtergraph on input parameter changes", "" },
2922  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2923  "create a complex filtergraph", "graph_description" },
2924  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2925  "create a complex filtergraph", "graph_description" },
2926  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2927  "read complex filtergraph description from a file", "filename" },
2928  { "stats", OPT_BOOL, { &print_stats },
2929  "print progress report during encoding", },
2930  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2931  OPT_OUTPUT, { .func_arg = opt_attach },
2932  "add an attachment to the output file", "filename" },
2933  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2934  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2935  "extract an attachment into a file", "filename" },
2936  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2937  "print timestamp debugging info" },
2938  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2939  "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2940  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2941  OPT_INPUT, { .off = OFFSET(discard) },
2942  "discard", "" },
2943  { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
2944  OPT_OUTPUT, { .off = OFFSET(disposition) },
2945  "disposition", "" },
2946 
2947  /* video options */
2948  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2949  "set the number of video frames to output", "number" },
2950  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2951  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2952  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2954  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2955  "set frame size (WxH or abbreviation)", "size" },
2956  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2957  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2958  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2959  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2960  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2961  "set pixel format", "format" },
2962  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2963  "set the number of bits per raw sample", "number" },
2964  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2965  "deprecated use -g 1" },
2967  "disable video" },
2968  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2969  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2970  "rate control override for specific intervals", "override" },
2971  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2972  OPT_OUTPUT, { .func_arg = opt_video_codec },
2973  "force video codec ('copy' to copy stream)", "codec" },
2974  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2975  "Removed" },
2976  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2977  "Removed" },
2978  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2979  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2980  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2981  "select the pass number (1 to 3)", "n" },
2982  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2983  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2984  "select two pass log file name prefix", "prefix" },
2985  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2986  "this option is deprecated, use the yadif filter instead" },
2987  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2988  "calculate PSNR of compressed frames" },
2989  { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2990  "dump video coding statistics to file" },
2991  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2992  "dump video coding statistics to file", "file" },
2993  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2994  "set video filters", "filter_graph" },
2995  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2996  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2997  "specify intra matrix coeffs", "matrix" },
2998  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2999  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3000  "specify inter matrix coeffs", "matrix" },
3001  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3002  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3003  "specify intra matrix coeffs", "matrix" },
3004  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3005  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3006  "top=1/bottom=0/auto=-1 field first", "" },
3007  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3008  OPT_OUTPUT, { .func_arg = opt_old2new },
3009  "force video tag/fourcc", "fourcc/tag" },
3010  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3011  "show QP histogram" },
3012  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3013  OPT_OUTPUT, { .off = OFFSET(force_fps) },
3014  "force the selected framerate, disable the best supported framerate selection" },
3015  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3016  OPT_OUTPUT, { .func_arg = opt_streamid },
3017  "set the value of an outfile streamid", "streamIndex:value" },
3018  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3019  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3020  "force key frames at specified timestamps", "timestamps" },
3021  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3022  "audio bitrate (please use -b:a)", "bitrate" },
3023  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3024  "video bitrate (please use -b:v)", "bitrate" },
3025  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3026  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3027  "use HW accelerated decoding", "hwaccel name" },
3028  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3029  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3030  "select a device for HW acceleration" "devicename" },
3031 #if HAVE_VDPAU_X11
3032  { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3033 #endif
3034 
3035  /* audio options */
3036  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3037  "set the number of audio frames to output", "number" },
3038  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3039  "set audio quality (codec-specific)", "quality", },
3040  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3041  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3042  "set audio sampling rate (in Hz)", "rate" },
3043  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3044  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3045  "set number of audio channels", "channels" },
3047  "disable audio" },
3048  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3049  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3050  "force audio codec ('copy' to copy stream)", "codec" },
3051  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3052  OPT_OUTPUT, { .func_arg = opt_old2new },
3053  "force audio tag/fourcc", "fourcc/tag" },
3054  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3055  "change audio volume (256=normal)" , "volume" },
3056  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3058  "set sample format", "format" },
3059  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3060  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3061  "set channel layout", "layout" },
3062  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3063  "set audio filters", "filter_graph" },
3064  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3065  "set the maximum number of channels to try to guess the channel layout" },
3066 
3067  /* subtitle options */
3069  "disable subtitle" },
3070  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3071  "force subtitle codec ('copy' to copy stream)", "codec" },
3072  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3073  , "force subtitle tag/fourcc", "fourcc/tag" },
3074  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3075  "fix subtitles duration" },
3076  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3077  "set canvas size (WxH or abbreviation)", "size" },
3078 
3079  /* grab options */
3080  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3081  "deprecated, use -channel", "channel" },
3082  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3083  "deprecated, use -standard", "standard" },
3084  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3085 
3086  /* muxer options */
3087  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3088  "set the maximum demux-decode delay", "seconds" },
3089  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3090  "set the initial demux-decode delay", "seconds" },
3091  { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3092  "override the options from ffserver", "" },
3093  { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3094  "specify a file in which to print sdp information", "file" },
3095 
3096  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3097  "A comma-separated list of bitstream filters", "bitstream_filters" },
3098  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3099  "deprecated", "audio bitstream_filters" },
3100  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3101  "deprecated", "video bitstream_filters" },
3102 
3103  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3104  "set the audio options to the indicated preset", "preset" },
3105  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3106  "set the video options to the indicated preset", "preset" },
3107  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3108  "set the subtitle options to the indicated preset", "preset" },
3109  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3110  "set options from indicated preset file", "filename" },
3111  /* data codec support */
3112  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3113  "force data codec ('copy' to copy stream)", "codec" },
3114  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3115  "disable data" },
3116 
3117  { NULL, },
3118 };