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