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;
1151 video_enc->flags |= CODEC_FLAG_PASS2;
1155 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1156 if (ost->logfile_prefix &&
1157 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1160 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1161 if (ost->forced_keyframes)
1162 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1164 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1166 ost->top_field_first = -1;
1167 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1169 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1170 ost->avfilter = av_strdup(filters);
1172 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1178 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1183 AVCodecContext *audio_enc;
1185 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1188 audio_enc = st->codec;
1189 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1191 if (!ost->stream_copy) {
1192 char *sample_fmt = NULL;
1193 const char *filters = "anull";
1195 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1197 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1199 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1200 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1204 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1206 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1208 av_assert1(filters);
1209 ost->avfilter = av_strdup(filters);
1211 /* check for channel mapping for this audio stream */
1212 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1213 AudioChannelMap *map = &o->audio_channel_maps[n];
1214 InputStream *ist = input_streams[ost->source_index];
1215 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1216 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1217 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1218 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1219 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1221 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1222 ost->file_index, ost->st->index);
1230 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1234 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1235 if (!ost->stream_copy) {
1236 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1243 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1245 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1246 ost->stream_copy = 1;
1250 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1254 AVCodecContext *subtitle_enc;
1256 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1258 subtitle_enc = st->codec;
1260 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1262 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1264 if (!ost->stream_copy) {
1265 char *frame_size = NULL;
1267 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1268 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1269 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1277 /* arg format is "output-stream-index:streamid-value". */
1278 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1280 OptionsContext *o = optctx;
1285 av_strlcpy(idx_str, arg, sizeof(idx_str));
1286 p = strchr(idx_str, ':');
1288 av_log(NULL, AV_LOG_FATAL,
1289 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1294 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1295 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1296 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1300 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1302 AVFormatContext *is = ifile->ctx;
1303 AVFormatContext *os = ofile->ctx;
1307 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1309 return AVERROR(ENOMEM);
1312 for (i = 0; i < is->nb_chapters; i++) {
1313 AVChapter *in_ch = is->chapters[i], *out_ch;
1314 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1315 AV_TIME_BASE_Q, in_ch->time_base);
1316 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1317 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1320 if (in_ch->end < ts_off)
1322 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1325 out_ch = av_mallocz(sizeof(AVChapter));
1327 return AVERROR(ENOMEM);
1329 out_ch->id = in_ch->id;
1330 out_ch->time_base = in_ch->time_base;
1331 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1332 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1335 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1337 os->chapters[os->nb_chapters++] = out_ch;
1342 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1345 AVFormatContext *ic = avformat_alloc_context();
1347 ic->interrupt_callback = int_cb;
1348 err = avformat_open_input(&ic, filename, NULL, NULL);
1351 /* copy stream format */
1352 for(i=0;i<ic->nb_streams;i++) {
1356 AVCodecContext *avctx;
1358 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1359 ost = new_output_stream(o, s, codec->type, -1);
1364 // FIXME: a more elegant solution is needed
1365 memcpy(st, ic->streams[i], sizeof(AVStream));
1367 st->info = av_malloc(sizeof(*st->info));
1368 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1370 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1372 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1373 choose_sample_fmt(st, codec);
1374 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1375 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1378 /* ffserver seeking with date=... needs a date reference */
1379 err = parse_option(o, "metadata", "creation_time=now", options);
1381 avformat_close_input(&ic);
1385 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1386 AVFormatContext *oc)
1390 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1391 ofilter->out_tmp->pad_idx)) {
1392 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1393 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1395 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1400 ost->source_index = -1;
1401 ost->filter = ofilter;
1405 if (ost->stream_copy) {
1406 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1407 "which is fed from a complex filtergraph. Filtering and streamcopy "
1408 "cannot be used together.\n", ost->file_index, ost->index);
1412 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1413 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1416 avfilter_inout_free(&ofilter->out_tmp);
1419 static int configure_complex_filters(void)
1423 for (i = 0; i < nb_filtergraphs; i++)
1424 if (!filtergraphs[i]->graph &&
1425 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1430 static int open_output_file(OptionsContext *o, const char *filename)
1432 AVFormatContext *oc;
1434 AVOutputFormat *file_oformat;
1438 if (configure_complex_filters() < 0) {
1439 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1443 if (!strcmp(filename, "-"))
1446 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1448 print_error(filename, err);
1451 file_oformat= oc->oformat;
1452 oc->interrupt_callback = int_cb;
1454 /* create streams for all unlabeled output pads */
1455 for (i = 0; i < nb_filtergraphs; i++) {
1456 FilterGraph *fg = filtergraphs[i];
1457 for (j = 0; j < fg->nb_outputs; j++) {
1458 OutputFilter *ofilter = fg->outputs[j];
1460 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1463 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1464 ofilter->out_tmp->pad_idx)) {
1465 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1466 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1467 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1469 init_output_filter(ofilter, o, oc);
1473 if (!strcmp(file_oformat->name, "ffm") &&
1474 av_strstart(filename, "http:", NULL)) {
1476 /* special case for files sent to ffserver: we get the stream
1477 parameters from ffserver */
1478 int err = read_ffserver_streams(o, oc, filename);
1480 print_error(filename, err);
1483 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1484 ost = output_streams[j];
1485 for (i = 0; i < nb_input_streams; i++) {
1486 ist = input_streams[i];
1487 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1489 ost->source_index= i;
1490 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1491 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1493 ist->st->discard = AVDISCARD_NONE;
1498 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));
1502 } else if (!o->nb_stream_maps) {
1503 char *subtitle_codec_name = NULL;
1504 /* pick the "best" stream of each type */
1506 /* video: highest resolution */
1507 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1508 int area = 0, idx = -1;
1509 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1510 for (i = 0; i < nb_input_streams; i++) {
1512 ist = input_streams[i];
1513 new_area = ist->st->codec->width * ist->st->codec->height;
1514 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1516 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1518 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1525 new_video_stream(o, oc, idx);
1528 /* audio: most channels */
1529 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1530 int channels = 0, idx = -1;
1531 for (i = 0; i < nb_input_streams; i++) {
1532 ist = input_streams[i];
1533 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1534 ist->st->codec->channels > channels) {
1535 channels = ist->st->codec->channels;
1540 new_audio_stream(o, oc, idx);
1543 /* subtitles: pick first */
1544 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1545 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1546 for (i = 0; i < nb_input_streams; i++)
1547 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1548 new_subtitle_stream(o, oc, i);
1552 /* do something with data? */
1554 for (i = 0; i < o->nb_stream_maps; i++) {
1555 StreamMap *map = &o->stream_maps[i];
1556 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1561 if (map->linklabel) {
1563 OutputFilter *ofilter = NULL;
1566 for (j = 0; j < nb_filtergraphs; j++) {
1567 fg = filtergraphs[j];
1568 for (k = 0; k < fg->nb_outputs; k++) {
1569 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1570 if (out && !strcmp(out->name, map->linklabel)) {
1571 ofilter = fg->outputs[k];
1578 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1579 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1582 init_output_filter(ofilter, o, oc);
1584 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1585 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1587 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1589 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1591 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1594 switch (ist->st->codec->codec_type) {
1595 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1596 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1597 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1598 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1599 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1601 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1602 map->file_index, map->stream_index);
1609 /* handle attached files */
1610 for (i = 0; i < o->nb_attachments; i++) {
1612 uint8_t *attachment;
1616 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1617 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1621 if ((len = avio_size(pb)) <= 0) {
1622 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1626 if (!(attachment = av_malloc(len))) {
1627 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1631 avio_read(pb, attachment, len);
1633 ost = new_attachment_stream(o, oc, -1);
1634 ost->stream_copy = 0;
1635 ost->attachment_filename = o->attachments[i];
1637 ost->st->codec->extradata = attachment;
1638 ost->st->codec->extradata_size = len;
1640 p = strrchr(o->attachments[i], '/');
1641 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1645 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1646 AVDictionaryEntry *e;
1647 ost = output_streams[i];
1649 if ((ost->stream_copy || ost->attachment_filename)
1650 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1651 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1652 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1656 GROW_ARRAY(output_files, nb_output_files);
1657 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1660 output_files[nb_output_files - 1]->ctx = oc;
1661 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1662 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1663 if (o->recording_time != INT64_MAX)
1664 oc->duration = o->recording_time;
1665 output_files[nb_output_files - 1]->start_time = o->start_time;
1666 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1667 output_files[nb_output_files - 1]->shortest = o->shortest;
1668 av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1670 /* check filename in case of an image number is expected */
1671 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1672 if (!av_filename_number_test(oc->filename)) {
1673 print_error(oc->filename, AVERROR(EINVAL));
1678 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1679 /* test if it already exists to avoid losing precious files */
1680 assert_file_overwrite(filename);
1683 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1684 &oc->interrupt_callback,
1685 &output_files[nb_output_files - 1]->opts)) < 0) {
1686 print_error(filename, err);
1691 if (o->mux_preload) {
1693 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1694 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1696 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1699 for (i = 0; i < o->nb_metadata_map; i++) {
1701 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1703 if (in_file_index >= nb_input_files) {
1704 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1707 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1708 in_file_index >= 0 ?
1709 input_files[in_file_index]->ctx : NULL, o);
1713 if (o->chapters_input_file >= nb_input_files) {
1714 if (o->chapters_input_file == INT_MAX) {
1715 /* copy chapters from the first input file that has them*/
1716 o->chapters_input_file = -1;
1717 for (i = 0; i < nb_input_files; i++)
1718 if (input_files[i]->ctx->nb_chapters) {
1719 o->chapters_input_file = i;
1723 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1724 o->chapters_input_file);
1728 if (o->chapters_input_file >= 0)
1729 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1730 !o->metadata_chapters_manual);
1732 /* copy global metadata by default */
1733 if (!o->metadata_global_manual && nb_input_files){
1734 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1735 AV_DICT_DONT_OVERWRITE);
1736 if(o->recording_time != INT64_MAX)
1737 av_dict_set(&oc->metadata, "duration", NULL, 0);
1738 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1740 if (!o->metadata_streams_manual)
1741 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1743 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1745 ist = input_streams[output_streams[i]->source_index];
1746 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1749 /* process manually set metadata */
1750 for (i = 0; i < o->nb_metadata; i++) {
1753 const char *stream_spec;
1754 int index = 0, j, ret = 0;
1756 val = strchr(o->metadata[i].u.str, '=');
1758 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1759 o->metadata[i].u.str);
1764 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1766 for (j = 0; j < oc->nb_streams; j++) {
1767 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1768 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1779 if (index < 0 || index >= oc->nb_chapters) {
1780 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1783 m = &oc->chapters[index]->metadata;
1786 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1789 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1796 static int opt_target(void *optctx, const char *opt, const char *arg)
1798 OptionsContext *o = optctx;
1799 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1800 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1802 if (!strncmp(arg, "pal-", 4)) {
1805 } else if (!strncmp(arg, "ntsc-", 5)) {
1808 } else if (!strncmp(arg, "film-", 5)) {
1812 /* Try to determine PAL/NTSC by peeking in the input files */
1813 if (nb_input_files) {
1815 for (j = 0; j < nb_input_files; j++) {
1816 for (i = 0; i < input_files[j]->nb_streams; i++) {
1817 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1818 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1820 fr = c->time_base.den * 1000 / c->time_base.num;
1824 } else if ((fr == 29970) || (fr == 23976)) {
1829 if (norm != UNKNOWN)
1833 if (norm != UNKNOWN)
1834 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1837 if (norm == UNKNOWN) {
1838 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1839 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1840 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1844 if (!strcmp(arg, "vcd")) {
1845 opt_video_codec(o, "c:v", "mpeg1video");
1846 opt_audio_codec(o, "c:a", "mp2");
1847 parse_option(o, "f", "vcd", options);
1848 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1850 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1851 parse_option(o, "r", frame_rates[norm], options);
1852 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1854 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1855 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1856 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1857 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1859 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1860 parse_option(o, "ar", "44100", options);
1861 parse_option(o, "ac", "2", options);
1863 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1864 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1866 /* We have to offset the PTS, so that it is consistent with the SCR.
1867 SCR starts at 36000, but the first two packs contain only padding
1868 and the first pack from the other stream, respectively, may also have
1869 been written before.
1870 So the real data starts at SCR 36000+3*1200. */
1871 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1872 } else if (!strcmp(arg, "svcd")) {
1874 opt_video_codec(o, "c:v", "mpeg2video");
1875 opt_audio_codec(o, "c:a", "mp2");
1876 parse_option(o, "f", "svcd", options);
1878 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1879 parse_option(o, "r", frame_rates[norm], options);
1880 parse_option(o, "pix_fmt", "yuv420p", options);
1881 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1883 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1884 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1885 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1886 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1887 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1889 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1890 parse_option(o, "ar", "44100", options);
1892 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1894 } else if (!strcmp(arg, "dvd")) {
1896 opt_video_codec(o, "c:v", "mpeg2video");
1897 opt_audio_codec(o, "c:a", "ac3");
1898 parse_option(o, "f", "dvd", options);
1900 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1901 parse_option(o, "r", frame_rates[norm], options);
1902 parse_option(o, "pix_fmt", "yuv420p", options);
1903 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1905 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1906 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1907 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1908 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1910 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.
1911 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1913 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1914 parse_option(o, "ar", "48000", options);
1916 } else if (!strncmp(arg, "dv", 2)) {
1918 parse_option(o, "f", "dv", options);
1920 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1921 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1922 norm == PAL ? "yuv420p" : "yuv411p", options);
1923 parse_option(o, "r", frame_rates[norm], options);
1925 parse_option(o, "ar", "48000", options);
1926 parse_option(o, "ac", "2", options);
1929 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1930 return AVERROR(EINVAL);
1935 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1937 av_free (vstats_filename);
1938 vstats_filename = av_strdup (arg);
1942 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1945 time_t today2 = time(NULL);
1946 struct tm *today = localtime(&today2);
1948 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1950 return opt_vstats_file(NULL, opt, filename);
1953 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1955 OptionsContext *o = optctx;
1956 return parse_option(o, "frames:v", arg, options);
1959 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1961 OptionsContext *o = optctx;
1962 return parse_option(o, "frames:a", arg, options);
1965 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1967 OptionsContext *o = optctx;
1968 return parse_option(o, "frames:d", arg, options);
1971 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1974 AVDictionary *cbak = codec_opts;
1975 AVDictionary *fbak = format_opts;
1979 ret = opt_default(NULL, opt, arg);
1981 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
1982 av_dict_copy(&o->g->format_opts, format_opts, 0);
1983 av_dict_free(&codec_opts);
1984 av_dict_free(&format_opts);
1991 static int opt_preset(void *optctx, const char *opt, const char *arg)
1993 OptionsContext *o = optctx;
1995 char filename[1000], line[1000], tmp_line[1000];
1996 const char *codec_name = NULL;
2000 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2002 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2003 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2004 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2006 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2010 while (fgets(line, sizeof(line), f)) {
2011 char *key = tmp_line, *value, *endptr;
2013 if (strcspn(line, "#\n\r") == 0)
2015 strcpy(tmp_line, line);
2016 if (!av_strtok(key, "=", &value) ||
2017 !av_strtok(value, "\r\n", &endptr)) {
2018 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2021 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2023 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2024 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2025 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2026 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2027 else if (opt_default_new(o, key, value) < 0) {
2028 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2029 filename, line, key, value);
2039 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2041 OptionsContext *o = optctx;
2042 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2043 int ret = parse_option(o, s, arg, options);
2048 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2050 OptionsContext *o = optctx;
2051 if(!strcmp(opt, "b")){
2052 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2053 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2056 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2060 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2062 OptionsContext *o = optctx;
2065 if(!strcmp(opt, "qscale")){
2066 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2067 return parse_option(o, "q:v", arg, options);
2069 s = av_asprintf("q%s", opt + 6);
2070 ret = parse_option(o, s, arg, options);
2075 static int opt_profile(void *optctx, const char *opt, const char *arg)
2077 OptionsContext *o = optctx;
2078 if(!strcmp(opt, "profile")){
2079 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2080 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2083 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2087 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2089 OptionsContext *o = optctx;
2090 return parse_option(o, "filter:v", arg, options);
2093 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2095 OptionsContext *o = optctx;
2096 return parse_option(o, "filter:a", arg, options);
2099 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2101 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2102 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2103 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2104 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2106 if (video_sync_method == VSYNC_AUTO)
2107 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2111 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2113 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2118 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2120 OptionsContext *o = optctx;
2121 char *tcr = av_asprintf("timecode=%s", arg);
2122 int ret = parse_option(o, "metadata:g", tcr, options);
2124 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2129 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2131 OptionsContext *o = optctx;
2132 char layout_str[32];
2135 int ret, channels, ac_str_size;
2138 layout = av_get_channel_layout(arg);
2140 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2141 return AVERROR(EINVAL);
2143 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2144 ret = opt_default_new(o, opt, layout_str);
2148 /* set 'ac' option based on channel layout */
2149 channels = av_get_channel_layout_nb_channels(layout);
2150 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2151 stream_str = strchr(opt, ':');
2152 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2153 ac_str = av_mallocz(ac_str_size);
2155 return AVERROR(ENOMEM);
2156 av_strlcpy(ac_str, "ac", 3);
2158 av_strlcat(ac_str, stream_str, ac_str_size);
2159 ret = parse_option(o, ac_str, layout_str, options);
2165 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2167 OptionsContext *o = optctx;
2168 return parse_option(o, "q:a", arg, options);
2171 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2173 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2174 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2175 return AVERROR(ENOMEM);
2176 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2177 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2181 void show_help_default(const char *opt, const char *arg)
2183 /* per-file options have at least one of those set */
2184 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2185 int show_advanced = 0, show_avoptions = 0;
2188 if (!strcmp(opt, "long"))
2190 else if (!strcmp(opt, "full"))
2191 show_advanced = show_avoptions = 1;
2193 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2198 printf("Getting help:\n"
2199 " -h -- print basic options\n"
2200 " -h long -- print more options\n"
2201 " -h full -- print all options (including all format and codec specific options, very long)\n"
2202 " See man %s for detailed description of the options.\n"
2203 "\n", program_name);
2205 show_help_options(options, "Print help / information / capabilities:",
2208 show_help_options(options, "Global options (affect whole program "
2209 "instead of just one file:",
2210 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2212 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2213 per_file | OPT_EXIT, 0);
2215 show_help_options(options, "Per-file main options:", 0,
2216 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2217 OPT_EXIT, per_file);
2219 show_help_options(options, "Advanced per-file options:",
2220 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2222 show_help_options(options, "Video options:",
2223 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2225 show_help_options(options, "Advanced Video options:",
2226 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2228 show_help_options(options, "Audio options:",
2229 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2231 show_help_options(options, "Advanced Audio options:",
2232 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2233 show_help_options(options, "Subtitle options:",
2234 OPT_SUBTITLE, 0, 0);
2237 if (show_avoptions) {
2238 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2239 show_help_children(avcodec_get_class(), flags);
2240 show_help_children(avformat_get_class(), flags);
2241 show_help_children(sws_get_class(), flags);
2242 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2243 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2247 void show_usage(void)
2249 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2250 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2251 av_log(NULL, AV_LOG_INFO, "\n");
2259 static const OptionGroupDef groups[] = {
2260 [GROUP_OUTFILE] = { "output file", NULL },
2261 [GROUP_INFILE] = { "input file", "i" },
2264 static int open_files(OptionGroupList *l, const char *inout,
2265 int (*open_file)(OptionsContext*, const char*))
2269 for (i = 0; i < l->nb_groups; i++) {
2270 OptionGroup *g = &l->groups[i];
2273 init_options(&o, !strcmp(inout, "input"));
2276 ret = parse_optgroup(&o, g);
2278 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2279 "%s.\n", inout, g->arg);
2283 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2284 ret = open_file(&o, g->arg);
2285 uninit_options(&o, !strcmp(inout, "input"));
2287 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2291 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2297 int ffmpeg_parse_options(int argc, char **argv)
2299 OptionParseContext octx;
2303 memset(&octx, 0, sizeof(octx));
2305 /* split the commandline into an internal representation */
2306 ret = split_commandline(&octx, argc, argv, options, groups,
2307 FF_ARRAY_ELEMS(groups));
2309 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2313 /* apply global options */
2314 ret = parse_optgroup(NULL, &octx.global_opts);
2316 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2320 /* open input files */
2321 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2323 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2327 /* open output files */
2328 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2330 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2335 uninit_parse_context(&octx);
2337 av_strerror(ret, error, sizeof(error));
2338 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2343 static int opt_progress(void *optctx, const char *opt, const char *arg)
2345 AVIOContext *avio = NULL;
2348 if (!strcmp(arg, "-"))
2350 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2352 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2353 arg, av_err2str(ret));
2356 progress_avio = avio;
2360 #define OFFSET(x) offsetof(OptionsContext, x)
2361 const OptionDef options[] = {
2363 #include "cmdutils_common_opts.h"
2364 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2365 "force format", "fmt" },
2366 { "y", OPT_BOOL, { &file_overwrite },
2367 "overwrite output files" },
2368 { "n", OPT_BOOL, { &no_file_overwrite },
2369 "do not overwrite output files" },
2370 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2371 "codec name", "codec" },
2372 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2373 "codec name", "codec" },
2374 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2375 "preset name", "preset" },
2376 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2377 "set input stream mapping",
2378 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2379 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2380 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2381 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2382 "set metadata information of outfile from infile",
2383 "outfile[,metadata]:infile[,metadata]" },
2384 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2385 "set chapters mapping", "input_file_index" },
2386 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2387 "record or transcode \"duration\" seconds of audio/video",
2389 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2390 "set the limit file size in bytes", "limit_size" },
2391 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2392 "set the start time offset", "time_off" },
2393 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2394 "set the input ts offset", "time_off" },
2395 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2396 "set the input ts scale", "scale" },
2397 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2398 "set the recording timestamp ('now' to set the current time)", "time" },
2399 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2400 "add metadata", "string=string" },
2401 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2402 "set the number of data frames to record", "number" },
2403 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2404 "add timings for benchmarking" },
2405 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2406 "add timings for each task" },
2407 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2408 "write program-readable progress information", "url" },
2409 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2410 "enable or disable interaction on standard input" },
2411 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2412 "set max runtime in seconds", "limit" },
2413 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2414 "dump each input packet" },
2415 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2416 "when dumping packets, also dump the payload" },
2417 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2418 "read input at native frame rate", "" },
2419 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2420 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2421 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2422 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2423 "video sync method", "" },
2424 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2425 "audio sync method", "" },
2426 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2427 "audio drift threshold", "threshold" },
2428 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2429 "copy timestamps" },
2430 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2431 "copy input stream time base when stream copying", "mode" },
2432 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2433 "finish encoding within shortest input" },
2434 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2435 "timestamp discontinuity delta threshold", "threshold" },
2436 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2437 "timestamp error delta threshold", "threshold" },
2438 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2439 "exit on error", "error" },
2440 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2441 "copy initial non-keyframes" },
2442 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2443 "copy or discard frames before start time" },
2444 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2445 "set the number of frames to record", "number" },
2446 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2447 "force codec tag/fourcc", "fourcc/tag" },
2448 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2449 "use fixed quality scale (VBR)", "q" },
2450 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2451 "use fixed quality scale (VBR)", "q" },
2452 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2453 "set profile", "profile" },
2454 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2455 "set stream filtergraph", "filter_graph" },
2456 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2457 "reinit filtergraph on input parameter changes", "" },
2458 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2459 "create a complex filtergraph", "graph_description" },
2460 { "stats", OPT_BOOL, { &print_stats },
2461 "print progress report during encoding", },
2462 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2463 "add an attachment to the output file", "filename" },
2464 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2465 "extract an attachment into a file", "filename" },
2466 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2467 "print timestamp debugging info" },
2470 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2471 "set the number of video frames to record", "number" },
2472 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2473 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2474 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2475 "set frame size (WxH or abbreviation)", "size" },
2476 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2477 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2478 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2479 "set pixel format", "format" },
2480 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2481 "set the number of bits per raw sample", "number" },
2482 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2483 "deprecated use -g 1" },
2484 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2486 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2487 "discard threshold", "n" },
2488 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2489 "rate control override for specific intervals", "override" },
2490 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2491 "force video codec ('copy' to copy stream)", "codec" },
2492 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2494 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2496 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2497 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2498 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2499 "select the pass number (1 to 3)", "n" },
2500 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2501 "select two pass log file name prefix", "prefix" },
2502 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2503 "this option is deprecated, use the yadif filter instead" },
2504 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2505 "calculate PSNR of compressed frames" },
2506 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2507 "dump video coding statistics to file" },
2508 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2509 "dump video coding statistics to file", "file" },
2510 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2511 "set video filters", "filter_graph" },
2512 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2513 "specify intra matrix coeffs", "matrix" },
2514 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2515 "specify inter matrix coeffs", "matrix" },
2516 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2517 "top=1/bottom=0/auto=-1 field first", "" },
2518 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2519 "intra_dc_precision", "precision" },
2520 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2521 "force video tag/fourcc", "fourcc/tag" },
2522 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2523 "show QP histogram" },
2524 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2525 "force the selected framerate, disable the best supported framerate selection" },
2526 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2527 "set the value of an outfile streamid", "streamIndex:value" },
2528 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2529 { .off = OFFSET(forced_key_frames) },
2530 "force key frames at specified timestamps", "timestamps" },
2531 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2532 "video bitrate (please use -b:v)", "bitrate" },
2535 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2536 "set the number of audio frames to record", "number" },
2537 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2538 "set audio quality (codec-specific)", "quality", },
2539 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2540 "set audio sampling rate (in Hz)", "rate" },
2541 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2542 "set number of audio channels", "channels" },
2543 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2545 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2546 "force audio codec ('copy' to copy stream)", "codec" },
2547 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2548 "force audio tag/fourcc", "fourcc/tag" },
2549 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2550 "change audio volume (256=normal)" , "volume" },
2551 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2552 "set sample format", "format" },
2553 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2554 "set channel layout", "layout" },
2555 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2556 "set audio filters", "filter_graph" },
2557 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(guess_layout_max) },
2558 "set the maximum number of channels to try to guess the channel layout" },
2560 /* subtitle options */
2561 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2562 "disable subtitle" },
2563 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2564 "force subtitle codec ('copy' to copy stream)", "codec" },
2565 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2566 , "force subtitle tag/fourcc", "fourcc/tag" },
2567 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2568 "fix subtitles duration" },
2571 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2572 "deprecated, use -channel", "channel" },
2573 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2574 "deprecated, use -standard", "standard" },
2575 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2578 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2579 "set the maximum demux-decode delay", "seconds" },
2580 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2581 "set the initial demux-decode delay", "seconds" },
2583 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2584 "A comma-separated list of bitstream filters", "bitstream_filters" },
2585 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2586 "deprecated", "audio bitstream_filters" },
2587 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2588 "deprecated", "video bitstream_filters" },
2590 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2591 "set the audio options to the indicated preset", "preset" },
2592 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2593 "set the video options to the indicated preset", "preset" },
2594 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2595 "set the subtitle options to the indicated preset", "preset" },
2596 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2597 "set options from indicated preset file", "filename" },
2598 /* data codec support */
2599 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2600 "force data codec ('copy' to copy stream)", "codec" },
2601 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },