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