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