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");
862 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
864 ic->video_codec_id = video_codec_name ?
865 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
866 ic->audio_codec_id = audio_codec_name ?
867 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
868 ic->subtitle_codec_id= subtitle_codec_name ?
869 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
870 ic->data_codec_id = data_codec_name ?
871 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
873 if (video_codec_name)
874 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
875 if (audio_codec_name)
876 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
877 if (subtitle_codec_name)
878 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
880 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
882 ic->flags |= AVFMT_FLAG_NONBLOCK;
883 ic->interrupt_callback = int_cb;
885 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
886 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
887 scan_all_pmts_set = 1;
889 /* open the input file with generic avformat function */
890 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
892 print_error(filename, err);
895 if (scan_all_pmts_set)
896 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
897 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
898 assert_avoptions(o->g->format_opts);
900 /* apply forced codec ids */
901 for (i = 0; i < ic->nb_streams; i++)
902 choose_decoder(o, ic, ic->streams[i]);
904 /* Set AVCodecContext options for avformat_find_stream_info */
905 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
906 orig_nb_streams = ic->nb_streams;
908 /* If not enough info to get the stream parameters, we decode the
909 first frames to get it. (used in mpeg case for example) */
910 ret = avformat_find_stream_info(ic, opts);
912 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
913 if (ic->nb_streams == 0) {
914 avformat_close_input(&ic);
919 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
920 /* add the stream start time */
921 if (ic->start_time != AV_NOPTS_VALUE)
922 timestamp += ic->start_time;
924 /* if seeking requested, we execute it */
925 if (o->start_time != AV_NOPTS_VALUE) {
926 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
928 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
929 filename, (double)timestamp / AV_TIME_BASE);
933 /* update the current parameters so that they match the one of the input stream */
934 add_input_streams(o, ic);
936 /* dump the file content */
937 av_dump_format(ic, nb_input_files, filename, 0);
939 GROW_ARRAY(input_files, nb_input_files);
940 f = av_mallocz(sizeof(*f));
943 input_files[nb_input_files - 1] = f;
946 f->ist_index = nb_input_streams - ic->nb_streams;
947 f->start_time = o->start_time;
948 f->recording_time = o->recording_time;
949 f->input_ts_offset = o->input_ts_offset;
950 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
951 f->nb_streams = ic->nb_streams;
952 f->rate_emu = o->rate_emu;
953 f->accurate_seek = o->accurate_seek;
955 /* check if all codec options have been used */
956 unused_opts = strip_specifiers(o->g->codec_opts);
957 for (i = f->ist_index; i < nb_input_streams; i++) {
959 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
960 AV_DICT_IGNORE_SUFFIX)))
961 av_dict_set(&unused_opts, e->key, NULL, 0);
965 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
966 const AVClass *class = avcodec_get_class();
967 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
968 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
969 const AVClass *fclass = avformat_get_class();
970 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
971 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
972 if (!option || foption)
976 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
977 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
978 "input file #%d (%s) is not a decoding option.\n", e->key,
979 option->help ? option->help : "", nb_input_files - 1,
984 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
985 "input file #%d (%s) has not been used for any stream. The most "
986 "likely reason is either wrong type (e.g. a video option with "
987 "no video streams) or that it is a private option of some decoder "
988 "which was not actually used for any stream.\n", e->key,
989 option->help ? option->help : "", nb_input_files - 1, filename);
991 av_dict_free(&unused_opts);
993 for (i = 0; i < o->nb_dump_attachment; i++) {
996 for (j = 0; j < ic->nb_streams; j++) {
997 AVStream *st = ic->streams[j];
999 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1000 dump_attachment(st, o->dump_attachment[i].u.str);
1004 for (i = 0; i < orig_nb_streams; i++)
1005 av_dict_free(&opts[i]);
1011 static uint8_t *get_line(AVIOContext *s)
1017 if (avio_open_dyn_buf(&line) < 0) {
1018 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1022 while ((c = avio_r8(s)) && c != '\n')
1025 avio_close_dyn_buf(line, &buf);
1030 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1033 char filename[1000];
1034 const char *base[3] = { getenv("AVCONV_DATADIR"),
1039 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1043 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1044 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1045 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1048 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1049 i != 1 ? "" : "/.avconv", preset_name);
1050 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1056 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1058 char *codec_name = NULL;
1060 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1062 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1063 NULL, ost->st->codec->codec_type);
1064 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1065 } else if (!strcmp(codec_name, "copy"))
1066 ost->stream_copy = 1;
1068 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1069 ost->st->codec->codec_id = ost->enc->id;
1073 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1076 AVStream *st = avformat_new_stream(oc, NULL);
1077 int idx = oc->nb_streams - 1, ret = 0;
1078 char *bsf = NULL, *next, *codec_tag = NULL;
1079 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1084 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1088 if (oc->nb_streams - 1 < o->nb_streamid_map)
1089 st->id = o->streamid_map[oc->nb_streams - 1];
1091 GROW_ARRAY(output_streams, nb_output_streams);
1092 if (!(ost = av_mallocz(sizeof(*ost))))
1094 output_streams[nb_output_streams - 1] = ost;
1096 ost->file_index = nb_output_files - 1;
1099 st->codec->codec_type = type;
1100 choose_encoder(o, oc, ost);
1102 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1103 if (!ost->enc_ctx) {
1104 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1107 ost->enc_ctx->codec_type = type;
1110 AVIOContext *s = NULL;
1111 char *buf = NULL, *arg = NULL, *preset = NULL;
1113 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1115 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1116 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1119 if (!buf[0] || buf[0] == '#') {
1123 if (!(arg = strchr(buf, '='))) {
1124 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1128 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1130 } while (!s->eof_reached);
1134 av_log(NULL, AV_LOG_FATAL,
1135 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1136 preset, ost->file_index, ost->index);
1140 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1143 ost->max_frames = INT64_MAX;
1144 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1145 for (i = 0; i<o->nb_max_frames; i++) {
1146 char *p = o->max_frames[i].specifier;
1147 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1148 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1153 ost->copy_prior_start = -1;
1154 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1156 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1159 if (next = strchr(bsf, ','))
1161 if (arg = strchr(bsf, '='))
1163 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1164 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1168 bsfc_prev->next = bsfc;
1170 ost->bitstream_filters = bsfc;
1171 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1177 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1179 uint32_t tag = strtol(codec_tag, &next, 0);
1181 tag = AV_RL32(codec_tag);
1182 ost->enc_ctx->codec_tag = tag;
1185 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1187 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1188 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1191 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1192 ost->disposition = av_strdup(ost->disposition);
1194 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1195 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1197 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1199 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1200 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1201 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1203 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1205 ost->source_index = source_index;
1206 if (source_index >= 0) {
1207 ost->sync_ist = input_streams[source_index];
1208 input_streams[source_index]->discard = 0;
1209 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1211 ost->last_mux_dts = AV_NOPTS_VALUE;
1216 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1219 const char *p = str;
1226 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1233 /* read file contents into a string */
1234 static uint8_t *read_file(const char *filename)
1236 AVIOContext *pb = NULL;
1237 AVIOContext *dyn_buf = NULL;
1238 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1239 uint8_t buf[1024], *str;
1242 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1246 ret = avio_open_dyn_buf(&dyn_buf);
1251 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1252 avio_write(dyn_buf, buf, ret);
1253 avio_w8(dyn_buf, 0);
1256 ret = avio_close_dyn_buf(dyn_buf, &str);
1262 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1265 AVStream *st = ost->st;
1267 if (ost->filters_script && ost->filters) {
1268 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1269 "output stream #%d:%d.\n", nb_output_files, st->index);
1273 if (ost->filters_script)
1274 return read_file(ost->filters_script);
1275 else if (ost->filters)
1276 return av_strdup(ost->filters);
1278 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1282 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1283 const OutputStream *ost, enum AVMediaType type)
1285 if (ost->filters_script || ost->filters) {
1286 av_log(NULL, AV_LOG_ERROR,
1287 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1288 "Filtering and streamcopy cannot be used together.\n",
1289 ost->filters ? "Filtergraph" : "Filtergraph script",
1290 ost->filters ? ost->filters : ost->filters_script,
1291 av_get_media_type_string(type), ost->file_index, ost->index);
1296 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1300 AVCodecContext *video_enc;
1301 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1303 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1305 video_enc = ost->enc_ctx;
1307 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1308 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1309 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1312 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1313 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1315 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1316 if (frame_aspect_ratio) {
1318 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1319 q.num <= 0 || q.den <= 0) {
1320 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1323 ost->frame_aspect_ratio = q;
1326 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1327 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1329 if (!ost->stream_copy) {
1330 const char *p = NULL;
1331 char *frame_size = NULL;
1332 char *frame_pix_fmt = NULL;
1333 char *intra_matrix = NULL, *inter_matrix = NULL;
1334 char *chroma_intra_matrix = NULL;
1338 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1339 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1340 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1344 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1345 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1346 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1347 ost->keep_pix_fmt = 1;
1348 if (!*++frame_pix_fmt)
1349 frame_pix_fmt = NULL;
1351 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1352 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1355 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1358 video_enc->gop_size = 0;
1359 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1361 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1362 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1365 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1367 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1368 if (chroma_intra_matrix) {
1369 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1371 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1374 av_codec_set_chroma_intra_matrix(video_enc, p);
1375 parse_matrix_coeffs(p, chroma_intra_matrix);
1377 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1379 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1380 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1383 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1386 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1387 for (i = 0; p; i++) {
1389 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1391 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1394 video_enc->rc_override =
1395 av_realloc_array(video_enc->rc_override,
1396 i + 1, sizeof(RcOverride));
1397 if (!video_enc->rc_override) {
1398 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1401 video_enc->rc_override[i].start_frame = start;
1402 video_enc->rc_override[i].end_frame = end;
1404 video_enc->rc_override[i].qscale = q;
1405 video_enc->rc_override[i].quality_factor = 1.0;
1408 video_enc->rc_override[i].qscale = 0;
1409 video_enc->rc_override[i].quality_factor = -q/100.0;
1414 video_enc->rc_override_count = i;
1417 video_enc->flags|= CODEC_FLAG_PSNR;
1420 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1423 video_enc->flags |= CODEC_FLAG_PASS1;
1424 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1427 video_enc->flags |= CODEC_FLAG_PASS2;
1428 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1432 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1433 if (ost->logfile_prefix &&
1434 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1437 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1438 if (ost->forced_keyframes)
1439 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1441 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1443 ost->top_field_first = -1;
1444 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1447 ost->avfilter = get_ost_filters(o, oc, ost);
1451 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1454 if (ost->stream_copy)
1455 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1460 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1465 AVCodecContext *audio_enc;
1467 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1470 audio_enc = ost->enc_ctx;
1471 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1473 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1474 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1476 if (!ost->stream_copy) {
1477 char *sample_fmt = NULL;
1479 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1481 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1483 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1484 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1488 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1490 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1491 ost->apad = av_strdup(ost->apad);
1493 ost->avfilter = get_ost_filters(o, oc, ost);
1497 /* check for channel mapping for this audio stream */
1498 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1499 AudioChannelMap *map = &o->audio_channel_maps[n];
1500 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1501 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1504 if (map->channel_idx == -1) {
1506 } else if (ost->source_index < 0) {
1507 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1508 ost->file_index, ost->st->index);
1511 ist = input_streams[ost->source_index];
1514 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1515 if (av_reallocp_array(&ost->audio_channels_map,
1516 ost->audio_channels_mapped + 1,
1517 sizeof(*ost->audio_channels_map)
1521 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1527 if (ost->stream_copy)
1528 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1533 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1537 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1538 if (!ost->stream_copy) {
1539 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1546 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1548 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1549 ost->stream_copy = 1;
1554 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1558 AVCodecContext *subtitle_enc;
1560 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1562 subtitle_enc = ost->enc_ctx;
1564 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1566 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1568 if (!ost->stream_copy) {
1569 char *frame_size = NULL;
1571 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1572 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1573 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1581 /* arg format is "output-stream-index:streamid-value". */
1582 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1584 OptionsContext *o = optctx;
1589 av_strlcpy(idx_str, arg, sizeof(idx_str));
1590 p = strchr(idx_str, ':');
1592 av_log(NULL, AV_LOG_FATAL,
1593 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1598 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1599 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1600 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1604 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1606 AVFormatContext *is = ifile->ctx;
1607 AVFormatContext *os = ofile->ctx;
1611 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1613 return AVERROR(ENOMEM);
1616 for (i = 0; i < is->nb_chapters; i++) {
1617 AVChapter *in_ch = is->chapters[i], *out_ch;
1618 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1619 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1620 AV_TIME_BASE_Q, in_ch->time_base);
1621 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1622 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1625 if (in_ch->end < ts_off)
1627 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1630 out_ch = av_mallocz(sizeof(AVChapter));
1632 return AVERROR(ENOMEM);
1634 out_ch->id = in_ch->id;
1635 out_ch->time_base = in_ch->time_base;
1636 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1637 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1640 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1642 os->chapters[os->nb_chapters++] = out_ch;
1647 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1650 AVFormatContext *ic = avformat_alloc_context();
1652 ic->interrupt_callback = int_cb;
1653 err = avformat_open_input(&ic, filename, NULL, NULL);
1656 /* copy stream format */
1657 for(i=0;i<ic->nb_streams;i++) {
1661 const char *enc_config;
1663 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1665 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1666 return AVERROR(EINVAL);
1668 if (codec->type == AVMEDIA_TYPE_AUDIO)
1669 opt_audio_codec(o, "c:a", codec->name);
1670 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1671 opt_video_codec(o, "c:v", codec->name);
1672 ost = new_output_stream(o, s, codec->type, -1);
1675 avcodec_get_context_defaults3(st->codec, codec);
1676 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1678 AVDictionary *opts = NULL;
1679 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1680 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1681 av_dict_free(&opts);
1684 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1685 choose_sample_fmt(st, codec);
1686 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1687 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1688 avcodec_copy_context(ost->enc_ctx, st->codec);
1690 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1693 avformat_close_input(&ic);
1697 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1698 AVFormatContext *oc)
1702 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1703 ofilter->out_tmp->pad_idx)) {
1704 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1705 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1707 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1712 ost->source_index = -1;
1713 ost->filter = ofilter;
1717 if (ost->stream_copy) {
1718 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1719 "which is fed from a complex filtergraph. Filtering and streamcopy "
1720 "cannot be used together.\n", ost->file_index, ost->index);
1724 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1725 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1726 av_log(NULL, AV_LOG_ERROR,
1727 "%s '%s' was specified through the %s option "
1728 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1729 "%s and -filter_complex cannot be used together for the same stream.\n",
1730 ost->filters ? "Filtergraph" : "Filtergraph script",
1731 ost->filters ? ost->filters : ost->filters_script,
1732 opt, ost->file_index, ost->index, opt);
1736 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1737 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1740 avfilter_inout_free(&ofilter->out_tmp);
1743 static int configure_complex_filters(void)
1747 for (i = 0; i < nb_filtergraphs; i++)
1748 if (!filtergraphs[i]->graph &&
1749 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1754 static int open_output_file(OptionsContext *o, const char *filename)
1756 AVFormatContext *oc;
1758 AVOutputFormat *file_oformat;
1762 AVDictionary *unused_opts = NULL;
1763 AVDictionaryEntry *e = NULL;
1765 if (configure_complex_filters() < 0) {
1766 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1770 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1771 o->stop_time = INT64_MAX;
1772 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1775 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1776 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1777 if (o->stop_time <= start_time) {
1778 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1781 o->recording_time = o->stop_time - start_time;
1785 GROW_ARRAY(output_files, nb_output_files);
1786 of = av_mallocz(sizeof(*of));
1789 output_files[nb_output_files - 1] = of;
1791 of->ost_index = nb_output_streams;
1792 of->recording_time = o->recording_time;
1793 of->start_time = o->start_time;
1794 of->limit_filesize = o->limit_filesize;
1795 of->shortest = o->shortest;
1796 av_dict_copy(&of->opts, o->g->format_opts, 0);
1798 if (!strcmp(filename, "-"))
1801 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1803 print_error(filename, err);
1808 if (o->recording_time != INT64_MAX)
1809 oc->duration = o->recording_time;
1811 file_oformat= oc->oformat;
1812 oc->interrupt_callback = int_cb;
1814 /* create streams for all unlabeled output pads */
1815 for (i = 0; i < nb_filtergraphs; i++) {
1816 FilterGraph *fg = filtergraphs[i];
1817 for (j = 0; j < fg->nb_outputs; j++) {
1818 OutputFilter *ofilter = fg->outputs[j];
1820 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1823 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1824 ofilter->out_tmp->pad_idx)) {
1825 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1826 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1827 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1829 init_output_filter(ofilter, o, oc);
1833 /* ffserver seeking with date=... needs a date reference */
1834 if (!strcmp(file_oformat->name, "ffm") &&
1835 av_strstart(filename, "http:", NULL)) {
1836 int err = parse_option(o, "metadata", "creation_time=now", options);
1838 print_error(filename, err);
1843 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1844 av_strstart(filename, "http:", NULL)) {
1846 /* special case for files sent to ffserver: we get the stream
1847 parameters from ffserver */
1848 int err = read_ffserver_streams(o, oc, filename);
1850 print_error(filename, err);
1853 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1854 ost = output_streams[j];
1855 for (i = 0; i < nb_input_streams; i++) {
1856 ist = input_streams[i];
1857 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1859 ost->source_index= i;
1860 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1861 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1863 ist->st->discard = ist->user_set_discard;
1868 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));
1872 } else if (!o->nb_stream_maps) {
1873 char *subtitle_codec_name = NULL;
1874 /* pick the "best" stream of each type */
1876 /* video: highest resolution */
1877 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1878 int area = 0, idx = -1;
1879 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1880 for (i = 0; i < nb_input_streams; i++) {
1882 ist = input_streams[i];
1883 new_area = ist->st->codec->width * ist->st->codec->height;
1884 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1886 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1888 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1895 new_video_stream(o, oc, idx);
1898 /* audio: most channels */
1899 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1900 int channels = 0, idx = -1;
1901 for (i = 0; i < nb_input_streams; i++) {
1902 ist = input_streams[i];
1903 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1904 ist->st->codec->channels > channels) {
1905 channels = ist->st->codec->channels;
1910 new_audio_stream(o, oc, idx);
1913 /* subtitles: pick first */
1914 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1915 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1916 for (i = 0; i < nb_input_streams; i++)
1917 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1918 AVCodecDescriptor const *input_descriptor =
1919 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1920 AVCodecDescriptor const *output_descriptor = NULL;
1921 AVCodec const *output_codec =
1922 avcodec_find_encoder(oc->oformat->subtitle_codec);
1923 int input_props = 0, output_props = 0;
1925 output_descriptor = avcodec_descriptor_get(output_codec->id);
1926 if (input_descriptor)
1927 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1928 if (output_descriptor)
1929 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1930 if (subtitle_codec_name ||
1931 input_props & output_props ||
1932 // Map dvb teletext which has neither property to any output subtitle encoder
1933 input_descriptor && output_descriptor &&
1934 (!input_descriptor->props ||
1935 !output_descriptor->props)) {
1936 new_subtitle_stream(o, oc, i);
1941 /* Data only if codec id match */
1942 if (!o->data_disable ) {
1943 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
1944 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1945 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1946 && input_streams[i]->st->codec->codec_id == codec_id )
1947 new_data_stream(o, oc, i);
1951 for (i = 0; i < o->nb_stream_maps; i++) {
1952 StreamMap *map = &o->stream_maps[i];
1957 if (map->linklabel) {
1959 OutputFilter *ofilter = NULL;
1962 for (j = 0; j < nb_filtergraphs; j++) {
1963 fg = filtergraphs[j];
1964 for (k = 0; k < fg->nb_outputs; k++) {
1965 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1966 if (out && !strcmp(out->name, map->linklabel)) {
1967 ofilter = fg->outputs[k];
1974 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1975 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1978 init_output_filter(ofilter, o, oc);
1980 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1982 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1983 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1985 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1987 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1989 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1992 switch (ist->st->codec->codec_type) {
1993 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1994 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1995 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1996 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1997 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1999 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
2000 map->file_index, map->stream_index);
2007 /* handle attached files */
2008 for (i = 0; i < o->nb_attachments; i++) {
2010 uint8_t *attachment;
2014 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2015 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2019 if ((len = avio_size(pb)) <= 0) {
2020 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2024 if (!(attachment = av_malloc(len))) {
2025 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2029 avio_read(pb, attachment, len);
2031 ost = new_attachment_stream(o, oc, -1);
2032 ost->stream_copy = 0;
2033 ost->attachment_filename = o->attachments[i];
2035 ost->enc_ctx->extradata = attachment;
2036 ost->enc_ctx->extradata_size = len;
2038 p = strrchr(o->attachments[i], '/');
2039 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2043 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2044 AVDictionaryEntry *e;
2045 ost = output_streams[i];
2047 if ((ost->stream_copy || ost->attachment_filename)
2048 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2049 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2050 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2054 /* check if all codec options have been used */
2055 unused_opts = strip_specifiers(o->g->codec_opts);
2056 for (i = of->ost_index; i < nb_output_streams; i++) {
2058 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2059 AV_DICT_IGNORE_SUFFIX)))
2060 av_dict_set(&unused_opts, e->key, NULL, 0);
2064 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2065 const AVClass *class = avcodec_get_class();
2066 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2067 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2068 const AVClass *fclass = avformat_get_class();
2069 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2070 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2071 if (!option || foption)
2075 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2076 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2077 "output file #%d (%s) is not an encoding option.\n", e->key,
2078 option->help ? option->help : "", nb_output_files - 1,
2083 // gop_timecode is injected by generic code but not always used
2084 if (!strcmp(e->key, "gop_timecode"))
2087 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2088 "output file #%d (%s) has not been used for any stream. The most "
2089 "likely reason is either wrong type (e.g. a video option with "
2090 "no video streams) or that it is a private option of some encoder "
2091 "which was not actually used for any stream.\n", e->key,
2092 option->help ? option->help : "", nb_output_files - 1, filename);
2094 av_dict_free(&unused_opts);
2096 /* check filename in case of an image number is expected */
2097 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2098 if (!av_filename_number_test(oc->filename)) {
2099 print_error(oc->filename, AVERROR(EINVAL));
2104 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2105 /* test if it already exists to avoid losing precious files */
2106 assert_file_overwrite(filename);
2109 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2110 &oc->interrupt_callback,
2112 print_error(filename, err);
2115 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2116 assert_file_overwrite(filename);
2118 if (o->mux_preload) {
2119 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2121 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2124 for (i = 0; i < o->nb_metadata_map; i++) {
2126 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2128 if (in_file_index >= nb_input_files) {
2129 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2132 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2133 in_file_index >= 0 ?
2134 input_files[in_file_index]->ctx : NULL, o);
2138 if (o->chapters_input_file >= nb_input_files) {
2139 if (o->chapters_input_file == INT_MAX) {
2140 /* copy chapters from the first input file that has them*/
2141 o->chapters_input_file = -1;
2142 for (i = 0; i < nb_input_files; i++)
2143 if (input_files[i]->ctx->nb_chapters) {
2144 o->chapters_input_file = i;
2148 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2149 o->chapters_input_file);
2153 if (o->chapters_input_file >= 0)
2154 copy_chapters(input_files[o->chapters_input_file], of,
2155 !o->metadata_chapters_manual);
2157 /* copy global metadata by default */
2158 if (!o->metadata_global_manual && nb_input_files){
2159 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2160 AV_DICT_DONT_OVERWRITE);
2161 if(o->recording_time != INT64_MAX)
2162 av_dict_set(&oc->metadata, "duration", NULL, 0);
2163 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2165 if (!o->metadata_streams_manual)
2166 for (i = of->ost_index; i < nb_output_streams; i++) {
2168 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2170 ist = input_streams[output_streams[i]->source_index];
2171 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2172 if (!output_streams[i]->stream_copy)
2173 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2176 /* process manually set metadata */
2177 for (i = 0; i < o->nb_metadata; i++) {
2180 const char *stream_spec;
2181 int index = 0, j, ret = 0;
2183 val = strchr(o->metadata[i].u.str, '=');
2185 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2186 o->metadata[i].u.str);
2191 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2193 for (j = 0; j < oc->nb_streams; j++) {
2194 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2195 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2206 if (index < 0 || index >= oc->nb_chapters) {
2207 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2210 m = &oc->chapters[index]->metadata;
2213 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2216 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2223 static int opt_target(void *optctx, const char *opt, const char *arg)
2225 OptionsContext *o = optctx;
2226 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2227 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2229 if (!strncmp(arg, "pal-", 4)) {
2232 } else if (!strncmp(arg, "ntsc-", 5)) {
2235 } else if (!strncmp(arg, "film-", 5)) {
2239 /* Try to determine PAL/NTSC by peeking in the input files */
2240 if (nb_input_files) {
2242 for (j = 0; j < nb_input_files; j++) {
2243 for (i = 0; i < input_files[j]->nb_streams; i++) {
2244 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2245 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2248 fr = c->time_base.den * 1000 / c->time_base.num;
2252 } else if ((fr == 29970) || (fr == 23976)) {
2257 if (norm != UNKNOWN)
2261 if (norm != UNKNOWN)
2262 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2265 if (norm == UNKNOWN) {
2266 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2267 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2268 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2272 if (!strcmp(arg, "vcd")) {
2273 opt_video_codec(o, "c:v", "mpeg1video");
2274 opt_audio_codec(o, "c:a", "mp2");
2275 parse_option(o, "f", "vcd", options);
2277 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2278 parse_option(o, "r", frame_rates[norm], options);
2279 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2281 opt_default(NULL, "b:v", "1150000");
2282 opt_default(NULL, "maxrate", "1150000");
2283 opt_default(NULL, "minrate", "1150000");
2284 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2286 opt_default(NULL, "b:a", "224000");
2287 parse_option(o, "ar", "44100", options);
2288 parse_option(o, "ac", "2", options);
2290 opt_default(NULL, "packetsize", "2324");
2291 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2293 /* We have to offset the PTS, so that it is consistent with the SCR.
2294 SCR starts at 36000, but the first two packs contain only padding
2295 and the first pack from the other stream, respectively, may also have
2296 been written before.
2297 So the real data starts at SCR 36000+3*1200. */
2298 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2299 } else if (!strcmp(arg, "svcd")) {
2301 opt_video_codec(o, "c:v", "mpeg2video");
2302 opt_audio_codec(o, "c:a", "mp2");
2303 parse_option(o, "f", "svcd", options);
2305 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2306 parse_option(o, "r", frame_rates[norm], options);
2307 parse_option(o, "pix_fmt", "yuv420p", options);
2308 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2310 opt_default(NULL, "b:v", "2040000");
2311 opt_default(NULL, "maxrate", "2516000");
2312 opt_default(NULL, "minrate", "0"); // 1145000;
2313 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2314 opt_default(NULL, "scan_offset", "1");
2316 opt_default(NULL, "b:a", "224000");
2317 parse_option(o, "ar", "44100", options);
2319 opt_default(NULL, "packetsize", "2324");
2321 } else if (!strcmp(arg, "dvd")) {
2323 opt_video_codec(o, "c:v", "mpeg2video");
2324 opt_audio_codec(o, "c:a", "ac3");
2325 parse_option(o, "f", "dvd", options);
2327 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2328 parse_option(o, "r", frame_rates[norm], options);
2329 parse_option(o, "pix_fmt", "yuv420p", options);
2330 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2332 opt_default(NULL, "b:v", "6000000");
2333 opt_default(NULL, "maxrate", "9000000");
2334 opt_default(NULL, "minrate", "0"); // 1500000;
2335 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2337 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2338 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2340 opt_default(NULL, "b:a", "448000");
2341 parse_option(o, "ar", "48000", options);
2343 } else if (!strncmp(arg, "dv", 2)) {
2345 parse_option(o, "f", "dv", options);
2347 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2348 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2349 norm == PAL ? "yuv420p" : "yuv411p", options);
2350 parse_option(o, "r", frame_rates[norm], options);
2352 parse_option(o, "ar", "48000", options);
2353 parse_option(o, "ac", "2", options);
2356 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2357 return AVERROR(EINVAL);
2360 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2361 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2366 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2368 av_free (vstats_filename);
2369 vstats_filename = av_strdup (arg);
2373 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2376 time_t today2 = time(NULL);
2377 struct tm *today = localtime(&today2);
2379 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2381 return opt_vstats_file(NULL, opt, filename);
2384 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2386 OptionsContext *o = optctx;
2387 return parse_option(o, "frames:v", arg, options);
2390 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2392 OptionsContext *o = optctx;
2393 return parse_option(o, "frames:a", arg, options);
2396 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2398 OptionsContext *o = optctx;
2399 return parse_option(o, "frames:d", arg, options);
2402 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2405 AVDictionary *cbak = codec_opts;
2406 AVDictionary *fbak = format_opts;
2410 ret = opt_default(NULL, opt, arg);
2412 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2413 av_dict_copy(&o->g->format_opts, format_opts, 0);
2414 av_dict_free(&codec_opts);
2415 av_dict_free(&format_opts);
2422 static int opt_preset(void *optctx, const char *opt, const char *arg)
2424 OptionsContext *o = optctx;
2426 char filename[1000], line[1000], tmp_line[1000];
2427 const char *codec_name = NULL;
2431 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2433 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2434 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2435 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2437 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2441 while (fgets(line, sizeof(line), f)) {
2442 char *key = tmp_line, *value, *endptr;
2444 if (strcspn(line, "#\n\r") == 0)
2446 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2447 if (!av_strtok(key, "=", &value) ||
2448 !av_strtok(value, "\r\n", &endptr)) {
2449 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2452 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2454 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2455 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2456 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2457 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2458 else if (opt_default_new(o, key, value) < 0) {
2459 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2460 filename, line, key, value);
2470 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2472 OptionsContext *o = optctx;
2473 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2474 int ret = parse_option(o, s, arg, options);
2479 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2481 OptionsContext *o = optctx;
2483 if(!strcmp(opt, "ab")){
2484 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2486 } else if(!strcmp(opt, "b")){
2487 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2488 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2491 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2495 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2497 OptionsContext *o = optctx;
2500 if(!strcmp(opt, "qscale")){
2501 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2502 return parse_option(o, "q:v", arg, options);
2504 s = av_asprintf("q%s", opt + 6);
2505 ret = parse_option(o, s, arg, options);
2510 static int opt_profile(void *optctx, const char *opt, const char *arg)
2512 OptionsContext *o = optctx;
2513 if(!strcmp(opt, "profile")){
2514 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2515 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2518 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2522 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2524 OptionsContext *o = optctx;
2525 return parse_option(o, "filter:v", arg, options);
2528 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2530 OptionsContext *o = optctx;
2531 return parse_option(o, "filter:a", arg, options);
2534 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2536 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2537 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2538 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2539 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2541 if (video_sync_method == VSYNC_AUTO)
2542 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2546 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2548 OptionsContext *o = optctx;
2549 char *tcr = av_asprintf("timecode=%s", arg);
2550 int ret = parse_option(o, "metadata:g", tcr, options);
2552 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2557 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2559 OptionsContext *o = optctx;
2560 char layout_str[32];
2563 int ret, channels, ac_str_size;
2566 layout = av_get_channel_layout(arg);
2568 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2569 return AVERROR(EINVAL);
2571 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2572 ret = opt_default_new(o, opt, layout_str);
2576 /* set 'ac' option based on channel layout */
2577 channels = av_get_channel_layout_nb_channels(layout);
2578 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2579 stream_str = strchr(opt, ':');
2580 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2581 ac_str = av_mallocz(ac_str_size);
2583 return AVERROR(ENOMEM);
2584 av_strlcpy(ac_str, "ac", 3);
2586 av_strlcat(ac_str, stream_str, ac_str_size);
2587 ret = parse_option(o, ac_str, layout_str, options);
2593 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2595 OptionsContext *o = optctx;
2596 return parse_option(o, "q:a", arg, options);
2599 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2601 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2602 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2603 return AVERROR(ENOMEM);
2604 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2605 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2606 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2607 return AVERROR(ENOMEM);
2611 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2613 uint8_t *graph_desc = read_file(arg);
2615 return AVERROR(EINVAL);
2617 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2618 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2619 return AVERROR(ENOMEM);
2620 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2621 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2625 void show_help_default(const char *opt, const char *arg)
2627 /* per-file options have at least one of those set */
2628 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2629 int show_advanced = 0, show_avoptions = 0;
2632 if (!strcmp(opt, "long"))
2634 else if (!strcmp(opt, "full"))
2635 show_advanced = show_avoptions = 1;
2637 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2642 printf("Getting help:\n"
2643 " -h -- print basic options\n"
2644 " -h long -- print more options\n"
2645 " -h full -- print all options (including all format and codec specific options, very long)\n"
2646 " See man %s for detailed description of the options.\n"
2647 "\n", program_name);
2649 show_help_options(options, "Print help / information / capabilities:",
2652 show_help_options(options, "Global options (affect whole program "
2653 "instead of just one file:",
2654 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2656 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2657 per_file | OPT_EXIT, 0);
2659 show_help_options(options, "Per-file main options:", 0,
2660 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2661 OPT_EXIT, per_file);
2663 show_help_options(options, "Advanced per-file options:",
2664 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2666 show_help_options(options, "Video options:",
2667 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2669 show_help_options(options, "Advanced Video options:",
2670 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2672 show_help_options(options, "Audio options:",
2673 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2675 show_help_options(options, "Advanced Audio options:",
2676 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2677 show_help_options(options, "Subtitle options:",
2678 OPT_SUBTITLE, 0, 0);
2681 if (show_avoptions) {
2682 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2683 show_help_children(avcodec_get_class(), flags);
2684 show_help_children(avformat_get_class(), flags);
2686 show_help_children(sws_get_class(), flags);
2688 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2689 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2693 void show_usage(void)
2695 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2696 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2697 av_log(NULL, AV_LOG_INFO, "\n");
2705 static const OptionGroupDef groups[] = {
2706 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2707 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2710 static int open_files(OptionGroupList *l, const char *inout,
2711 int (*open_file)(OptionsContext*, const char*))
2715 for (i = 0; i < l->nb_groups; i++) {
2716 OptionGroup *g = &l->groups[i];
2722 ret = parse_optgroup(&o, g);
2724 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2725 "%s.\n", inout, g->arg);
2729 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2730 ret = open_file(&o, g->arg);
2733 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2737 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2743 int ffmpeg_parse_options(int argc, char **argv)
2745 OptionParseContext octx;
2749 memset(&octx, 0, sizeof(octx));
2751 /* split the commandline into an internal representation */
2752 ret = split_commandline(&octx, argc, argv, options, groups,
2753 FF_ARRAY_ELEMS(groups));
2755 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2759 /* apply global options */
2760 ret = parse_optgroup(NULL, &octx.global_opts);
2762 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2766 /* open input files */
2767 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2769 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2773 /* open output files */
2774 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2776 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2781 uninit_parse_context(&octx);
2783 av_strerror(ret, error, sizeof(error));
2784 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2789 static int opt_progress(void *optctx, const char *opt, const char *arg)
2791 AVIOContext *avio = NULL;
2794 if (!strcmp(arg, "-"))
2796 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2798 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2799 arg, av_err2str(ret));
2802 progress_avio = avio;
2806 #define OFFSET(x) offsetof(OptionsContext, x)
2807 const OptionDef options[] = {
2809 #include "cmdutils_common_opts.h"
2810 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2811 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2812 "force format", "fmt" },
2813 { "y", OPT_BOOL, { &file_overwrite },
2814 "overwrite output files" },
2815 { "n", OPT_BOOL, { &no_file_overwrite },
2816 "never overwrite output files" },
2817 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2818 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2819 "codec name", "codec" },
2820 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2821 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2822 "codec name", "codec" },
2823 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2824 OPT_OUTPUT, { .off = OFFSET(presets) },
2825 "preset name", "preset" },
2826 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2827 OPT_OUTPUT, { .func_arg = opt_map },
2828 "set input stream mapping",
2829 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2830 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2831 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2832 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2833 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2834 "set metadata information of outfile from infile",
2835 "outfile[,metadata]:infile[,metadata]" },
2836 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2837 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2838 "set chapters mapping", "input_file_index" },
2839 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2840 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2841 "record or transcode \"duration\" seconds of audio/video",
2843 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2844 "record or transcode stop time", "time_stop" },
2845 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2846 "set the limit file size in bytes", "limit_size" },
2847 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2848 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2849 "set the start time offset", "time_off" },
2850 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2851 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2852 "enable/disable accurate seeking with -ss" },
2853 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2854 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2855 "set the input ts offset", "time_off" },
2856 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2857 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2858 "set the input ts scale", "scale" },
2859 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2860 "set the recording timestamp ('now' to set the current time)", "time" },
2861 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2862 "add metadata", "string=string" },
2863 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2864 OPT_OUTPUT, { .func_arg = opt_data_frames },
2865 "set the number of data frames to output", "number" },
2866 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2867 "add timings for benchmarking" },
2868 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2869 "add timings for each task" },
2870 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2871 "write program-readable progress information", "url" },
2872 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2873 "enable or disable interaction on standard input" },
2874 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2875 "set max runtime in seconds", "limit" },
2876 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2877 "dump each input packet" },
2878 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2879 "when dumping packets, also dump the payload" },
2880 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2881 OPT_INPUT, { .off = OFFSET(rate_emu) },
2882 "read input at native frame rate", "" },
2883 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2884 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2885 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2886 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2887 "video sync method", "" },
2888 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2889 "frame drop threshold", "" },
2890 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2891 "audio sync method", "" },
2892 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2893 "audio drift threshold", "threshold" },
2894 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2895 "copy timestamps" },
2896 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2897 "shift input timestamps to start at 0 when using copyts" },
2898 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2899 "copy input stream time base when stream copying", "mode" },
2900 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2901 OPT_OUTPUT, { .off = OFFSET(shortest) },
2902 "finish encoding within shortest input" },
2903 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2904 OPT_OUTPUT, { .off = OFFSET(apad) },
2906 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2907 "timestamp discontinuity delta threshold", "threshold" },
2908 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2909 "timestamp error delta threshold", "threshold" },
2910 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2911 "exit on error", "error" },
2912 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2913 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2914 "copy initial non-keyframes" },
2915 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2916 "copy or discard frames before start time" },
2917 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2918 "set the number of frames to output", "number" },
2919 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2920 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2921 "force codec tag/fourcc", "fourcc/tag" },
2922 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2923 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2924 "use fixed quality scale (VBR)", "q" },
2925 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2926 OPT_OUTPUT, { .func_arg = opt_qscale },
2927 "use fixed quality scale (VBR)", "q" },
2928 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2929 "set profile", "profile" },
2930 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2931 "set stream filtergraph", "filter_graph" },
2932 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2933 "read stream filtergraph description from a file", "filename" },
2934 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2935 "reinit filtergraph on input parameter changes", "" },
2936 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2937 "create a complex filtergraph", "graph_description" },
2938 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2939 "create a complex filtergraph", "graph_description" },
2940 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2941 "read complex filtergraph description from a file", "filename" },
2942 { "stats", OPT_BOOL, { &print_stats },
2943 "print progress report during encoding", },
2944 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2945 OPT_OUTPUT, { .func_arg = opt_attach },
2946 "add an attachment to the output file", "filename" },
2947 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2948 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2949 "extract an attachment into a file", "filename" },
2950 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2951 "print timestamp debugging info" },
2952 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2953 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2954 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2955 OPT_INPUT, { .off = OFFSET(discard) },
2957 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
2958 OPT_OUTPUT, { .off = OFFSET(disposition) },
2959 "disposition", "" },
2962 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2963 "set the number of video frames to output", "number" },
2964 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2965 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2966 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2967 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2968 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2969 "set frame size (WxH or abbreviation)", "size" },
2970 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2971 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2972 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2973 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2974 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2975 "set pixel format", "format" },
2976 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2977 "set the number of bits per raw sample", "number" },
2978 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2979 "deprecated use -g 1" },
2980 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2982 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2983 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2984 "rate control override for specific intervals", "override" },
2985 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2986 OPT_OUTPUT, { .func_arg = opt_video_codec },
2987 "force video codec ('copy' to copy stream)", "codec" },
2988 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2990 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2992 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2993 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2994 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2995 "select the pass number (1 to 3)", "n" },
2996 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2997 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2998 "select two pass log file name prefix", "prefix" },
2999 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3000 "this option is deprecated, use the yadif filter instead" },
3001 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3002 "calculate PSNR of compressed frames" },
3003 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3004 "dump video coding statistics to file" },
3005 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3006 "dump video coding statistics to file", "file" },
3007 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3008 "set video filters", "filter_graph" },
3009 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3010 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3011 "specify intra matrix coeffs", "matrix" },
3012 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3013 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3014 "specify inter matrix coeffs", "matrix" },
3015 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3016 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3017 "specify intra matrix coeffs", "matrix" },
3018 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3019 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3020 "top=1/bottom=0/auto=-1 field first", "" },
3021 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3022 OPT_OUTPUT, { .func_arg = opt_old2new },
3023 "force video tag/fourcc", "fourcc/tag" },
3024 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3025 "show QP histogram" },
3026 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3027 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3028 "force the selected framerate, disable the best supported framerate selection" },
3029 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3030 OPT_OUTPUT, { .func_arg = opt_streamid },
3031 "set the value of an outfile streamid", "streamIndex:value" },
3032 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3033 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3034 "force key frames at specified timestamps", "timestamps" },
3035 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3036 "audio bitrate (please use -b:a)", "bitrate" },
3037 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3038 "video bitrate (please use -b:v)", "bitrate" },
3039 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3040 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3041 "use HW accelerated decoding", "hwaccel name" },
3042 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3043 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3044 "select a device for HW acceleration" "devicename" },
3046 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3050 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3051 "set the number of audio frames to output", "number" },
3052 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3053 "set audio quality (codec-specific)", "quality", },
3054 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3055 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3056 "set audio sampling rate (in Hz)", "rate" },
3057 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3058 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3059 "set number of audio channels", "channels" },
3060 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3062 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3063 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3064 "force audio codec ('copy' to copy stream)", "codec" },
3065 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3066 OPT_OUTPUT, { .func_arg = opt_old2new },
3067 "force audio tag/fourcc", "fourcc/tag" },
3068 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3069 "change audio volume (256=normal)" , "volume" },
3070 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3071 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3072 "set sample format", "format" },
3073 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3074 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3075 "set channel layout", "layout" },
3076 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3077 "set audio filters", "filter_graph" },
3078 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3079 "set the maximum number of channels to try to guess the channel layout" },
3081 /* subtitle options */
3082 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3083 "disable subtitle" },
3084 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3085 "force subtitle codec ('copy' to copy stream)", "codec" },
3086 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3087 , "force subtitle tag/fourcc", "fourcc/tag" },
3088 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3089 "fix subtitles duration" },
3090 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3091 "set canvas size (WxH or abbreviation)", "size" },
3094 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3095 "deprecated, use -channel", "channel" },
3096 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3097 "deprecated, use -standard", "standard" },
3098 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3101 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3102 "set the maximum demux-decode delay", "seconds" },
3103 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3104 "set the initial demux-decode delay", "seconds" },
3105 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3106 "override the options from ffserver", "" },
3107 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3108 "specify a file in which to print sdp information", "file" },
3110 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3111 "A comma-separated list of bitstream filters", "bitstream_filters" },
3112 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3113 "deprecated", "audio bitstream_filters" },
3114 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3115 "deprecated", "video bitstream_filters" },
3117 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3118 "set the audio options to the indicated preset", "preset" },
3119 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3120 "set the video options to the indicated preset", "preset" },
3121 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3122 "set the subtitle options to the indicated preset", "preset" },
3123 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3124 "set options from indicated preset file", "filename" },
3125 /* data codec support */
3126 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3127 "force data codec ('copy' to copy stream)", "codec" },
3128 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },