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"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
82 float audio_drift_threshold = 0.1;
83 float dts_delta_threshold = 10;
84 float dts_error_threshold = 3600*30;
86 int audio_volume = 256;
87 int audio_sync_method = 0;
88 int video_sync_method = VSYNC_AUTO;
89 float frame_drop_threshold = 0;
90 int do_deinterlace = 0;
92 int do_benchmark_all = 0;
96 int start_at_zero = 0;
99 int exit_on_error = 0;
100 int print_stats = -1;
102 int stdin_interaction = 1;
103 int frame_bits_per_raw_sample = 0;
104 float max_error_rate = 2.0/3;
107 static int intra_only = 0;
108 static int file_overwrite = 0;
109 static int no_file_overwrite = 0;
110 static int do_psnr = 0;
111 static int input_sync;
112 static int override_ffserver = 0;
114 static void uninit_options(OptionsContext *o)
116 const OptionDef *po = options;
119 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
121 void *dst = (uint8_t*)o + po->u.off;
123 if (po->flags & OPT_SPEC) {
124 SpecifierOpt **so = dst;
125 int i, *count = (int*)(so + 1);
126 for (i = 0; i < *count; i++) {
127 av_freep(&(*so)[i].specifier);
128 if (po->flags & OPT_STRING)
129 av_freep(&(*so)[i].u.str);
133 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
138 for (i = 0; i < o->nb_stream_maps; i++)
139 av_freep(&o->stream_maps[i].linklabel);
140 av_freep(&o->stream_maps);
141 av_freep(&o->audio_channel_maps);
142 av_freep(&o->streamid_map);
143 av_freep(&o->attachments);
146 static void init_options(OptionsContext *o)
148 memset(o, 0, sizeof(*o));
150 o->stop_time = INT64_MAX;
151 o->mux_max_delay = 0.7;
152 o->start_time = AV_NOPTS_VALUE;
153 o->recording_time = INT64_MAX;
154 o->limit_filesize = UINT64_MAX;
155 o->chapters_input_file = INT_MAX;
156 o->accurate_seek = 1;
159 /* return a copy of the input with the stream specifiers removed from the keys */
160 static AVDictionary *strip_specifiers(AVDictionary *dict)
162 AVDictionaryEntry *e = NULL;
163 AVDictionary *ret = NULL;
165 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
166 char *p = strchr(e->key, ':');
170 av_dict_set(&ret, e->key, e->value, 0);
177 static int opt_sameq(void *optctx, const char *opt, const char *arg)
179 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
180 "If you are looking for an option to preserve the quality (which is not "
181 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
183 return AVERROR(EINVAL);
186 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
188 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
189 return opt_default(optctx, "channel", arg);
192 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
194 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
195 return opt_default(optctx, "standard", arg);
198 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
200 OptionsContext *o = optctx;
201 return parse_option(o, "codec:a", arg, options);
204 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
206 OptionsContext *o = optctx;
207 return parse_option(o, "codec:v", arg, options);
210 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
212 OptionsContext *o = optctx;
213 return parse_option(o, "codec:s", arg, options);
216 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
218 OptionsContext *o = optctx;
219 return parse_option(o, "codec:d", arg, options);
222 static int opt_map(void *optctx, const char *opt, const char *arg)
224 OptionsContext *o = optctx;
226 int i, negative = 0, file_idx;
227 int sync_file_idx = -1, sync_stream_idx = 0;
235 map = av_strdup(arg);
237 return AVERROR(ENOMEM);
239 /* parse sync stream first, just pick first matching stream */
240 if (sync = strchr(map, ',')) {
242 sync_file_idx = strtol(sync + 1, &sync, 0);
243 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
244 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
249 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
250 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
251 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
255 if (i == input_files[sync_file_idx]->nb_streams) {
256 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
257 "match any streams.\n", arg);
264 /* this mapping refers to lavfi output */
265 const char *c = map + 1;
266 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
267 m = &o->stream_maps[o->nb_stream_maps - 1];
268 m->linklabel = av_get_token(&c, "]");
270 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
274 file_idx = strtol(map, &p, 0);
275 if (file_idx >= nb_input_files || file_idx < 0) {
276 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
280 /* disable some already defined maps */
281 for (i = 0; i < o->nb_stream_maps; i++) {
282 m = &o->stream_maps[i];
283 if (file_idx == m->file_index &&
284 check_stream_specifier(input_files[m->file_index]->ctx,
285 input_files[m->file_index]->ctx->streams[m->stream_index],
286 *p == ':' ? p + 1 : p) > 0)
290 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
291 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
292 *p == ':' ? p + 1 : p) <= 0)
294 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
295 m = &o->stream_maps[o->nb_stream_maps - 1];
297 m->file_index = file_idx;
300 if (sync_file_idx >= 0) {
301 m->sync_file_index = sync_file_idx;
302 m->sync_stream_index = sync_stream_idx;
304 m->sync_file_index = file_idx;
305 m->sync_stream_index = i;
311 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
319 static int opt_attach(void *optctx, const char *opt, const char *arg)
321 OptionsContext *o = optctx;
322 GROW_ARRAY(o->attachments, o->nb_attachments);
323 o->attachments[o->nb_attachments - 1] = arg;
327 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
329 OptionsContext *o = optctx;
334 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
335 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
337 /* muted channel syntax */
338 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
339 if ((n == 1 || n == 3) && m->channel_idx == -1) {
340 m->file_idx = m->stream_idx = -1;
342 m->ofile_idx = m->ostream_idx = -1;
347 n = sscanf(arg, "%d.%d.%d:%d.%d",
348 &m->file_idx, &m->stream_idx, &m->channel_idx,
349 &m->ofile_idx, &m->ostream_idx);
351 if (n != 3 && n != 5) {
352 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
353 "[file.stream.channel|-1][:syncfile:syncstream]\n");
357 if (n != 5) // only file.stream.channel specified
358 m->ofile_idx = m->ostream_idx = -1;
361 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
362 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
366 if (m->stream_idx < 0 ||
367 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
368 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
369 m->file_idx, m->stream_idx);
372 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
373 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
374 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
375 m->file_idx, m->stream_idx);
378 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
379 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
380 m->file_idx, m->stream_idx, m->channel_idx);
386 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
388 av_free(sdp_filename);
389 sdp_filename = av_strdup(arg);
394 * Parse a metadata specifier passed as 'arg' parameter.
395 * @param arg metadata string to parse
396 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
397 * @param index for type c/p, chapter/program index is written here
398 * @param stream_spec for type s, the stream specifier is written here
400 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
408 if (*(++arg) && *arg != ':') {
409 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
412 *stream_spec = *arg == ':' ? arg + 1 : "";
417 *index = strtol(++arg, NULL, 0);
420 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
427 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
429 AVDictionary **meta_in = NULL;
430 AVDictionary **meta_out = NULL;
432 char type_in, type_out;
433 const char *istream_spec = NULL, *ostream_spec = NULL;
434 int idx_in = 0, idx_out = 0;
436 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
437 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
440 if (type_out == 'g' || !*outspec)
441 o->metadata_global_manual = 1;
442 if (type_out == 's' || !*outspec)
443 o->metadata_streams_manual = 1;
444 if (type_out == 'c' || !*outspec)
445 o->metadata_chapters_manual = 1;
449 if (type_in == 'g' || type_out == 'g')
450 o->metadata_global_manual = 1;
451 if (type_in == 's' || type_out == 's')
452 o->metadata_streams_manual = 1;
453 if (type_in == 'c' || type_out == 'c')
454 o->metadata_chapters_manual = 1;
456 /* ic is NULL when just disabling automatic mappings */
460 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
461 if ((index) < 0 || (index) >= (nb_elems)) {\
462 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
467 #define SET_DICT(type, meta, context, index)\
470 meta = &context->metadata;\
473 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
474 meta = &context->chapters[index]->metadata;\
477 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
478 meta = &context->programs[index]->metadata;\
481 break; /* handled separately below */ \
482 default: av_assert0(0);\
485 SET_DICT(type_in, meta_in, ic, idx_in);
486 SET_DICT(type_out, meta_out, oc, idx_out);
488 /* for input streams choose first matching stream */
489 if (type_in == 's') {
490 for (i = 0; i < ic->nb_streams; i++) {
491 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
492 meta_in = &ic->streams[i]->metadata;
498 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
503 if (type_out == 's') {
504 for (i = 0; i < oc->nb_streams; i++) {
505 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
506 meta_out = &oc->streams[i]->metadata;
507 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
512 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
517 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
519 OptionsContext *o = optctx;
521 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
522 struct tm time = *gmtime((time_t*)&recording_timestamp);
523 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
525 parse_option(o, "metadata", buf, options);
527 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
528 "tag instead.\n", opt);
532 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
534 const AVCodecDescriptor *desc;
535 const char *codec_string = encoder ? "encoder" : "decoder";
539 avcodec_find_encoder_by_name(name) :
540 avcodec_find_decoder_by_name(name);
542 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
543 codec = encoder ? avcodec_find_encoder(desc->id) :
544 avcodec_find_decoder(desc->id);
546 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
547 codec_string, codec->name, desc->name);
551 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
554 if (codec->type != type) {
555 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
561 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
563 char *codec_name = NULL;
565 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
567 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
568 st->codec->codec_id = codec->id;
571 return avcodec_find_decoder(st->codec->codec_id);
574 /* Add all the streams from the given input file to the global
575 * list of input streams. */
576 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
580 for (i = 0; i < ic->nb_streams; i++) {
581 AVStream *st = ic->streams[i];
582 AVCodecContext *dec = st->codec;
583 InputStream *ist = av_mallocz(sizeof(*ist));
584 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
585 char *codec_tag = NULL;
587 char *discard_str = NULL;
588 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
593 GROW_ARRAY(input_streams, nb_input_streams);
594 input_streams[nb_input_streams - 1] = ist;
597 ist->file_index = nb_input_files;
599 st->discard = AVDISCARD_ALL;
602 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
604 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
606 uint32_t tag = strtol(codec_tag, &next, 0);
608 tag = AV_RL32(codec_tag);
609 st->codec->codec_tag = tag;
612 ist->dec = choose_decoder(o, ic, st);
613 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
615 ist->reinit_filters = -1;
616 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
618 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
619 ist->user_set_discard = AVDISCARD_NONE;
620 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
621 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
626 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
628 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
630 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
634 ret = avcodec_copy_context(ist->dec_ctx, dec);
636 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
640 switch (dec->codec_type) {
641 case AVMEDIA_TYPE_VIDEO:
643 ist->dec = avcodec_find_decoder(dec->codec_id);
644 if (av_codec_get_lowres(dec)) {
645 dec->flags |= CODEC_FLAG_EMU_EDGE;
648 ist->resample_height = ist->dec_ctx->height;
649 ist->resample_width = ist->dec_ctx->width;
650 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
652 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
653 if (framerate && av_parse_video_rate(&ist->framerate,
655 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
660 ist->top_field_first = -1;
661 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
663 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
665 if (!strcmp(hwaccel, "none"))
666 ist->hwaccel_id = HWACCEL_NONE;
667 else if (!strcmp(hwaccel, "auto"))
668 ist->hwaccel_id = HWACCEL_AUTO;
671 for (i = 0; hwaccels[i].name; i++) {
672 if (!strcmp(hwaccels[i].name, hwaccel)) {
673 ist->hwaccel_id = hwaccels[i].id;
678 if (!ist->hwaccel_id) {
679 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
681 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
682 for (i = 0; hwaccels[i].name; i++)
683 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
684 av_log(NULL, AV_LOG_FATAL, "\n");
690 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
691 if (hwaccel_device) {
692 ist->hwaccel_device = av_strdup(hwaccel_device);
693 if (!ist->hwaccel_device)
696 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
699 case AVMEDIA_TYPE_AUDIO:
700 ist->guess_layout_max = INT_MAX;
701 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
702 guess_input_channel_layout(ist);
704 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
705 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
706 ist->resample_channels = ist->dec_ctx->channels;
707 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
710 case AVMEDIA_TYPE_DATA:
711 case AVMEDIA_TYPE_SUBTITLE: {
712 char *canvas_size = NULL;
714 ist->dec = avcodec_find_decoder(dec->codec_id);
715 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
716 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
718 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
719 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
724 case AVMEDIA_TYPE_ATTACHMENT:
725 case AVMEDIA_TYPE_UNKNOWN:
733 static void assert_file_overwrite(const char *filename)
735 if (file_overwrite && no_file_overwrite) {
736 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
740 if (!file_overwrite) {
741 const char *proto_name = avio_find_protocol_name(filename);
742 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
743 if (stdin_interaction && !no_file_overwrite) {
744 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
747 signal(SIGINT, SIG_DFL);
749 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
755 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
762 static void dump_attachment(AVStream *st, const char *filename)
765 AVIOContext *out = NULL;
766 AVDictionaryEntry *e;
768 if (!st->codec->extradata_size) {
769 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
770 nb_input_files - 1, st->index);
773 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
776 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
777 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
781 assert_file_overwrite(filename);
783 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
784 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
789 avio_write(out, st->codec->extradata, st->codec->extradata_size);
794 static int open_input_file(OptionsContext *o, const char *filename)
798 AVInputFormat *file_iformat = NULL;
802 AVDictionary *unused_opts = NULL;
803 AVDictionaryEntry *e = NULL;
804 int orig_nb_streams; // number of streams before avformat_find_stream_info
805 char * video_codec_name = NULL;
806 char * audio_codec_name = NULL;
807 char *subtitle_codec_name = NULL;
808 char * data_codec_name = NULL;
809 int scan_all_pmts_set = 0;
812 if (!(file_iformat = av_find_input_format(o->format))) {
813 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
818 if (!strcmp(filename, "-"))
821 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
822 strcmp(filename, "/dev/stdin");
824 /* get default parameters from command line */
825 ic = avformat_alloc_context();
827 print_error(filename, AVERROR(ENOMEM));
830 if (o->nb_audio_sample_rate) {
831 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
833 if (o->nb_audio_channels) {
834 /* because we set audio_channels based on both the "ac" and
835 * "channel_layout" options, we need to check that the specified
836 * demuxer actually has the "channels" option before setting it */
837 if (file_iformat && file_iformat->priv_class &&
838 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
839 AV_OPT_SEARCH_FAKE_OBJ)) {
840 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
843 if (o->nb_frame_rates) {
844 /* set the format-level framerate option;
845 * this is important for video grabbers, e.g. x11 */
846 if (file_iformat && file_iformat->priv_class &&
847 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
848 AV_OPT_SEARCH_FAKE_OBJ)) {
849 av_dict_set(&o->g->format_opts, "framerate",
850 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
853 if (o->nb_frame_sizes) {
854 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
856 if (o->nb_frame_pix_fmts)
857 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
859 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
860 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
861 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
863 ic->video_codec_id = video_codec_name ?
864 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
865 ic->audio_codec_id = audio_codec_name ?
866 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
867 ic->subtitle_codec_id= subtitle_codec_name ?
868 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
869 ic->data_codec_id = data_codec_name ?
870 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
872 if (video_codec_name)
873 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
874 if (audio_codec_name)
875 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
876 if (subtitle_codec_name)
877 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
879 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
881 ic->flags |= AVFMT_FLAG_NONBLOCK;
882 ic->interrupt_callback = int_cb;
884 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
885 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
886 scan_all_pmts_set = 1;
888 /* open the input file with generic avformat function */
889 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
891 print_error(filename, err);
894 if (scan_all_pmts_set)
895 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
896 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
897 assert_avoptions(o->g->format_opts);
899 /* apply forced codec ids */
900 for (i = 0; i < ic->nb_streams; i++)
901 choose_decoder(o, ic, ic->streams[i]);
903 /* Set AVCodecContext options for avformat_find_stream_info */
904 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
905 orig_nb_streams = ic->nb_streams;
907 /* If not enough info to get the stream parameters, we decode the
908 first frames to get it. (used in mpeg case for example) */
909 ret = avformat_find_stream_info(ic, opts);
911 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
912 if (ic->nb_streams == 0) {
913 avformat_close_input(&ic);
918 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
919 /* add the stream start time */
920 if (ic->start_time != AV_NOPTS_VALUE)
921 timestamp += ic->start_time;
923 /* if seeking requested, we execute it */
924 if (o->start_time != AV_NOPTS_VALUE) {
925 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
927 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
928 filename, (double)timestamp / AV_TIME_BASE);
932 /* update the current parameters so that they match the one of the input stream */
933 add_input_streams(o, ic);
935 /* dump the file content */
936 av_dump_format(ic, nb_input_files, filename, 0);
938 GROW_ARRAY(input_files, nb_input_files);
939 f = av_mallocz(sizeof(*f));
942 input_files[nb_input_files - 1] = f;
945 f->ist_index = nb_input_streams - ic->nb_streams;
946 f->start_time = o->start_time;
947 f->recording_time = o->recording_time;
948 f->input_ts_offset = o->input_ts_offset;
949 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
950 f->nb_streams = ic->nb_streams;
951 f->rate_emu = o->rate_emu;
952 f->accurate_seek = o->accurate_seek;
954 /* check if all codec options have been used */
955 unused_opts = strip_specifiers(o->g->codec_opts);
956 for (i = f->ist_index; i < nb_input_streams; i++) {
958 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
959 AV_DICT_IGNORE_SUFFIX)))
960 av_dict_set(&unused_opts, e->key, NULL, 0);
964 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
965 const AVClass *class = avcodec_get_class();
966 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
967 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
968 const AVClass *fclass = avformat_get_class();
969 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
970 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
971 if (!option || foption)
975 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
976 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
977 "input file #%d (%s) is not a decoding option.\n", e->key,
978 option->help ? option->help : "", nb_input_files - 1,
983 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
984 "input file #%d (%s) has not been used for any stream. The most "
985 "likely reason is either wrong type (e.g. a video option with "
986 "no video streams) or that it is a private option of some decoder "
987 "which was not actually used for any stream.\n", e->key,
988 option->help ? option->help : "", nb_input_files - 1, filename);
990 av_dict_free(&unused_opts);
992 for (i = 0; i < o->nb_dump_attachment; i++) {
995 for (j = 0; j < ic->nb_streams; j++) {
996 AVStream *st = ic->streams[j];
998 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
999 dump_attachment(st, o->dump_attachment[i].u.str);
1003 for (i = 0; i < orig_nb_streams; i++)
1004 av_dict_free(&opts[i]);
1010 static uint8_t *get_line(AVIOContext *s)
1016 if (avio_open_dyn_buf(&line) < 0) {
1017 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1021 while ((c = avio_r8(s)) && c != '\n')
1024 avio_close_dyn_buf(line, &buf);
1029 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1032 char filename[1000];
1033 const char *base[3] = { getenv("AVCONV_DATADIR"),
1038 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1042 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1043 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1044 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1047 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1048 i != 1 ? "" : "/.avconv", preset_name);
1049 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1055 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1057 char *codec_name = NULL;
1059 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1061 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1062 NULL, ost->st->codec->codec_type);
1063 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1064 } else if (!strcmp(codec_name, "copy"))
1065 ost->stream_copy = 1;
1067 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1068 ost->st->codec->codec_id = ost->enc->id;
1072 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1075 AVStream *st = avformat_new_stream(oc, NULL);
1076 int idx = oc->nb_streams - 1, ret = 0;
1077 char *bsf = NULL, *next, *codec_tag = NULL;
1078 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1083 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1087 if (oc->nb_streams - 1 < o->nb_streamid_map)
1088 st->id = o->streamid_map[oc->nb_streams - 1];
1090 GROW_ARRAY(output_streams, nb_output_streams);
1091 if (!(ost = av_mallocz(sizeof(*ost))))
1093 output_streams[nb_output_streams - 1] = ost;
1095 ost->file_index = nb_output_files - 1;
1098 st->codec->codec_type = type;
1099 choose_encoder(o, oc, ost);
1101 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1102 if (!ost->enc_ctx) {
1103 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1106 ost->enc_ctx->codec_type = type;
1109 AVIOContext *s = NULL;
1110 char *buf = NULL, *arg = NULL, *preset = NULL;
1112 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1114 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1115 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1118 if (!buf[0] || buf[0] == '#') {
1122 if (!(arg = strchr(buf, '='))) {
1123 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1127 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1129 } while (!s->eof_reached);
1133 av_log(NULL, AV_LOG_FATAL,
1134 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1135 preset, ost->file_index, ost->index);
1139 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1142 ost->max_frames = INT64_MAX;
1143 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1144 for (i = 0; i<o->nb_max_frames; i++) {
1145 char *p = o->max_frames[i].specifier;
1146 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1147 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1152 ost->copy_prior_start = -1;
1153 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1155 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1158 if (next = strchr(bsf, ','))
1160 if (arg = strchr(bsf, '='))
1162 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1163 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1167 bsfc_prev->next = bsfc;
1169 ost->bitstream_filters = bsfc;
1170 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1176 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1178 uint32_t tag = strtol(codec_tag, &next, 0);
1180 tag = AV_RL32(codec_tag);
1181 ost->enc_ctx->codec_tag = tag;
1184 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1186 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1187 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1190 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1191 ost->disposition = av_strdup(ost->disposition);
1193 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1194 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1196 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1198 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1199 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1200 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1202 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1204 ost->source_index = source_index;
1205 if (source_index >= 0) {
1206 ost->sync_ist = input_streams[source_index];
1207 input_streams[source_index]->discard = 0;
1208 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1210 ost->last_mux_dts = AV_NOPTS_VALUE;
1215 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1218 const char *p = str;
1225 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1232 /* read file contents into a string */
1233 static uint8_t *read_file(const char *filename)
1235 AVIOContext *pb = NULL;
1236 AVIOContext *dyn_buf = NULL;
1237 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1238 uint8_t buf[1024], *str;
1241 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1245 ret = avio_open_dyn_buf(&dyn_buf);
1250 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1251 avio_write(dyn_buf, buf, ret);
1252 avio_w8(dyn_buf, 0);
1255 ret = avio_close_dyn_buf(dyn_buf, &str);
1261 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1264 AVStream *st = ost->st;
1266 if (ost->filters_script && ost->filters) {
1267 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1268 "output stream #%d:%d.\n", nb_output_files, st->index);
1272 if (ost->filters_script)
1273 return read_file(ost->filters_script);
1274 else if (ost->filters)
1275 return av_strdup(ost->filters);
1277 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1281 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1282 const OutputStream *ost, enum AVMediaType type)
1284 if (ost->filters_script || ost->filters) {
1285 av_log(NULL, AV_LOG_ERROR,
1286 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1287 "Filtering and streamcopy cannot be used together.\n",
1288 ost->filters ? "Filtergraph" : "Filtergraph script",
1289 ost->filters ? ost->filters : ost->filters_script,
1290 av_get_media_type_string(type), ost->file_index, ost->index);
1295 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1299 AVCodecContext *video_enc;
1300 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1302 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1304 video_enc = ost->enc_ctx;
1306 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1307 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1308 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1311 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1312 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1314 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1315 if (frame_aspect_ratio) {
1317 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1318 q.num <= 0 || q.den <= 0) {
1319 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1322 ost->frame_aspect_ratio = q;
1325 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1326 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1328 if (!ost->stream_copy) {
1329 const char *p = NULL;
1330 char *frame_size = NULL;
1331 char *frame_pix_fmt = NULL;
1332 char *intra_matrix = NULL, *inter_matrix = NULL;
1333 char *chroma_intra_matrix = NULL;
1337 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1338 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1339 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1343 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1344 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1345 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1346 ost->keep_pix_fmt = 1;
1347 if (!*++frame_pix_fmt)
1348 frame_pix_fmt = NULL;
1350 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1351 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1354 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1357 video_enc->gop_size = 0;
1358 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1360 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1361 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1364 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1366 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1367 if (chroma_intra_matrix) {
1368 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1370 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1373 av_codec_set_chroma_intra_matrix(video_enc, p);
1374 parse_matrix_coeffs(p, chroma_intra_matrix);
1376 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1378 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1379 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1382 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1385 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1386 for (i = 0; p; i++) {
1388 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1390 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1393 video_enc->rc_override =
1394 av_realloc_array(video_enc->rc_override,
1395 i + 1, sizeof(RcOverride));
1396 if (!video_enc->rc_override) {
1397 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1400 video_enc->rc_override[i].start_frame = start;
1401 video_enc->rc_override[i].end_frame = end;
1403 video_enc->rc_override[i].qscale = q;
1404 video_enc->rc_override[i].quality_factor = 1.0;
1407 video_enc->rc_override[i].qscale = 0;
1408 video_enc->rc_override[i].quality_factor = -q/100.0;
1413 video_enc->rc_override_count = i;
1416 video_enc->flags|= CODEC_FLAG_PSNR;
1419 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1422 video_enc->flags |= CODEC_FLAG_PASS1;
1423 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1426 video_enc->flags |= CODEC_FLAG_PASS2;
1427 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1431 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1432 if (ost->logfile_prefix &&
1433 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1436 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1437 if (ost->forced_keyframes)
1438 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1440 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1442 ost->top_field_first = -1;
1443 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1446 ost->avfilter = get_ost_filters(o, oc, ost);
1450 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1453 if (ost->stream_copy)
1454 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1459 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1464 AVCodecContext *audio_enc;
1466 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1469 audio_enc = ost->enc_ctx;
1470 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1472 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1473 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1475 if (!ost->stream_copy) {
1476 char *sample_fmt = NULL;
1478 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1480 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1482 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1483 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1487 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1489 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1490 ost->apad = av_strdup(ost->apad);
1492 ost->avfilter = get_ost_filters(o, oc, ost);
1496 /* check for channel mapping for this audio stream */
1497 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1498 AudioChannelMap *map = &o->audio_channel_maps[n];
1499 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1500 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1503 if (map->channel_idx == -1) {
1505 } else if (ost->source_index < 0) {
1506 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1507 ost->file_index, ost->st->index);
1510 ist = input_streams[ost->source_index];
1513 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1514 if (av_reallocp_array(&ost->audio_channels_map,
1515 ost->audio_channels_mapped + 1,
1516 sizeof(*ost->audio_channels_map)
1520 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1526 if (ost->stream_copy)
1527 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1532 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1536 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1537 if (!ost->stream_copy) {
1538 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1545 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1547 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1548 ost->stream_copy = 1;
1553 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1557 AVCodecContext *subtitle_enc;
1559 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1561 subtitle_enc = ost->enc_ctx;
1563 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1565 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1567 if (!ost->stream_copy) {
1568 char *frame_size = NULL;
1570 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1571 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1572 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1580 /* arg format is "output-stream-index:streamid-value". */
1581 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1583 OptionsContext *o = optctx;
1588 av_strlcpy(idx_str, arg, sizeof(idx_str));
1589 p = strchr(idx_str, ':');
1591 av_log(NULL, AV_LOG_FATAL,
1592 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1597 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1598 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1599 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1603 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1605 AVFormatContext *is = ifile->ctx;
1606 AVFormatContext *os = ofile->ctx;
1610 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1612 return AVERROR(ENOMEM);
1615 for (i = 0; i < is->nb_chapters; i++) {
1616 AVChapter *in_ch = is->chapters[i], *out_ch;
1617 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1618 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1619 AV_TIME_BASE_Q, in_ch->time_base);
1620 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1621 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1624 if (in_ch->end < ts_off)
1626 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1629 out_ch = av_mallocz(sizeof(AVChapter));
1631 return AVERROR(ENOMEM);
1633 out_ch->id = in_ch->id;
1634 out_ch->time_base = in_ch->time_base;
1635 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1636 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1639 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1641 os->chapters[os->nb_chapters++] = out_ch;
1646 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1649 AVFormatContext *ic = avformat_alloc_context();
1651 ic->interrupt_callback = int_cb;
1652 err = avformat_open_input(&ic, filename, NULL, NULL);
1655 /* copy stream format */
1656 for(i=0;i<ic->nb_streams;i++) {
1660 const char *enc_config;
1662 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1664 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1665 return AVERROR(EINVAL);
1667 if (codec->type == AVMEDIA_TYPE_AUDIO)
1668 opt_audio_codec(o, "c:a", codec->name);
1669 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1670 opt_video_codec(o, "c:v", codec->name);
1671 ost = new_output_stream(o, s, codec->type, -1);
1674 avcodec_get_context_defaults3(st->codec, codec);
1675 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1677 AVDictionary *opts = NULL;
1678 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1679 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1680 av_dict_free(&opts);
1683 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1684 choose_sample_fmt(st, codec);
1685 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1686 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1687 avcodec_copy_context(ost->enc_ctx, st->codec);
1689 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1692 avformat_close_input(&ic);
1696 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1697 AVFormatContext *oc)
1701 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1702 ofilter->out_tmp->pad_idx)) {
1703 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1704 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1706 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1711 ost->source_index = -1;
1712 ost->filter = ofilter;
1716 if (ost->stream_copy) {
1717 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1718 "which is fed from a complex filtergraph. Filtering and streamcopy "
1719 "cannot be used together.\n", ost->file_index, ost->index);
1723 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1724 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1725 av_log(NULL, AV_LOG_ERROR,
1726 "%s '%s' was specified through the %s option "
1727 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1728 "%s and -filter_complex cannot be used together for the same stream.\n",
1729 ost->filters ? "Filtergraph" : "Filtergraph script",
1730 ost->filters ? ost->filters : ost->filters_script,
1731 opt, ost->file_index, ost->index, opt);
1735 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1736 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1739 avfilter_inout_free(&ofilter->out_tmp);
1742 static int configure_complex_filters(void)
1746 for (i = 0; i < nb_filtergraphs; i++)
1747 if (!filtergraphs[i]->graph &&
1748 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1753 static int open_output_file(OptionsContext *o, const char *filename)
1755 AVFormatContext *oc;
1757 AVOutputFormat *file_oformat;
1761 AVDictionary *unused_opts = NULL;
1762 AVDictionaryEntry *e = NULL;
1764 if (configure_complex_filters() < 0) {
1765 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1769 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1770 o->stop_time = INT64_MAX;
1771 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1774 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1775 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1776 if (o->stop_time <= start_time) {
1777 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1780 o->recording_time = o->stop_time - start_time;
1784 GROW_ARRAY(output_files, nb_output_files);
1785 of = av_mallocz(sizeof(*of));
1788 output_files[nb_output_files - 1] = of;
1790 of->ost_index = nb_output_streams;
1791 of->recording_time = o->recording_time;
1792 of->start_time = o->start_time;
1793 of->limit_filesize = o->limit_filesize;
1794 of->shortest = o->shortest;
1795 av_dict_copy(&of->opts, o->g->format_opts, 0);
1797 if (!strcmp(filename, "-"))
1800 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1802 print_error(filename, err);
1807 if (o->recording_time != INT64_MAX)
1808 oc->duration = o->recording_time;
1810 file_oformat= oc->oformat;
1811 oc->interrupt_callback = int_cb;
1813 /* create streams for all unlabeled output pads */
1814 for (i = 0; i < nb_filtergraphs; i++) {
1815 FilterGraph *fg = filtergraphs[i];
1816 for (j = 0; j < fg->nb_outputs; j++) {
1817 OutputFilter *ofilter = fg->outputs[j];
1819 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1822 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1823 ofilter->out_tmp->pad_idx)) {
1824 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1825 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1826 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1828 init_output_filter(ofilter, o, oc);
1832 /* ffserver seeking with date=... needs a date reference */
1833 if (!strcmp(file_oformat->name, "ffm") &&
1834 av_strstart(filename, "http:", NULL)) {
1835 int err = parse_option(o, "metadata", "creation_time=now", options);
1837 print_error(filename, err);
1842 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1843 av_strstart(filename, "http:", NULL)) {
1845 /* special case for files sent to ffserver: we get the stream
1846 parameters from ffserver */
1847 int err = read_ffserver_streams(o, oc, filename);
1849 print_error(filename, err);
1852 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1853 ost = output_streams[j];
1854 for (i = 0; i < nb_input_streams; i++) {
1855 ist = input_streams[i];
1856 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1858 ost->source_index= i;
1859 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1860 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1862 ist->st->discard = ist->user_set_discard;
1867 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));
1871 } else if (!o->nb_stream_maps) {
1872 char *subtitle_codec_name = NULL;
1873 /* pick the "best" stream of each type */
1875 /* video: highest resolution */
1876 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1877 int area = 0, idx = -1;
1878 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1879 for (i = 0; i < nb_input_streams; i++) {
1881 ist = input_streams[i];
1882 new_area = ist->st->codec->width * ist->st->codec->height;
1883 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1885 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1887 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1894 new_video_stream(o, oc, idx);
1897 /* audio: most channels */
1898 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1899 int channels = 0, idx = -1;
1900 for (i = 0; i < nb_input_streams; i++) {
1901 ist = input_streams[i];
1902 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1903 ist->st->codec->channels > channels) {
1904 channels = ist->st->codec->channels;
1909 new_audio_stream(o, oc, idx);
1912 /* subtitles: pick first */
1913 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1914 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1915 for (i = 0; i < nb_input_streams; i++)
1916 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1917 AVCodecDescriptor const *input_descriptor =
1918 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1919 AVCodecDescriptor const *output_descriptor = NULL;
1920 AVCodec const *output_codec =
1921 avcodec_find_encoder(oc->oformat->subtitle_codec);
1922 int input_props = 0, output_props = 0;
1924 output_descriptor = avcodec_descriptor_get(output_codec->id);
1925 if (input_descriptor)
1926 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1927 if (output_descriptor)
1928 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1929 if (subtitle_codec_name ||
1930 input_props & output_props ||
1931 // Map dvb teletext which has neither property to any output subtitle encoder
1932 input_descriptor && output_descriptor &&
1933 (!input_descriptor->props ||
1934 !output_descriptor->props)) {
1935 new_subtitle_stream(o, oc, i);
1940 /* Data only if codec id match */
1941 if (!o->data_disable ) {
1942 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
1943 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1944 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1945 && input_streams[i]->st->codec->codec_id == codec_id )
1946 new_data_stream(o, oc, i);
1950 for (i = 0; i < o->nb_stream_maps; i++) {
1951 StreamMap *map = &o->stream_maps[i];
1956 if (map->linklabel) {
1958 OutputFilter *ofilter = NULL;
1961 for (j = 0; j < nb_filtergraphs; j++) {
1962 fg = filtergraphs[j];
1963 for (k = 0; k < fg->nb_outputs; k++) {
1964 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1965 if (out && !strcmp(out->name, map->linklabel)) {
1966 ofilter = fg->outputs[k];
1973 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1974 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1977 init_output_filter(ofilter, o, oc);
1979 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1981 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1982 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1984 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1986 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1988 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1991 switch (ist->st->codec->codec_type) {
1992 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1993 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1994 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1995 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1996 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1998 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1999 map->file_index, map->stream_index);
2006 /* handle attached files */
2007 for (i = 0; i < o->nb_attachments; i++) {
2009 uint8_t *attachment;
2013 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2014 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2018 if ((len = avio_size(pb)) <= 0) {
2019 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2023 if (!(attachment = av_malloc(len))) {
2024 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2028 avio_read(pb, attachment, len);
2030 ost = new_attachment_stream(o, oc, -1);
2031 ost->stream_copy = 0;
2032 ost->attachment_filename = o->attachments[i];
2034 ost->enc_ctx->extradata = attachment;
2035 ost->enc_ctx->extradata_size = len;
2037 p = strrchr(o->attachments[i], '/');
2038 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2042 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2043 AVDictionaryEntry *e;
2044 ost = output_streams[i];
2046 if ((ost->stream_copy || ost->attachment_filename)
2047 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2048 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2049 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2053 /* check if all codec options have been used */
2054 unused_opts = strip_specifiers(o->g->codec_opts);
2055 for (i = of->ost_index; i < nb_output_streams; i++) {
2057 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2058 AV_DICT_IGNORE_SUFFIX)))
2059 av_dict_set(&unused_opts, e->key, NULL, 0);
2063 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2064 const AVClass *class = avcodec_get_class();
2065 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2066 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2067 const AVClass *fclass = avformat_get_class();
2068 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2069 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2070 if (!option || foption)
2074 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2075 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2076 "output file #%d (%s) is not an encoding option.\n", e->key,
2077 option->help ? option->help : "", nb_output_files - 1,
2082 // gop_timecode is injected by generic code but not always used
2083 if (!strcmp(e->key, "gop_timecode"))
2086 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2087 "output file #%d (%s) has not been used for any stream. The most "
2088 "likely reason is either wrong type (e.g. a video option with "
2089 "no video streams) or that it is a private option of some encoder "
2090 "which was not actually used for any stream.\n", e->key,
2091 option->help ? option->help : "", nb_output_files - 1, filename);
2093 av_dict_free(&unused_opts);
2095 /* check filename in case of an image number is expected */
2096 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2097 if (!av_filename_number_test(oc->filename)) {
2098 print_error(oc->filename, AVERROR(EINVAL));
2103 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2104 /* test if it already exists to avoid losing precious files */
2105 assert_file_overwrite(filename);
2108 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2109 &oc->interrupt_callback,
2111 print_error(filename, err);
2114 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2115 assert_file_overwrite(filename);
2117 if (o->mux_preload) {
2118 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2120 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2123 for (i = 0; i < o->nb_metadata_map; i++) {
2125 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2127 if (in_file_index >= nb_input_files) {
2128 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2131 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2132 in_file_index >= 0 ?
2133 input_files[in_file_index]->ctx : NULL, o);
2137 if (o->chapters_input_file >= nb_input_files) {
2138 if (o->chapters_input_file == INT_MAX) {
2139 /* copy chapters from the first input file that has them*/
2140 o->chapters_input_file = -1;
2141 for (i = 0; i < nb_input_files; i++)
2142 if (input_files[i]->ctx->nb_chapters) {
2143 o->chapters_input_file = i;
2147 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2148 o->chapters_input_file);
2152 if (o->chapters_input_file >= 0)
2153 copy_chapters(input_files[o->chapters_input_file], of,
2154 !o->metadata_chapters_manual);
2156 /* copy global metadata by default */
2157 if (!o->metadata_global_manual && nb_input_files){
2158 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2159 AV_DICT_DONT_OVERWRITE);
2160 if(o->recording_time != INT64_MAX)
2161 av_dict_set(&oc->metadata, "duration", NULL, 0);
2162 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2164 if (!o->metadata_streams_manual)
2165 for (i = of->ost_index; i < nb_output_streams; i++) {
2167 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2169 ist = input_streams[output_streams[i]->source_index];
2170 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2171 if (!output_streams[i]->stream_copy)
2172 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2175 /* process manually set metadata */
2176 for (i = 0; i < o->nb_metadata; i++) {
2179 const char *stream_spec;
2180 int index = 0, j, ret = 0;
2182 val = strchr(o->metadata[i].u.str, '=');
2184 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2185 o->metadata[i].u.str);
2190 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2192 for (j = 0; j < oc->nb_streams; j++) {
2193 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2194 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2205 if (index < 0 || index >= oc->nb_chapters) {
2206 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2209 m = &oc->chapters[index]->metadata;
2212 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2215 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2222 static int opt_target(void *optctx, const char *opt, const char *arg)
2224 OptionsContext *o = optctx;
2225 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2226 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2228 if (!strncmp(arg, "pal-", 4)) {
2231 } else if (!strncmp(arg, "ntsc-", 5)) {
2234 } else if (!strncmp(arg, "film-", 5)) {
2238 /* Try to determine PAL/NTSC by peeking in the input files */
2239 if (nb_input_files) {
2241 for (j = 0; j < nb_input_files; j++) {
2242 for (i = 0; i < input_files[j]->nb_streams; i++) {
2243 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2244 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2247 fr = c->time_base.den * 1000 / c->time_base.num;
2251 } else if ((fr == 29970) || (fr == 23976)) {
2256 if (norm != UNKNOWN)
2260 if (norm != UNKNOWN)
2261 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2264 if (norm == UNKNOWN) {
2265 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2266 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2267 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2271 if (!strcmp(arg, "vcd")) {
2272 opt_video_codec(o, "c:v", "mpeg1video");
2273 opt_audio_codec(o, "c:a", "mp2");
2274 parse_option(o, "f", "vcd", options);
2276 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2277 parse_option(o, "r", frame_rates[norm], options);
2278 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2280 opt_default(NULL, "b:v", "1150000");
2281 opt_default(NULL, "maxrate", "1150000");
2282 opt_default(NULL, "minrate", "1150000");
2283 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2285 opt_default(NULL, "b:a", "224000");
2286 parse_option(o, "ar", "44100", options);
2287 parse_option(o, "ac", "2", options);
2289 opt_default(NULL, "packetsize", "2324");
2290 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2292 /* We have to offset the PTS, so that it is consistent with the SCR.
2293 SCR starts at 36000, but the first two packs contain only padding
2294 and the first pack from the other stream, respectively, may also have
2295 been written before.
2296 So the real data starts at SCR 36000+3*1200. */
2297 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2298 } else if (!strcmp(arg, "svcd")) {
2300 opt_video_codec(o, "c:v", "mpeg2video");
2301 opt_audio_codec(o, "c:a", "mp2");
2302 parse_option(o, "f", "svcd", options);
2304 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2305 parse_option(o, "r", frame_rates[norm], options);
2306 parse_option(o, "pix_fmt", "yuv420p", options);
2307 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2309 opt_default(NULL, "b:v", "2040000");
2310 opt_default(NULL, "maxrate", "2516000");
2311 opt_default(NULL, "minrate", "0"); // 1145000;
2312 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2313 opt_default(NULL, "scan_offset", "1");
2315 opt_default(NULL, "b:a", "224000");
2316 parse_option(o, "ar", "44100", options);
2318 opt_default(NULL, "packetsize", "2324");
2320 } else if (!strcmp(arg, "dvd")) {
2322 opt_video_codec(o, "c:v", "mpeg2video");
2323 opt_audio_codec(o, "c:a", "ac3");
2324 parse_option(o, "f", "dvd", options);
2326 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2327 parse_option(o, "r", frame_rates[norm], options);
2328 parse_option(o, "pix_fmt", "yuv420p", options);
2329 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2331 opt_default(NULL, "b:v", "6000000");
2332 opt_default(NULL, "maxrate", "9000000");
2333 opt_default(NULL, "minrate", "0"); // 1500000;
2334 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2336 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2337 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2339 opt_default(NULL, "b:a", "448000");
2340 parse_option(o, "ar", "48000", options);
2342 } else if (!strncmp(arg, "dv", 2)) {
2344 parse_option(o, "f", "dv", options);
2346 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2347 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2348 norm == PAL ? "yuv420p" : "yuv411p", options);
2349 parse_option(o, "r", frame_rates[norm], options);
2351 parse_option(o, "ar", "48000", options);
2352 parse_option(o, "ac", "2", options);
2355 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2356 return AVERROR(EINVAL);
2359 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2360 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2365 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2367 av_free (vstats_filename);
2368 vstats_filename = av_strdup (arg);
2372 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2375 time_t today2 = time(NULL);
2376 struct tm *today = localtime(&today2);
2378 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2380 return opt_vstats_file(NULL, opt, filename);
2383 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2385 OptionsContext *o = optctx;
2386 return parse_option(o, "frames:v", arg, options);
2389 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2391 OptionsContext *o = optctx;
2392 return parse_option(o, "frames:a", arg, options);
2395 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2397 OptionsContext *o = optctx;
2398 return parse_option(o, "frames:d", arg, options);
2401 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2404 AVDictionary *cbak = codec_opts;
2405 AVDictionary *fbak = format_opts;
2409 ret = opt_default(NULL, opt, arg);
2411 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2412 av_dict_copy(&o->g->format_opts, format_opts, 0);
2413 av_dict_free(&codec_opts);
2414 av_dict_free(&format_opts);
2421 static int opt_preset(void *optctx, const char *opt, const char *arg)
2423 OptionsContext *o = optctx;
2425 char filename[1000], line[1000], tmp_line[1000];
2426 const char *codec_name = NULL;
2430 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2432 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2433 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2434 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2436 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2440 while (fgets(line, sizeof(line), f)) {
2441 char *key = tmp_line, *value, *endptr;
2443 if (strcspn(line, "#\n\r") == 0)
2445 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2446 if (!av_strtok(key, "=", &value) ||
2447 !av_strtok(value, "\r\n", &endptr)) {
2448 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2451 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2453 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2454 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2455 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2456 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2457 else if (opt_default_new(o, key, value) < 0) {
2458 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2459 filename, line, key, value);
2469 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2471 OptionsContext *o = optctx;
2472 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2473 int ret = parse_option(o, s, arg, options);
2478 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2480 OptionsContext *o = optctx;
2482 if(!strcmp(opt, "ab")){
2483 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2485 } else if(!strcmp(opt, "b")){
2486 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2487 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2490 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2494 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2496 OptionsContext *o = optctx;
2499 if(!strcmp(opt, "qscale")){
2500 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2501 return parse_option(o, "q:v", arg, options);
2503 s = av_asprintf("q%s", opt + 6);
2504 ret = parse_option(o, s, arg, options);
2509 static int opt_profile(void *optctx, const char *opt, const char *arg)
2511 OptionsContext *o = optctx;
2512 if(!strcmp(opt, "profile")){
2513 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2514 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2517 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2521 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2523 OptionsContext *o = optctx;
2524 return parse_option(o, "filter:v", arg, options);
2527 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2529 OptionsContext *o = optctx;
2530 return parse_option(o, "filter:a", arg, options);
2533 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2535 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2536 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2537 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2538 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2540 if (video_sync_method == VSYNC_AUTO)
2541 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2545 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2547 OptionsContext *o = optctx;
2548 char *tcr = av_asprintf("timecode=%s", arg);
2549 int ret = parse_option(o, "metadata:g", tcr, options);
2551 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2556 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2558 OptionsContext *o = optctx;
2559 char layout_str[32];
2562 int ret, channels, ac_str_size;
2565 layout = av_get_channel_layout(arg);
2567 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2568 return AVERROR(EINVAL);
2570 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2571 ret = opt_default_new(o, opt, layout_str);
2575 /* set 'ac' option based on channel layout */
2576 channels = av_get_channel_layout_nb_channels(layout);
2577 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2578 stream_str = strchr(opt, ':');
2579 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2580 ac_str = av_mallocz(ac_str_size);
2582 return AVERROR(ENOMEM);
2583 av_strlcpy(ac_str, "ac", 3);
2585 av_strlcat(ac_str, stream_str, ac_str_size);
2586 ret = parse_option(o, ac_str, layout_str, options);
2592 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2594 OptionsContext *o = optctx;
2595 return parse_option(o, "q:a", arg, options);
2598 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2600 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2601 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2602 return AVERROR(ENOMEM);
2603 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2604 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2605 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2606 return AVERROR(ENOMEM);
2610 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2612 uint8_t *graph_desc = read_file(arg);
2614 return AVERROR(EINVAL);
2616 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2617 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2618 return AVERROR(ENOMEM);
2619 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2620 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2624 void show_help_default(const char *opt, const char *arg)
2626 /* per-file options have at least one of those set */
2627 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2628 int show_advanced = 0, show_avoptions = 0;
2631 if (!strcmp(opt, "long"))
2633 else if (!strcmp(opt, "full"))
2634 show_advanced = show_avoptions = 1;
2636 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2641 printf("Getting help:\n"
2642 " -h -- print basic options\n"
2643 " -h long -- print more options\n"
2644 " -h full -- print all options (including all format and codec specific options, very long)\n"
2645 " See man %s for detailed description of the options.\n"
2646 "\n", program_name);
2648 show_help_options(options, "Print help / information / capabilities:",
2651 show_help_options(options, "Global options (affect whole program "
2652 "instead of just one file:",
2653 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2655 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2656 per_file | OPT_EXIT, 0);
2658 show_help_options(options, "Per-file main options:", 0,
2659 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2660 OPT_EXIT, per_file);
2662 show_help_options(options, "Advanced per-file options:",
2663 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2665 show_help_options(options, "Video options:",
2666 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2668 show_help_options(options, "Advanced Video options:",
2669 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2671 show_help_options(options, "Audio options:",
2672 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2674 show_help_options(options, "Advanced Audio options:",
2675 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2676 show_help_options(options, "Subtitle options:",
2677 OPT_SUBTITLE, 0, 0);
2680 if (show_avoptions) {
2681 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2682 show_help_children(avcodec_get_class(), flags);
2683 show_help_children(avformat_get_class(), flags);
2685 show_help_children(sws_get_class(), flags);
2687 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2688 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2692 void show_usage(void)
2694 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2695 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2696 av_log(NULL, AV_LOG_INFO, "\n");
2704 static const OptionGroupDef groups[] = {
2705 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2706 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2709 static int open_files(OptionGroupList *l, const char *inout,
2710 int (*open_file)(OptionsContext*, const char*))
2714 for (i = 0; i < l->nb_groups; i++) {
2715 OptionGroup *g = &l->groups[i];
2721 ret = parse_optgroup(&o, g);
2723 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2724 "%s.\n", inout, g->arg);
2728 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2729 ret = open_file(&o, g->arg);
2732 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2736 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2742 int ffmpeg_parse_options(int argc, char **argv)
2744 OptionParseContext octx;
2748 memset(&octx, 0, sizeof(octx));
2750 /* split the commandline into an internal representation */
2751 ret = split_commandline(&octx, argc, argv, options, groups,
2752 FF_ARRAY_ELEMS(groups));
2754 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2758 /* apply global options */
2759 ret = parse_optgroup(NULL, &octx.global_opts);
2761 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2765 /* open input files */
2766 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2768 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2772 /* open output files */
2773 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2775 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2780 uninit_parse_context(&octx);
2782 av_strerror(ret, error, sizeof(error));
2783 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2788 static int opt_progress(void *optctx, const char *opt, const char *arg)
2790 AVIOContext *avio = NULL;
2793 if (!strcmp(arg, "-"))
2795 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2797 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2798 arg, av_err2str(ret));
2801 progress_avio = avio;
2805 #define OFFSET(x) offsetof(OptionsContext, x)
2806 const OptionDef options[] = {
2808 #include "cmdutils_common_opts.h"
2809 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2810 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2811 "force format", "fmt" },
2812 { "y", OPT_BOOL, { &file_overwrite },
2813 "overwrite output files" },
2814 { "n", OPT_BOOL, { &no_file_overwrite },
2815 "never overwrite output files" },
2816 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2817 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2818 "codec name", "codec" },
2819 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2820 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2821 "codec name", "codec" },
2822 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2823 OPT_OUTPUT, { .off = OFFSET(presets) },
2824 "preset name", "preset" },
2825 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2826 OPT_OUTPUT, { .func_arg = opt_map },
2827 "set input stream mapping",
2828 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2829 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2830 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2831 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2832 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2833 "set metadata information of outfile from infile",
2834 "outfile[,metadata]:infile[,metadata]" },
2835 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2836 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2837 "set chapters mapping", "input_file_index" },
2838 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2839 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2840 "record or transcode \"duration\" seconds of audio/video",
2842 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2843 "record or transcode stop time", "time_stop" },
2844 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2845 "set the limit file size in bytes", "limit_size" },
2846 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2847 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2848 "set the start time offset", "time_off" },
2849 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2850 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2851 "enable/disable accurate seeking with -ss" },
2852 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2853 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2854 "set the input ts offset", "time_off" },
2855 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2856 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2857 "set the input ts scale", "scale" },
2858 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2859 "set the recording timestamp ('now' to set the current time)", "time" },
2860 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2861 "add metadata", "string=string" },
2862 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2863 OPT_OUTPUT, { .func_arg = opt_data_frames },
2864 "set the number of data frames to output", "number" },
2865 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2866 "add timings for benchmarking" },
2867 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2868 "add timings for each task" },
2869 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2870 "write program-readable progress information", "url" },
2871 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2872 "enable or disable interaction on standard input" },
2873 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2874 "set max runtime in seconds", "limit" },
2875 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2876 "dump each input packet" },
2877 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2878 "when dumping packets, also dump the payload" },
2879 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2880 OPT_INPUT, { .off = OFFSET(rate_emu) },
2881 "read input at native frame rate", "" },
2882 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2883 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2884 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2885 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2886 "video sync method", "" },
2887 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2888 "frame drop threshold", "" },
2889 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2890 "audio sync method", "" },
2891 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2892 "audio drift threshold", "threshold" },
2893 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2894 "copy timestamps" },
2895 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2896 "shift input timestamps to start at 0 when using copyts" },
2897 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2898 "copy input stream time base when stream copying", "mode" },
2899 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2900 OPT_OUTPUT, { .off = OFFSET(shortest) },
2901 "finish encoding within shortest input" },
2902 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2903 OPT_OUTPUT, { .off = OFFSET(apad) },
2905 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2906 "timestamp discontinuity delta threshold", "threshold" },
2907 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2908 "timestamp error delta threshold", "threshold" },
2909 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2910 "exit on error", "error" },
2911 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2912 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2913 "copy initial non-keyframes" },
2914 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2915 "copy or discard frames before start time" },
2916 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2917 "set the number of frames to output", "number" },
2918 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2919 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2920 "force codec tag/fourcc", "fourcc/tag" },
2921 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2922 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2923 "use fixed quality scale (VBR)", "q" },
2924 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2925 OPT_OUTPUT, { .func_arg = opt_qscale },
2926 "use fixed quality scale (VBR)", "q" },
2927 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2928 "set profile", "profile" },
2929 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2930 "set stream filtergraph", "filter_graph" },
2931 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2932 "read stream filtergraph description from a file", "filename" },
2933 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2934 "reinit filtergraph on input parameter changes", "" },
2935 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2936 "create a complex filtergraph", "graph_description" },
2937 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2938 "create a complex filtergraph", "graph_description" },
2939 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2940 "read complex filtergraph description from a file", "filename" },
2941 { "stats", OPT_BOOL, { &print_stats },
2942 "print progress report during encoding", },
2943 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2944 OPT_OUTPUT, { .func_arg = opt_attach },
2945 "add an attachment to the output file", "filename" },
2946 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2947 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2948 "extract an attachment into a file", "filename" },
2949 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2950 "print timestamp debugging info" },
2951 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2952 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2953 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2954 OPT_INPUT, { .off = OFFSET(discard) },
2956 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
2957 OPT_OUTPUT, { .off = OFFSET(disposition) },
2958 "disposition", "" },
2961 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2962 "set the number of video frames to output", "number" },
2963 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2964 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2965 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2966 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2967 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2968 "set frame size (WxH or abbreviation)", "size" },
2969 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2970 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2971 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2972 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2973 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2974 "set pixel format", "format" },
2975 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2976 "set the number of bits per raw sample", "number" },
2977 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2978 "deprecated use -g 1" },
2979 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2981 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2982 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2983 "rate control override for specific intervals", "override" },
2984 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2985 OPT_OUTPUT, { .func_arg = opt_video_codec },
2986 "force video codec ('copy' to copy stream)", "codec" },
2987 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2989 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2991 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2992 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2993 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2994 "select the pass number (1 to 3)", "n" },
2995 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2996 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2997 "select two pass log file name prefix", "prefix" },
2998 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2999 "this option is deprecated, use the yadif filter instead" },
3000 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3001 "calculate PSNR of compressed frames" },
3002 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3003 "dump video coding statistics to file" },
3004 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3005 "dump video coding statistics to file", "file" },
3006 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3007 "set video filters", "filter_graph" },
3008 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3009 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3010 "specify intra matrix coeffs", "matrix" },
3011 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3012 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3013 "specify inter matrix coeffs", "matrix" },
3014 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3015 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3016 "specify intra matrix coeffs", "matrix" },
3017 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3018 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3019 "top=1/bottom=0/auto=-1 field first", "" },
3020 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3021 OPT_OUTPUT, { .func_arg = opt_old2new },
3022 "force video tag/fourcc", "fourcc/tag" },
3023 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3024 "show QP histogram" },
3025 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3026 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3027 "force the selected framerate, disable the best supported framerate selection" },
3028 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3029 OPT_OUTPUT, { .func_arg = opt_streamid },
3030 "set the value of an outfile streamid", "streamIndex:value" },
3031 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3032 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3033 "force key frames at specified timestamps", "timestamps" },
3034 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3035 "audio bitrate (please use -b:a)", "bitrate" },
3036 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3037 "video bitrate (please use -b:v)", "bitrate" },
3038 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3039 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3040 "use HW accelerated decoding", "hwaccel name" },
3041 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3042 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3043 "select a device for HW acceleration" "devicename" },
3045 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3049 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3050 "set the number of audio frames to output", "number" },
3051 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3052 "set audio quality (codec-specific)", "quality", },
3053 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3054 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3055 "set audio sampling rate (in Hz)", "rate" },
3056 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3057 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3058 "set number of audio channels", "channels" },
3059 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3061 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3062 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3063 "force audio codec ('copy' to copy stream)", "codec" },
3064 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3065 OPT_OUTPUT, { .func_arg = opt_old2new },
3066 "force audio tag/fourcc", "fourcc/tag" },
3067 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3068 "change audio volume (256=normal)" , "volume" },
3069 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3070 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3071 "set sample format", "format" },
3072 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3073 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3074 "set channel layout", "layout" },
3075 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3076 "set audio filters", "filter_graph" },
3077 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3078 "set the maximum number of channels to try to guess the channel layout" },
3080 /* subtitle options */
3081 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3082 "disable subtitle" },
3083 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3084 "force subtitle codec ('copy' to copy stream)", "codec" },
3085 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3086 , "force subtitle tag/fourcc", "fourcc/tag" },
3087 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3088 "fix subtitles duration" },
3089 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3090 "set canvas size (WxH or abbreviation)", "size" },
3093 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3094 "deprecated, use -channel", "channel" },
3095 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3096 "deprecated, use -standard", "standard" },
3097 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3100 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3101 "set the maximum demux-decode delay", "seconds" },
3102 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3103 "set the initial demux-decode delay", "seconds" },
3104 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3105 "override the options from ffserver", "" },
3106 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3107 "specify a file in which to print sdp information", "file" },
3109 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3110 "A comma-separated list of bitstream filters", "bitstream_filters" },
3111 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3112 "deprecated", "audio bitstream_filters" },
3113 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3114 "deprecated", "video bitstream_filters" },
3116 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3117 "set the audio options to the indicated preset", "preset" },
3118 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3119 "set the video options to the indicated preset", "preset" },
3120 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3121 "set the subtitle options to the indicated preset", "preset" },
3122 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3123 "set options from indicated preset file", "filename" },
3124 /* data codec support */
3125 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3126 "force data codec ('copy' to copy stream)", "codec" },
3127 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },