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