2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
82 float audio_drift_threshold = 0.1;
83 float dts_delta_threshold = 10;
84 float dts_error_threshold = 3600*30;
86 int audio_volume = 256;
87 int audio_sync_method = 0;
88 int video_sync_method = VSYNC_AUTO;
89 float frame_drop_threshold = 0;
90 int do_deinterlace = 0;
92 int do_benchmark_all = 0;
96 int start_at_zero = 0;
99 int exit_on_error = 0;
100 int print_stats = -1;
102 int stdin_interaction = 1;
103 int frame_bits_per_raw_sample = 0;
104 float max_error_rate = 2.0/3;
107 static int intra_only = 0;
108 static int file_overwrite = 0;
109 static int no_file_overwrite = 0;
110 static int do_psnr = 0;
111 static int input_sync;
112 static int override_ffserver = 0;
114 static void uninit_options(OptionsContext *o)
116 const OptionDef *po = options;
119 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
121 void *dst = (uint8_t*)o + po->u.off;
123 if (po->flags & OPT_SPEC) {
124 SpecifierOpt **so = dst;
125 int i, *count = (int*)(so + 1);
126 for (i = 0; i < *count; i++) {
127 av_freep(&(*so)[i].specifier);
128 if (po->flags & OPT_STRING)
129 av_freep(&(*so)[i].u.str);
133 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
138 for (i = 0; i < o->nb_stream_maps; i++)
139 av_freep(&o->stream_maps[i].linklabel);
140 av_freep(&o->stream_maps);
141 av_freep(&o->audio_channel_maps);
142 av_freep(&o->streamid_map);
143 av_freep(&o->attachments);
146 static void init_options(OptionsContext *o)
148 memset(o, 0, sizeof(*o));
150 o->stop_time = INT64_MAX;
151 o->mux_max_delay = 0.7;
152 o->start_time = AV_NOPTS_VALUE;
153 o->recording_time = INT64_MAX;
154 o->limit_filesize = UINT64_MAX;
155 o->chapters_input_file = INT_MAX;
156 o->accurate_seek = 1;
159 /* return a copy of the input with the stream specifiers removed from the keys */
160 static AVDictionary *strip_specifiers(AVDictionary *dict)
162 AVDictionaryEntry *e = NULL;
163 AVDictionary *ret = NULL;
165 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
166 char *p = strchr(e->key, ':');
170 av_dict_set(&ret, e->key, e->value, 0);
177 static int opt_sameq(void *optctx, const char *opt, const char *arg)
179 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
180 "If you are looking for an option to preserve the quality (which is not "
181 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
183 return AVERROR(EINVAL);
186 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
188 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
189 return opt_default(optctx, "channel", arg);
192 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
194 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
195 return opt_default(optctx, "standard", arg);
198 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
200 OptionsContext *o = optctx;
201 return parse_option(o, "codec:a", arg, options);
204 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
206 OptionsContext *o = optctx;
207 return parse_option(o, "codec:v", arg, options);
210 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
212 OptionsContext *o = optctx;
213 return parse_option(o, "codec:s", arg, options);
216 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
218 OptionsContext *o = optctx;
219 return parse_option(o, "codec:d", arg, options);
222 static int opt_map(void *optctx, const char *opt, const char *arg)
224 OptionsContext *o = optctx;
226 int i, negative = 0, file_idx;
227 int sync_file_idx = -1, sync_stream_idx = 0;
235 map = av_strdup(arg);
237 return AVERROR(ENOMEM);
239 /* parse sync stream first, just pick first matching stream */
240 if (sync = strchr(map, ',')) {
242 sync_file_idx = strtol(sync + 1, &sync, 0);
243 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
244 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
249 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
250 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
251 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
255 if (i == input_files[sync_file_idx]->nb_streams) {
256 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
257 "match any streams.\n", arg);
264 /* this mapping refers to lavfi output */
265 const char *c = map + 1;
266 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
267 m = &o->stream_maps[o->nb_stream_maps - 1];
268 m->linklabel = av_get_token(&c, "]");
270 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
274 file_idx = strtol(map, &p, 0);
275 if (file_idx >= nb_input_files || file_idx < 0) {
276 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
280 /* disable some already defined maps */
281 for (i = 0; i < o->nb_stream_maps; i++) {
282 m = &o->stream_maps[i];
283 if (file_idx == m->file_index &&
284 check_stream_specifier(input_files[m->file_index]->ctx,
285 input_files[m->file_index]->ctx->streams[m->stream_index],
286 *p == ':' ? p + 1 : p) > 0)
290 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
291 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
292 *p == ':' ? p + 1 : p) <= 0)
294 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
295 m = &o->stream_maps[o->nb_stream_maps - 1];
297 m->file_index = file_idx;
300 if (sync_file_idx >= 0) {
301 m->sync_file_index = sync_file_idx;
302 m->sync_stream_index = sync_stream_idx;
304 m->sync_file_index = file_idx;
305 m->sync_stream_index = i;
311 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
319 static int opt_attach(void *optctx, const char *opt, const char *arg)
321 OptionsContext *o = optctx;
322 GROW_ARRAY(o->attachments, o->nb_attachments);
323 o->attachments[o->nb_attachments - 1] = arg;
327 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
329 OptionsContext *o = optctx;
334 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
335 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
337 /* muted channel syntax */
338 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
339 if ((n == 1 || n == 3) && m->channel_idx == -1) {
340 m->file_idx = m->stream_idx = -1;
342 m->ofile_idx = m->ostream_idx = -1;
347 n = sscanf(arg, "%d.%d.%d:%d.%d",
348 &m->file_idx, &m->stream_idx, &m->channel_idx,
349 &m->ofile_idx, &m->ostream_idx);
351 if (n != 3 && n != 5) {
352 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
353 "[file.stream.channel|-1][:syncfile:syncstream]\n");
357 if (n != 5) // only file.stream.channel specified
358 m->ofile_idx = m->ostream_idx = -1;
361 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
362 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
366 if (m->stream_idx < 0 ||
367 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
368 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
369 m->file_idx, m->stream_idx);
372 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
373 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
374 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
375 m->file_idx, m->stream_idx);
378 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
379 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
380 m->file_idx, m->stream_idx, m->channel_idx);
386 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
388 av_free(sdp_filename);
389 sdp_filename = av_strdup(arg);
394 * Parse a metadata specifier passed as 'arg' parameter.
395 * @param arg metadata string to parse
396 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
397 * @param index for type c/p, chapter/program index is written here
398 * @param stream_spec for type s, the stream specifier is written here
400 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
408 if (*(++arg) && *arg != ':') {
409 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
412 *stream_spec = *arg == ':' ? arg + 1 : "";
417 *index = strtol(++arg, NULL, 0);
420 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
427 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
429 AVDictionary **meta_in = NULL;
430 AVDictionary **meta_out = NULL;
432 char type_in, type_out;
433 const char *istream_spec = NULL, *ostream_spec = NULL;
434 int idx_in = 0, idx_out = 0;
436 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
437 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
440 if (type_out == 'g' || !*outspec)
441 o->metadata_global_manual = 1;
442 if (type_out == 's' || !*outspec)
443 o->metadata_streams_manual = 1;
444 if (type_out == 'c' || !*outspec)
445 o->metadata_chapters_manual = 1;
449 if (type_in == 'g' || type_out == 'g')
450 o->metadata_global_manual = 1;
451 if (type_in == 's' || type_out == 's')
452 o->metadata_streams_manual = 1;
453 if (type_in == 'c' || type_out == 'c')
454 o->metadata_chapters_manual = 1;
456 /* ic is NULL when just disabling automatic mappings */
460 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
461 if ((index) < 0 || (index) >= (nb_elems)) {\
462 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
467 #define SET_DICT(type, meta, context, index)\
470 meta = &context->metadata;\
473 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
474 meta = &context->chapters[index]->metadata;\
477 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
478 meta = &context->programs[index]->metadata;\
481 break; /* handled separately below */ \
482 default: av_assert0(0);\
485 SET_DICT(type_in, meta_in, ic, idx_in);
486 SET_DICT(type_out, meta_out, oc, idx_out);
488 /* for input streams choose first matching stream */
489 if (type_in == 's') {
490 for (i = 0; i < ic->nb_streams; i++) {
491 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
492 meta_in = &ic->streams[i]->metadata;
498 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
503 if (type_out == 's') {
504 for (i = 0; i < oc->nb_streams; i++) {
505 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
506 meta_out = &oc->streams[i]->metadata;
507 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
512 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
517 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
519 OptionsContext *o = optctx;
521 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
522 struct tm time = *gmtime((time_t*)&recording_timestamp);
523 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
525 parse_option(o, "metadata", buf, options);
527 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
528 "tag instead.\n", opt);
532 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
534 const AVCodecDescriptor *desc;
535 const char *codec_string = encoder ? "encoder" : "decoder";
539 avcodec_find_encoder_by_name(name) :
540 avcodec_find_decoder_by_name(name);
542 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
543 codec = encoder ? avcodec_find_encoder(desc->id) :
544 avcodec_find_decoder(desc->id);
546 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
547 codec_string, codec->name, desc->name);
551 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
554 if (codec->type != type) {
555 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
561 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
563 char *codec_name = NULL;
565 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
567 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
568 st->codec->codec_id = codec->id;
571 return avcodec_find_decoder(st->codec->codec_id);
574 /* Add all the streams from the given input file to the global
575 * list of input streams. */
576 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
580 for (i = 0; i < ic->nb_streams; i++) {
581 AVStream *st = ic->streams[i];
582 AVCodecContext *dec = st->codec;
583 InputStream *ist = av_mallocz(sizeof(*ist));
584 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
585 char *codec_tag = NULL;
587 char *discard_str = NULL;
588 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
593 GROW_ARRAY(input_streams, nb_input_streams);
594 input_streams[nb_input_streams - 1] = ist;
597 ist->file_index = nb_input_files;
599 st->discard = AVDISCARD_ALL;
602 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
604 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
606 uint32_t tag = strtol(codec_tag, &next, 0);
608 tag = AV_RL32(codec_tag);
609 st->codec->codec_tag = tag;
612 ist->dec = choose_decoder(o, ic, st);
613 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
615 ist->reinit_filters = -1;
616 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
618 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
619 ist->user_set_discard = AVDISCARD_NONE;
620 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
621 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
626 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
628 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
630 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
634 ret = avcodec_copy_context(ist->dec_ctx, dec);
636 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
640 switch (dec->codec_type) {
641 case AVMEDIA_TYPE_VIDEO:
643 ist->dec = avcodec_find_decoder(dec->codec_id);
644 if (av_codec_get_lowres(dec)) {
645 dec->flags |= CODEC_FLAG_EMU_EDGE;
648 ist->resample_height = ist->dec_ctx->height;
649 ist->resample_width = ist->dec_ctx->width;
650 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
652 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
653 if (framerate && av_parse_video_rate(&ist->framerate,
655 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
660 ist->top_field_first = -1;
661 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
663 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
665 if (!strcmp(hwaccel, "none"))
666 ist->hwaccel_id = HWACCEL_NONE;
667 else if (!strcmp(hwaccel, "auto"))
668 ist->hwaccel_id = HWACCEL_AUTO;
671 for (i = 0; hwaccels[i].name; i++) {
672 if (!strcmp(hwaccels[i].name, hwaccel)) {
673 ist->hwaccel_id = hwaccels[i].id;
678 if (!ist->hwaccel_id) {
679 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
681 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
682 for (i = 0; hwaccels[i].name; i++)
683 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
684 av_log(NULL, AV_LOG_FATAL, "\n");
690 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
691 if (hwaccel_device) {
692 ist->hwaccel_device = av_strdup(hwaccel_device);
693 if (!ist->hwaccel_device)
696 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
699 case AVMEDIA_TYPE_AUDIO:
700 ist->guess_layout_max = INT_MAX;
701 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
702 guess_input_channel_layout(ist);
704 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
705 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
706 ist->resample_channels = ist->dec_ctx->channels;
707 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
710 case AVMEDIA_TYPE_DATA:
711 case AVMEDIA_TYPE_SUBTITLE: {
712 char *canvas_size = NULL;
714 ist->dec = avcodec_find_decoder(dec->codec_id);
715 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
716 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
718 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
719 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
724 case AVMEDIA_TYPE_ATTACHMENT:
725 case AVMEDIA_TYPE_UNKNOWN:
733 static void assert_file_overwrite(const char *filename)
735 if (file_overwrite && no_file_overwrite) {
736 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
740 if (!file_overwrite) {
741 const char *proto_name = avio_find_protocol_name(filename);
742 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
743 if (stdin_interaction && !no_file_overwrite) {
744 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
747 signal(SIGINT, SIG_DFL);
749 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
755 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
762 static void dump_attachment(AVStream *st, const char *filename)
765 AVIOContext *out = NULL;
766 AVDictionaryEntry *e;
768 if (!st->codec->extradata_size) {
769 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
770 nb_input_files - 1, st->index);
773 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
776 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
777 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
781 assert_file_overwrite(filename);
783 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
784 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
789 avio_write(out, st->codec->extradata, st->codec->extradata_size);
794 static int open_input_file(OptionsContext *o, const char *filename)
798 AVInputFormat *file_iformat = NULL;
802 AVDictionary *unused_opts = NULL;
803 AVDictionaryEntry *e = NULL;
804 int orig_nb_streams; // number of streams before avformat_find_stream_info
805 char * video_codec_name = NULL;
806 char * audio_codec_name = NULL;
807 char *subtitle_codec_name = NULL;
808 char * data_codec_name = NULL;
809 int scan_all_pmts_set = 0;
812 if (!(file_iformat = av_find_input_format(o->format))) {
813 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
818 if (!strcmp(filename, "-"))
821 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
822 strcmp(filename, "/dev/stdin");
824 /* get default parameters from command line */
825 ic = avformat_alloc_context();
827 print_error(filename, AVERROR(ENOMEM));
830 if (o->nb_audio_sample_rate) {
831 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
833 if (o->nb_audio_channels) {
834 /* because we set audio_channels based on both the "ac" and
835 * "channel_layout" options, we need to check that the specified
836 * demuxer actually has the "channels" option before setting it */
837 if (file_iformat && file_iformat->priv_class &&
838 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
839 AV_OPT_SEARCH_FAKE_OBJ)) {
840 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
843 if (o->nb_frame_rates) {
844 /* set the format-level framerate option;
845 * this is important for video grabbers, e.g. x11 */
846 if (file_iformat && file_iformat->priv_class &&
847 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
848 AV_OPT_SEARCH_FAKE_OBJ)) {
849 av_dict_set(&o->g->format_opts, "framerate",
850 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
853 if (o->nb_frame_sizes) {
854 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
856 if (o->nb_frame_pix_fmts)
857 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
859 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
860 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
861 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
863 ic->video_codec_id = video_codec_name ?
864 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
865 ic->audio_codec_id = audio_codec_name ?
866 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
867 ic->subtitle_codec_id= subtitle_codec_name ?
868 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
869 ic->data_codec_id = data_codec_name ?
870 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
872 if (video_codec_name)
873 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
874 if (audio_codec_name)
875 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
876 if (subtitle_codec_name)
877 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
879 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
881 ic->flags |= AVFMT_FLAG_NONBLOCK;
882 ic->interrupt_callback = int_cb;
884 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
885 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
886 scan_all_pmts_set = 1;
888 /* open the input file with generic avformat function */
889 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
891 print_error(filename, err);
894 if (scan_all_pmts_set)
895 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
896 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
897 assert_avoptions(o->g->format_opts);
899 /* apply forced codec ids */
900 for (i = 0; i < ic->nb_streams; i++)
901 choose_decoder(o, ic, ic->streams[i]);
903 /* Set AVCodecContext options for avformat_find_stream_info */
904 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
905 orig_nb_streams = ic->nb_streams;
907 /* If not enough info to get the stream parameters, we decode the
908 first frames to get it. (used in mpeg case for example) */
909 ret = avformat_find_stream_info(ic, opts);
911 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
912 if (ic->nb_streams == 0) {
913 avformat_close_input(&ic);
918 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
919 /* add the stream start time */
920 if (ic->start_time != AV_NOPTS_VALUE)
921 timestamp += ic->start_time;
923 /* if seeking requested, we execute it */
924 if (o->start_time != AV_NOPTS_VALUE) {
925 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
927 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
928 filename, (double)timestamp / AV_TIME_BASE);
932 /* update the current parameters so that they match the one of the input stream */
933 add_input_streams(o, ic);
935 /* dump the file content */
936 av_dump_format(ic, nb_input_files, filename, 0);
938 GROW_ARRAY(input_files, nb_input_files);
939 f = av_mallocz(sizeof(*f));
942 input_files[nb_input_files - 1] = f;
945 f->ist_index = nb_input_streams - ic->nb_streams;
946 f->start_time = o->start_time;
947 f->recording_time = o->recording_time;
948 f->input_ts_offset = o->input_ts_offset;
949 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
950 f->nb_streams = ic->nb_streams;
951 f->rate_emu = o->rate_emu;
952 f->accurate_seek = o->accurate_seek;
954 /* check if all codec options have been used */
955 unused_opts = strip_specifiers(o->g->codec_opts);
956 for (i = f->ist_index; i < nb_input_streams; i++) {
958 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
959 AV_DICT_IGNORE_SUFFIX)))
960 av_dict_set(&unused_opts, e->key, NULL, 0);
964 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
965 const AVClass *class = avcodec_get_class();
966 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
967 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
968 const AVClass *fclass = avformat_get_class();
969 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
970 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
971 if (!option || foption)
975 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
976 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
977 "input file #%d (%s) is not a decoding option.\n", e->key,
978 option->help ? option->help : "", nb_input_files - 1,
983 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
984 "input file #%d (%s) has not been used for any stream. The most "
985 "likely reason is either wrong type (e.g. a video option with "
986 "no video streams) or that it is a private option of some decoder "
987 "which was not actually used for any stream.\n", e->key,
988 option->help ? option->help : "", nb_input_files - 1, filename);
990 av_dict_free(&unused_opts);
992 for (i = 0; i < o->nb_dump_attachment; i++) {
995 for (j = 0; j < ic->nb_streams; j++) {
996 AVStream *st = ic->streams[j];
998 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
999 dump_attachment(st, o->dump_attachment[i].u.str);
1003 for (i = 0; i < orig_nb_streams; i++)
1004 av_dict_free(&opts[i]);
1010 static uint8_t *get_line(AVIOContext *s)
1016 if (avio_open_dyn_buf(&line) < 0) {
1017 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1021 while ((c = avio_r8(s)) && c != '\n')
1024 avio_close_dyn_buf(line, &buf);
1029 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1032 char filename[1000];
1033 const char *base[3] = { getenv("AVCONV_DATADIR"),
1038 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1042 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1043 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1044 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1047 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1048 i != 1 ? "" : "/.avconv", preset_name);
1049 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1055 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1057 char *codec_name = NULL;
1059 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1061 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1062 NULL, ost->st->codec->codec_type);
1063 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1064 } else if (!strcmp(codec_name, "copy"))
1065 ost->stream_copy = 1;
1067 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1068 ost->st->codec->codec_id = ost->enc->id;
1072 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1075 AVStream *st = avformat_new_stream(oc, NULL);
1076 int idx = oc->nb_streams - 1, ret = 0;
1077 char *bsf = NULL, *next, *codec_tag = NULL;
1078 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1083 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1087 if (oc->nb_streams - 1 < o->nb_streamid_map)
1088 st->id = o->streamid_map[oc->nb_streams - 1];
1090 GROW_ARRAY(output_streams, nb_output_streams);
1091 if (!(ost = av_mallocz(sizeof(*ost))))
1093 output_streams[nb_output_streams - 1] = ost;
1095 ost->file_index = nb_output_files - 1;
1098 st->codec->codec_type = type;
1099 choose_encoder(o, oc, ost);
1101 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1102 if (!ost->enc_ctx) {
1103 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1106 ost->enc_ctx->codec_type = type;
1109 AVIOContext *s = NULL;
1110 char *buf = NULL, *arg = NULL, *preset = NULL;
1112 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1114 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1115 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1118 if (!buf[0] || buf[0] == '#') {
1122 if (!(arg = strchr(buf, '='))) {
1123 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1127 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1129 } while (!s->eof_reached);
1133 av_log(NULL, AV_LOG_FATAL,
1134 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1135 preset, ost->file_index, ost->index);
1139 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1142 ost->max_frames = INT64_MAX;
1143 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1144 for (i = 0; i<o->nb_max_frames; i++) {
1145 char *p = o->max_frames[i].specifier;
1146 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1147 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1152 ost->copy_prior_start = -1;
1153 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1155 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1158 if (next = strchr(bsf, ','))
1160 if (arg = strchr(bsf, '='))
1162 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1163 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1167 bsfc_prev->next = bsfc;
1169 ost->bitstream_filters = bsfc;
1170 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1176 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1178 uint32_t tag = strtol(codec_tag, &next, 0);
1180 tag = AV_RL32(codec_tag);
1181 ost->enc_ctx->codec_tag = tag;
1184 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1186 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1187 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1190 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1191 ost->disposition = av_strdup(ost->disposition);
1193 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1194 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1196 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1198 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1199 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1200 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1202 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1204 ost->source_index = source_index;
1205 if (source_index >= 0) {
1206 ost->sync_ist = input_streams[source_index];
1207 input_streams[source_index]->discard = 0;
1208 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1210 ost->last_mux_dts = AV_NOPTS_VALUE;
1215 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1218 const char *p = str;
1225 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1232 /* read file contents into a string */
1233 static uint8_t *read_file(const char *filename)
1235 AVIOContext *pb = NULL;
1236 AVIOContext *dyn_buf = NULL;
1237 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1238 uint8_t buf[1024], *str;
1241 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1245 ret = avio_open_dyn_buf(&dyn_buf);
1250 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1251 avio_write(dyn_buf, buf, ret);
1252 avio_w8(dyn_buf, 0);
1255 ret = avio_close_dyn_buf(dyn_buf, &str);
1261 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1264 AVStream *st = ost->st;
1266 if (ost->filters_script && ost->filters) {
1267 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1268 "output stream #%d:%d.\n", nb_output_files, st->index);
1272 if (ost->filters_script)
1273 return read_file(ost->filters_script);
1274 else if (ost->filters)
1275 return av_strdup(ost->filters);
1277 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1281 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1282 const OutputStream *ost, enum AVMediaType type)
1284 if (ost->filters_script || ost->filters) {
1285 av_log(NULL, AV_LOG_ERROR,
1286 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1287 "Filtering and streamcopy cannot be used together.\n",
1288 ost->filters ? "Filtergraph" : "Filtergraph script",
1289 ost->filters ? ost->filters : ost->filters_script,
1290 av_get_media_type_string(type), ost->file_index, ost->index);
1295 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1299 AVCodecContext *video_enc;
1300 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1302 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1304 video_enc = ost->enc_ctx;
1306 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1307 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1308 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1311 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1312 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1314 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1315 if (frame_aspect_ratio) {
1317 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1318 q.num <= 0 || q.den <= 0) {
1319 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1322 ost->frame_aspect_ratio = q;
1325 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1326 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1328 if (!ost->stream_copy) {
1329 const char *p = NULL;
1330 char *frame_size = NULL;
1331 char *frame_pix_fmt = NULL;
1332 char *intra_matrix = NULL, *inter_matrix = NULL;
1333 char *chroma_intra_matrix = NULL;
1337 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1338 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1339 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1343 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1344 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1345 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1346 ost->keep_pix_fmt = 1;
1347 if (!*++frame_pix_fmt)
1348 frame_pix_fmt = NULL;
1350 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1351 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1354 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1357 video_enc->gop_size = 0;
1358 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1360 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1361 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1364 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1366 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1367 if (chroma_intra_matrix) {
1368 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1370 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1373 av_codec_set_chroma_intra_matrix(video_enc, p);
1374 parse_matrix_coeffs(p, chroma_intra_matrix);
1376 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1378 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1379 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1382 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1385 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1386 for (i = 0; p; i++) {
1388 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1390 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1393 video_enc->rc_override =
1394 av_realloc_array(video_enc->rc_override,
1395 i + 1, sizeof(RcOverride));
1396 if (!video_enc->rc_override)
1398 video_enc->rc_override[i].start_frame = start;
1399 video_enc->rc_override[i].end_frame = end;
1401 video_enc->rc_override[i].qscale = q;
1402 video_enc->rc_override[i].quality_factor = 1.0;
1405 video_enc->rc_override[i].qscale = 0;
1406 video_enc->rc_override[i].quality_factor = -q/100.0;
1411 video_enc->rc_override_count = i;
1414 video_enc->flags|= CODEC_FLAG_PSNR;
1417 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1420 video_enc->flags |= CODEC_FLAG_PASS1;
1421 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1424 video_enc->flags |= CODEC_FLAG_PASS2;
1425 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1429 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1430 if (ost->logfile_prefix &&
1431 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1434 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1435 if (ost->forced_keyframes)
1436 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1438 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1440 ost->top_field_first = -1;
1441 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1444 ost->avfilter = get_ost_filters(o, oc, ost);
1448 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1451 if (ost->stream_copy)
1452 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1457 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1462 AVCodecContext *audio_enc;
1464 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1467 audio_enc = ost->enc_ctx;
1468 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1470 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1471 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1473 if (!ost->stream_copy) {
1474 char *sample_fmt = NULL;
1476 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1478 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1480 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1481 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1485 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1487 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1488 ost->apad = av_strdup(ost->apad);
1490 ost->avfilter = get_ost_filters(o, oc, ost);
1494 /* check for channel mapping for this audio stream */
1495 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1496 AudioChannelMap *map = &o->audio_channel_maps[n];
1497 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1498 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1501 if (map->channel_idx == -1) {
1503 } else if (ost->source_index < 0) {
1504 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1505 ost->file_index, ost->st->index);
1508 ist = input_streams[ost->source_index];
1511 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1512 if (av_reallocp_array(&ost->audio_channels_map,
1513 ost->audio_channels_mapped + 1,
1514 sizeof(*ost->audio_channels_map)
1518 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1524 if (ost->stream_copy)
1525 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1530 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1534 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1535 if (!ost->stream_copy) {
1536 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1543 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1545 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1546 ost->stream_copy = 1;
1551 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1555 AVCodecContext *subtitle_enc;
1557 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1559 subtitle_enc = ost->enc_ctx;
1561 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1563 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1565 if (!ost->stream_copy) {
1566 char *frame_size = NULL;
1568 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1569 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1570 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1578 /* arg format is "output-stream-index:streamid-value". */
1579 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1581 OptionsContext *o = optctx;
1586 av_strlcpy(idx_str, arg, sizeof(idx_str));
1587 p = strchr(idx_str, ':');
1589 av_log(NULL, AV_LOG_FATAL,
1590 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1595 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1596 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1597 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1601 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1603 AVFormatContext *is = ifile->ctx;
1604 AVFormatContext *os = ofile->ctx;
1608 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1610 return AVERROR(ENOMEM);
1613 for (i = 0; i < is->nb_chapters; i++) {
1614 AVChapter *in_ch = is->chapters[i], *out_ch;
1615 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1616 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1617 AV_TIME_BASE_Q, in_ch->time_base);
1618 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1619 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1622 if (in_ch->end < ts_off)
1624 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1627 out_ch = av_mallocz(sizeof(AVChapter));
1629 return AVERROR(ENOMEM);
1631 out_ch->id = in_ch->id;
1632 out_ch->time_base = in_ch->time_base;
1633 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1634 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1637 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1639 os->chapters[os->nb_chapters++] = out_ch;
1644 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1647 AVFormatContext *ic = avformat_alloc_context();
1649 ic->interrupt_callback = int_cb;
1650 err = avformat_open_input(&ic, filename, NULL, NULL);
1653 /* copy stream format */
1654 for(i=0;i<ic->nb_streams;i++) {
1658 const char *enc_config;
1660 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1662 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1663 return AVERROR(EINVAL);
1665 if (codec->type == AVMEDIA_TYPE_AUDIO)
1666 opt_audio_codec(o, "c:a", codec->name);
1667 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1668 opt_video_codec(o, "c:v", codec->name);
1669 ost = new_output_stream(o, s, codec->type, -1);
1672 avcodec_get_context_defaults3(st->codec, codec);
1673 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1675 AVDictionary *opts = NULL;
1676 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1677 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1678 av_dict_free(&opts);
1681 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1682 choose_sample_fmt(st, codec);
1683 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1684 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1685 avcodec_copy_context(ost->enc_ctx, st->codec);
1687 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1690 avformat_close_input(&ic);
1694 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1695 AVFormatContext *oc)
1699 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1700 ofilter->out_tmp->pad_idx)) {
1701 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1702 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1704 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1709 ost->source_index = -1;
1710 ost->filter = ofilter;
1714 if (ost->stream_copy) {
1715 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1716 "which is fed from a complex filtergraph. Filtering and streamcopy "
1717 "cannot be used together.\n", ost->file_index, ost->index);
1721 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1722 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1723 av_log(NULL, AV_LOG_ERROR,
1724 "%s '%s' was specified through the %s option "
1725 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1726 "%s and -filter_complex cannot be used together for the same stream.\n",
1727 ost->filters ? "Filtergraph" : "Filtergraph script",
1728 ost->filters ? ost->filters : ost->filters_script,
1729 opt, ost->file_index, ost->index, opt);
1733 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1734 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1737 avfilter_inout_free(&ofilter->out_tmp);
1740 static int configure_complex_filters(void)
1744 for (i = 0; i < nb_filtergraphs; i++)
1745 if (!filtergraphs[i]->graph &&
1746 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1751 static int open_output_file(OptionsContext *o, const char *filename)
1753 AVFormatContext *oc;
1755 AVOutputFormat *file_oformat;
1759 AVDictionary *unused_opts = NULL;
1760 AVDictionaryEntry *e = NULL;
1762 if (configure_complex_filters() < 0) {
1763 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1767 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1768 o->stop_time = INT64_MAX;
1769 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1772 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1773 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1774 if (o->stop_time <= start_time) {
1775 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1778 o->recording_time = o->stop_time - start_time;
1782 GROW_ARRAY(output_files, nb_output_files);
1783 of = av_mallocz(sizeof(*of));
1786 output_files[nb_output_files - 1] = of;
1788 of->ost_index = nb_output_streams;
1789 of->recording_time = o->recording_time;
1790 of->start_time = o->start_time;
1791 of->limit_filesize = o->limit_filesize;
1792 of->shortest = o->shortest;
1793 av_dict_copy(&of->opts, o->g->format_opts, 0);
1795 if (!strcmp(filename, "-"))
1798 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1800 print_error(filename, err);
1805 if (o->recording_time != INT64_MAX)
1806 oc->duration = o->recording_time;
1808 file_oformat= oc->oformat;
1809 oc->interrupt_callback = int_cb;
1811 /* create streams for all unlabeled output pads */
1812 for (i = 0; i < nb_filtergraphs; i++) {
1813 FilterGraph *fg = filtergraphs[i];
1814 for (j = 0; j < fg->nb_outputs; j++) {
1815 OutputFilter *ofilter = fg->outputs[j];
1817 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1820 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1821 ofilter->out_tmp->pad_idx)) {
1822 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1823 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1824 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1826 init_output_filter(ofilter, o, oc);
1830 /* ffserver seeking with date=... needs a date reference */
1831 if (!strcmp(file_oformat->name, "ffm") &&
1832 av_strstart(filename, "http:", NULL)) {
1833 int err = parse_option(o, "metadata", "creation_time=now", options);
1835 print_error(filename, err);
1840 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1841 av_strstart(filename, "http:", NULL)) {
1843 /* special case for files sent to ffserver: we get the stream
1844 parameters from ffserver */
1845 int err = read_ffserver_streams(o, oc, filename);
1847 print_error(filename, err);
1850 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1851 ost = output_streams[j];
1852 for (i = 0; i < nb_input_streams; i++) {
1853 ist = input_streams[i];
1854 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1856 ost->source_index= i;
1857 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1858 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1860 ist->st->discard = ist->user_set_discard;
1865 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));
1869 } else if (!o->nb_stream_maps) {
1870 char *subtitle_codec_name = NULL;
1871 /* pick the "best" stream of each type */
1873 /* video: highest resolution */
1874 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1875 int area = 0, idx = -1;
1876 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1877 for (i = 0; i < nb_input_streams; i++) {
1879 ist = input_streams[i];
1880 new_area = ist->st->codec->width * ist->st->codec->height;
1881 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1883 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1885 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1892 new_video_stream(o, oc, idx);
1895 /* audio: most channels */
1896 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1897 int channels = 0, idx = -1;
1898 for (i = 0; i < nb_input_streams; i++) {
1899 ist = input_streams[i];
1900 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1901 ist->st->codec->channels > channels) {
1902 channels = ist->st->codec->channels;
1907 new_audio_stream(o, oc, idx);
1910 /* subtitles: pick first */
1911 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1912 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1913 for (i = 0; i < nb_input_streams; i++)
1914 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1915 AVCodecDescriptor const *input_descriptor =
1916 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1917 AVCodecDescriptor const *output_descriptor = NULL;
1918 AVCodec const *output_codec =
1919 avcodec_find_encoder(oc->oformat->subtitle_codec);
1920 int input_props = 0, output_props = 0;
1922 output_descriptor = avcodec_descriptor_get(output_codec->id);
1923 if (input_descriptor)
1924 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1925 if (output_descriptor)
1926 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1927 if (subtitle_codec_name ||
1928 input_props & output_props ||
1929 // Map dvb teletext which has neither property to any output subtitle encoder
1930 input_descriptor && output_descriptor &&
1931 (!input_descriptor->props ||
1932 !output_descriptor->props)) {
1933 new_subtitle_stream(o, oc, i);
1938 /* Data only if codec id match */
1939 if (!o->data_disable ) {
1940 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
1941 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1942 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1943 && input_streams[i]->st->codec->codec_id == codec_id )
1944 new_data_stream(o, oc, i);
1948 for (i = 0; i < o->nb_stream_maps; i++) {
1949 StreamMap *map = &o->stream_maps[i];
1954 if (map->linklabel) {
1956 OutputFilter *ofilter = NULL;
1959 for (j = 0; j < nb_filtergraphs; j++) {
1960 fg = filtergraphs[j];
1961 for (k = 0; k < fg->nb_outputs; k++) {
1962 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1963 if (out && !strcmp(out->name, map->linklabel)) {
1964 ofilter = fg->outputs[k];
1971 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1972 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1975 init_output_filter(ofilter, o, oc);
1977 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1979 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1980 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1982 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1984 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1986 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1989 switch (ist->st->codec->codec_type) {
1990 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1991 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1992 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1993 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1994 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1996 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1997 map->file_index, map->stream_index);
2004 /* handle attached files */
2005 for (i = 0; i < o->nb_attachments; i++) {
2007 uint8_t *attachment;
2011 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2012 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2016 if ((len = avio_size(pb)) <= 0) {
2017 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2021 if (!(attachment = av_malloc(len))) {
2022 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2026 avio_read(pb, attachment, len);
2028 ost = new_attachment_stream(o, oc, -1);
2029 ost->stream_copy = 0;
2030 ost->attachment_filename = o->attachments[i];
2032 ost->enc_ctx->extradata = attachment;
2033 ost->enc_ctx->extradata_size = len;
2035 p = strrchr(o->attachments[i], '/');
2036 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2040 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2041 AVDictionaryEntry *e;
2042 ost = output_streams[i];
2044 if ((ost->stream_copy || ost->attachment_filename)
2045 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2046 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2047 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2051 /* check if all codec options have been used */
2052 unused_opts = strip_specifiers(o->g->codec_opts);
2053 for (i = of->ost_index; i < nb_output_streams; i++) {
2055 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2056 AV_DICT_IGNORE_SUFFIX)))
2057 av_dict_set(&unused_opts, e->key, NULL, 0);
2061 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2062 const AVClass *class = avcodec_get_class();
2063 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2064 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2065 const AVClass *fclass = avformat_get_class();
2066 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2067 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2068 if (!option || foption)
2072 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2073 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2074 "output file #%d (%s) is not an encoding option.\n", e->key,
2075 option->help ? option->help : "", nb_output_files - 1,
2080 // gop_timecode is injected by generic code but not always used
2081 if (!strcmp(e->key, "gop_timecode"))
2084 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2085 "output file #%d (%s) has not been used for any stream. The most "
2086 "likely reason is either wrong type (e.g. a video option with "
2087 "no video streams) or that it is a private option of some encoder "
2088 "which was not actually used for any stream.\n", e->key,
2089 option->help ? option->help : "", nb_output_files - 1, filename);
2091 av_dict_free(&unused_opts);
2093 /* check filename in case of an image number is expected */
2094 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2095 if (!av_filename_number_test(oc->filename)) {
2096 print_error(oc->filename, AVERROR(EINVAL));
2101 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2102 /* test if it already exists to avoid losing precious files */
2103 assert_file_overwrite(filename);
2106 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2107 &oc->interrupt_callback,
2109 print_error(filename, err);
2112 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2113 assert_file_overwrite(filename);
2115 if (o->mux_preload) {
2116 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2118 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2121 for (i = 0; i < o->nb_metadata_map; i++) {
2123 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2125 if (in_file_index >= nb_input_files) {
2126 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2129 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2130 in_file_index >= 0 ?
2131 input_files[in_file_index]->ctx : NULL, o);
2135 if (o->chapters_input_file >= nb_input_files) {
2136 if (o->chapters_input_file == INT_MAX) {
2137 /* copy chapters from the first input file that has them*/
2138 o->chapters_input_file = -1;
2139 for (i = 0; i < nb_input_files; i++)
2140 if (input_files[i]->ctx->nb_chapters) {
2141 o->chapters_input_file = i;
2145 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2146 o->chapters_input_file);
2150 if (o->chapters_input_file >= 0)
2151 copy_chapters(input_files[o->chapters_input_file], of,
2152 !o->metadata_chapters_manual);
2154 /* copy global metadata by default */
2155 if (!o->metadata_global_manual && nb_input_files){
2156 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2157 AV_DICT_DONT_OVERWRITE);
2158 if(o->recording_time != INT64_MAX)
2159 av_dict_set(&oc->metadata, "duration", NULL, 0);
2160 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2162 if (!o->metadata_streams_manual)
2163 for (i = of->ost_index; i < nb_output_streams; i++) {
2165 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2167 ist = input_streams[output_streams[i]->source_index];
2168 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2169 if (!output_streams[i]->stream_copy)
2170 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2173 /* process manually set metadata */
2174 for (i = 0; i < o->nb_metadata; i++) {
2177 const char *stream_spec;
2178 int index = 0, j, ret = 0;
2180 val = strchr(o->metadata[i].u.str, '=');
2182 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2183 o->metadata[i].u.str);
2188 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2190 for (j = 0; j < oc->nb_streams; j++) {
2191 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2192 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2203 if (index < 0 || index >= oc->nb_chapters) {
2204 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2207 m = &oc->chapters[index]->metadata;
2210 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2213 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2220 static int opt_target(void *optctx, const char *opt, const char *arg)
2222 OptionsContext *o = optctx;
2223 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2224 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2226 if (!strncmp(arg, "pal-", 4)) {
2229 } else if (!strncmp(arg, "ntsc-", 5)) {
2232 } else if (!strncmp(arg, "film-", 5)) {
2236 /* Try to determine PAL/NTSC by peeking in the input files */
2237 if (nb_input_files) {
2239 for (j = 0; j < nb_input_files; j++) {
2240 for (i = 0; i < input_files[j]->nb_streams; i++) {
2241 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2242 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2245 fr = c->time_base.den * 1000 / c->time_base.num;
2249 } else if ((fr == 29970) || (fr == 23976)) {
2254 if (norm != UNKNOWN)
2258 if (norm != UNKNOWN)
2259 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2262 if (norm == UNKNOWN) {
2263 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2264 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2265 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2269 if (!strcmp(arg, "vcd")) {
2270 opt_video_codec(o, "c:v", "mpeg1video");
2271 opt_audio_codec(o, "c:a", "mp2");
2272 parse_option(o, "f", "vcd", options);
2274 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2275 parse_option(o, "r", frame_rates[norm], options);
2276 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2278 opt_default(NULL, "b:v", "1150000");
2279 opt_default(NULL, "maxrate", "1150000");
2280 opt_default(NULL, "minrate", "1150000");
2281 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2283 opt_default(NULL, "b:a", "224000");
2284 parse_option(o, "ar", "44100", options);
2285 parse_option(o, "ac", "2", options);
2287 opt_default(NULL, "packetsize", "2324");
2288 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2290 /* We have to offset the PTS, so that it is consistent with the SCR.
2291 SCR starts at 36000, but the first two packs contain only padding
2292 and the first pack from the other stream, respectively, may also have
2293 been written before.
2294 So the real data starts at SCR 36000+3*1200. */
2295 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2296 } else if (!strcmp(arg, "svcd")) {
2298 opt_video_codec(o, "c:v", "mpeg2video");
2299 opt_audio_codec(o, "c:a", "mp2");
2300 parse_option(o, "f", "svcd", options);
2302 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2303 parse_option(o, "r", frame_rates[norm], options);
2304 parse_option(o, "pix_fmt", "yuv420p", options);
2305 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2307 opt_default(NULL, "b:v", "2040000");
2308 opt_default(NULL, "maxrate", "2516000");
2309 opt_default(NULL, "minrate", "0"); // 1145000;
2310 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2311 opt_default(NULL, "scan_offset", "1");
2313 opt_default(NULL, "b:a", "224000");
2314 parse_option(o, "ar", "44100", options);
2316 opt_default(NULL, "packetsize", "2324");
2318 } else if (!strcmp(arg, "dvd")) {
2320 opt_video_codec(o, "c:v", "mpeg2video");
2321 opt_audio_codec(o, "c:a", "ac3");
2322 parse_option(o, "f", "dvd", options);
2324 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2325 parse_option(o, "r", frame_rates[norm], options);
2326 parse_option(o, "pix_fmt", "yuv420p", options);
2327 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2329 opt_default(NULL, "b:v", "6000000");
2330 opt_default(NULL, "maxrate", "9000000");
2331 opt_default(NULL, "minrate", "0"); // 1500000;
2332 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2334 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2335 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2337 opt_default(NULL, "b:a", "448000");
2338 parse_option(o, "ar", "48000", options);
2340 } else if (!strncmp(arg, "dv", 2)) {
2342 parse_option(o, "f", "dv", options);
2344 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2345 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2346 norm == PAL ? "yuv420p" : "yuv411p", options);
2347 parse_option(o, "r", frame_rates[norm], options);
2349 parse_option(o, "ar", "48000", options);
2350 parse_option(o, "ac", "2", options);
2353 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2354 return AVERROR(EINVAL);
2357 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2358 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2363 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2365 av_free (vstats_filename);
2366 vstats_filename = av_strdup (arg);
2370 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2373 time_t today2 = time(NULL);
2374 struct tm *today = localtime(&today2);
2376 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2378 return opt_vstats_file(NULL, opt, filename);
2381 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2383 OptionsContext *o = optctx;
2384 return parse_option(o, "frames:v", arg, options);
2387 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2389 OptionsContext *o = optctx;
2390 return parse_option(o, "frames:a", arg, options);
2393 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2395 OptionsContext *o = optctx;
2396 return parse_option(o, "frames:d", arg, options);
2399 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2402 AVDictionary *cbak = codec_opts;
2403 AVDictionary *fbak = format_opts;
2407 ret = opt_default(NULL, opt, arg);
2409 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2410 av_dict_copy(&o->g->format_opts, format_opts, 0);
2411 av_dict_free(&codec_opts);
2412 av_dict_free(&format_opts);
2419 static int opt_preset(void *optctx, const char *opt, const char *arg)
2421 OptionsContext *o = optctx;
2423 char filename[1000], line[1000], tmp_line[1000];
2424 const char *codec_name = NULL;
2428 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2430 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2431 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2432 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2434 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2438 while (fgets(line, sizeof(line), f)) {
2439 char *key = tmp_line, *value, *endptr;
2441 if (strcspn(line, "#\n\r") == 0)
2443 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2444 if (!av_strtok(key, "=", &value) ||
2445 !av_strtok(value, "\r\n", &endptr)) {
2446 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2449 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2451 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2452 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2453 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2454 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2455 else if (opt_default_new(o, key, value) < 0) {
2456 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2457 filename, line, key, value);
2467 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2469 OptionsContext *o = optctx;
2470 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2471 int ret = parse_option(o, s, arg, options);
2476 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2478 OptionsContext *o = optctx;
2480 if(!strcmp(opt, "ab")){
2481 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2483 } else if(!strcmp(opt, "b")){
2484 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2485 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2488 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2492 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2494 OptionsContext *o = optctx;
2497 if(!strcmp(opt, "qscale")){
2498 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2499 return parse_option(o, "q:v", arg, options);
2501 s = av_asprintf("q%s", opt + 6);
2502 ret = parse_option(o, s, arg, options);
2507 static int opt_profile(void *optctx, const char *opt, const char *arg)
2509 OptionsContext *o = optctx;
2510 if(!strcmp(opt, "profile")){
2511 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2512 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2515 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2519 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2521 OptionsContext *o = optctx;
2522 return parse_option(o, "filter:v", arg, options);
2525 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2527 OptionsContext *o = optctx;
2528 return parse_option(o, "filter:a", arg, options);
2531 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2533 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2534 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2535 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2536 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2538 if (video_sync_method == VSYNC_AUTO)
2539 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2543 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2545 OptionsContext *o = optctx;
2546 char *tcr = av_asprintf("timecode=%s", arg);
2547 int ret = parse_option(o, "metadata:g", tcr, options);
2549 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2554 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2556 OptionsContext *o = optctx;
2557 char layout_str[32];
2560 int ret, channels, ac_str_size;
2563 layout = av_get_channel_layout(arg);
2565 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2566 return AVERROR(EINVAL);
2568 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2569 ret = opt_default_new(o, opt, layout_str);
2573 /* set 'ac' option based on channel layout */
2574 channels = av_get_channel_layout_nb_channels(layout);
2575 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2576 stream_str = strchr(opt, ':');
2577 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2578 ac_str = av_mallocz(ac_str_size);
2580 return AVERROR(ENOMEM);
2581 av_strlcpy(ac_str, "ac", 3);
2583 av_strlcat(ac_str, stream_str, ac_str_size);
2584 ret = parse_option(o, ac_str, layout_str, options);
2590 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2592 OptionsContext *o = optctx;
2593 return parse_option(o, "q:a", arg, options);
2596 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2598 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2599 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2600 return AVERROR(ENOMEM);
2601 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2602 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2603 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2604 return AVERROR(ENOMEM);
2608 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2610 uint8_t *graph_desc = read_file(arg);
2612 return AVERROR(EINVAL);
2614 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2615 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2616 return AVERROR(ENOMEM);
2617 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2618 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2622 void show_help_default(const char *opt, const char *arg)
2624 /* per-file options have at least one of those set */
2625 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2626 int show_advanced = 0, show_avoptions = 0;
2629 if (!strcmp(opt, "long"))
2631 else if (!strcmp(opt, "full"))
2632 show_advanced = show_avoptions = 1;
2634 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2639 printf("Getting help:\n"
2640 " -h -- print basic options\n"
2641 " -h long -- print more options\n"
2642 " -h full -- print all options (including all format and codec specific options, very long)\n"
2643 " See man %s for detailed description of the options.\n"
2644 "\n", program_name);
2646 show_help_options(options, "Print help / information / capabilities:",
2649 show_help_options(options, "Global options (affect whole program "
2650 "instead of just one file:",
2651 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2653 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2654 per_file | OPT_EXIT, 0);
2656 show_help_options(options, "Per-file main options:", 0,
2657 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2658 OPT_EXIT, per_file);
2660 show_help_options(options, "Advanced per-file options:",
2661 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2663 show_help_options(options, "Video options:",
2664 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2666 show_help_options(options, "Advanced Video options:",
2667 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2669 show_help_options(options, "Audio options:",
2670 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2672 show_help_options(options, "Advanced Audio options:",
2673 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2674 show_help_options(options, "Subtitle options:",
2675 OPT_SUBTITLE, 0, 0);
2678 if (show_avoptions) {
2679 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2680 show_help_children(avcodec_get_class(), flags);
2681 show_help_children(avformat_get_class(), flags);
2683 show_help_children(sws_get_class(), flags);
2685 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2686 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2690 void show_usage(void)
2692 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2693 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2694 av_log(NULL, AV_LOG_INFO, "\n");
2702 static const OptionGroupDef groups[] = {
2703 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2704 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2707 static int open_files(OptionGroupList *l, const char *inout,
2708 int (*open_file)(OptionsContext*, const char*))
2712 for (i = 0; i < l->nb_groups; i++) {
2713 OptionGroup *g = &l->groups[i];
2719 ret = parse_optgroup(&o, g);
2721 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2722 "%s.\n", inout, g->arg);
2726 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2727 ret = open_file(&o, g->arg);
2730 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2734 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2740 int ffmpeg_parse_options(int argc, char **argv)
2742 OptionParseContext octx;
2746 memset(&octx, 0, sizeof(octx));
2748 /* split the commandline into an internal representation */
2749 ret = split_commandline(&octx, argc, argv, options, groups,
2750 FF_ARRAY_ELEMS(groups));
2752 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2756 /* apply global options */
2757 ret = parse_optgroup(NULL, &octx.global_opts);
2759 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2763 /* open input files */
2764 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2766 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2770 /* open output files */
2771 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2773 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2778 uninit_parse_context(&octx);
2780 av_strerror(ret, error, sizeof(error));
2781 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2786 static int opt_progress(void *optctx, const char *opt, const char *arg)
2788 AVIOContext *avio = NULL;
2791 if (!strcmp(arg, "-"))
2793 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2795 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2796 arg, av_err2str(ret));
2799 progress_avio = avio;
2803 #define OFFSET(x) offsetof(OptionsContext, x)
2804 const OptionDef options[] = {
2806 #include "cmdutils_common_opts.h"
2807 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2808 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2809 "force format", "fmt" },
2810 { "y", OPT_BOOL, { &file_overwrite },
2811 "overwrite output files" },
2812 { "n", OPT_BOOL, { &no_file_overwrite },
2813 "never overwrite output files" },
2814 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2815 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2816 "codec name", "codec" },
2817 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2818 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2819 "codec name", "codec" },
2820 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2821 OPT_OUTPUT, { .off = OFFSET(presets) },
2822 "preset name", "preset" },
2823 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2824 OPT_OUTPUT, { .func_arg = opt_map },
2825 "set input stream mapping",
2826 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2827 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2828 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2829 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2830 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2831 "set metadata information of outfile from infile",
2832 "outfile[,metadata]:infile[,metadata]" },
2833 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2834 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2835 "set chapters mapping", "input_file_index" },
2836 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2837 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2838 "record or transcode \"duration\" seconds of audio/video",
2840 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2841 "record or transcode stop time", "time_stop" },
2842 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2843 "set the limit file size in bytes", "limit_size" },
2844 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2845 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2846 "set the start time offset", "time_off" },
2847 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2848 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2849 "enable/disable accurate seeking with -ss" },
2850 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2851 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2852 "set the input ts offset", "time_off" },
2853 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2854 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2855 "set the input ts scale", "scale" },
2856 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2857 "set the recording timestamp ('now' to set the current time)", "time" },
2858 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2859 "add metadata", "string=string" },
2860 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2861 OPT_OUTPUT, { .func_arg = opt_data_frames },
2862 "set the number of data frames to output", "number" },
2863 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2864 "add timings for benchmarking" },
2865 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2866 "add timings for each task" },
2867 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2868 "write program-readable progress information", "url" },
2869 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2870 "enable or disable interaction on standard input" },
2871 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2872 "set max runtime in seconds", "limit" },
2873 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2874 "dump each input packet" },
2875 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2876 "when dumping packets, also dump the payload" },
2877 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2878 OPT_INPUT, { .off = OFFSET(rate_emu) },
2879 "read input at native frame rate", "" },
2880 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2881 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2882 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2883 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2884 "video sync method", "" },
2885 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2886 "frame drop threshold", "" },
2887 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2888 "audio sync method", "" },
2889 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2890 "audio drift threshold", "threshold" },
2891 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2892 "copy timestamps" },
2893 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2894 "shift input timestamps to start at 0 when using copyts" },
2895 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2896 "copy input stream time base when stream copying", "mode" },
2897 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2898 OPT_OUTPUT, { .off = OFFSET(shortest) },
2899 "finish encoding within shortest input" },
2900 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2901 OPT_OUTPUT, { .off = OFFSET(apad) },
2903 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2904 "timestamp discontinuity delta threshold", "threshold" },
2905 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2906 "timestamp error delta threshold", "threshold" },
2907 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2908 "exit on error", "error" },
2909 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2910 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2911 "copy initial non-keyframes" },
2912 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2913 "copy or discard frames before start time" },
2914 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2915 "set the number of frames to output", "number" },
2916 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2917 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2918 "force codec tag/fourcc", "fourcc/tag" },
2919 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2920 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2921 "use fixed quality scale (VBR)", "q" },
2922 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2923 OPT_OUTPUT, { .func_arg = opt_qscale },
2924 "use fixed quality scale (VBR)", "q" },
2925 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2926 "set profile", "profile" },
2927 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2928 "set stream filtergraph", "filter_graph" },
2929 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2930 "read stream filtergraph description from a file", "filename" },
2931 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2932 "reinit filtergraph on input parameter changes", "" },
2933 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2934 "create a complex filtergraph", "graph_description" },
2935 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2936 "create a complex filtergraph", "graph_description" },
2937 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2938 "read complex filtergraph description from a file", "filename" },
2939 { "stats", OPT_BOOL, { &print_stats },
2940 "print progress report during encoding", },
2941 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2942 OPT_OUTPUT, { .func_arg = opt_attach },
2943 "add an attachment to the output file", "filename" },
2944 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2945 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2946 "extract an attachment into a file", "filename" },
2947 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2948 "print timestamp debugging info" },
2949 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2950 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2951 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2952 OPT_INPUT, { .off = OFFSET(discard) },
2954 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
2955 OPT_OUTPUT, { .off = OFFSET(disposition) },
2956 "disposition", "" },
2959 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2960 "set the number of video frames to output", "number" },
2961 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2962 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2963 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2964 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2965 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2966 "set frame size (WxH or abbreviation)", "size" },
2967 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2968 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2969 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2970 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2971 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2972 "set pixel format", "format" },
2973 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2974 "set the number of bits per raw sample", "number" },
2975 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2976 "deprecated use -g 1" },
2977 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2979 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2980 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2981 "rate control override for specific intervals", "override" },
2982 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2983 OPT_OUTPUT, { .func_arg = opt_video_codec },
2984 "force video codec ('copy' to copy stream)", "codec" },
2985 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2987 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2989 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2990 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2991 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2992 "select the pass number (1 to 3)", "n" },
2993 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2994 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2995 "select two pass log file name prefix", "prefix" },
2996 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2997 "this option is deprecated, use the yadif filter instead" },
2998 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2999 "calculate PSNR of compressed frames" },
3000 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3001 "dump video coding statistics to file" },
3002 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3003 "dump video coding statistics to file", "file" },
3004 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3005 "set video filters", "filter_graph" },
3006 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3007 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3008 "specify intra matrix coeffs", "matrix" },
3009 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3010 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3011 "specify inter matrix coeffs", "matrix" },
3012 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3013 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3014 "specify intra matrix coeffs", "matrix" },
3015 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3016 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3017 "top=1/bottom=0/auto=-1 field first", "" },
3018 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3019 OPT_OUTPUT, { .func_arg = opt_old2new },
3020 "force video tag/fourcc", "fourcc/tag" },
3021 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3022 "show QP histogram" },
3023 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3024 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3025 "force the selected framerate, disable the best supported framerate selection" },
3026 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3027 OPT_OUTPUT, { .func_arg = opt_streamid },
3028 "set the value of an outfile streamid", "streamIndex:value" },
3029 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3030 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3031 "force key frames at specified timestamps", "timestamps" },
3032 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3033 "audio bitrate (please use -b:a)", "bitrate" },
3034 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3035 "video bitrate (please use -b:v)", "bitrate" },
3036 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3037 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3038 "use HW accelerated decoding", "hwaccel name" },
3039 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3040 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3041 "select a device for HW acceleration" "devicename" },
3043 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3047 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3048 "set the number of audio frames to output", "number" },
3049 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3050 "set audio quality (codec-specific)", "quality", },
3051 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3052 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3053 "set audio sampling rate (in Hz)", "rate" },
3054 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3055 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3056 "set number of audio channels", "channels" },
3057 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3059 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3060 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3061 "force audio codec ('copy' to copy stream)", "codec" },
3062 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3063 OPT_OUTPUT, { .func_arg = opt_old2new },
3064 "force audio tag/fourcc", "fourcc/tag" },
3065 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3066 "change audio volume (256=normal)" , "volume" },
3067 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3068 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3069 "set sample format", "format" },
3070 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3071 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3072 "set channel layout", "layout" },
3073 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3074 "set audio filters", "filter_graph" },
3075 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3076 "set the maximum number of channels to try to guess the channel layout" },
3078 /* subtitle options */
3079 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3080 "disable subtitle" },
3081 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3082 "force subtitle codec ('copy' to copy stream)", "codec" },
3083 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3084 , "force subtitle tag/fourcc", "fourcc/tag" },
3085 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3086 "fix subtitles duration" },
3087 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3088 "set canvas size (WxH or abbreviation)", "size" },
3091 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3092 "deprecated, use -channel", "channel" },
3093 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3094 "deprecated, use -standard", "standard" },
3095 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3098 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3099 "set the maximum demux-decode delay", "seconds" },
3100 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3101 "set the initial demux-decode delay", "seconds" },
3102 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3103 "override the options from ffserver", "" },
3104 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3105 "specify a file in which to print sdp information", "file" },
3107 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3108 "A comma-separated list of bitstream filters", "bitstream_filters" },
3109 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3110 "deprecated", "audio bitstream_filters" },
3111 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3112 "deprecated", "video bitstream_filters" },
3114 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3115 "set the audio options to the indicated preset", "preset" },
3116 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3117 "set the video options to the indicated preset", "preset" },
3118 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3119 "set the subtitle options to the indicated preset", "preset" },
3120 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3121 "set options from indicated preset file", "filename" },
3122 /* data codec support */
3123 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3124 "force data codec ('copy' to copy stream)", "codec" },
3125 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },