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  AVDictionary **opts;
789  AVDictionary *unused_opts = NULL;
790  AVDictionaryEntry *e = NULL;
791  int orig_nb_streams; // number of streams before avformat_find_stream_info
792  char * video_codec_name = NULL;
793  char * audio_codec_name = NULL;
794  char *subtitle_codec_name = NULL;
795 
796  if (o->format) {
797  if (!(file_iformat = av_find_input_format(o->format))) {
798  av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
799  exit_program(1);
800  }
801  }
802 
803  if (!strcmp(filename, "-"))
804  filename = "pipe:";
805 
806  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
807  strcmp(filename, "/dev/stdin");
808 
809  /* get default parameters from command line */
810  ic = avformat_alloc_context();
811  if (!ic) {
812  print_error(filename, AVERROR(ENOMEM));
813  exit_program(1);
814  }
815  if (o->nb_audio_sample_rate) {
816  av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
817  }
818  if (o->nb_audio_channels) {
819  /* because we set audio_channels based on both the "ac" and
820  * "channel_layout" options, we need to check that the specified
821  * demuxer actually has the "channels" option before setting it */
822  if (file_iformat && file_iformat->priv_class &&
823  av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
825  av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
826  }
827  }
828  if (o->nb_frame_rates) {
829  /* set the format-level framerate option;
830  * this is important for video grabbers, e.g. x11 */
831  if (file_iformat && file_iformat->priv_class &&
832  av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
834  av_dict_set(&o->g->format_opts, "framerate",
835  o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
836  }
837  }
838  if (o->nb_frame_sizes) {
839  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
840  }
841  if (o->nb_frame_pix_fmts)
842  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
843 
844  MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
845  MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
846  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
847 
848  ic->video_codec_id = video_codec_name ?
849  find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
850  ic->audio_codec_id = audio_codec_name ?
851  find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
852  ic->subtitle_codec_id= subtitle_codec_name ?
853  find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
854 
855  if (video_codec_name)
856  av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
857  if (audio_codec_name)
858  av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
859  if (subtitle_codec_name)
861 
862  ic->flags |= AVFMT_FLAG_NONBLOCK;
864 
865  /* open the input file with generic avformat function */
866  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
867  if (err < 0) {
868  print_error(filename, err);
869  exit_program(1);
870  }
873 
874  /* apply forced codec ids */
875  for (i = 0; i < ic->nb_streams; i++)
876  choose_decoder(o, ic, ic->streams[i]);
877 
878  /* Set AVCodecContext options for avformat_find_stream_info */
879  opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
880  orig_nb_streams = ic->nb_streams;
881 
882  /* If not enough info to get the stream parameters, we decode the
883  first frames to get it. (used in mpeg case for example) */
884  ret = avformat_find_stream_info(ic, opts);
885  if (ret < 0) {
886  av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
887  if (ic->nb_streams == 0) {
889  exit_program(1);
890  }
891  }
892 
893  timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
894  /* add the stream start time */
895  if (ic->start_time != AV_NOPTS_VALUE)
896  timestamp += ic->start_time;
897 
898  /* if seeking requested, we execute it */
899  if (o->start_time != AV_NOPTS_VALUE) {
900  ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
901  if (ret < 0) {
902  av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
903  filename, (double)timestamp / AV_TIME_BASE);
904  }
905  }
906 
907  /* update the current parameters so that they match the one of the input stream */
908  add_input_streams(o, ic);
909 
910  /* dump the file content */
911  av_dump_format(ic, nb_input_files, filename, 0);
912 
914  f = av_mallocz(sizeof(*f));
915  if (!f)
916  exit_program(1);
917  input_files[nb_input_files - 1] = f;
918 
919  f->ctx = ic;
921  f->start_time = o->start_time;
924  f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
925  f->nb_streams = ic->nb_streams;
926  f->rate_emu = o->rate_emu;
928 
929  /* check if all codec options have been used */
930  unused_opts = strip_specifiers(o->g->codec_opts);
931  for (i = f->ist_index; i < nb_input_streams; i++) {
932  e = NULL;
933  while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
935  av_dict_set(&unused_opts, e->key, NULL, 0);
936  }
937 
938  e = NULL;
939  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
940  const AVClass *class = avcodec_get_class();
941  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
943  const AVClass *fclass = avformat_get_class();
944  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
946  if (!option || foption)
947  continue;
948 
949 
950  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
951  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
952  "input file #%d (%s) is not a decoding option.\n", e->key,
953  option->help ? option->help : "", nb_input_files - 1,
954  filename);
955  exit_program(1);
956  }
957 
958  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
959  "input file #%d (%s) has not been used for any stream. The most "
960  "likely reason is either wrong type (e.g. a video option with "
961  "no video streams) or that it is a private option of some decoder "
962  "which was not actually used for any stream.\n", e->key,
963  option->help ? option->help : "", nb_input_files - 1, filename);
964  }
965  av_dict_free(&unused_opts);
966 
967  for (i = 0; i < o->nb_dump_attachment; i++) {
968  int j;
969 
970  for (j = 0; j < ic->nb_streams; j++) {
971  AVStream *st = ic->streams[j];
972 
973  if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
975  }
976  }
977 
978  for (i = 0; i < orig_nb_streams; i++)
979  av_dict_free(&opts[i]);
980  av_freep(&opts);
981 
982  return 0;
983 }
984 
986 {
987  AVIOContext *line;
988  uint8_t *buf;
989  char c;
990 
991  if (avio_open_dyn_buf(&line) < 0) {
992  av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
993  exit_program(1);
994  }
995 
996  while ((c = avio_r8(s)) && c != '\n')
997  avio_w8(line, c);
998  avio_w8(line, 0);
999  avio_close_dyn_buf(line, &buf);
1000 
1001  return buf;
1002 }
1003 
1004 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1005 {
1006  int i, ret = -1;
1007  char filename[1000];
1008  const char *base[3] = { getenv("AVCONV_DATADIR"),
1009  getenv("HOME"),
1010  AVCONV_DATADIR,
1011  };
1012 
1013  for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1014  if (!base[i])
1015  continue;
1016  if (codec_name) {
1017  snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1018  i != 1 ? "" : "/.avconv", codec_name, preset_name);
1019  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1020  }
1021  if (ret < 0) {
1022  snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1023  i != 1 ? "" : "/.avconv", preset_name);
1024  ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1025  }
1026  }
1027  return ret;
1028 }
1029 
1031 {
1032  char *codec_name = NULL;
1033 
1034  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1035  if (!codec_name) {
1036  ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1037  NULL, ost->st->codec->codec_type);
1038  ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1039  } else if (!strcmp(codec_name, "copy"))
1040  ost->stream_copy = 1;
1041  else {
1042  ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1043  ost->st->codec->codec_id = ost->enc->id;
1044  }
1045 }
1046 
1048 {
1049  OutputStream *ost;
1050  AVStream *st = avformat_new_stream(oc, NULL);
1051  int idx = oc->nb_streams - 1, ret = 0;
1052  char *bsf = NULL, *next, *codec_tag = NULL;
1053  AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1054  double qscale = -1;
1055  int i;
1056 
1057  if (!st) {
1058  av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1059  exit_program(1);
1060  }
1061 
1062  if (oc->nb_streams - 1 < o->nb_streamid_map)
1063  st->id = o->streamid_map[oc->nb_streams - 1];
1064 
1066  if (!(ost = av_mallocz(sizeof(*ost))))
1067  exit_program(1);
1068  output_streams[nb_output_streams - 1] = ost;
1069 
1070  ost->file_index = nb_output_files - 1;
1071  ost->index = idx;
1072  ost->st = st;
1073  st->codec->codec_type = type;
1074  choose_encoder(o, oc, ost);
1075 
1076  ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1077  if (!ost->enc_ctx) {
1078  av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1079  exit_program(1);
1080  }
1081  ost->enc_ctx->codec_type = type;
1082 
1083  if (ost->enc) {
1084  AVIOContext *s = NULL;
1085  char *buf = NULL, *arg = NULL, *preset = NULL;
1086 
1087  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1088 
1089  MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1090  if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1091  do {
1092  buf = get_line(s);
1093  if (!buf[0] || buf[0] == '#') {
1094  av_free(buf);
1095  continue;
1096  }
1097  if (!(arg = strchr(buf, '='))) {
1098  av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1099  exit_program(1);
1100  }
1101  *arg++ = 0;
1103  av_free(buf);
1104  } while (!s->eof_reached);
1105  avio_close(s);
1106  }
1107  if (ret) {
1108  av_log(NULL, AV_LOG_FATAL,
1109  "Preset %s specified for stream %d:%d, but could not be opened.\n",
1110  preset, ost->file_index, ost->index);
1111  exit_program(1);
1112  }
1113  } else {
1114  ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1115  }
1116 
1117  ost->max_frames = INT64_MAX;
1118  MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1119  for (i = 0; i<o->nb_max_frames; i++) {
1120  char *p = o->max_frames[i].specifier;
1121  if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1122  av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1123  break;
1124  }
1125  }
1126 
1127  ost->copy_prior_start = -1;
1128  MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1129 
1130  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1131  while (bsf) {
1132  if (next = strchr(bsf, ','))
1133  *next++ = 0;
1134  if (!(bsfc = av_bitstream_filter_init(bsf))) {
1135  av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1136  exit_program(1);
1137  }
1138  if (bsfc_prev)
1139  bsfc_prev->next = bsfc;
1140  else
1141  ost->bitstream_filters = bsfc;
1142 
1143  bsfc_prev = bsfc;
1144  bsf = next;
1145  }
1146 
1147  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1148  if (codec_tag) {
1149  uint32_t tag = strtol(codec_tag, &next, 0);
1150  if (*next)
1151  tag = AV_RL32(codec_tag);
1152  ost->enc_ctx->codec_tag = tag;
1153  }
1154 
1155  MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1156  if (qscale >= 0) {
1157  ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1158  ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1159  }
1160 
1161  if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1163 
1164  av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1165 
1166  av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1167  if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1168  av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1169 
1170  av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1171 
1172  ost->source_index = source_index;
1173  if (source_index >= 0) {
1174  ost->sync_ist = input_streams[source_index];
1175  input_streams[source_index]->discard = 0;
1176  input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1177  }
1179 
1180  return ost;
1181 }
1182 
1183 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1184 {
1185  int i;
1186  const char *p = str;
1187  for (i = 0;; i++) {
1188  dest[i] = atoi(p);
1189  if (i == 63)
1190  break;
1191  p = strchr(p, ',');
1192  if (!p) {
1193  av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1194  exit_program(1);
1195  }
1196  p++;
1197  }
1198 }
1199 
1200 /* read file contents into a string */
1201 static uint8_t *read_file(const char *filename)
1202 {
1203  AVIOContext *pb = NULL;
1204  AVIOContext *dyn_buf = NULL;
1205  int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1206  uint8_t buf[1024], *str;
1207 
1208  if (ret < 0) {
1209  av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1210  return NULL;
1211  }
1212 
1213  ret = avio_open_dyn_buf(&dyn_buf);
1214  if (ret < 0) {
1215  avio_closep(&pb);
1216  return NULL;
1217  }
1218  while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1219  avio_write(dyn_buf, buf, ret);
1220  avio_w8(dyn_buf, 0);
1221  avio_closep(&pb);
1222 
1223  ret = avio_close_dyn_buf(dyn_buf, &str);
1224  if (ret < 0)
1225  return NULL;
1226  return str;
1227 }
1228 
1230  OutputStream *ost)
1231 {
1232  AVStream *st = ost->st;
1233 
1234  if (ost->filters_script && ost->filters) {
1235  av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1236  "output stream #%d:%d.\n", nb_output_files, st->index);
1237  exit_program(1);
1238  }
1239 
1240  if (ost->filters_script)
1241  return read_file(ost->filters_script);
1242  else if (ost->filters)
1243  return av_strdup(ost->filters);
1244 
1245  return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1246  "null" : "anull");
1247 }
1248 
1250  const OutputStream *ost, enum AVMediaType type)
1251 {
1252  if (ost->filters_script || ost->filters) {
1253  av_log(NULL, AV_LOG_ERROR,
1254  "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1255  "Filtering and streamcopy cannot be used together.\n",
1256  ost->filters ? "Filtergraph" : "Filtergraph script",
1257  ost->filters ? ost->filters : ost->filters_script,
1258  av_get_media_type_string(type), ost->file_index, ost->index);
1259  exit_program(1);
1260  }
1261 }
1262 
1264 {
1265  AVStream *st;
1266  OutputStream *ost;
1267  AVCodecContext *video_enc;
1268  char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1269 
1270  ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1271  st = ost->st;
1272  video_enc = ost->enc_ctx;
1273 
1274  MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1275  if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1276  av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1277  exit_program(1);
1278  }
1279 
1280  MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1281  if (frame_aspect_ratio) {
1282  AVRational q;
1283  if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1284  q.num <= 0 || q.den <= 0) {
1285  av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1286  exit_program(1);
1287  }
1288  ost->frame_aspect_ratio = q;
1289  }
1290 
1291  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1292  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1293 
1294  if (!ost->stream_copy) {
1295  const char *p = NULL;
1296  char *frame_size = NULL;
1297  char *frame_pix_fmt = NULL;
1298  char *intra_matrix = NULL, *inter_matrix = NULL;
1299  char *chroma_intra_matrix = NULL;
1300  int do_pass = 0;
1301  int i;
1302 
1303  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1304  if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1305  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1306  exit_program(1);
1307  }
1308 
1310  MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1311  if (frame_pix_fmt && *frame_pix_fmt == '+') {
1312  ost->keep_pix_fmt = 1;
1313  if (!*++frame_pix_fmt)
1314  frame_pix_fmt = NULL;
1315  }
1316  if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1317  av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1318  exit_program(1);
1319  }
1320  st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1321 
1322  if (intra_only)
1323  video_enc->gop_size = 0;
1324  MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1325  if (intra_matrix) {
1326  if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1327  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1328  exit_program(1);
1329  }
1330  parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1331  }
1332  MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1333  if (chroma_intra_matrix) {
1334  uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1335  if (!p) {
1336  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1337  exit_program(1);
1338  }
1339  av_codec_set_chroma_intra_matrix(video_enc, p);
1340  parse_matrix_coeffs(p, chroma_intra_matrix);
1341  }
1342  MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1343  if (inter_matrix) {
1344  if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1345  av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1346  exit_program(1);
1347  }
1348  parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1349  }
1350 
1351  MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1352  for (i = 0; p; i++) {
1353  int start, end, q;
1354  int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1355  if (e != 3) {
1356  av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1357  exit_program(1);
1358  }
1359  /* FIXME realloc failure */
1360  video_enc->rc_override =
1361  av_realloc(video_enc->rc_override,
1362  sizeof(RcOverride) * (i + 1));
1363  video_enc->rc_override[i].start_frame = start;
1364  video_enc->rc_override[i].end_frame = end;
1365  if (q > 0) {
1366  video_enc->rc_override[i].qscale = q;
1367  video_enc->rc_override[i].quality_factor = 1.0;
1368  }
1369  else {
1370  video_enc->rc_override[i].qscale = 0;
1371  video_enc->rc_override[i].quality_factor = -q/100.0;
1372  }
1373  p = strchr(p, '/');
1374  if (p) p++;
1375  }
1376  video_enc->rc_override_count = i;
1377 
1378  if (do_psnr)
1379  video_enc->flags|= CODEC_FLAG_PSNR;
1380 
1381  /* two pass mode */
1382  MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1383  if (do_pass) {
1384  if (do_pass & 1) {
1385  video_enc->flags |= CODEC_FLAG_PASS1;
1386  av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1387  }
1388  if (do_pass & 2) {
1389  video_enc->flags |= CODEC_FLAG_PASS2;
1390  av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1391  }
1392  }
1393 
1394  MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1395  if (ost->logfile_prefix &&
1396  !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1397  exit_program(1);
1398 
1399  MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1400  if (ost->forced_keyframes)
1402 
1403  MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1404 
1405  ost->top_field_first = -1;
1406  MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1407 
1408 
1409  ost->avfilter = get_ost_filters(o, oc, ost);
1410  if (!ost->avfilter)
1411  exit_program(1);
1412  } else {
1413  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1414  }
1415 
1416  if (ost->stream_copy)
1418 
1419  return ost;
1420 }
1421 
1423 {
1424  int n;
1425  AVStream *st;
1426  OutputStream *ost;
1427  AVCodecContext *audio_enc;
1428 
1429  ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1430  st = ost->st;
1431 
1432  audio_enc = ost->enc_ctx;
1433  audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1434 
1435  MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1436  MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1437 
1438  if (!ost->stream_copy) {
1439  char *sample_fmt = NULL;
1440 
1441  MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1442 
1443  MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1444  if (sample_fmt &&
1445  (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1446  av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1447  exit_program(1);
1448  }
1449 
1450  MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1451 
1452  MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1453  ost->apad = av_strdup(ost->apad);
1454 
1455  ost->avfilter = get_ost_filters(o, oc, ost);
1456  if (!ost->avfilter)
1457  exit_program(1);
1458 
1459  /* check for channel mapping for this audio stream */
1460  for (n = 0; n < o->nb_audio_channel_maps; n++) {
1461  AudioChannelMap *map = &o->audio_channel_maps[n];
1462  if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1463  (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1464  InputStream *ist;
1465 
1466  if (map->channel_idx == -1) {
1467  ist = NULL;
1468  } else if (ost->source_index < 0) {
1469  av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1470  ost->file_index, ost->st->index);
1471  continue;
1472  } else {
1473  ist = input_streams[ost->source_index];
1474  }
1475 
1476  if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1478  ost->audio_channels_mapped + 1,
1479  sizeof(*ost->audio_channels_map)
1480  ) < 0 )
1481  exit_program(1);
1482 
1484  }
1485  }
1486  }
1487  }
1488 
1489  if (ost->stream_copy)
1491 
1492  return ost;
1493 }
1494 
1496 {
1497  OutputStream *ost;
1498 
1499  ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1500  if (!ost->stream_copy) {
1501  av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1502  exit_program(1);
1503  }
1504 
1505  return ost;
1506 }
1507 
1509 {
1510  OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1511  ost->stream_copy = 1;
1512  ost->finished = 1;
1513  return ost;
1514 }
1515 
1517 {
1518  AVStream *st;
1519  OutputStream *ost;
1520  AVCodecContext *subtitle_enc;
1521 
1522  ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1523  st = ost->st;
1524  subtitle_enc = ost->enc_ctx;
1525 
1526  subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1527 
1528  MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1529 
1530  if (!ost->stream_copy) {
1531  char *frame_size = NULL;
1532 
1533  MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1534  if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1535  av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1536  exit_program(1);
1537  }
1538  }
1539 
1540  return ost;
1541 }
1542 
1543 /* arg format is "output-stream-index:streamid-value". */
1544 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1545 {
1546  OptionsContext *o = optctx;
1547  int idx;
1548  char *p;
1549  char idx_str[16];
1550 
1551  av_strlcpy(idx_str, arg, sizeof(idx_str));
1552  p = strchr(idx_str, ':');
1553  if (!p) {
1554  av_log(NULL, AV_LOG_FATAL,
1555  "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1556  arg, opt);
1557  exit_program(1);
1558  }
1559  *p++ = '\0';
1560  idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1561  o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1562  o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1563  return 0;
1564 }
1565 
1567 {
1568  AVFormatContext *is = ifile->ctx;
1569  AVFormatContext *os = ofile->ctx;
1570  AVChapter **tmp;
1571  int i;
1572 
1573  tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1574  if (!tmp)
1575  return AVERROR(ENOMEM);
1576  os->chapters = tmp;
1577 
1578  for (i = 0; i < is->nb_chapters; i++) {
1579  AVChapter *in_ch = is->chapters[i], *out_ch;
1580  int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1581  int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1582  AV_TIME_BASE_Q, in_ch->time_base);
1583  int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1585 
1586 
1587  if (in_ch->end < ts_off)
1588  continue;
1589  if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1590  break;
1591 
1592  out_ch = av_mallocz(sizeof(AVChapter));
1593  if (!out_ch)
1594  return AVERROR(ENOMEM);
1595 
1596  out_ch->id = in_ch->id;
1597  out_ch->time_base = in_ch->time_base;
1598  out_ch->start = FFMAX(0, in_ch->start - ts_off);
1599  out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1600 
1601  if (copy_metadata)
1602  av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1603 
1604  os->chapters[os->nb_chapters++] = out_ch;
1605  }
1606  return 0;
1607 }
1608 
1609 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1610 {
1611  int i, err;
1613 
1614  ic->interrupt_callback = int_cb;
1615  err = avformat_open_input(&ic, filename, NULL, NULL);
1616  if (err < 0)
1617  return err;
1618  /* copy stream format */
1619  for(i=0;i<ic->nb_streams;i++) {
1620  AVStream *st;
1621  OutputStream *ost;
1622  AVCodec *codec;
1623  AVCodecContext *avctx;
1624 
1625  codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1626  if (!codec) {
1627  av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1628  return AVERROR(EINVAL);
1629  }
1630  ost = new_output_stream(o, s, codec->type, -1);
1631  st = ost->st;
1632  avctx = st->codec;
1633  ost->enc = codec;
1634 
1635  // FIXME: a more elegant solution is needed
1636  memcpy(st, ic->streams[i], sizeof(AVStream));
1637  st->cur_dts = 0;
1638  st->info = av_malloc(sizeof(*st->info));
1639  memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1640  st->codec= avctx;
1641  avcodec_copy_context(st->codec, ic->streams[i]->codec);
1642 
1643  if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1644  choose_sample_fmt(st, codec);
1645  else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1646  choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1647  avcodec_copy_context(ost->enc_ctx, st->codec);
1648  }
1649 
1650  avformat_close_input(&ic);
1651  return err;
1652 }
1653 
1655  AVFormatContext *oc)
1656 {
1657  OutputStream *ost;
1658 
1660  ofilter->out_tmp->pad_idx)) {
1661  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1662  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1663  default:
1664  av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1665  "currently.\n");
1666  exit_program(1);
1667  }
1668 
1669  ost->source_index = -1;
1670  ost->filter = ofilter;
1671 
1672  ofilter->ost = ost;
1673 
1674  if (ost->stream_copy) {
1675  av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1676  "which is fed from a complex filtergraph. Filtering and streamcopy "
1677  "cannot be used together.\n", ost->file_index, ost->index);
1678  exit_program(1);
1679  }
1680 
1681  if (ost->avfilter && (ost->filters || ost->filters_script)) {
1682  const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1683  av_log(NULL, AV_LOG_ERROR,
1684  "%s '%s' was specified through the %s option "
1685  "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1686  "%s and -filter_complex cannot be used together for the same stream.\n",
1687  ost->filters ? "Filtergraph" : "Filtergraph script",
1688  ost->filters ? ost->filters : ost->filters_script,
1689  opt, ost->file_index, ost->index, opt);
1690  exit_program(1);
1691  }
1692 
1693  if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1694  av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1695  exit_program(1);
1696  }
1697  avfilter_inout_free(&ofilter->out_tmp);
1698 }
1699 
1701 {
1702  int i, ret = 0;
1703 
1704  for (i = 0; i < nb_filtergraphs; i++)
1705  if (!filtergraphs[i]->graph &&
1706  (ret = configure_filtergraph(filtergraphs[i])) < 0)
1707  return ret;
1708  return 0;
1709 }
1710 
1711 static int open_output_file(OptionsContext *o, const char *filename)
1712 {
1713  AVFormatContext *oc;
1714  int i, j, err;
1715  AVOutputFormat *file_oformat;
1716  OutputFile *of;
1717  OutputStream *ost;
1718  InputStream *ist;
1719  AVDictionary *unused_opts = NULL;
1720  AVDictionaryEntry *e = NULL;
1721 
1722  if (configure_complex_filters() < 0) {
1723  av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1724  exit_program(1);
1725  }
1726 
1727  if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1728  o->stop_time = INT64_MAX;
1729  av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1730  }
1731 
1732  if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1733  int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1734  if (o->stop_time <= start_time) {
1735  av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1736  exit_program(1);
1737  } else {
1739  }
1740  }
1741 
1743  of = av_mallocz(sizeof(*of));
1744  if (!of)
1745  exit_program(1);
1746  output_files[nb_output_files - 1] = of;
1747 
1749  of->recording_time = o->recording_time;
1750  of->start_time = o->start_time;
1751  of->limit_filesize = o->limit_filesize;
1752  of->shortest = o->shortest;
1753  av_dict_copy(&of->opts, o->g->format_opts, 0);
1754 
1755  if (!strcmp(filename, "-"))
1756  filename = "pipe:";
1757 
1758  err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1759  if (!oc) {
1760  print_error(filename, err);
1761  exit_program(1);
1762  }
1763 
1764  of->ctx = oc;
1765  if (o->recording_time != INT64_MAX)
1766  oc->duration = o->recording_time;
1767 
1768  file_oformat= oc->oformat;
1769  oc->interrupt_callback = int_cb;
1770 
1771  /* create streams for all unlabeled output pads */
1772  for (i = 0; i < nb_filtergraphs; i++) {
1773  FilterGraph *fg = filtergraphs[i];
1774  for (j = 0; j < fg->nb_outputs; j++) {
1775  OutputFilter *ofilter = fg->outputs[j];
1776 
1777  if (!ofilter->out_tmp || ofilter->out_tmp->name)
1778  continue;
1779 
1781  ofilter->out_tmp->pad_idx)) {
1782  case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1783  case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1784  case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1785  }
1786  init_output_filter(ofilter, o, oc);
1787  }
1788  }
1789 
1790  /* ffserver seeking with date=... needs a date reference */
1791  if (!strcmp(file_oformat->name, "ffm") &&
1792  av_strstart(filename, "http:", NULL)) {
1793  int err = parse_option(o, "metadata", "creation_time=now", options);
1794  if (err < 0) {
1795  print_error(filename, err);
1796  exit_program(1);
1797  }
1798  }
1799 
1800  if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1801  av_strstart(filename, "http:", NULL)) {
1802  int j;
1803  /* special case for files sent to ffserver: we get the stream
1804  parameters from ffserver */
1805  int err = read_ffserver_streams(o, oc, filename);
1806  if (err < 0) {
1807  print_error(filename, err);
1808  exit_program(1);
1809  }
1810  for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1811  ost = output_streams[j];
1812  for (i = 0; i < nb_input_streams; i++) {
1813  ist = input_streams[i];
1814  if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1815  ost->sync_ist= ist;
1816  ost->source_index= i;
1817  if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1818  if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1819  ist->discard = 0;
1820  ist->st->discard = ist->user_set_discard;
1821  break;
1822  }
1823  }
1824  if(!ost->sync_ist){
1825  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));
1826  exit_program(1);
1827  }
1828  }
1829  } else if (!o->nb_stream_maps) {
1830  char *subtitle_codec_name = NULL;
1831  /* pick the "best" stream of each type */
1832 
1833  /* video: highest resolution */
1834  if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1835  int area = 0, idx = -1;
1836  int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1837  for (i = 0; i < nb_input_streams; i++) {
1838  int new_area;
1839  ist = input_streams[i];
1840  new_area = ist->st->codec->width * ist->st->codec->height;
1841  if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1842  new_area = 1;
1843  if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1844  new_area > area) {
1845  if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1846  continue;
1847  area = new_area;
1848  idx = i;
1849  }
1850  }
1851  if (idx >= 0)
1852  new_video_stream(o, oc, idx);
1853  }
1854 
1855  /* audio: most channels */
1856  if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1857  int channels = 0, idx = -1;
1858  for (i = 0; i < nb_input_streams; i++) {
1859  ist = input_streams[i];
1860  if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1861  ist->st->codec->channels > channels) {
1862  channels = ist->st->codec->channels;
1863  idx = i;
1864  }
1865  }
1866  if (idx >= 0)
1867  new_audio_stream(o, oc, idx);
1868  }
1869 
1870  /* subtitles: pick first */
1871  MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1872  if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1873  for (i = 0; i < nb_input_streams; i++)
1874  if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1875  AVCodecDescriptor const *input_descriptor =
1876  avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1877  AVCodecDescriptor const *output_descriptor = NULL;
1878  AVCodec const *output_codec =
1880  int input_props = 0, output_props = 0;
1881  if (output_codec)
1882  output_descriptor = avcodec_descriptor_get(output_codec->id);
1883  if (input_descriptor)
1884  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1885  if (output_descriptor)
1886  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1887  if (subtitle_codec_name ||
1888  input_props & output_props ||
1889  // Map dvb teletext which has neither property to any output subtitle encoder
1890  input_descriptor && output_descriptor &&
1891  (!input_descriptor->props ||
1892  !output_descriptor->props)) {
1893  new_subtitle_stream(o, oc, i);
1894  break;
1895  }
1896  }
1897  }
1898  /* do something with data? */
1899  } else {
1900  for (i = 0; i < o->nb_stream_maps; i++) {
1901  StreamMap *map = &o->stream_maps[i];
1902 
1903  if (map->disabled)
1904  continue;
1905 
1906  if (map->linklabel) {
1907  FilterGraph *fg;
1908  OutputFilter *ofilter = NULL;
1909  int j, k;
1910 
1911  for (j = 0; j < nb_filtergraphs; j++) {
1912  fg = filtergraphs[j];
1913  for (k = 0; k < fg->nb_outputs; k++) {
1914  AVFilterInOut *out = fg->outputs[k]->out_tmp;
1915  if (out && !strcmp(out->name, map->linklabel)) {
1916  ofilter = fg->outputs[k];
1917  goto loop_end;
1918  }
1919  }
1920  }
1921 loop_end:
1922  if (!ofilter) {
1923  av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1924  "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1925  exit_program(1);
1926  }
1927  init_output_filter(ofilter, o, oc);
1928  } else {
1929  int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1930 
1933  continue;
1934  if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1935  continue;
1936  if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1937  continue;
1938  if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1939  continue;
1940 
1941  switch (ist->st->codec->codec_type) {
1942  case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1943  case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1944  case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1945  case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1946  case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1947  default:
1948  av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1949  map->file_index, map->stream_index);
1950  exit_program(1);
1951  }
1952  }
1953  }
1954  }
1955 
1956  /* handle attached files */
1957  for (i = 0; i < o->nb_attachments; i++) {
1958  AVIOContext *pb;
1959  uint8_t *attachment;
1960  const char *p;
1961  int64_t len;
1962 
1963  if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1964  av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1965  o->attachments[i]);
1966  exit_program(1);
1967  }
1968  if ((len = avio_size(pb)) <= 0) {
1969  av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1970  o->attachments[i]);
1971  exit_program(1);
1972  }
1973  if (!(attachment = av_malloc(len))) {
1974  av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1975  o->attachments[i]);
1976  exit_program(1);
1977  }
1978  avio_read(pb, attachment, len);
1979 
1980  ost = new_attachment_stream(o, oc, -1);
1981  ost->stream_copy = 0;
1982  ost->attachment_filename = o->attachments[i];
1983  ost->finished = 1;
1984  ost->enc_ctx->extradata = attachment;
1985  ost->enc_ctx->extradata_size = len;
1986 
1987  p = strrchr(o->attachments[i], '/');
1988  av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1989  avio_close(pb);
1990  }
1991 
1992  for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1993  AVDictionaryEntry *e;
1994  ost = output_streams[i];
1995 
1996  if ((ost->stream_copy || ost->attachment_filename)
1997  && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1998  && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1999  if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2000  exit_program(1);
2001  }
2002 
2003  /* check if all codec options have been used */
2004  unused_opts = strip_specifiers(o->g->codec_opts);
2005  for (i = of->ost_index; i < nb_output_streams; i++) {
2006  e = NULL;
2007  while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2009  av_dict_set(&unused_opts, e->key, NULL, 0);
2010  }
2011 
2012  e = NULL;
2013  while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2014  const AVClass *class = avcodec_get_class();
2015  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2017  const AVClass *fclass = avformat_get_class();
2018  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2020  if (!option || foption)
2021  continue;
2022 
2023 
2024  if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2025  av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2026  "output file #%d (%s) is not an encoding option.\n", e->key,
2027  option->help ? option->help : "", nb_output_files - 1,
2028  filename);
2029  exit_program(1);
2030  }
2031 
2032  // gop_timecode is injected by generic code but not always used
2033  if (!strcmp(e->key, "gop_timecode"))
2034  continue;
2035 
2036  av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2037  "output file #%d (%s) has not been used for any stream. The most "
2038  "likely reason is either wrong type (e.g. a video option with "
2039  "no video streams) or that it is a private option of some encoder "
2040  "which was not actually used for any stream.\n", e->key,
2041  option->help ? option->help : "", nb_output_files - 1, filename);
2042  }
2043  av_dict_free(&unused_opts);
2044 
2045  /* check filename in case of an image number is expected */
2046  if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2047  if (!av_filename_number_test(oc->filename)) {
2048  print_error(oc->filename, AVERROR(EINVAL));
2049  exit_program(1);
2050  }
2051  }
2052 
2053  if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2054  /* test if it already exists to avoid losing precious files */
2055  assert_file_overwrite(filename);
2056 
2057  /* open the file */
2058  if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2059  &oc->interrupt_callback,
2060  &of->opts)) < 0) {
2061  print_error(filename, err);
2062  exit_program(1);
2063  }
2064  } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2065  assert_file_overwrite(filename);
2066 
2067  if (o->mux_preload) {
2068  av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2069  }
2070  oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2071 
2072  /* copy metadata */
2073  for (i = 0; i < o->nb_metadata_map; i++) {
2074  char *p;
2075  int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2076 
2077  if (in_file_index >= nb_input_files) {
2078  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2079  exit_program(1);
2080  }
2081  copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2082  in_file_index >= 0 ?
2083  input_files[in_file_index]->ctx : NULL, o);
2084  }
2085 
2086  /* copy chapters */
2087  if (o->chapters_input_file >= nb_input_files) {
2088  if (o->chapters_input_file == INT_MAX) {
2089  /* copy chapters from the first input file that has them*/
2090  o->chapters_input_file = -1;
2091  for (i = 0; i < nb_input_files; i++)
2092  if (input_files[i]->ctx->nb_chapters) {
2093  o->chapters_input_file = i;
2094  break;
2095  }
2096  } else {
2097  av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2098  o->chapters_input_file);
2099  exit_program(1);
2100  }
2101  }
2102  if (o->chapters_input_file >= 0)
2105 
2106  /* copy global metadata by default */
2110  if(o->recording_time != INT64_MAX)
2111  av_dict_set(&oc->metadata, "duration", NULL, 0);
2112  av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2113  }
2114  if (!o->metadata_streams_manual)
2115  for (i = of->ost_index; i < nb_output_streams; i++) {
2116  InputStream *ist;
2117  if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2118  continue;
2120  av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2121  if (!output_streams[i]->stream_copy)
2122  av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2123  }
2124 
2125  /* process manually set metadata */
2126  for (i = 0; i < o->nb_metadata; i++) {
2127  AVDictionary **m;
2128  char type, *val;
2129  const char *stream_spec;
2130  int index = 0, j, ret = 0;
2131 
2132  val = strchr(o->metadata[i].u.str, '=');
2133  if (!val) {
2134  av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2135  o->metadata[i].u.str);
2136  exit_program(1);
2137  }
2138  *val++ = 0;
2139 
2140  parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2141  if (type == 's') {
2142  for (j = 0; j < oc->nb_streams; j++) {
2143  if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2144  av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2145  } else if (ret < 0)
2146  exit_program(1);
2147  }
2148  }
2149  else {
2150  switch (type) {
2151  case 'g':
2152  m = &oc->metadata;
2153  break;
2154  case 'c':
2155  if (index < 0 || index >= oc->nb_chapters) {
2156  av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2157  exit_program(1);
2158  }
2159  m = &oc->chapters[index]->metadata;
2160  break;
2161  default:
2162  av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2163  exit_program(1);
2164  }
2165  av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2166  }
2167  }
2168 
2169  return 0;
2170 }
2171 
2172 static int opt_target(void *optctx, const char *opt, const char *arg)
2173 {
2174  OptionsContext *o = optctx;
2175  enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2176  static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2177 
2178  if (!strncmp(arg, "pal-", 4)) {
2179  norm = PAL;
2180  arg += 4;
2181  } else if (!strncmp(arg, "ntsc-", 5)) {
2182  norm = NTSC;
2183  arg += 5;
2184  } else if (!strncmp(arg, "film-", 5)) {
2185  norm = FILM;
2186  arg += 5;
2187  } else {
2188  /* Try to determine PAL/NTSC by peeking in the input files */
2189  if (nb_input_files) {
2190  int i, j, fr;
2191  for (j = 0; j < nb_input_files; j++) {
2192  for (i = 0; i < input_files[j]->nb_streams; i++) {
2194  if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2195  !c->time_base.num)
2196  continue;
2197  fr = c->time_base.den * 1000 / c->time_base.num;
2198  if (fr == 25000) {
2199  norm = PAL;
2200  break;
2201  } else if ((fr == 29970) || (fr == 23976)) {
2202  norm = NTSC;
2203  break;
2204  }
2205  }
2206  if (norm != UNKNOWN)
2207  break;
2208  }
2209  }
2210  if (norm != UNKNOWN)
2211  av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2212  }
2213 
2214  if (norm == UNKNOWN) {
2215  av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2216  av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2217  av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2218  exit_program(1);
2219  }
2220 
2221  if (!strcmp(arg, "vcd")) {
2222  opt_video_codec(o, "c:v", "mpeg1video");
2223  opt_audio_codec(o, "c:a", "mp2");
2224  parse_option(o, "f", "vcd", options);
2225 
2226  parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2227  parse_option(o, "r", frame_rates[norm], options);
2228  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2229 
2230  opt_default(NULL, "b:v", "1150000");
2231  opt_default(NULL, "maxrate", "1150000");
2232  opt_default(NULL, "minrate", "1150000");
2233  opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2234 
2235  opt_default(NULL, "b:a", "224000");
2236  parse_option(o, "ar", "44100", options);
2237  parse_option(o, "ac", "2", options);
2238 
2239  opt_default(NULL, "packetsize", "2324");
2240  opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2241 
2242  /* We have to offset the PTS, so that it is consistent with the SCR.
2243  SCR starts at 36000, but the first two packs contain only padding
2244  and the first pack from the other stream, respectively, may also have
2245  been written before.
2246  So the real data starts at SCR 36000+3*1200. */
2247  o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2248  } else if (!strcmp(arg, "svcd")) {
2249 
2250  opt_video_codec(o, "c:v", "mpeg2video");
2251  opt_audio_codec(o, "c:a", "mp2");
2252  parse_option(o, "f", "svcd", options);
2253 
2254  parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2255  parse_option(o, "r", frame_rates[norm], options);
2256  parse_option(o, "pix_fmt", "yuv420p", options);
2257  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2258 
2259  opt_default(NULL, "b:v", "2040000");
2260  opt_default(NULL, "maxrate", "2516000");
2261  opt_default(NULL, "minrate", "0"); // 1145000;
2262  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2263  opt_default(NULL, "scan_offset", "1");
2264 
2265  opt_default(NULL, "b:a", "224000");
2266  parse_option(o, "ar", "44100", options);
2267 
2268  opt_default(NULL, "packetsize", "2324");
2269 
2270  } else if (!strcmp(arg, "dvd")) {
2271 
2272  opt_video_codec(o, "c:v", "mpeg2video");
2273  opt_audio_codec(o, "c:a", "ac3");
2274  parse_option(o, "f", "dvd", options);
2275 
2276  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2277  parse_option(o, "r", frame_rates[norm], options);
2278  parse_option(o, "pix_fmt", "yuv420p", options);
2279  opt_default(NULL, "g", norm == PAL ? "15" : "18");
2280 
2281  opt_default(NULL, "b:v", "6000000");
2282  opt_default(NULL, "maxrate", "9000000");
2283  opt_default(NULL, "minrate", "0"); // 1500000;
2284  opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2285 
2286  opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2287  opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2288 
2289  opt_default(NULL, "b:a", "448000");
2290  parse_option(o, "ar", "48000", options);
2291 
2292  } else if (!strncmp(arg, "dv", 2)) {
2293 
2294  parse_option(o, "f", "dv", options);
2295 
2296  parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2297  parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2298  norm == PAL ? "yuv420p" : "yuv411p", options);
2299  parse_option(o, "r", frame_rates[norm], options);
2300 
2301  parse_option(o, "ar", "48000", options);
2302  parse_option(o, "ac", "2", options);
2303 
2304  } else {
2305  av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2306  return AVERROR(EINVAL);
2307  }
2308 
2311 
2312  return 0;
2313 }
2314 
2315 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2316 {
2318  vstats_filename = av_strdup (arg);
2319  return 0;
2320 }
2321 
2322 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2323 {
2324  char filename[40];
2325  time_t today2 = time(NULL);
2326  struct tm *today = localtime(&today2);
2327 
2328  snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2329  today->tm_sec);
2330  return opt_vstats_file(NULL, opt, filename);
2331 }
2332 
2333 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2334 {
2335  OptionsContext *o = optctx;
2336  return parse_option(o, "frames:v", arg, options);
2337 }
2338 
2339 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2340 {
2341  OptionsContext *o = optctx;
2342  return parse_option(o, "frames:a", arg, options);
2343 }
2344 
2345 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2346 {
2347  OptionsContext *o = optctx;
2348  return parse_option(o, "frames:d", arg, options);
2349 }
2350 
2351 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2352 {
2353  int ret;
2354  AVDictionary *cbak = codec_opts;
2355  AVDictionary *fbak = format_opts;
2356  codec_opts = NULL;
2357  format_opts = NULL;
2358 
2359  ret = opt_default(NULL, opt, arg);
2360 
2361  av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2365  codec_opts = cbak;
2366  format_opts = fbak;
2367 
2368  return ret;
2369 }
2370 
2371 static int opt_preset(void *optctx, const char *opt, const char *arg)
2372 {
2373  OptionsContext *o = optctx;
2374  FILE *f=NULL;
2375  char filename[1000], line[1000], tmp_line[1000];
2376  const char *codec_name = NULL;
2377 
2378  tmp_line[0] = *opt;
2379  tmp_line[1] = 0;
2380  MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2381 
2382  if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2383  if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2384  av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2385  }else
2386  av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2387  exit_program(1);
2388  }
2389 
2390  while (fgets(line, sizeof(line), f)) {
2391  char *key = tmp_line, *value, *endptr;
2392 
2393  if (strcspn(line, "#\n\r") == 0)
2394  continue;
2395  av_strlcpy(tmp_line, line, sizeof(tmp_line));
2396  if (!av_strtok(key, "=", &value) ||
2397  !av_strtok(value, "\r\n", &endptr)) {
2398  av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2399  exit_program(1);
2400  }
2401  av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2402 
2403  if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2404  else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2405  else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2406  else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2407  else if (opt_default_new(o, key, value) < 0) {
2408  av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2409  filename, line, key, value);
2410  exit_program(1);
2411  }
2412  }
2413 
2414  fclose(f);
2415 
2416  return 0;
2417 }
2418 
2419 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2420 {
2421  OptionsContext *o = optctx;
2422  char *s = av_asprintf("%s:%c", opt + 1, *opt);
2423  int ret = parse_option(o, s, arg, options);
2424  av_free(s);
2425  return ret;
2426 }
2427 
2428 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2429 {
2430  OptionsContext *o = optctx;
2431 
2432  if(!strcmp(opt, "ab")){
2433  av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2434  return 0;
2435  } else if(!strcmp(opt, "b")){
2436  av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2437  av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2438  return 0;
2439  }
2440  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2441  return 0;
2442 }
2443 
2444 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2445 {
2446  OptionsContext *o = optctx;
2447  char *s;
2448  int ret;
2449  if(!strcmp(opt, "qscale")){
2450  av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2451  return parse_option(o, "q:v", arg, options);
2452  }
2453  s = av_asprintf("q%s", opt + 6);
2454  ret = parse_option(o, s, arg, options);
2455  av_free(s);
2456  return ret;
2457 }
2458 
2459 static int opt_profile(void *optctx, const char *opt, const char *arg)
2460 {
2461  OptionsContext *o = optctx;
2462  if(!strcmp(opt, "profile")){
2463  av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2464  av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2465  return 0;
2466  }
2467  av_dict_set(&o->g->codec_opts, opt, arg, 0);
2468  return 0;
2469 }
2470 
2471 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2472 {
2473  OptionsContext *o = optctx;
2474  return parse_option(o, "filter:v", arg, options);
2475 }
2476 
2477 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2478 {
2479  OptionsContext *o = optctx;
2480  return parse_option(o, "filter:a", arg, options);
2481 }
2482 
2483 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2484 {
2485  if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2486  else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2487  else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2488  else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2489 
2492  return 0;
2493 }
2494 
2495 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2496 {
2497  OptionsContext *o = optctx;
2498  char *tcr = av_asprintf("timecode=%s", arg);
2499  int ret = parse_option(o, "metadata:g", tcr, options);
2500  if (ret >= 0)
2501  ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2502  av_free(tcr);
2503  return 0;
2504 }
2505 
2506 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2507 {
2508  OptionsContext *o = optctx;
2509  char layout_str[32];
2510  char *stream_str;
2511  char *ac_str;
2512  int ret, channels, ac_str_size;
2513  uint64_t layout;
2514 
2515  layout = av_get_channel_layout(arg);
2516  if (!layout) {
2517  av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2518  return AVERROR(EINVAL);
2519  }
2520  snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2521  ret = opt_default_new(o, opt, layout_str);
2522  if (ret < 0)
2523  return ret;
2524 
2525  /* set 'ac' option based on channel layout */
2526  channels = av_get_channel_layout_nb_channels(layout);
2527  snprintf(layout_str, sizeof(layout_str), "%d", channels);
2528  stream_str = strchr(opt, ':');
2529  ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2530  ac_str = av_mallocz(ac_str_size);
2531  if (!ac_str)
2532  return AVERROR(ENOMEM);
2533  av_strlcpy(ac_str, "ac", 3);
2534  if (stream_str)
2535  av_strlcat(ac_str, stream_str, ac_str_size);
2536  ret = parse_option(o, ac_str, layout_str, options);
2537  av_free(ac_str);
2538 
2539  return ret;
2540 }
2541 
2542 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2543 {
2544  OptionsContext *o = optctx;
2545  return parse_option(o, "q:a", arg, options);
2546 }
2547 
2548 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2549 {
2551  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2552  return AVERROR(ENOMEM);
2555  if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2556  return AVERROR(ENOMEM);
2557  return 0;
2558 }
2559 
2560 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2561 {
2562  uint8_t *graph_desc = read_file(arg);
2563  if (!graph_desc)
2564  return AVERROR(EINVAL);
2565 
2567  if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2568  return AVERROR(ENOMEM);
2570  filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2571  return 0;
2572 }
2573 
2574 void show_help_default(const char *opt, const char *arg)
2575 {
2576  /* per-file options have at least one of those set */
2577  const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2578  int show_advanced = 0, show_avoptions = 0;
2579 
2580  if (opt && *opt) {
2581  if (!strcmp(opt, "long"))
2582  show_advanced = 1;
2583  else if (!strcmp(opt, "full"))
2584  show_advanced = show_avoptions = 1;
2585  else
2586  av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2587  }
2588 
2589  show_usage();
2590 
2591  printf("Getting help:\n"
2592  " -h -- print basic options\n"
2593  " -h long -- print more options\n"
2594  " -h full -- print all options (including all format and codec specific options, very long)\n"
2595  " See man %s for detailed description of the options.\n"
2596  "\n", program_name);
2597 
2598  show_help_options(options, "Print help / information / capabilities:",
2599  OPT_EXIT, 0, 0);
2600 
2601  show_help_options(options, "Global options (affect whole program "
2602  "instead of just one file:",
2603  0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2604  if (show_advanced)
2605  show_help_options(options, "Advanced global options:", OPT_EXPERT,
2606  per_file | OPT_EXIT, 0);
2607 
2608  show_help_options(options, "Per-file main options:", 0,
2610  OPT_EXIT, per_file);
2611  if (show_advanced)
2612  show_help_options(options, "Advanced per-file options:",
2613  OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2614 
2615  show_help_options(options, "Video options:",
2617  if (show_advanced)
2618  show_help_options(options, "Advanced Video options:",
2620 
2621  show_help_options(options, "Audio options:",
2623  if (show_advanced)
2624  show_help_options(options, "Advanced Audio options:",
2626  show_help_options(options, "Subtitle options:",
2627  OPT_SUBTITLE, 0, 0);
2628  printf("\n");
2629 
2630  if (show_avoptions) {
2634 #if CONFIG_SWSCALE
2636 #endif
2639  }
2640 }
2641 
2642 void show_usage(void)
2643 {
2644  av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2645  av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2646  av_log(NULL, AV_LOG_INFO, "\n");
2647 }
2648 
2649 enum OptGroup {
2652 };
2653 
2654 static const OptionGroupDef groups[] = {
2655  [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2656  [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2657 };
2658 
2659 static int open_files(OptionGroupList *l, const char *inout,
2660  int (*open_file)(OptionsContext*, const char*))
2661 {
2662  int i, ret;
2663 
2664  for (i = 0; i < l->nb_groups; i++) {
2665  OptionGroup *g = &l->groups[i];
2666  OptionsContext o;
2667 
2668  init_options(&o);
2669  o.g = g;
2670 
2671  ret = parse_optgroup(&o, g);
2672  if (ret < 0) {
2673  av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2674  "%s.\n", inout, g->arg);
2675  return ret;
2676  }
2677 
2678  av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2679  ret = open_file(&o, g->arg);
2680  uninit_options(&o);
2681  if (ret < 0) {
2682  av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2683  inout, g->arg);
2684  return ret;
2685  }
2686  av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2687  }
2688 
2689  return 0;
2690 }
2691 
2692 int ffmpeg_parse_options(int argc, char **argv)
2693 {
2694  OptionParseContext octx;
2695  uint8_t error[128];
2696  int ret;
2697 
2698  memset(&octx, 0, sizeof(octx));
2699 
2700  /* split the commandline into an internal representation */
2701  ret = split_commandline(&octx, argc, argv, options, groups,
2702  FF_ARRAY_ELEMS(groups));
2703  if (ret < 0) {
2704  av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2705  goto fail;
2706  }
2707 
2708  /* apply global options */
2709  ret = parse_optgroup(NULL, &octx.global_opts);
2710  if (ret < 0) {
2711  av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2712  goto fail;
2713  }
2714 
2715  /* open input files */
2716  ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2717  if (ret < 0) {
2718  av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2719  goto fail;
2720  }
2721 
2722  /* open output files */
2723  ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2724  if (ret < 0) {
2725  av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2726  goto fail;
2727  }
2728 
2729 fail:
2730  uninit_parse_context(&octx);
2731  if (ret < 0) {
2732  av_strerror(ret, error, sizeof(error));
2733  av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2734  }
2735  return ret;
2736 }
2737 
2738 static int opt_progress(void *optctx, const char *opt, const char *arg)
2739 {
2740  AVIOContext *avio = NULL;
2741  int ret;
2742 
2743  if (!strcmp(arg, "-"))
2744  arg = "pipe:";
2745  ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2746  if (ret < 0) {
2747  av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2748  arg, av_err2str(ret));
2749  return ret;
2750  }
2751  progress_avio = avio;
2752  return 0;
2753 }
2754 
2755 #define OFFSET(x) offsetof(OptionsContext, x)
2756 const OptionDef options[] = {
2757  /* main options */
2758 #include "cmdutils_common_opts.h"
2759  { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2760  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2761  "force format", "fmt" },
2762  { "y", OPT_BOOL, { &file_overwrite },
2763  "overwrite output files" },
2764  { "n", OPT_BOOL, { &no_file_overwrite },
2765  "never overwrite output files" },
2766  { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2767  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2768  "codec name", "codec" },
2769  { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2770  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2771  "codec name", "codec" },
2772  { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2773  OPT_OUTPUT, { .off = OFFSET(presets) },
2774  "preset name", "preset" },
2775  { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2776  OPT_OUTPUT, { .func_arg = opt_map },
2777  "set input stream mapping",
2778  "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2779  { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2780  "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2781  { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2782  OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2783  "set metadata information of outfile from infile",
2784  "outfile[,metadata]:infile[,metadata]" },
2785  { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2786  OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2787  "set chapters mapping", "input_file_index" },
2788  { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2789  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2790  "record or transcode \"duration\" seconds of audio/video",
2791  "duration" },
2792  { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2793  "record or transcode stop time", "time_stop" },
2794  { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2795  "set the limit file size in bytes", "limit_size" },
2796  { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2797  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2798  "set the start time offset", "time_off" },
2799  { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2800  OPT_INPUT, { .off = OFFSET(accurate_seek) },
2801  "enable/disable accurate seeking with -ss" },
2802  { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2803  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2804  "set the input ts offset", "time_off" },
2805  { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2806  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2807  "set the input ts scale", "scale" },
2808  { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2809  "set the recording timestamp ('now' to set the current time)", "time" },
2810  { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2811  "add metadata", "string=string" },
2812  { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2813  OPT_OUTPUT, { .func_arg = opt_data_frames },
2814  "set the number of data frames to record", "number" },
2815  { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2816  "add timings for benchmarking" },
2817  { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2818  "add timings for each task" },
2819  { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2820  "write program-readable progress information", "url" },
2821  { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2822  "enable or disable interaction on standard input" },
2823  { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2824  "set max runtime in seconds", "limit" },
2825  { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2826  "dump each input packet" },
2827  { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2828  "when dumping packets, also dump the payload" },
2829  { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2830  OPT_INPUT, { .off = OFFSET(rate_emu) },
2831  "read input at native frame rate", "" },
2832  { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2833  "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2834  " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2835  { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2836  "video sync method", "" },
2837  { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2838  "audio sync method", "" },
2839  { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2840  "audio drift threshold", "threshold" },
2841  { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2842  "copy timestamps" },
2843  { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
2844  "copy input stream time base when stream copying", "mode" },
2845  { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2846  OPT_OUTPUT, { .off = OFFSET(shortest) },
2847  "finish encoding within shortest input" },
2848  { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2849  OPT_OUTPUT, { .off = OFFSET(apad) },
2850  "audio pad", "" },
2851  { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2852  "timestamp discontinuity delta threshold", "threshold" },
2853  { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2854  "timestamp error delta threshold", "threshold" },
2855  { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2856  "exit on error", "error" },
2857  { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2858  OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2859  "copy initial non-keyframes" },
2860  { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2861  "copy or discard frames before start time" },
2862  { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2863  "set the number of frames to record", "number" },
2864  { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2865  OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2866  "force codec tag/fourcc", "fourcc/tag" },
2867  { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2868  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2869  "use fixed quality scale (VBR)", "q" },
2870  { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2871  OPT_OUTPUT, { .func_arg = opt_qscale },
2872  "use fixed quality scale (VBR)", "q" },
2873  { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2874  "set profile", "profile" },
2875  { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2876  "set stream filtergraph", "filter_graph" },
2877  { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2878  "read stream filtergraph description from a file", "filename" },
2879  { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2880  "reinit filtergraph on input parameter changes", "" },
2881  { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2882  "create a complex filtergraph", "graph_description" },
2883  { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2884  "create a complex filtergraph", "graph_description" },
2885  { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2886  "read complex filtergraph description from a file", "filename" },
2887  { "stats", OPT_BOOL, { &print_stats },
2888  "print progress report during encoding", },
2889  { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2890  OPT_OUTPUT, { .func_arg = opt_attach },
2891  "add an attachment to the output file", "filename" },
2892  { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2893  OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2894  "extract an attachment into a file", "filename" },
2895  { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2896  "print timestamp debugging info" },
2897  { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2898  "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2899  { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2900  OPT_INPUT, { .off = OFFSET(discard) },
2901  "discard", "" },
2902 
2903  /* video options */
2904  { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2905  "set the number of video frames to record", "number" },
2906  { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2907  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2908  "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2910  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2911  "set frame size (WxH or abbreviation)", "size" },
2912  { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2913  OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2914  "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2915  { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2916  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2917  "set pixel format", "format" },
2918  { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2919  "set the number of bits per raw sample", "number" },
2920  { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2921  "deprecated use -g 1" },
2923  "disable video" },
2924  { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2925  OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2926  "rate control override for specific intervals", "override" },
2927  { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2928  OPT_OUTPUT, { .func_arg = opt_video_codec },
2929  "force video codec ('copy' to copy stream)", "codec" },
2930  { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2931  "Removed" },
2932  { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2933  "Removed" },
2934  { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2935  "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2936  { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2937  "select the pass number (1 to 3)", "n" },
2938  { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2939  OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2940  "select two pass log file name prefix", "prefix" },
2941  { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2942  "this option is deprecated, use the yadif filter instead" },
2943  { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2944  "calculate PSNR of compressed frames" },
2945  { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2946  "dump video coding statistics to file" },
2947  { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2948  "dump video coding statistics to file", "file" },
2949  { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2950  "set video filters", "filter_graph" },
2951  { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2952  OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2953  "specify intra matrix coeffs", "matrix" },
2954  { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2955  OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2956  "specify inter matrix coeffs", "matrix" },
2957  { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2958  OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2959  "specify intra matrix coeffs", "matrix" },
2960  { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2961  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2962  "top=1/bottom=0/auto=-1 field first", "" },
2963  { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2964  OPT_OUTPUT, { .func_arg = opt_old2new },
2965  "force video tag/fourcc", "fourcc/tag" },
2966  { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2967  "show QP histogram" },
2968  { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2969  OPT_OUTPUT, { .off = OFFSET(force_fps) },
2970  "force the selected framerate, disable the best supported framerate selection" },
2971  { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2972  OPT_OUTPUT, { .func_arg = opt_streamid },
2973  "set the value of an outfile streamid", "streamIndex:value" },
2974  { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2975  OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2976  "force key frames at specified timestamps", "timestamps" },
2977  { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2978  "audio bitrate (please use -b:a)", "bitrate" },
2979  { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2980  "video bitrate (please use -b:v)", "bitrate" },
2981  { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2982  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2983  "use HW accelerated decoding", "hwaccel name" },
2984  { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2985  OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2986  "select a device for HW acceleration" "devicename" },
2987 #if HAVE_VDPAU_X11
2988  { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
2989 #endif
2990 
2991  /* audio options */
2992  { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2993  "set the number of audio frames to record", "number" },
2994  { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2995  "set audio quality (codec-specific)", "quality", },
2996  { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2997  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2998  "set audio sampling rate (in Hz)", "rate" },
2999  { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3000  OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3001  "set number of audio channels", "channels" },
3003  "disable audio" },
3004  { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3005  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3006  "force audio codec ('copy' to copy stream)", "codec" },
3007  { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3008  OPT_OUTPUT, { .func_arg = opt_old2new },
3009  "force audio tag/fourcc", "fourcc/tag" },
3010  { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3011  "change audio volume (256=normal)" , "volume" },
3012  { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3014  "set sample format", "format" },
3015  { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3016  OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3017  "set channel layout", "layout" },
3018  { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3019  "set audio filters", "filter_graph" },
3020  { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3021  "set the maximum number of channels to try to guess the channel layout" },
3022 
3023  /* subtitle options */
3025  "disable subtitle" },
3026  { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3027  "force subtitle codec ('copy' to copy stream)", "codec" },
3028  { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3029  , "force subtitle tag/fourcc", "fourcc/tag" },
3030  { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3031  "fix subtitles duration" },
3032  { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3033  "set canvas size (WxH or abbreviation)", "size" },
3034 
3035  /* grab options */
3036  { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3037  "deprecated, use -channel", "channel" },
3038  { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3039  "deprecated, use -standard", "standard" },
3040  { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3041 
3042  /* muxer options */
3043  { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3044  "set the maximum demux-decode delay", "seconds" },
3045  { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3046  "set the initial demux-decode delay", "seconds" },
3047  { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3048  "override the options from ffserver", "" },
3049 
3050  { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3051  "A comma-separated list of bitstream filters", "bitstream_filters" },
3052  { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3053  "deprecated", "audio bitstream_filters" },
3054  { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3055  "deprecated", "video bitstream_filters" },
3056 
3057  { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3058  "set the audio options to the indicated preset", "preset" },
3059  { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3060  "set the video options to the indicated preset", "preset" },
3061  { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3062  "set the subtitle options to the indicated preset", "preset" },
3063  { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3064  "set options from indicated preset file", "filename" },
3065  /* data codec support */
3066  { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3067  "force data codec ('copy' to copy stream)", "codec" },
3068  { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3069  "disable data" },
3070 
3071  { NULL, },
3072 };