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);
1006 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1007 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1008 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1010 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1012 ost->source_index = source_index;
1013 if (source_index >= 0) {
1014 ost->sync_ist = input_streams[source_index];
1015 input_streams[source_index]->discard = 0;
1016 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1022 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1025 const char *p = str;
1032 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1039 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1043 AVCodecContext *video_enc;
1044 char *frame_rate = NULL;
1046 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1048 video_enc = st->codec;
1050 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1051 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1052 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1056 if (!ost->stream_copy) {
1057 const char *p = NULL;
1058 char *frame_size = NULL;
1059 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1060 char *intra_matrix = NULL, *inter_matrix = NULL;
1061 const char *filters = "null";
1065 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1066 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1067 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1071 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1072 if (frame_aspect_ratio) {
1074 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1075 q.num <= 0 || q.den <= 0) {
1076 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1079 ost->frame_aspect_ratio = av_q2d(q);
1082 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1083 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1084 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1085 ost->keep_pix_fmt = 1;
1086 if (!*++frame_pix_fmt)
1087 frame_pix_fmt = NULL;
1089 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1090 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1093 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1096 video_enc->gop_size = 0;
1097 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1099 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1100 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1103 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1105 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1107 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1108 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1111 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1114 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1115 for (i = 0; p; i++) {
1117 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1119 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1122 /* FIXME realloc failure */
1123 video_enc->rc_override =
1124 av_realloc(video_enc->rc_override,
1125 sizeof(RcOverride) * (i + 1));
1126 video_enc->rc_override[i].start_frame = start;
1127 video_enc->rc_override[i].end_frame = end;
1129 video_enc->rc_override[i].qscale = q;
1130 video_enc->rc_override[i].quality_factor = 1.0;
1133 video_enc->rc_override[i].qscale = 0;
1134 video_enc->rc_override[i].quality_factor = -q/100.0;
1139 video_enc->rc_override_count = i;
1140 video_enc->intra_dc_precision = intra_dc_precision - 8;
1143 video_enc->flags|= CODEC_FLAG_PSNR;
1146 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1149 video_enc->flags |= CODEC_FLAG_PASS1;
1150 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1153 video_enc->flags |= CODEC_FLAG_PASS2;
1154 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1158 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1159 if (ost->logfile_prefix &&
1160 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1163 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1164 if (ost->forced_keyframes)
1165 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1167 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1169 ost->top_field_first = -1;
1170 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1172 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1173 ost->avfilter = av_strdup(filters);
1175 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1181 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1186 AVCodecContext *audio_enc;
1188 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1191 audio_enc = st->codec;
1192 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1194 if (!ost->stream_copy) {
1195 char *sample_fmt = NULL;
1196 const char *filters = "anull";
1198 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1200 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1202 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1203 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1207 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1209 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1211 av_assert1(filters);
1212 ost->avfilter = av_strdup(filters);
1214 /* check for channel mapping for this audio stream */
1215 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1216 AudioChannelMap *map = &o->audio_channel_maps[n];
1217 InputStream *ist = input_streams[ost->source_index];
1218 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1219 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1220 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1221 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1222 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1224 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1225 ost->file_index, ost->st->index);
1233 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1237 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1238 if (!ost->stream_copy) {
1239 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1246 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1248 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1249 ost->stream_copy = 1;
1253 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1257 AVCodecContext *subtitle_enc;
1259 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1261 subtitle_enc = st->codec;
1263 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1265 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1267 if (!ost->stream_copy) {
1268 char *frame_size = NULL;
1270 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1271 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1272 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1280 /* arg format is "output-stream-index:streamid-value". */
1281 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1283 OptionsContext *o = optctx;
1288 av_strlcpy(idx_str, arg, sizeof(idx_str));
1289 p = strchr(idx_str, ':');
1291 av_log(NULL, AV_LOG_FATAL,
1292 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1297 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1298 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1299 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1303 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1305 AVFormatContext *is = ifile->ctx;
1306 AVFormatContext *os = ofile->ctx;
1310 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1312 return AVERROR(ENOMEM);
1315 for (i = 0; i < is->nb_chapters; i++) {
1316 AVChapter *in_ch = is->chapters[i], *out_ch;
1317 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1318 AV_TIME_BASE_Q, in_ch->time_base);
1319 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1320 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1323 if (in_ch->end < ts_off)
1325 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1328 out_ch = av_mallocz(sizeof(AVChapter));
1330 return AVERROR(ENOMEM);
1332 out_ch->id = in_ch->id;
1333 out_ch->time_base = in_ch->time_base;
1334 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1335 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1338 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1340 os->chapters[os->nb_chapters++] = out_ch;
1345 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1348 AVFormatContext *ic = avformat_alloc_context();
1350 ic->interrupt_callback = int_cb;
1351 err = avformat_open_input(&ic, filename, NULL, NULL);
1354 /* copy stream format */
1355 for(i=0;i<ic->nb_streams;i++) {
1359 AVCodecContext *avctx;
1361 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1362 ost = new_output_stream(o, s, codec->type, -1);
1367 // FIXME: a more elegant solution is needed
1368 memcpy(st, ic->streams[i], sizeof(AVStream));
1370 st->info = av_malloc(sizeof(*st->info));
1371 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1373 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1375 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1376 choose_sample_fmt(st, codec);
1377 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1378 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1381 /* ffserver seeking with date=... needs a date reference */
1382 err = parse_option(o, "metadata", "creation_time=now", options);
1384 avformat_close_input(&ic);
1388 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1389 AVFormatContext *oc)
1393 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1394 ofilter->out_tmp->pad_idx)) {
1395 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1396 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1398 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1403 ost->source_index = -1;
1404 ost->filter = ofilter;
1408 if (ost->stream_copy) {
1409 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1410 "which is fed from a complex filtergraph. Filtering and streamcopy "
1411 "cannot be used together.\n", ost->file_index, ost->index);
1415 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1416 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1419 avfilter_inout_free(&ofilter->out_tmp);
1422 static int configure_complex_filters(void)
1426 for (i = 0; i < nb_filtergraphs; i++)
1427 if (!filtergraphs[i]->graph &&
1428 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1433 static int open_output_file(OptionsContext *o, const char *filename)
1435 AVFormatContext *oc;
1437 AVOutputFormat *file_oformat;
1441 if (configure_complex_filters() < 0) {
1442 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1446 if (!strcmp(filename, "-"))
1449 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1451 print_error(filename, err);
1454 file_oformat= oc->oformat;
1455 oc->interrupt_callback = int_cb;
1457 /* create streams for all unlabeled output pads */
1458 for (i = 0; i < nb_filtergraphs; i++) {
1459 FilterGraph *fg = filtergraphs[i];
1460 for (j = 0; j < fg->nb_outputs; j++) {
1461 OutputFilter *ofilter = fg->outputs[j];
1463 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1466 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1467 ofilter->out_tmp->pad_idx)) {
1468 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1469 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1470 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1472 init_output_filter(ofilter, o, oc);
1476 if (!strcmp(file_oformat->name, "ffm") &&
1477 av_strstart(filename, "http:", NULL)) {
1479 /* special case for files sent to ffserver: we get the stream
1480 parameters from ffserver */
1481 int err = read_ffserver_streams(o, oc, filename);
1483 print_error(filename, err);
1486 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1487 ost = output_streams[j];
1488 for (i = 0; i < nb_input_streams; i++) {
1489 ist = input_streams[i];
1490 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1492 ost->source_index= i;
1493 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1494 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1496 ist->st->discard = AVDISCARD_NONE;
1501 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));
1505 } else if (!o->nb_stream_maps) {
1506 char *subtitle_codec_name = NULL;
1507 /* pick the "best" stream of each type */
1509 /* video: highest resolution */
1510 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1511 int area = 0, idx = -1;
1512 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1513 for (i = 0; i < nb_input_streams; i++) {
1515 ist = input_streams[i];
1516 new_area = ist->st->codec->width * ist->st->codec->height;
1517 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1519 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1521 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1528 new_video_stream(o, oc, idx);
1531 /* audio: most channels */
1532 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1533 int channels = 0, idx = -1;
1534 for (i = 0; i < nb_input_streams; i++) {
1535 ist = input_streams[i];
1536 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1537 ist->st->codec->channels > channels) {
1538 channels = ist->st->codec->channels;
1543 new_audio_stream(o, oc, idx);
1546 /* subtitles: pick first */
1547 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1548 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1549 for (i = 0; i < nb_input_streams; i++)
1550 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1551 new_subtitle_stream(o, oc, i);
1555 /* do something with data? */
1557 for (i = 0; i < o->nb_stream_maps; i++) {
1558 StreamMap *map = &o->stream_maps[i];
1559 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1564 if (map->linklabel) {
1566 OutputFilter *ofilter = NULL;
1569 for (j = 0; j < nb_filtergraphs; j++) {
1570 fg = filtergraphs[j];
1571 for (k = 0; k < fg->nb_outputs; k++) {
1572 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1573 if (out && !strcmp(out->name, map->linklabel)) {
1574 ofilter = fg->outputs[k];
1581 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1582 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1585 init_output_filter(ofilter, o, oc);
1587 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1588 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1590 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1592 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1594 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1597 switch (ist->st->codec->codec_type) {
1598 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1599 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1600 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1601 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1602 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1604 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1605 map->file_index, map->stream_index);
1612 /* handle attached files */
1613 for (i = 0; i < o->nb_attachments; i++) {
1615 uint8_t *attachment;
1619 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1620 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1624 if ((len = avio_size(pb)) <= 0) {
1625 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1629 if (!(attachment = av_malloc(len))) {
1630 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1634 avio_read(pb, attachment, len);
1636 ost = new_attachment_stream(o, oc, -1);
1637 ost->stream_copy = 0;
1638 ost->attachment_filename = o->attachments[i];
1640 ost->st->codec->extradata = attachment;
1641 ost->st->codec->extradata_size = len;
1643 p = strrchr(o->attachments[i], '/');
1644 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1648 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1649 AVDictionaryEntry *e;
1650 ost = output_streams[i];
1652 if ((ost->stream_copy || ost->attachment_filename)
1653 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1654 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1655 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1659 GROW_ARRAY(output_files, nb_output_files);
1660 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1663 output_files[nb_output_files - 1]->ctx = oc;
1664 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1665 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1666 if (o->recording_time != INT64_MAX)
1667 oc->duration = o->recording_time;
1668 output_files[nb_output_files - 1]->start_time = o->start_time;
1669 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1670 output_files[nb_output_files - 1]->shortest = o->shortest;
1671 av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1673 /* check filename in case of an image number is expected */
1674 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1675 if (!av_filename_number_test(oc->filename)) {
1676 print_error(oc->filename, AVERROR(EINVAL));
1681 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1682 /* test if it already exists to avoid losing precious files */
1683 assert_file_overwrite(filename);
1686 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1687 &oc->interrupt_callback,
1688 &output_files[nb_output_files - 1]->opts)) < 0) {
1689 print_error(filename, err);
1694 if (o->mux_preload) {
1696 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1697 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1699 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1702 for (i = 0; i < o->nb_metadata_map; i++) {
1704 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1706 if (in_file_index >= nb_input_files) {
1707 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1710 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1711 in_file_index >= 0 ?
1712 input_files[in_file_index]->ctx : NULL, o);
1716 if (o->chapters_input_file >= nb_input_files) {
1717 if (o->chapters_input_file == INT_MAX) {
1718 /* copy chapters from the first input file that has them*/
1719 o->chapters_input_file = -1;
1720 for (i = 0; i < nb_input_files; i++)
1721 if (input_files[i]->ctx->nb_chapters) {
1722 o->chapters_input_file = i;
1726 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1727 o->chapters_input_file);
1731 if (o->chapters_input_file >= 0)
1732 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1733 !o->metadata_chapters_manual);
1735 /* copy global metadata by default */
1736 if (!o->metadata_global_manual && nb_input_files){
1737 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1738 AV_DICT_DONT_OVERWRITE);
1739 if(o->recording_time != INT64_MAX)
1740 av_dict_set(&oc->metadata, "duration", NULL, 0);
1741 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1743 if (!o->metadata_streams_manual)
1744 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1746 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1748 ist = input_streams[output_streams[i]->source_index];
1749 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1752 /* process manually set metadata */
1753 for (i = 0; i < o->nb_metadata; i++) {
1756 const char *stream_spec;
1757 int index = 0, j, ret = 0;
1759 val = strchr(o->metadata[i].u.str, '=');
1761 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1762 o->metadata[i].u.str);
1767 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1769 for (j = 0; j < oc->nb_streams; j++) {
1770 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1771 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1782 if (index < 0 || index >= oc->nb_chapters) {
1783 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1786 m = &oc->chapters[index]->metadata;
1789 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1792 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1799 static int opt_target(void *optctx, const char *opt, const char *arg)
1801 OptionsContext *o = optctx;
1802 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1803 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1805 if (!strncmp(arg, "pal-", 4)) {
1808 } else if (!strncmp(arg, "ntsc-", 5)) {
1811 } else if (!strncmp(arg, "film-", 5)) {
1815 /* Try to determine PAL/NTSC by peeking in the input files */
1816 if (nb_input_files) {
1818 for (j = 0; j < nb_input_files; j++) {
1819 for (i = 0; i < input_files[j]->nb_streams; i++) {
1820 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1821 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1823 fr = c->time_base.den * 1000 / c->time_base.num;
1827 } else if ((fr == 29970) || (fr == 23976)) {
1832 if (norm != UNKNOWN)
1836 if (norm != UNKNOWN)
1837 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1840 if (norm == UNKNOWN) {
1841 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1842 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1843 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1847 if (!strcmp(arg, "vcd")) {
1848 opt_video_codec(o, "c:v", "mpeg1video");
1849 opt_audio_codec(o, "c:a", "mp2");
1850 parse_option(o, "f", "vcd", options);
1851 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1853 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1854 parse_option(o, "r", frame_rates[norm], options);
1855 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1857 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1858 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1859 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1860 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1862 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1863 parse_option(o, "ar", "44100", options);
1864 parse_option(o, "ac", "2", options);
1866 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1867 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1869 /* We have to offset the PTS, so that it is consistent with the SCR.
1870 SCR starts at 36000, but the first two packs contain only padding
1871 and the first pack from the other stream, respectively, may also have
1872 been written before.
1873 So the real data starts at SCR 36000+3*1200. */
1874 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1875 } else if (!strcmp(arg, "svcd")) {
1877 opt_video_codec(o, "c:v", "mpeg2video");
1878 opt_audio_codec(o, "c:a", "mp2");
1879 parse_option(o, "f", "svcd", options);
1881 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1882 parse_option(o, "r", frame_rates[norm], options);
1883 parse_option(o, "pix_fmt", "yuv420p", options);
1884 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1886 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1887 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1888 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1889 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1890 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1892 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1893 parse_option(o, "ar", "44100", options);
1895 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1897 } else if (!strcmp(arg, "dvd")) {
1899 opt_video_codec(o, "c:v", "mpeg2video");
1900 opt_audio_codec(o, "c:a", "ac3");
1901 parse_option(o, "f", "dvd", options);
1903 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1904 parse_option(o, "r", frame_rates[norm], options);
1905 parse_option(o, "pix_fmt", "yuv420p", options);
1906 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1908 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1909 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1910 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1911 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1913 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.
1914 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1916 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1917 parse_option(o, "ar", "48000", options);
1919 } else if (!strncmp(arg, "dv", 2)) {
1921 parse_option(o, "f", "dv", options);
1923 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1924 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1925 norm == PAL ? "yuv420p" : "yuv411p", options);
1926 parse_option(o, "r", frame_rates[norm], options);
1928 parse_option(o, "ar", "48000", options);
1929 parse_option(o, "ac", "2", options);
1932 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1933 return AVERROR(EINVAL);
1938 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1940 av_free (vstats_filename);
1941 vstats_filename = av_strdup (arg);
1945 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1948 time_t today2 = time(NULL);
1949 struct tm *today = localtime(&today2);
1951 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1953 return opt_vstats_file(NULL, opt, filename);
1956 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1958 OptionsContext *o = optctx;
1959 return parse_option(o, "frames:v", arg, options);
1962 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1964 OptionsContext *o = optctx;
1965 return parse_option(o, "frames:a", arg, options);
1968 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1970 OptionsContext *o = optctx;
1971 return parse_option(o, "frames:d", arg, options);
1974 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1977 AVDictionary *cbak = codec_opts;
1978 AVDictionary *fbak = format_opts;
1982 ret = opt_default(NULL, opt, arg);
1984 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
1985 av_dict_copy(&o->g->format_opts, format_opts, 0);
1986 av_dict_free(&codec_opts);
1987 av_dict_free(&format_opts);
1994 static int opt_preset(void *optctx, const char *opt, const char *arg)
1996 OptionsContext *o = optctx;
1998 char filename[1000], line[1000], tmp_line[1000];
1999 const char *codec_name = NULL;
2003 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2005 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2006 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2007 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2009 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2013 while (fgets(line, sizeof(line), f)) {
2014 char *key = tmp_line, *value, *endptr;
2016 if (strcspn(line, "#\n\r") == 0)
2018 strcpy(tmp_line, line);
2019 if (!av_strtok(key, "=", &value) ||
2020 !av_strtok(value, "\r\n", &endptr)) {
2021 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2024 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2026 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2027 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2028 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2029 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2030 else if (opt_default_new(o, key, value) < 0) {
2031 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2032 filename, line, key, value);
2042 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2044 OptionsContext *o = optctx;
2045 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2046 int ret = parse_option(o, s, arg, options);
2051 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2053 OptionsContext *o = optctx;
2054 if(!strcmp(opt, "b")){
2055 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2056 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2059 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2063 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2065 OptionsContext *o = optctx;
2068 if(!strcmp(opt, "qscale")){
2069 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2070 return parse_option(o, "q:v", arg, options);
2072 s = av_asprintf("q%s", opt + 6);
2073 ret = parse_option(o, s, arg, options);
2078 static int opt_profile(void *optctx, const char *opt, const char *arg)
2080 OptionsContext *o = optctx;
2081 if(!strcmp(opt, "profile")){
2082 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2083 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2086 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2090 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2092 OptionsContext *o = optctx;
2093 return parse_option(o, "filter:v", arg, options);
2096 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2098 OptionsContext *o = optctx;
2099 return parse_option(o, "filter:a", arg, options);
2102 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2104 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2105 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2106 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2107 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2109 if (video_sync_method == VSYNC_AUTO)
2110 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2114 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2116 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2121 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2123 OptionsContext *o = optctx;
2124 char *tcr = av_asprintf("timecode=%s", arg);
2125 int ret = parse_option(o, "metadata:g", tcr, options);
2127 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2132 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2134 OptionsContext *o = optctx;
2135 char layout_str[32];
2138 int ret, channels, ac_str_size;
2141 layout = av_get_channel_layout(arg);
2143 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2144 return AVERROR(EINVAL);
2146 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2147 ret = opt_default_new(o, opt, layout_str);
2151 /* set 'ac' option based on channel layout */
2152 channels = av_get_channel_layout_nb_channels(layout);
2153 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2154 stream_str = strchr(opt, ':');
2155 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2156 ac_str = av_mallocz(ac_str_size);
2158 return AVERROR(ENOMEM);
2159 av_strlcpy(ac_str, "ac", 3);
2161 av_strlcat(ac_str, stream_str, ac_str_size);
2162 ret = parse_option(o, ac_str, layout_str, options);
2168 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2170 OptionsContext *o = optctx;
2171 return parse_option(o, "q:a", arg, options);
2174 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2176 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2177 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2178 return AVERROR(ENOMEM);
2179 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2180 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2184 void show_help_default(const char *opt, const char *arg)
2186 /* per-file options have at least one of those set */
2187 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2188 int show_advanced = 0, show_avoptions = 0;
2191 if (!strcmp(opt, "long"))
2193 else if (!strcmp(opt, "full"))
2194 show_advanced = show_avoptions = 1;
2196 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2201 printf("Getting help:\n"
2202 " -h -- print basic options\n"
2203 " -h long -- print more options\n"
2204 " -h full -- print all options (including all format and codec specific options, very long)\n"
2205 " See man %s for detailed description of the options.\n"
2206 "\n", program_name);
2208 show_help_options(options, "Print help / information / capabilities:",
2211 show_help_options(options, "Global options (affect whole program "
2212 "instead of just one file:",
2213 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2215 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2216 per_file | OPT_EXIT, 0);
2218 show_help_options(options, "Per-file main options:", 0,
2219 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2220 OPT_EXIT, per_file);
2222 show_help_options(options, "Advanced per-file options:",
2223 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2225 show_help_options(options, "Video options:",
2226 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2228 show_help_options(options, "Advanced Video options:",
2229 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2231 show_help_options(options, "Audio options:",
2232 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2234 show_help_options(options, "Advanced Audio options:",
2235 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2236 show_help_options(options, "Subtitle options:",
2237 OPT_SUBTITLE, 0, 0);
2240 if (show_avoptions) {
2241 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2242 show_help_children(avcodec_get_class(), flags);
2243 show_help_children(avformat_get_class(), flags);
2244 show_help_children(sws_get_class(), flags);
2245 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2246 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2250 void show_usage(void)
2252 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2253 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2254 av_log(NULL, AV_LOG_INFO, "\n");
2262 static const OptionGroupDef groups[] = {
2263 [GROUP_OUTFILE] = { "output file", NULL },
2264 [GROUP_INFILE] = { "input file", "i" },
2267 static int open_files(OptionGroupList *l, const char *inout,
2268 int (*open_file)(OptionsContext*, const char*))
2272 for (i = 0; i < l->nb_groups; i++) {
2273 OptionGroup *g = &l->groups[i];
2276 init_options(&o, !strcmp(inout, "input"));
2279 ret = parse_optgroup(&o, g);
2281 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2282 "%s.\n", inout, g->arg);
2286 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2287 ret = open_file(&o, g->arg);
2288 uninit_options(&o, !strcmp(inout, "input"));
2290 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2294 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2300 int ffmpeg_parse_options(int argc, char **argv)
2302 OptionParseContext octx;
2306 memset(&octx, 0, sizeof(octx));
2308 /* split the commandline into an internal representation */
2309 ret = split_commandline(&octx, argc, argv, options, groups,
2310 FF_ARRAY_ELEMS(groups));
2312 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2316 /* apply global options */
2317 ret = parse_optgroup(NULL, &octx.global_opts);
2319 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2323 /* open input files */
2324 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2326 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2330 /* open output files */
2331 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2333 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2338 uninit_parse_context(&octx);
2340 av_strerror(ret, error, sizeof(error));
2341 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2346 static int opt_progress(void *optctx, const char *opt, const char *arg)
2348 AVIOContext *avio = NULL;
2351 if (!strcmp(arg, "-"))
2353 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2355 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2356 arg, av_err2str(ret));
2359 progress_avio = avio;
2363 #define OFFSET(x) offsetof(OptionsContext, x)
2364 const OptionDef options[] = {
2366 #include "cmdutils_common_opts.h"
2367 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2368 "force format", "fmt" },
2369 { "y", OPT_BOOL, { &file_overwrite },
2370 "overwrite output files" },
2371 { "n", OPT_BOOL, { &no_file_overwrite },
2372 "do not overwrite output files" },
2373 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2374 "codec name", "codec" },
2375 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2376 "codec name", "codec" },
2377 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2378 "preset name", "preset" },
2379 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2380 "set input stream mapping",
2381 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2382 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2383 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2384 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2385 "set metadata information of outfile from infile",
2386 "outfile[,metadata]:infile[,metadata]" },
2387 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2388 "set chapters mapping", "input_file_index" },
2389 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2390 "record or transcode \"duration\" seconds of audio/video",
2392 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2393 "set the limit file size in bytes", "limit_size" },
2394 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2395 "set the start time offset", "time_off" },
2396 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2397 "set the input ts offset", "time_off" },
2398 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2399 "set the input ts scale", "scale" },
2400 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2401 "set the recording timestamp ('now' to set the current time)", "time" },
2402 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2403 "add metadata", "string=string" },
2404 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2405 "set the number of data frames to record", "number" },
2406 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2407 "add timings for benchmarking" },
2408 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2409 "add timings for each task" },
2410 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2411 "write program-readable progress information", "url" },
2412 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2413 "enable or disable interaction on standard input" },
2414 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2415 "set max runtime in seconds", "limit" },
2416 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2417 "dump each input packet" },
2418 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2419 "when dumping packets, also dump the payload" },
2420 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2421 "read input at native frame rate", "" },
2422 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2423 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2424 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2425 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2426 "video sync method", "" },
2427 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2428 "audio sync method", "" },
2429 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2430 "audio drift threshold", "threshold" },
2431 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2432 "copy timestamps" },
2433 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2434 "copy input stream time base when stream copying", "mode" },
2435 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2436 "finish encoding within shortest input" },
2437 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2438 "timestamp discontinuity delta threshold", "threshold" },
2439 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2440 "timestamp error delta threshold", "threshold" },
2441 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2442 "exit on error", "error" },
2443 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2444 "copy initial non-keyframes" },
2445 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2446 "copy or discard frames before start time" },
2447 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2448 "set the number of frames to record", "number" },
2449 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2450 "force codec tag/fourcc", "fourcc/tag" },
2451 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2452 "use fixed quality scale (VBR)", "q" },
2453 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2454 "use fixed quality scale (VBR)", "q" },
2455 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2456 "set profile", "profile" },
2457 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2458 "set stream filtergraph", "filter_graph" },
2459 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2460 "reinit filtergraph on input parameter changes", "" },
2461 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2462 "create a complex filtergraph", "graph_description" },
2463 { "stats", OPT_BOOL, { &print_stats },
2464 "print progress report during encoding", },
2465 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2466 "add an attachment to the output file", "filename" },
2467 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2468 "extract an attachment into a file", "filename" },
2469 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2470 "print timestamp debugging info" },
2473 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2474 "set the number of video frames to record", "number" },
2475 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2476 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2477 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2478 "set frame size (WxH or abbreviation)", "size" },
2479 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2480 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2481 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2482 "set pixel format", "format" },
2483 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2484 "set the number of bits per raw sample", "number" },
2485 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2486 "deprecated use -g 1" },
2487 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2489 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2490 "discard threshold", "n" },
2491 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2492 "rate control override for specific intervals", "override" },
2493 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2494 "force video codec ('copy' to copy stream)", "codec" },
2495 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2497 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2499 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2500 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2501 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2502 "select the pass number (1 to 3)", "n" },
2503 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2504 "select two pass log file name prefix", "prefix" },
2505 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2506 "this option is deprecated, use the yadif filter instead" },
2507 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2508 "calculate PSNR of compressed frames" },
2509 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2510 "dump video coding statistics to file" },
2511 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2512 "dump video coding statistics to file", "file" },
2513 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2514 "set video filters", "filter_graph" },
2515 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2516 "specify intra matrix coeffs", "matrix" },
2517 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2518 "specify inter matrix coeffs", "matrix" },
2519 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2520 "top=1/bottom=0/auto=-1 field first", "" },
2521 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2522 "intra_dc_precision", "precision" },
2523 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2524 "force video tag/fourcc", "fourcc/tag" },
2525 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2526 "show QP histogram" },
2527 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2528 "force the selected framerate, disable the best supported framerate selection" },
2529 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2530 "set the value of an outfile streamid", "streamIndex:value" },
2531 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2532 { .off = OFFSET(forced_key_frames) },
2533 "force key frames at specified timestamps", "timestamps" },
2534 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2535 "video bitrate (please use -b:v)", "bitrate" },
2538 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2539 "set the number of audio frames to record", "number" },
2540 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2541 "set audio quality (codec-specific)", "quality", },
2542 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2543 "set audio sampling rate (in Hz)", "rate" },
2544 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2545 "set number of audio channels", "channels" },
2546 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2548 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2549 "force audio codec ('copy' to copy stream)", "codec" },
2550 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2551 "force audio tag/fourcc", "fourcc/tag" },
2552 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2553 "change audio volume (256=normal)" , "volume" },
2554 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2555 "set sample format", "format" },
2556 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2557 "set channel layout", "layout" },
2558 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2559 "set audio filters", "filter_graph" },
2560 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(guess_layout_max) },
2561 "set the maximum number of channels to try to guess the channel layout" },
2563 /* subtitle options */
2564 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2565 "disable subtitle" },
2566 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2567 "force subtitle codec ('copy' to copy stream)", "codec" },
2568 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2569 , "force subtitle tag/fourcc", "fourcc/tag" },
2570 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2571 "fix subtitles duration" },
2574 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2575 "deprecated, use -channel", "channel" },
2576 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2577 "deprecated, use -standard", "standard" },
2578 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2581 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2582 "set the maximum demux-decode delay", "seconds" },
2583 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2584 "set the initial demux-decode delay", "seconds" },
2586 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2587 "A comma-separated list of bitstream filters", "bitstream_filters" },
2588 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2589 "deprecated", "audio bitstream_filters" },
2590 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2591 "deprecated", "video bitstream_filters" },
2593 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2594 "set the audio options to the indicated preset", "preset" },
2595 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2596 "set the video options to the indicated preset", "preset" },
2597 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2598 "set the subtitle options to the indicated preset", "preset" },
2599 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2600 "set options from indicated preset file", "filename" },
2601 /* data codec support */
2602 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2603 "force data codec ('copy' to copy stream)", "codec" },
2604 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },