2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
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.
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.
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
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 for (i = 0; i < o->nb_ ## name; i++) {\
61 char *spec = o->name[i].specifier;\
62 if (!strcmp(spec, mediatype))\
63 outvar = o->name[i].u.type;\
66 char *vstats_filename;
68 float audio_drift_threshold = 0.1;
69 float dts_delta_threshold = 10;
70 float dts_error_threshold = 3600*30;
72 int audio_volume = 256;
73 int audio_sync_method = 0;
74 int video_sync_method = VSYNC_AUTO;
75 int do_deinterlace = 0;
77 int do_benchmark_all = 0;
83 int exit_on_error = 0;
86 int stdin_interaction = 1;
87 int frame_bits_per_raw_sample = 0;
90 static int intra_only = 0;
91 static int file_overwrite = 0;
92 static int no_file_overwrite = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int do_psnr = 0;
96 static int input_sync;
98 static int64_t recording_time = INT64_MAX;
100 static void uninit_options(OptionsContext *o, int is_input)
102 const OptionDef *po = options;
105 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
107 void *dst = (uint8_t*)o + po->u.off;
109 if (po->flags & OPT_SPEC) {
110 SpecifierOpt **so = dst;
111 int i, *count = (int*)(so + 1);
112 for (i = 0; i < *count; i++) {
113 av_freep(&(*so)[i].specifier);
114 if (po->flags & OPT_STRING)
115 av_freep(&(*so)[i].u.str);
119 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
124 for (i = 0; i < o->nb_stream_maps; i++)
125 av_freep(&o->stream_maps[i].linklabel);
126 av_freep(&o->stream_maps);
127 av_freep(&o->audio_channel_maps);
128 av_freep(&o->streamid_map);
129 av_freep(&o->attachments);
132 recording_time = o->recording_time;
134 recording_time = INT64_MAX;
137 static void init_options(OptionsContext *o, int is_input)
139 memset(o, 0, sizeof(*o));
141 if (!is_input && recording_time != INT64_MAX) {
142 o->recording_time = recording_time;
143 av_log(NULL, AV_LOG_WARNING,
144 "-t is not an input option, keeping it for the next output;"
145 " consider fixing your command line.\n");
147 o->recording_time = INT64_MAX;
148 o->mux_max_delay = 0.7;
149 o->limit_filesize = UINT64_MAX;
150 o->chapters_input_file = INT_MAX;
153 static int opt_sameq(void *optctx, const char *opt, const char *arg)
155 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
156 "If you are looking for an option to preserve the quality (which is not "
157 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
159 return AVERROR(EINVAL);
162 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
164 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
165 return opt_default(optctx, "channel", arg);
168 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
170 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
171 return opt_default(optctx, "standard", arg);
174 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
176 OptionsContext *o = optctx;
177 return parse_option(o, "codec:a", arg, options);
180 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
182 OptionsContext *o = optctx;
183 return parse_option(o, "codec:v", arg, options);
186 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
188 OptionsContext *o = optctx;
189 return parse_option(o, "codec:s", arg, options);
192 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
194 OptionsContext *o = optctx;
195 return parse_option(o, "codec:d", arg, options);
198 static int opt_map(void *optctx, const char *opt, const char *arg)
200 OptionsContext *o = optctx;
202 int i, negative = 0, file_idx;
203 int sync_file_idx = -1, sync_stream_idx = 0;
211 map = av_strdup(arg);
213 /* parse sync stream first, just pick first matching stream */
214 if (sync = strchr(map, ',')) {
216 sync_file_idx = strtol(sync + 1, &sync, 0);
217 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
218 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
223 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
224 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
225 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
229 if (i == input_files[sync_file_idx]->nb_streams) {
230 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
231 "match any streams.\n", arg);
238 /* this mapping refers to lavfi output */
239 const char *c = map + 1;
240 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
241 m = &o->stream_maps[o->nb_stream_maps - 1];
242 m->linklabel = av_get_token(&c, "]");
244 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
248 file_idx = strtol(map, &p, 0);
249 if (file_idx >= nb_input_files || file_idx < 0) {
250 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
254 /* disable some already defined maps */
255 for (i = 0; i < o->nb_stream_maps; i++) {
256 m = &o->stream_maps[i];
257 if (file_idx == m->file_index &&
258 check_stream_specifier(input_files[m->file_index]->ctx,
259 input_files[m->file_index]->ctx->streams[m->stream_index],
260 *p == ':' ? p + 1 : p) > 0)
264 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
265 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
266 *p == ':' ? p + 1 : p) <= 0)
268 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
269 m = &o->stream_maps[o->nb_stream_maps - 1];
271 m->file_index = file_idx;
274 if (sync_file_idx >= 0) {
275 m->sync_file_index = sync_file_idx;
276 m->sync_stream_index = sync_stream_idx;
278 m->sync_file_index = file_idx;
279 m->sync_stream_index = i;
285 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
293 static int opt_attach(void *optctx, const char *opt, const char *arg)
295 OptionsContext *o = optctx;
296 GROW_ARRAY(o->attachments, o->nb_attachments);
297 o->attachments[o->nb_attachments - 1] = arg;
301 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
303 OptionsContext *o = optctx;
308 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
309 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
311 /* muted channel syntax */
312 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
313 if ((n == 1 || n == 3) && m->channel_idx == -1) {
314 m->file_idx = m->stream_idx = -1;
316 m->ofile_idx = m->ostream_idx = -1;
321 n = sscanf(arg, "%d.%d.%d:%d.%d",
322 &m->file_idx, &m->stream_idx, &m->channel_idx,
323 &m->ofile_idx, &m->ostream_idx);
325 if (n != 3 && n != 5) {
326 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
327 "[file.stream.channel|-1][:syncfile:syncstream]\n");
331 if (n != 5) // only file.stream.channel specified
332 m->ofile_idx = m->ostream_idx = -1;
335 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
336 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
340 if (m->stream_idx < 0 ||
341 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
342 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
343 m->file_idx, m->stream_idx);
346 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
347 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
348 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
349 m->file_idx, m->stream_idx);
352 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
353 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
354 m->file_idx, m->stream_idx, m->channel_idx);
361 * Parse a metadata specifier passed as 'arg' parameter.
362 * @param arg metadata string to parse
363 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
364 * @param index for type c/p, chapter/program index is written here
365 * @param stream_spec for type s, the stream specifier is written here
367 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
375 if (*(++arg) && *arg != ':') {
376 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
379 *stream_spec = *arg == ':' ? arg + 1 : "";
384 *index = strtol(++arg, NULL, 0);
387 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
394 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
396 AVDictionary **meta_in = NULL;
397 AVDictionary **meta_out = NULL;
399 char type_in, type_out;
400 const char *istream_spec = NULL, *ostream_spec = NULL;
401 int idx_in = 0, idx_out = 0;
403 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
404 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
407 if (type_out == 'g' || !*outspec)
408 o->metadata_global_manual = 1;
409 if (type_out == 's' || !*outspec)
410 o->metadata_streams_manual = 1;
411 if (type_out == 'c' || !*outspec)
412 o->metadata_chapters_manual = 1;
416 if (type_in == 'g' || type_out == 'g')
417 o->metadata_global_manual = 1;
418 if (type_in == 's' || type_out == 's')
419 o->metadata_streams_manual = 1;
420 if (type_in == 'c' || type_out == 'c')
421 o->metadata_chapters_manual = 1;
423 /* ic is NULL when just disabling automatic mappings */
427 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
428 if ((index) < 0 || (index) >= (nb_elems)) {\
429 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
434 #define SET_DICT(type, meta, context, index)\
437 meta = &context->metadata;\
440 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
441 meta = &context->chapters[index]->metadata;\
444 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
445 meta = &context->programs[index]->metadata;\
448 break; /* handled separately below */ \
449 default: av_assert0(0);\
452 SET_DICT(type_in, meta_in, ic, idx_in);
453 SET_DICT(type_out, meta_out, oc, idx_out);
455 /* for input streams choose first matching stream */
456 if (type_in == 's') {
457 for (i = 0; i < ic->nb_streams; i++) {
458 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
459 meta_in = &ic->streams[i]->metadata;
465 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
470 if (type_out == 's') {
471 for (i = 0; i < oc->nb_streams; i++) {
472 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
473 meta_out = &oc->streams[i]->metadata;
474 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
479 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
484 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
486 OptionsContext *o = optctx;
488 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
489 struct tm time = *gmtime((time_t*)&recording_timestamp);
490 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
491 parse_option(o, "metadata", buf, options);
493 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
494 "tag instead.\n", opt);
498 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
500 const AVCodecDescriptor *desc;
501 const char *codec_string = encoder ? "encoder" : "decoder";
505 avcodec_find_encoder_by_name(name) :
506 avcodec_find_decoder_by_name(name);
508 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
509 codec = encoder ? avcodec_find_encoder(desc->id) :
510 avcodec_find_decoder(desc->id);
512 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
513 codec_string, codec->name, desc->name);
517 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
520 if (codec->type != type) {
521 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
527 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
529 char *codec_name = NULL;
531 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
533 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
534 st->codec->codec_id = codec->id;
537 return avcodec_find_decoder(st->codec->codec_id);
540 /* Add all the streams from the given input file to the global
541 * list of input streams. */
542 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
545 char *next, *codec_tag = NULL;
547 for (i = 0; i < ic->nb_streams; i++) {
548 AVStream *st = ic->streams[i];
549 AVCodecContext *dec = st->codec;
550 InputStream *ist = av_mallocz(sizeof(*ist));
551 char *framerate = NULL;
556 GROW_ARRAY(input_streams, nb_input_streams);
557 input_streams[nb_input_streams - 1] = ist;
560 ist->file_index = nb_input_files;
562 st->discard = AVDISCARD_ALL;
565 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
567 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
569 uint32_t tag = strtol(codec_tag, &next, 0);
571 tag = AV_RL32(codec_tag);
572 st->codec->codec_tag = tag;
575 ist->dec = choose_decoder(o, ic, st);
576 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
578 ist->reinit_filters = -1;
579 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
581 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
583 switch (dec->codec_type) {
584 case AVMEDIA_TYPE_VIDEO:
586 ist->dec = avcodec_find_decoder(dec->codec_id);
588 dec->flags |= CODEC_FLAG_EMU_EDGE;
591 ist->resample_height = dec->height;
592 ist->resample_width = dec->width;
593 ist->resample_pix_fmt = dec->pix_fmt;
595 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
596 if (framerate && av_parse_video_rate(&ist->framerate,
598 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
603 ist->top_field_first = -1;
604 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
607 case AVMEDIA_TYPE_AUDIO:
608 ist->guess_layout_max = INT_MAX;
609 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
610 guess_input_channel_layout(ist);
612 ist->resample_sample_fmt = dec->sample_fmt;
613 ist->resample_sample_rate = dec->sample_rate;
614 ist->resample_channels = dec->channels;
615 ist->resample_channel_layout = dec->channel_layout;
618 case AVMEDIA_TYPE_DATA:
619 case AVMEDIA_TYPE_SUBTITLE:
621 ist->dec = avcodec_find_decoder(dec->codec_id);
622 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
624 case AVMEDIA_TYPE_ATTACHMENT:
625 case AVMEDIA_TYPE_UNKNOWN:
633 static void assert_file_overwrite(const char *filename)
635 if ((!file_overwrite || no_file_overwrite) &&
636 (strchr(filename, ':') == NULL || filename[1] == ':' ||
637 av_strstart(filename, "file:", NULL))) {
638 if (avio_check(filename, 0) == 0) {
639 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
640 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
643 signal(SIGINT, SIG_DFL);
645 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
651 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
658 static void dump_attachment(AVStream *st, const char *filename)
661 AVIOContext *out = NULL;
662 AVDictionaryEntry *e;
664 if (!st->codec->extradata_size) {
665 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
666 nb_input_files - 1, st->index);
669 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
672 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
673 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
677 assert_file_overwrite(filename);
679 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
680 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
685 avio_write(out, st->codec->extradata, st->codec->extradata_size);
690 static int open_input_file(OptionsContext *o, const char *filename)
693 AVInputFormat *file_iformat = NULL;
698 int orig_nb_streams; // number of streams before avformat_find_stream_info
699 char * video_codec_name = NULL;
700 char * audio_codec_name = NULL;
701 char *subtitle_codec_name = NULL;
704 if (!(file_iformat = av_find_input_format(o->format))) {
705 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
710 if (!strcmp(filename, "-"))
713 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
714 strcmp(filename, "/dev/stdin");
716 /* get default parameters from command line */
717 ic = avformat_alloc_context();
719 print_error(filename, AVERROR(ENOMEM));
722 if (o->nb_audio_sample_rate) {
723 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
724 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
726 if (o->nb_audio_channels) {
727 /* because we set audio_channels based on both the "ac" and
728 * "channel_layout" options, we need to check that the specified
729 * demuxer actually has the "channels" option before setting it */
730 if (file_iformat && file_iformat->priv_class &&
731 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
732 AV_OPT_SEARCH_FAKE_OBJ)) {
733 snprintf(buf, sizeof(buf), "%d",
734 o->audio_channels[o->nb_audio_channels - 1].u.i);
735 av_dict_set(&o->g->format_opts, "channels", buf, 0);
738 if (o->nb_frame_rates) {
739 /* set the format-level framerate option;
740 * this is important for video grabbers, e.g. x11 */
741 if (file_iformat && file_iformat->priv_class &&
742 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
743 AV_OPT_SEARCH_FAKE_OBJ)) {
744 av_dict_set(&o->g->format_opts, "framerate",
745 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
748 if (o->nb_frame_sizes) {
749 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
751 if (o->nb_frame_pix_fmts)
752 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
754 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
755 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
756 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
758 ic->video_codec_id = video_codec_name ?
759 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
760 ic->audio_codec_id = audio_codec_name ?
761 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
762 ic->subtitle_codec_id= subtitle_codec_name ?
763 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
764 ic->flags |= AVFMT_FLAG_NONBLOCK;
765 ic->interrupt_callback = int_cb;
767 /* open the input file with generic avformat function */
768 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
770 print_error(filename, err);
773 assert_avoptions(o->g->format_opts);
775 /* apply forced codec ids */
776 for (i = 0; i < ic->nb_streams; i++)
777 choose_decoder(o, ic, ic->streams[i]);
779 /* Set AVCodecContext options for avformat_find_stream_info */
780 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
781 orig_nb_streams = ic->nb_streams;
783 /* If not enough info to get the stream parameters, we decode the
784 first frames to get it. (used in mpeg case for example) */
785 ret = avformat_find_stream_info(ic, opts);
787 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
788 avformat_close_input(&ic);
792 timestamp = o->start_time;
793 /* add the stream start time */
794 if (ic->start_time != AV_NOPTS_VALUE)
795 timestamp += ic->start_time;
797 /* if seeking requested, we execute it */
798 if (o->start_time != 0) {
799 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
801 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
802 filename, (double)timestamp / AV_TIME_BASE);
806 /* update the current parameters so that they match the one of the input stream */
807 add_input_streams(o, ic);
809 /* dump the file content */
810 av_dump_format(ic, nb_input_files, filename, 0);
812 GROW_ARRAY(input_files, nb_input_files);
813 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
816 input_files[nb_input_files - 1]->ctx = ic;
817 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
818 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
819 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
820 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
822 for (i = 0; i < o->nb_dump_attachment; i++) {
825 for (j = 0; j < ic->nb_streams; j++) {
826 AVStream *st = ic->streams[j];
828 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
829 dump_attachment(st, o->dump_attachment[i].u.str);
833 for (i = 0; i < orig_nb_streams; i++)
834 av_dict_free(&opts[i]);
840 static uint8_t *get_line(AVIOContext *s)
846 if (avio_open_dyn_buf(&line) < 0) {
847 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
851 while ((c = avio_r8(s)) && c != '\n')
854 avio_close_dyn_buf(line, &buf);
859 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
863 const char *base[3] = { getenv("AVCONV_DATADIR"),
868 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
872 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
873 i != 1 ? "" : "/.avconv", codec_name, preset_name);
874 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
877 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
878 i != 1 ? "" : "/.avconv", preset_name);
879 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
885 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
887 char *codec_name = NULL;
889 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
891 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
892 NULL, ost->st->codec->codec_type);
893 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
894 } else if (!strcmp(codec_name, "copy"))
895 ost->stream_copy = 1;
897 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
898 ost->st->codec->codec_id = ost->enc->id;
902 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
905 AVStream *st = avformat_new_stream(oc, NULL);
906 int idx = oc->nb_streams - 1, ret = 0;
907 char *bsf = NULL, *next, *codec_tag = NULL;
908 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
912 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
916 if (oc->nb_streams - 1 < o->nb_streamid_map)
917 st->id = o->streamid_map[oc->nb_streams - 1];
919 GROW_ARRAY(output_streams, nb_output_streams);
920 if (!(ost = av_mallocz(sizeof(*ost))))
922 output_streams[nb_output_streams - 1] = ost;
924 ost->file_index = nb_output_files;
927 st->codec->codec_type = type;
928 choose_encoder(o, oc, ost);
930 AVIOContext *s = NULL;
931 char *buf = NULL, *arg = NULL, *preset = NULL;
933 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
935 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
936 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
939 if (!buf[0] || buf[0] == '#') {
943 if (!(arg = strchr(buf, '='))) {
944 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
948 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
950 } while (!s->eof_reached);
954 av_log(NULL, AV_LOG_FATAL,
955 "Preset %s specified for stream %d:%d, but could not be opened.\n",
956 preset, ost->file_index, ost->index);
961 avcodec_get_context_defaults3(st->codec, ost->enc);
962 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
964 ost->max_frames = INT64_MAX;
965 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
967 ost->copy_prior_start = -1;
968 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
970 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
972 if (next = strchr(bsf, ','))
974 if (!(bsfc = av_bitstream_filter_init(bsf))) {
975 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
979 bsfc_prev->next = bsfc;
981 ost->bitstream_filters = bsfc;
987 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
989 uint32_t tag = strtol(codec_tag, &next, 0);
991 tag = AV_RL32(codec_tag);
992 st->codec->codec_tag = tag;
995 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
997 st->codec->flags |= CODEC_FLAG_QSCALE;
998 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1001 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1002 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1004 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1005 av_opt_get_int (o->g->swr_opts, "filter_type" , 0, &ost->swr_filter_type);
1006 av_opt_get_int (o->g->swr_opts, "dither_method", 0, &ost->swr_dither_method);
1007 av_opt_get_double(o->g->swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1008 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1009 ost->swr_dither_scale = ost->swr_dither_scale*256;
1011 ost->source_index = source_index;
1012 if (source_index >= 0) {
1013 ost->sync_ist = input_streams[source_index];
1014 input_streams[source_index]->discard = 0;
1015 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1021 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1024 const char *p = str;
1031 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1038 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1042 AVCodecContext *video_enc;
1043 char *frame_rate = NULL;
1045 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1047 video_enc = st->codec;
1049 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1050 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1051 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1055 if (!ost->stream_copy) {
1056 const char *p = NULL;
1057 char *frame_size = NULL;
1058 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1059 char *intra_matrix = NULL, *inter_matrix = NULL;
1060 const char *filters = "null";
1064 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1065 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1066 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1070 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1071 if (frame_aspect_ratio) {
1073 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1074 q.num <= 0 || q.den <= 0) {
1075 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1078 ost->frame_aspect_ratio = av_q2d(q);
1081 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1082 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1083 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1084 ost->keep_pix_fmt = 1;
1085 if (!*++frame_pix_fmt)
1086 frame_pix_fmt = NULL;
1088 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1089 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1092 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1095 video_enc->gop_size = 0;
1096 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1098 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1099 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1102 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1104 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1106 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1107 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1110 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1113 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1114 for (i = 0; p; i++) {
1116 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1118 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1121 /* FIXME realloc failure */
1122 video_enc->rc_override =
1123 av_realloc(video_enc->rc_override,
1124 sizeof(RcOverride) * (i + 1));
1125 video_enc->rc_override[i].start_frame = start;
1126 video_enc->rc_override[i].end_frame = end;
1128 video_enc->rc_override[i].qscale = q;
1129 video_enc->rc_override[i].quality_factor = 1.0;
1132 video_enc->rc_override[i].qscale = 0;
1133 video_enc->rc_override[i].quality_factor = -q/100.0;
1138 video_enc->rc_override_count = i;
1139 video_enc->intra_dc_precision = intra_dc_precision - 8;
1142 video_enc->flags|= CODEC_FLAG_PSNR;
1145 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1148 video_enc->flags |= CODEC_FLAG_PASS1;
1149 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1152 video_enc->flags |= CODEC_FLAG_PASS2;
1153 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1157 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1158 if (ost->logfile_prefix &&
1159 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1162 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1163 if (ost->forced_keyframes)
1164 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1166 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1168 ost->top_field_first = -1;
1169 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1171 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1172 ost->avfilter = av_strdup(filters);
1174 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1180 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1185 AVCodecContext *audio_enc;
1187 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1190 audio_enc = st->codec;
1191 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1193 if (!ost->stream_copy) {
1194 char *sample_fmt = NULL;
1195 const char *filters = "anull";
1197 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1199 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1201 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1202 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1206 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1208 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1210 av_assert1(filters);
1211 ost->avfilter = av_strdup(filters);
1213 /* check for channel mapping for this audio stream */
1214 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1215 AudioChannelMap *map = &o->audio_channel_maps[n];
1216 InputStream *ist = input_streams[ost->source_index];
1217 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1218 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1219 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1220 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1221 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1223 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1224 ost->file_index, ost->st->index);
1232 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1236 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1237 if (!ost->stream_copy) {
1238 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1245 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1247 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1248 ost->stream_copy = 1;
1252 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1256 AVCodecContext *subtitle_enc;
1258 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1260 subtitle_enc = st->codec;
1262 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1264 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1266 if (!ost->stream_copy) {
1267 char *frame_size = NULL;
1269 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1270 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1271 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1279 /* arg format is "output-stream-index:streamid-value". */
1280 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1282 OptionsContext *o = optctx;
1287 av_strlcpy(idx_str, arg, sizeof(idx_str));
1288 p = strchr(idx_str, ':');
1290 av_log(NULL, AV_LOG_FATAL,
1291 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1296 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1297 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1298 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1302 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1304 AVFormatContext *is = ifile->ctx;
1305 AVFormatContext *os = ofile->ctx;
1309 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1311 return AVERROR(ENOMEM);
1314 for (i = 0; i < is->nb_chapters; i++) {
1315 AVChapter *in_ch = is->chapters[i], *out_ch;
1316 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1317 AV_TIME_BASE_Q, in_ch->time_base);
1318 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1319 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1322 if (in_ch->end < ts_off)
1324 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1327 out_ch = av_mallocz(sizeof(AVChapter));
1329 return AVERROR(ENOMEM);
1331 out_ch->id = in_ch->id;
1332 out_ch->time_base = in_ch->time_base;
1333 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1334 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1337 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1339 os->chapters[os->nb_chapters++] = out_ch;
1344 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1347 AVFormatContext *ic = avformat_alloc_context();
1349 ic->interrupt_callback = int_cb;
1350 err = avformat_open_input(&ic, filename, NULL, NULL);
1353 /* copy stream format */
1354 for(i=0;i<ic->nb_streams;i++) {
1358 AVCodecContext *avctx;
1360 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1361 ost = new_output_stream(o, s, codec->type, -1);
1366 // FIXME: a more elegant solution is needed
1367 memcpy(st, ic->streams[i], sizeof(AVStream));
1369 st->info = av_malloc(sizeof(*st->info));
1370 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1372 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1374 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1375 choose_sample_fmt(st, codec);
1376 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1377 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1380 /* ffserver seeking with date=... needs a date reference */
1381 err = parse_option(o, "metadata", "creation_time=now", options);
1383 avformat_close_input(&ic);
1387 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1388 AVFormatContext *oc)
1392 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1393 ofilter->out_tmp->pad_idx)) {
1394 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1395 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1397 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1402 ost->source_index = -1;
1403 ost->filter = ofilter;
1407 if (ost->stream_copy) {
1408 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1409 "which is fed from a complex filtergraph. Filtering and streamcopy "
1410 "cannot be used together.\n", ost->file_index, ost->index);
1414 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1415 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1418 avfilter_inout_free(&ofilter->out_tmp);
1421 static int configure_complex_filters(void)
1425 for (i = 0; i < nb_filtergraphs; i++)
1426 if (!filtergraphs[i]->graph &&
1427 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1432 static int open_output_file(OptionsContext *o, const char *filename)
1434 AVFormatContext *oc;
1436 AVOutputFormat *file_oformat;
1440 if (configure_complex_filters() < 0) {
1441 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1445 if (!strcmp(filename, "-"))
1448 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1450 print_error(filename, err);
1453 file_oformat= oc->oformat;
1454 oc->interrupt_callback = int_cb;
1456 /* create streams for all unlabeled output pads */
1457 for (i = 0; i < nb_filtergraphs; i++) {
1458 FilterGraph *fg = filtergraphs[i];
1459 for (j = 0; j < fg->nb_outputs; j++) {
1460 OutputFilter *ofilter = fg->outputs[j];
1462 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1465 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1466 ofilter->out_tmp->pad_idx)) {
1467 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1468 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1469 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1471 init_output_filter(ofilter, o, oc);
1475 if (!strcmp(file_oformat->name, "ffm") &&
1476 av_strstart(filename, "http:", NULL)) {
1478 /* special case for files sent to ffserver: we get the stream
1479 parameters from ffserver */
1480 int err = read_ffserver_streams(o, oc, filename);
1482 print_error(filename, err);
1485 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1486 ost = output_streams[j];
1487 for (i = 0; i < nb_input_streams; i++) {
1488 ist = input_streams[i];
1489 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1491 ost->source_index= i;
1492 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1493 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1495 ist->st->discard = AVDISCARD_NONE;
1500 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));
1504 } else if (!o->nb_stream_maps) {
1505 char *subtitle_codec_name = NULL;
1506 /* pick the "best" stream of each type */
1508 /* video: highest resolution */
1509 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1510 int area = 0, idx = -1;
1511 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1512 for (i = 0; i < nb_input_streams; i++) {
1514 ist = input_streams[i];
1515 new_area = ist->st->codec->width * ist->st->codec->height;
1516 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1518 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1520 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1527 new_video_stream(o, oc, idx);
1530 /* audio: most channels */
1531 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1532 int channels = 0, idx = -1;
1533 for (i = 0; i < nb_input_streams; i++) {
1534 ist = input_streams[i];
1535 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1536 ist->st->codec->channels > channels) {
1537 channels = ist->st->codec->channels;
1542 new_audio_stream(o, oc, idx);
1545 /* subtitles: pick first */
1546 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1547 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1548 for (i = 0; i < nb_input_streams; i++)
1549 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1550 new_subtitle_stream(o, oc, i);
1554 /* do something with data? */
1556 for (i = 0; i < o->nb_stream_maps; i++) {
1557 StreamMap *map = &o->stream_maps[i];
1558 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1563 if (map->linklabel) {
1565 OutputFilter *ofilter = NULL;
1568 for (j = 0; j < nb_filtergraphs; j++) {
1569 fg = filtergraphs[j];
1570 for (k = 0; k < fg->nb_outputs; k++) {
1571 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1572 if (out && !strcmp(out->name, map->linklabel)) {
1573 ofilter = fg->outputs[k];
1580 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1581 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1584 init_output_filter(ofilter, o, oc);
1586 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1587 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1589 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1591 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1593 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1596 switch (ist->st->codec->codec_type) {
1597 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1598 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1599 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1600 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1601 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1603 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1604 map->file_index, map->stream_index);
1611 /* handle attached files */
1612 for (i = 0; i < o->nb_attachments; i++) {
1614 uint8_t *attachment;
1618 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1619 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1623 if ((len = avio_size(pb)) <= 0) {
1624 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1628 if (!(attachment = av_malloc(len))) {
1629 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1633 avio_read(pb, attachment, len);
1635 ost = new_attachment_stream(o, oc, -1);
1636 ost->stream_copy = 0;
1637 ost->attachment_filename = o->attachments[i];
1639 ost->st->codec->extradata = attachment;
1640 ost->st->codec->extradata_size = len;
1642 p = strrchr(o->attachments[i], '/');
1643 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1647 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1648 AVDictionaryEntry *e;
1649 ost = output_streams[i];
1651 if ((ost->stream_copy || ost->attachment_filename)
1652 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1653 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1654 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1658 GROW_ARRAY(output_files, nb_output_files);
1659 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1662 output_files[nb_output_files - 1]->ctx = oc;
1663 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1664 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1665 if (o->recording_time != INT64_MAX)
1666 oc->duration = o->recording_time;
1667 output_files[nb_output_files - 1]->start_time = o->start_time;
1668 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1669 output_files[nb_output_files - 1]->shortest = o->shortest;
1670 av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1672 /* check filename in case of an image number is expected */
1673 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1674 if (!av_filename_number_test(oc->filename)) {
1675 print_error(oc->filename, AVERROR(EINVAL));
1680 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1681 /* test if it already exists to avoid losing precious files */
1682 assert_file_overwrite(filename);
1685 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1686 &oc->interrupt_callback,
1687 &output_files[nb_output_files - 1]->opts)) < 0) {
1688 print_error(filename, err);
1693 if (o->mux_preload) {
1695 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1696 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1698 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1701 for (i = 0; i < o->nb_metadata_map; i++) {
1703 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1705 if (in_file_index >= nb_input_files) {
1706 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1709 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1710 in_file_index >= 0 ?
1711 input_files[in_file_index]->ctx : NULL, o);
1715 if (o->chapters_input_file >= nb_input_files) {
1716 if (o->chapters_input_file == INT_MAX) {
1717 /* copy chapters from the first input file that has them*/
1718 o->chapters_input_file = -1;
1719 for (i = 0; i < nb_input_files; i++)
1720 if (input_files[i]->ctx->nb_chapters) {
1721 o->chapters_input_file = i;
1725 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1726 o->chapters_input_file);
1730 if (o->chapters_input_file >= 0)
1731 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1732 !o->metadata_chapters_manual);
1734 /* copy global metadata by default */
1735 if (!o->metadata_global_manual && nb_input_files){
1736 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1737 AV_DICT_DONT_OVERWRITE);
1738 if(o->recording_time != INT64_MAX)
1739 av_dict_set(&oc->metadata, "duration", NULL, 0);
1740 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1742 if (!o->metadata_streams_manual)
1743 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1745 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1747 ist = input_streams[output_streams[i]->source_index];
1748 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1751 /* process manually set metadata */
1752 for (i = 0; i < o->nb_metadata; i++) {
1755 const char *stream_spec;
1756 int index = 0, j, ret = 0;
1758 val = strchr(o->metadata[i].u.str, '=');
1760 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1761 o->metadata[i].u.str);
1766 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1768 for (j = 0; j < oc->nb_streams; j++) {
1769 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1770 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1781 if (index < 0 || index >= oc->nb_chapters) {
1782 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1785 m = &oc->chapters[index]->metadata;
1788 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1791 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1798 static int opt_target(void *optctx, const char *opt, const char *arg)
1800 OptionsContext *o = optctx;
1801 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1802 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1804 if (!strncmp(arg, "pal-", 4)) {
1807 } else if (!strncmp(arg, "ntsc-", 5)) {
1810 } else if (!strncmp(arg, "film-", 5)) {
1814 /* Try to determine PAL/NTSC by peeking in the input files */
1815 if (nb_input_files) {
1817 for (j = 0; j < nb_input_files; j++) {
1818 for (i = 0; i < input_files[j]->nb_streams; i++) {
1819 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1820 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1822 fr = c->time_base.den * 1000 / c->time_base.num;
1826 } else if ((fr == 29970) || (fr == 23976)) {
1831 if (norm != UNKNOWN)
1835 if (norm != UNKNOWN)
1836 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1839 if (norm == UNKNOWN) {
1840 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1841 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1842 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1846 if (!strcmp(arg, "vcd")) {
1847 opt_video_codec(o, "c:v", "mpeg1video");
1848 opt_audio_codec(o, "c:a", "mp2");
1849 parse_option(o, "f", "vcd", options);
1850 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1852 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1853 parse_option(o, "r", frame_rates[norm], options);
1854 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1856 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1857 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1858 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1859 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1861 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1862 parse_option(o, "ar", "44100", options);
1863 parse_option(o, "ac", "2", options);
1865 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1866 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1868 /* We have to offset the PTS, so that it is consistent with the SCR.
1869 SCR starts at 36000, but the first two packs contain only padding
1870 and the first pack from the other stream, respectively, may also have
1871 been written before.
1872 So the real data starts at SCR 36000+3*1200. */
1873 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1874 } else if (!strcmp(arg, "svcd")) {
1876 opt_video_codec(o, "c:v", "mpeg2video");
1877 opt_audio_codec(o, "c:a", "mp2");
1878 parse_option(o, "f", "svcd", options);
1880 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1881 parse_option(o, "r", frame_rates[norm], options);
1882 parse_option(o, "pix_fmt", "yuv420p", options);
1883 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1885 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1886 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1887 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1888 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1889 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1891 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1892 parse_option(o, "ar", "44100", options);
1894 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1896 } else if (!strcmp(arg, "dvd")) {
1898 opt_video_codec(o, "c:v", "mpeg2video");
1899 opt_audio_codec(o, "c:a", "ac3");
1900 parse_option(o, "f", "dvd", options);
1902 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1903 parse_option(o, "r", frame_rates[norm], options);
1904 parse_option(o, "pix_fmt", "yuv420p", options);
1905 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1907 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1908 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1909 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1910 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1912 av_dict_set(&o->g->format_opts, "packetsize", "2048", 0); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1913 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1915 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1916 parse_option(o, "ar", "48000", options);
1918 } else if (!strncmp(arg, "dv", 2)) {
1920 parse_option(o, "f", "dv", options);
1922 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1923 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1924 norm == PAL ? "yuv420p" : "yuv411p", options);
1925 parse_option(o, "r", frame_rates[norm], options);
1927 parse_option(o, "ar", "48000", options);
1928 parse_option(o, "ac", "2", options);
1931 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1932 return AVERROR(EINVAL);
1937 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1939 av_free (vstats_filename);
1940 vstats_filename = av_strdup (arg);
1944 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1947 time_t today2 = time(NULL);
1948 struct tm *today = localtime(&today2);
1950 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1952 return opt_vstats_file(NULL, opt, filename);
1955 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1957 OptionsContext *o = optctx;
1958 return parse_option(o, "frames:v", arg, options);
1961 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1963 OptionsContext *o = optctx;
1964 return parse_option(o, "frames:a", arg, options);
1967 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1969 OptionsContext *o = optctx;
1970 return parse_option(o, "frames:d", arg, options);
1973 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1976 AVDictionary *cbak = codec_opts;
1977 AVDictionary *fbak = format_opts;
1981 ret = opt_default(NULL, opt, arg);
1983 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
1984 av_dict_copy(&o->g->format_opts, format_opts, 0);
1985 av_dict_free(&codec_opts);
1986 av_dict_free(&format_opts);
1993 static int opt_preset(void *optctx, const char *opt, const char *arg)
1995 OptionsContext *o = optctx;
1997 char filename[1000], line[1000], tmp_line[1000];
1998 const char *codec_name = NULL;
2002 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2004 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2005 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2006 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2008 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2012 while (fgets(line, sizeof(line), f)) {
2013 char *key = tmp_line, *value, *endptr;
2015 if (strcspn(line, "#\n\r") == 0)
2017 strcpy(tmp_line, line);
2018 if (!av_strtok(key, "=", &value) ||
2019 !av_strtok(value, "\r\n", &endptr)) {
2020 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2023 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2025 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2026 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2027 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2028 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2029 else if (opt_default_new(o, key, value) < 0) {
2030 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2031 filename, line, key, value);
2041 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2043 OptionsContext *o = optctx;
2044 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2045 int ret = parse_option(o, s, arg, options);
2050 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2052 OptionsContext *o = optctx;
2053 if(!strcmp(opt, "b")){
2054 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2055 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2058 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2062 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2064 OptionsContext *o = optctx;
2067 if(!strcmp(opt, "qscale")){
2068 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2069 return parse_option(o, "q:v", arg, options);
2071 s = av_asprintf("q%s", opt + 6);
2072 ret = parse_option(o, s, arg, options);
2077 static int opt_profile(void *optctx, const char *opt, const char *arg)
2079 OptionsContext *o = optctx;
2080 if(!strcmp(opt, "profile")){
2081 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2082 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2085 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2089 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2091 OptionsContext *o = optctx;
2092 return parse_option(o, "filter:v", arg, options);
2095 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2097 OptionsContext *o = optctx;
2098 return parse_option(o, "filter:a", arg, options);
2101 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2103 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2104 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2105 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2106 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2108 if (video_sync_method == VSYNC_AUTO)
2109 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2113 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2115 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2120 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2122 OptionsContext *o = optctx;
2123 char *tcr = av_asprintf("timecode=%s", arg);
2124 int ret = parse_option(o, "metadata:g", tcr, options);
2126 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2131 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2133 OptionsContext *o = optctx;
2134 char layout_str[32];
2137 int ret, channels, ac_str_size;
2140 layout = av_get_channel_layout(arg);
2142 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2143 return AVERROR(EINVAL);
2145 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2146 ret = opt_default_new(o, opt, layout_str);
2150 /* set 'ac' option based on channel layout */
2151 channels = av_get_channel_layout_nb_channels(layout);
2152 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2153 stream_str = strchr(opt, ':');
2154 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2155 ac_str = av_mallocz(ac_str_size);
2157 return AVERROR(ENOMEM);
2158 av_strlcpy(ac_str, "ac", 3);
2160 av_strlcat(ac_str, stream_str, ac_str_size);
2161 ret = parse_option(o, ac_str, layout_str, options);
2167 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2169 OptionsContext *o = optctx;
2170 return parse_option(o, "q:a", arg, options);
2173 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2175 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2176 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2177 return AVERROR(ENOMEM);
2178 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2179 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2183 void show_help_default(const char *opt, const char *arg)
2185 /* per-file options have at least one of those set */
2186 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2187 int show_advanced = 0, show_avoptions = 0;
2190 if (!strcmp(opt, "long"))
2192 else if (!strcmp(opt, "full"))
2193 show_advanced = show_avoptions = 1;
2195 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2200 printf("Getting help:\n"
2201 " -h -- print basic options\n"
2202 " -h long -- print more options\n"
2203 " -h full -- print all options (including all format and codec specific options, very long)\n"
2204 " See man %s for detailed description of the options.\n"
2205 "\n", program_name);
2207 show_help_options(options, "Print help / information / capabilities:",
2210 show_help_options(options, "Global options (affect whole program "
2211 "instead of just one file:",
2212 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2214 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2215 per_file | OPT_EXIT, 0);
2217 show_help_options(options, "Per-file main options:", 0,
2218 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2219 OPT_EXIT, per_file);
2221 show_help_options(options, "Advanced per-file options:",
2222 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2224 show_help_options(options, "Video options:",
2225 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2227 show_help_options(options, "Advanced Video options:",
2228 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2230 show_help_options(options, "Audio options:",
2231 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2233 show_help_options(options, "Advanced Audio options:",
2234 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2235 show_help_options(options, "Subtitle options:",
2236 OPT_SUBTITLE, 0, 0);
2239 if (show_avoptions) {
2240 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2241 show_help_children(avcodec_get_class(), flags);
2242 show_help_children(avformat_get_class(), flags);
2243 show_help_children(sws_get_class(), flags);
2244 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2245 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2249 void show_usage(void)
2251 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2252 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2253 av_log(NULL, AV_LOG_INFO, "\n");
2261 static const OptionGroupDef groups[] = {
2262 [GROUP_OUTFILE] = { "output file", NULL },
2263 [GROUP_INFILE] = { "input file", "i" },
2266 static int open_files(OptionGroupList *l, const char *inout,
2267 int (*open_file)(OptionsContext*, const char*))
2271 for (i = 0; i < l->nb_groups; i++) {
2272 OptionGroup *g = &l->groups[i];
2275 init_options(&o, !strcmp(inout, "input"));
2278 ret = parse_optgroup(&o, g);
2280 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2281 "%s.\n", inout, g->arg);
2285 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2286 ret = open_file(&o, g->arg);
2287 uninit_options(&o, !strcmp(inout, "input"));
2289 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2293 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2299 int ffmpeg_parse_options(int argc, char **argv)
2301 OptionParseContext octx;
2305 memset(&octx, 0, sizeof(octx));
2307 /* split the commandline into an internal representation */
2308 ret = split_commandline(&octx, argc, argv, options, groups,
2309 FF_ARRAY_ELEMS(groups));
2311 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2315 /* apply global options */
2316 ret = parse_optgroup(NULL, &octx.global_opts);
2318 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2322 /* open input files */
2323 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2325 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2329 /* open output files */
2330 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2332 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2337 uninit_parse_context(&octx);
2339 av_strerror(ret, error, sizeof(error));
2340 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2345 static int opt_progress(void *optctx, const char *opt, const char *arg)
2347 AVIOContext *avio = NULL;
2350 if (!strcmp(arg, "-"))
2352 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2354 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2355 arg, av_err2str(ret));
2358 progress_avio = avio;
2362 #define OFFSET(x) offsetof(OptionsContext, x)
2363 const OptionDef options[] = {
2365 #include "cmdutils_common_opts.h"
2366 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2367 "force format", "fmt" },
2368 { "y", OPT_BOOL, { &file_overwrite },
2369 "overwrite output files" },
2370 { "n", OPT_BOOL, { &no_file_overwrite },
2371 "do not overwrite output files" },
2372 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2373 "codec name", "codec" },
2374 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2375 "codec name", "codec" },
2376 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2377 "preset name", "preset" },
2378 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2379 "set input stream mapping",
2380 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2381 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2382 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2383 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2384 "set metadata information of outfile from infile",
2385 "outfile[,metadata]:infile[,metadata]" },
2386 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2387 "set chapters mapping", "input_file_index" },
2388 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2389 "record or transcode \"duration\" seconds of audio/video",
2391 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2392 "set the limit file size in bytes", "limit_size" },
2393 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2394 "set the start time offset", "time_off" },
2395 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2396 "set the input ts offset", "time_off" },
2397 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2398 "set the input ts scale", "scale" },
2399 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2400 "set the recording timestamp ('now' to set the current time)", "time" },
2401 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2402 "add metadata", "string=string" },
2403 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2404 "set the number of data frames to record", "number" },
2405 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2406 "add timings for benchmarking" },
2407 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2408 "add timings for each task" },
2409 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2410 "write program-readable progress information", "url" },
2411 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2412 "enable or disable interaction on standard input" },
2413 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2414 "set max runtime in seconds", "limit" },
2415 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2416 "dump each input packet" },
2417 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2418 "when dumping packets, also dump the payload" },
2419 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2420 "read input at native frame rate", "" },
2421 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2422 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2423 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2424 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2425 "video sync method", "" },
2426 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2427 "audio sync method", "" },
2428 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2429 "audio drift threshold", "threshold" },
2430 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2431 "copy timestamps" },
2432 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2433 "copy input stream time base when stream copying", "mode" },
2434 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2435 "finish encoding within shortest input" },
2436 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2437 "timestamp discontinuity delta threshold", "threshold" },
2438 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2439 "timestamp error delta threshold", "threshold" },
2440 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2441 "exit on error", "error" },
2442 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2443 "copy initial non-keyframes" },
2444 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2445 "copy or discard frames before start time" },
2446 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2447 "set the number of frames to record", "number" },
2448 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2449 "force codec tag/fourcc", "fourcc/tag" },
2450 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2451 "use fixed quality scale (VBR)", "q" },
2452 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2453 "use fixed quality scale (VBR)", "q" },
2454 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2455 "set profile", "profile" },
2456 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2457 "set stream filtergraph", "filter_graph" },
2458 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2459 "reinit filtergraph on input parameter changes", "" },
2460 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2461 "create a complex filtergraph", "graph_description" },
2462 { "stats", OPT_BOOL, { &print_stats },
2463 "print progress report during encoding", },
2464 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2465 "add an attachment to the output file", "filename" },
2466 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2467 "extract an attachment into a file", "filename" },
2468 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2469 "print timestamp debugging info" },
2472 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2473 "set the number of video frames to record", "number" },
2474 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2475 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2476 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2477 "set frame size (WxH or abbreviation)", "size" },
2478 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2479 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2480 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2481 "set pixel format", "format" },
2482 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2483 "set the number of bits per raw sample", "number" },
2484 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2485 "deprecated use -g 1" },
2486 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2488 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2489 "discard threshold", "n" },
2490 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2491 "rate control override for specific intervals", "override" },
2492 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2493 "force video codec ('copy' to copy stream)", "codec" },
2494 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2496 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2498 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2499 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2500 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2501 "select the pass number (1 to 3)", "n" },
2502 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2503 "select two pass log file name prefix", "prefix" },
2504 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2505 "this option is deprecated, use the yadif filter instead" },
2506 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2507 "calculate PSNR of compressed frames" },
2508 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2509 "dump video coding statistics to file" },
2510 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2511 "dump video coding statistics to file", "file" },
2512 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2513 "set video filters", "filter_graph" },
2514 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2515 "specify intra matrix coeffs", "matrix" },
2516 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2517 "specify inter matrix coeffs", "matrix" },
2518 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2519 "top=1/bottom=0/auto=-1 field first", "" },
2520 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2521 "intra_dc_precision", "precision" },
2522 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2523 "force video tag/fourcc", "fourcc/tag" },
2524 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2525 "show QP histogram" },
2526 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2527 "force the selected framerate, disable the best supported framerate selection" },
2528 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2529 "set the value of an outfile streamid", "streamIndex:value" },
2530 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2531 { .off = OFFSET(forced_key_frames) },
2532 "force key frames at specified timestamps", "timestamps" },
2533 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2534 "video bitrate (please use -b:v)", "bitrate" },
2537 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2538 "set the number of audio frames to record", "number" },
2539 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2540 "set audio quality (codec-specific)", "quality", },
2541 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2542 "set audio sampling rate (in Hz)", "rate" },
2543 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2544 "set number of audio channels", "channels" },
2545 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2547 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2548 "force audio codec ('copy' to copy stream)", "codec" },
2549 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2550 "force audio tag/fourcc", "fourcc/tag" },
2551 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2552 "change audio volume (256=normal)" , "volume" },
2553 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2554 "set sample format", "format" },
2555 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2556 "set channel layout", "layout" },
2557 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2558 "set audio filters", "filter_graph" },
2559 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(guess_layout_max) },
2560 "set the maximum number of channels to try to guess the channel layout" },
2562 /* subtitle options */
2563 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2564 "disable subtitle" },
2565 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2566 "force subtitle codec ('copy' to copy stream)", "codec" },
2567 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2568 , "force subtitle tag/fourcc", "fourcc/tag" },
2569 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2570 "fix subtitles duration" },
2573 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2574 "deprecated, use -channel", "channel" },
2575 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2576 "deprecated, use -standard", "standard" },
2577 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2580 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2581 "set the maximum demux-decode delay", "seconds" },
2582 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2583 "set the initial demux-decode delay", "seconds" },
2585 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2586 "A comma-separated list of bitstream filters", "bitstream_filters" },
2587 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2588 "deprecated", "audio bitstream_filters" },
2589 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2590 "deprecated", "video bitstream_filters" },
2592 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2593 "set the audio options to the indicated preset", "preset" },
2594 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2595 "set the video options to the indicated preset", "preset" },
2596 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2597 "set the subtitle options to the indicated preset", "preset" },
2598 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2599 "set options from indicated preset file", "filename" },
2600 /* data codec support */
2601 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2602 "force data codec ('copy' to copy stream)", "codec" },
2603 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },