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