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