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 /* do something with data? */
1940 for (i = 0; i < o->nb_stream_maps; i++) {
1941 StreamMap *map = &o->stream_maps[i];
1946 if (map->linklabel) {
1948 OutputFilter *ofilter = NULL;
1951 for (j = 0; j < nb_filtergraphs; j++) {
1952 fg = filtergraphs[j];
1953 for (k = 0; k < fg->nb_outputs; k++) {
1954 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1955 if (out && !strcmp(out->name, map->linklabel)) {
1956 ofilter = fg->outputs[k];
1963 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1964 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1967 init_output_filter(ofilter, o, oc);
1969 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1971 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1972 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1974 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1976 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1978 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1981 switch (ist->st->codec->codec_type) {
1982 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1983 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1984 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1985 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1986 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1988 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1989 map->file_index, map->stream_index);
1996 /* handle attached files */
1997 for (i = 0; i < o->nb_attachments; i++) {
1999 uint8_t *attachment;
2003 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2004 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2008 if ((len = avio_size(pb)) <= 0) {
2009 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2013 if (!(attachment = av_malloc(len))) {
2014 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2018 avio_read(pb, attachment, len);
2020 ost = new_attachment_stream(o, oc, -1);
2021 ost->stream_copy = 0;
2022 ost->attachment_filename = o->attachments[i];
2024 ost->enc_ctx->extradata = attachment;
2025 ost->enc_ctx->extradata_size = len;
2027 p = strrchr(o->attachments[i], '/');
2028 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2032 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2033 AVDictionaryEntry *e;
2034 ost = output_streams[i];
2036 if ((ost->stream_copy || ost->attachment_filename)
2037 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2038 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2039 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2043 /* check if all codec options have been used */
2044 unused_opts = strip_specifiers(o->g->codec_opts);
2045 for (i = of->ost_index; i < nb_output_streams; i++) {
2047 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2048 AV_DICT_IGNORE_SUFFIX)))
2049 av_dict_set(&unused_opts, e->key, NULL, 0);
2053 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2054 const AVClass *class = avcodec_get_class();
2055 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2056 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2057 const AVClass *fclass = avformat_get_class();
2058 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2059 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2060 if (!option || foption)
2064 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2065 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2066 "output file #%d (%s) is not an encoding option.\n", e->key,
2067 option->help ? option->help : "", nb_output_files - 1,
2072 // gop_timecode is injected by generic code but not always used
2073 if (!strcmp(e->key, "gop_timecode"))
2076 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2077 "output file #%d (%s) has not been used for any stream. The most "
2078 "likely reason is either wrong type (e.g. a video option with "
2079 "no video streams) or that it is a private option of some encoder "
2080 "which was not actually used for any stream.\n", e->key,
2081 option->help ? option->help : "", nb_output_files - 1, filename);
2083 av_dict_free(&unused_opts);
2085 /* check filename in case of an image number is expected */
2086 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2087 if (!av_filename_number_test(oc->filename)) {
2088 print_error(oc->filename, AVERROR(EINVAL));
2093 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2094 /* test if it already exists to avoid losing precious files */
2095 assert_file_overwrite(filename);
2098 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2099 &oc->interrupt_callback,
2101 print_error(filename, err);
2104 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2105 assert_file_overwrite(filename);
2107 if (o->mux_preload) {
2108 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2110 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2113 for (i = 0; i < o->nb_metadata_map; i++) {
2115 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2117 if (in_file_index >= nb_input_files) {
2118 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2121 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2122 in_file_index >= 0 ?
2123 input_files[in_file_index]->ctx : NULL, o);
2127 if (o->chapters_input_file >= nb_input_files) {
2128 if (o->chapters_input_file == INT_MAX) {
2129 /* copy chapters from the first input file that has them*/
2130 o->chapters_input_file = -1;
2131 for (i = 0; i < nb_input_files; i++)
2132 if (input_files[i]->ctx->nb_chapters) {
2133 o->chapters_input_file = i;
2137 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2138 o->chapters_input_file);
2142 if (o->chapters_input_file >= 0)
2143 copy_chapters(input_files[o->chapters_input_file], of,
2144 !o->metadata_chapters_manual);
2146 /* copy global metadata by default */
2147 if (!o->metadata_global_manual && nb_input_files){
2148 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2149 AV_DICT_DONT_OVERWRITE);
2150 if(o->recording_time != INT64_MAX)
2151 av_dict_set(&oc->metadata, "duration", NULL, 0);
2152 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2154 if (!o->metadata_streams_manual)
2155 for (i = of->ost_index; i < nb_output_streams; i++) {
2157 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2159 ist = input_streams[output_streams[i]->source_index];
2160 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2161 if (!output_streams[i]->stream_copy)
2162 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2165 /* process manually set metadata */
2166 for (i = 0; i < o->nb_metadata; i++) {
2169 const char *stream_spec;
2170 int index = 0, j, ret = 0;
2172 val = strchr(o->metadata[i].u.str, '=');
2174 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2175 o->metadata[i].u.str);
2180 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2182 for (j = 0; j < oc->nb_streams; j++) {
2183 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2184 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2195 if (index < 0 || index >= oc->nb_chapters) {
2196 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2199 m = &oc->chapters[index]->metadata;
2202 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2205 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2212 static int opt_target(void *optctx, const char *opt, const char *arg)
2214 OptionsContext *o = optctx;
2215 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2216 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2218 if (!strncmp(arg, "pal-", 4)) {
2221 } else if (!strncmp(arg, "ntsc-", 5)) {
2224 } else if (!strncmp(arg, "film-", 5)) {
2228 /* Try to determine PAL/NTSC by peeking in the input files */
2229 if (nb_input_files) {
2231 for (j = 0; j < nb_input_files; j++) {
2232 for (i = 0; i < input_files[j]->nb_streams; i++) {
2233 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2234 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2237 fr = c->time_base.den * 1000 / c->time_base.num;
2241 } else if ((fr == 29970) || (fr == 23976)) {
2246 if (norm != UNKNOWN)
2250 if (norm != UNKNOWN)
2251 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2254 if (norm == UNKNOWN) {
2255 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2256 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2257 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2261 if (!strcmp(arg, "vcd")) {
2262 opt_video_codec(o, "c:v", "mpeg1video");
2263 opt_audio_codec(o, "c:a", "mp2");
2264 parse_option(o, "f", "vcd", options);
2266 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2267 parse_option(o, "r", frame_rates[norm], options);
2268 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2270 opt_default(NULL, "b:v", "1150000");
2271 opt_default(NULL, "maxrate", "1150000");
2272 opt_default(NULL, "minrate", "1150000");
2273 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2275 opt_default(NULL, "b:a", "224000");
2276 parse_option(o, "ar", "44100", options);
2277 parse_option(o, "ac", "2", options);
2279 opt_default(NULL, "packetsize", "2324");
2280 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2282 /* We have to offset the PTS, so that it is consistent with the SCR.
2283 SCR starts at 36000, but the first two packs contain only padding
2284 and the first pack from the other stream, respectively, may also have
2285 been written before.
2286 So the real data starts at SCR 36000+3*1200. */
2287 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2288 } else if (!strcmp(arg, "svcd")) {
2290 opt_video_codec(o, "c:v", "mpeg2video");
2291 opt_audio_codec(o, "c:a", "mp2");
2292 parse_option(o, "f", "svcd", options);
2294 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2295 parse_option(o, "r", frame_rates[norm], options);
2296 parse_option(o, "pix_fmt", "yuv420p", options);
2297 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2299 opt_default(NULL, "b:v", "2040000");
2300 opt_default(NULL, "maxrate", "2516000");
2301 opt_default(NULL, "minrate", "0"); // 1145000;
2302 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2303 opt_default(NULL, "scan_offset", "1");
2305 opt_default(NULL, "b:a", "224000");
2306 parse_option(o, "ar", "44100", options);
2308 opt_default(NULL, "packetsize", "2324");
2310 } else if (!strcmp(arg, "dvd")) {
2312 opt_video_codec(o, "c:v", "mpeg2video");
2313 opt_audio_codec(o, "c:a", "ac3");
2314 parse_option(o, "f", "dvd", options);
2316 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2317 parse_option(o, "r", frame_rates[norm], options);
2318 parse_option(o, "pix_fmt", "yuv420p", options);
2319 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2321 opt_default(NULL, "b:v", "6000000");
2322 opt_default(NULL, "maxrate", "9000000");
2323 opt_default(NULL, "minrate", "0"); // 1500000;
2324 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2326 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2327 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2329 opt_default(NULL, "b:a", "448000");
2330 parse_option(o, "ar", "48000", options);
2332 } else if (!strncmp(arg, "dv", 2)) {
2334 parse_option(o, "f", "dv", options);
2336 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2337 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2338 norm == PAL ? "yuv420p" : "yuv411p", options);
2339 parse_option(o, "r", frame_rates[norm], options);
2341 parse_option(o, "ar", "48000", options);
2342 parse_option(o, "ac", "2", options);
2345 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2346 return AVERROR(EINVAL);
2349 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2350 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2355 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2357 av_free (vstats_filename);
2358 vstats_filename = av_strdup (arg);
2362 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2365 time_t today2 = time(NULL);
2366 struct tm *today = localtime(&today2);
2368 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2370 return opt_vstats_file(NULL, opt, filename);
2373 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2375 OptionsContext *o = optctx;
2376 return parse_option(o, "frames:v", arg, options);
2379 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2381 OptionsContext *o = optctx;
2382 return parse_option(o, "frames:a", arg, options);
2385 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2387 OptionsContext *o = optctx;
2388 return parse_option(o, "frames:d", arg, options);
2391 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2394 AVDictionary *cbak = codec_opts;
2395 AVDictionary *fbak = format_opts;
2399 ret = opt_default(NULL, opt, arg);
2401 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2402 av_dict_copy(&o->g->format_opts, format_opts, 0);
2403 av_dict_free(&codec_opts);
2404 av_dict_free(&format_opts);
2411 static int opt_preset(void *optctx, const char *opt, const char *arg)
2413 OptionsContext *o = optctx;
2415 char filename[1000], line[1000], tmp_line[1000];
2416 const char *codec_name = NULL;
2420 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2422 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2423 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2424 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2426 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2430 while (fgets(line, sizeof(line), f)) {
2431 char *key = tmp_line, *value, *endptr;
2433 if (strcspn(line, "#\n\r") == 0)
2435 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2436 if (!av_strtok(key, "=", &value) ||
2437 !av_strtok(value, "\r\n", &endptr)) {
2438 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2441 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2443 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2444 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2445 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2446 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2447 else if (opt_default_new(o, key, value) < 0) {
2448 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2449 filename, line, key, value);
2459 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2461 OptionsContext *o = optctx;
2462 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2463 int ret = parse_option(o, s, arg, options);
2468 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2470 OptionsContext *o = optctx;
2472 if(!strcmp(opt, "ab")){
2473 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2475 } else if(!strcmp(opt, "b")){
2476 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2477 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2480 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2484 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2486 OptionsContext *o = optctx;
2489 if(!strcmp(opt, "qscale")){
2490 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2491 return parse_option(o, "q:v", arg, options);
2493 s = av_asprintf("q%s", opt + 6);
2494 ret = parse_option(o, s, arg, options);
2499 static int opt_profile(void *optctx, const char *opt, const char *arg)
2501 OptionsContext *o = optctx;
2502 if(!strcmp(opt, "profile")){
2503 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2504 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2507 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2511 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2513 OptionsContext *o = optctx;
2514 return parse_option(o, "filter:v", arg, options);
2517 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2519 OptionsContext *o = optctx;
2520 return parse_option(o, "filter:a", arg, options);
2523 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2525 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2526 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2527 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2528 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2530 if (video_sync_method == VSYNC_AUTO)
2531 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2535 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2537 OptionsContext *o = optctx;
2538 char *tcr = av_asprintf("timecode=%s", arg);
2539 int ret = parse_option(o, "metadata:g", tcr, options);
2541 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2546 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2548 OptionsContext *o = optctx;
2549 char layout_str[32];
2552 int ret, channels, ac_str_size;
2555 layout = av_get_channel_layout(arg);
2557 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2558 return AVERROR(EINVAL);
2560 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2561 ret = opt_default_new(o, opt, layout_str);
2565 /* set 'ac' option based on channel layout */
2566 channels = av_get_channel_layout_nb_channels(layout);
2567 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2568 stream_str = strchr(opt, ':');
2569 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2570 ac_str = av_mallocz(ac_str_size);
2572 return AVERROR(ENOMEM);
2573 av_strlcpy(ac_str, "ac", 3);
2575 av_strlcat(ac_str, stream_str, ac_str_size);
2576 ret = parse_option(o, ac_str, layout_str, options);
2582 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2584 OptionsContext *o = optctx;
2585 return parse_option(o, "q:a", arg, options);
2588 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2590 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2591 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2592 return AVERROR(ENOMEM);
2593 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2594 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2595 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2596 return AVERROR(ENOMEM);
2600 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2602 uint8_t *graph_desc = read_file(arg);
2604 return AVERROR(EINVAL);
2606 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2607 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2608 return AVERROR(ENOMEM);
2609 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2610 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2614 void show_help_default(const char *opt, const char *arg)
2616 /* per-file options have at least one of those set */
2617 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2618 int show_advanced = 0, show_avoptions = 0;
2621 if (!strcmp(opt, "long"))
2623 else if (!strcmp(opt, "full"))
2624 show_advanced = show_avoptions = 1;
2626 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2631 printf("Getting help:\n"
2632 " -h -- print basic options\n"
2633 " -h long -- print more options\n"
2634 " -h full -- print all options (including all format and codec specific options, very long)\n"
2635 " See man %s for detailed description of the options.\n"
2636 "\n", program_name);
2638 show_help_options(options, "Print help / information / capabilities:",
2641 show_help_options(options, "Global options (affect whole program "
2642 "instead of just one file:",
2643 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2645 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2646 per_file | OPT_EXIT, 0);
2648 show_help_options(options, "Per-file main options:", 0,
2649 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2650 OPT_EXIT, per_file);
2652 show_help_options(options, "Advanced per-file options:",
2653 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2655 show_help_options(options, "Video options:",
2656 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2658 show_help_options(options, "Advanced Video options:",
2659 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2661 show_help_options(options, "Audio options:",
2662 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2664 show_help_options(options, "Advanced Audio options:",
2665 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2666 show_help_options(options, "Subtitle options:",
2667 OPT_SUBTITLE, 0, 0);
2670 if (show_avoptions) {
2671 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2672 show_help_children(avcodec_get_class(), flags);
2673 show_help_children(avformat_get_class(), flags);
2675 show_help_children(sws_get_class(), flags);
2677 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2678 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2682 void show_usage(void)
2684 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2685 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2686 av_log(NULL, AV_LOG_INFO, "\n");
2694 static const OptionGroupDef groups[] = {
2695 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2696 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2699 static int open_files(OptionGroupList *l, const char *inout,
2700 int (*open_file)(OptionsContext*, const char*))
2704 for (i = 0; i < l->nb_groups; i++) {
2705 OptionGroup *g = &l->groups[i];
2711 ret = parse_optgroup(&o, g);
2713 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2714 "%s.\n", inout, g->arg);
2718 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2719 ret = open_file(&o, g->arg);
2722 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2726 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2732 int ffmpeg_parse_options(int argc, char **argv)
2734 OptionParseContext octx;
2738 memset(&octx, 0, sizeof(octx));
2740 /* split the commandline into an internal representation */
2741 ret = split_commandline(&octx, argc, argv, options, groups,
2742 FF_ARRAY_ELEMS(groups));
2744 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2748 /* apply global options */
2749 ret = parse_optgroup(NULL, &octx.global_opts);
2751 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2755 /* open input files */
2756 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2758 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2762 /* open output files */
2763 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2765 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2770 uninit_parse_context(&octx);
2772 av_strerror(ret, error, sizeof(error));
2773 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2778 static int opt_progress(void *optctx, const char *opt, const char *arg)
2780 AVIOContext *avio = NULL;
2783 if (!strcmp(arg, "-"))
2785 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2787 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2788 arg, av_err2str(ret));
2791 progress_avio = avio;
2795 #define OFFSET(x) offsetof(OptionsContext, x)
2796 const OptionDef options[] = {
2798 #include "cmdutils_common_opts.h"
2799 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2800 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2801 "force format", "fmt" },
2802 { "y", OPT_BOOL, { &file_overwrite },
2803 "overwrite output files" },
2804 { "n", OPT_BOOL, { &no_file_overwrite },
2805 "never overwrite output files" },
2806 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2807 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2808 "codec name", "codec" },
2809 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2810 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2811 "codec name", "codec" },
2812 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2813 OPT_OUTPUT, { .off = OFFSET(presets) },
2814 "preset name", "preset" },
2815 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2816 OPT_OUTPUT, { .func_arg = opt_map },
2817 "set input stream mapping",
2818 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2819 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2820 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2821 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2822 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2823 "set metadata information of outfile from infile",
2824 "outfile[,metadata]:infile[,metadata]" },
2825 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2826 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2827 "set chapters mapping", "input_file_index" },
2828 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2829 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2830 "record or transcode \"duration\" seconds of audio/video",
2832 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2833 "record or transcode stop time", "time_stop" },
2834 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2835 "set the limit file size in bytes", "limit_size" },
2836 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2837 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2838 "set the start time offset", "time_off" },
2839 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2840 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2841 "enable/disable accurate seeking with -ss" },
2842 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2843 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2844 "set the input ts offset", "time_off" },
2845 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2846 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2847 "set the input ts scale", "scale" },
2848 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2849 "set the recording timestamp ('now' to set the current time)", "time" },
2850 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2851 "add metadata", "string=string" },
2852 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2853 OPT_OUTPUT, { .func_arg = opt_data_frames },
2854 "set the number of data frames to output", "number" },
2855 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2856 "add timings for benchmarking" },
2857 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2858 "add timings for each task" },
2859 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2860 "write program-readable progress information", "url" },
2861 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2862 "enable or disable interaction on standard input" },
2863 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2864 "set max runtime in seconds", "limit" },
2865 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2866 "dump each input packet" },
2867 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2868 "when dumping packets, also dump the payload" },
2869 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2870 OPT_INPUT, { .off = OFFSET(rate_emu) },
2871 "read input at native frame rate", "" },
2872 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2873 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2874 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2875 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2876 "video sync method", "" },
2877 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2878 "frame drop threshold", "" },
2879 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2880 "audio sync method", "" },
2881 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2882 "audio drift threshold", "threshold" },
2883 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2884 "copy timestamps" },
2885 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2886 "shift input timestamps to start at 0 when using copyts" },
2887 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2888 "copy input stream time base when stream copying", "mode" },
2889 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2890 OPT_OUTPUT, { .off = OFFSET(shortest) },
2891 "finish encoding within shortest input" },
2892 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2893 OPT_OUTPUT, { .off = OFFSET(apad) },
2895 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2896 "timestamp discontinuity delta threshold", "threshold" },
2897 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2898 "timestamp error delta threshold", "threshold" },
2899 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2900 "exit on error", "error" },
2901 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2902 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2903 "copy initial non-keyframes" },
2904 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2905 "copy or discard frames before start time" },
2906 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2907 "set the number of frames to output", "number" },
2908 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2909 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2910 "force codec tag/fourcc", "fourcc/tag" },
2911 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2912 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2913 "use fixed quality scale (VBR)", "q" },
2914 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2915 OPT_OUTPUT, { .func_arg = opt_qscale },
2916 "use fixed quality scale (VBR)", "q" },
2917 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2918 "set profile", "profile" },
2919 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2920 "set stream filtergraph", "filter_graph" },
2921 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2922 "read stream filtergraph description from a file", "filename" },
2923 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2924 "reinit filtergraph on input parameter changes", "" },
2925 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2926 "create a complex filtergraph", "graph_description" },
2927 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2928 "create a complex filtergraph", "graph_description" },
2929 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2930 "read complex filtergraph description from a file", "filename" },
2931 { "stats", OPT_BOOL, { &print_stats },
2932 "print progress report during encoding", },
2933 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2934 OPT_OUTPUT, { .func_arg = opt_attach },
2935 "add an attachment to the output file", "filename" },
2936 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2937 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2938 "extract an attachment into a file", "filename" },
2939 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2940 "print timestamp debugging info" },
2941 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2942 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2943 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2944 OPT_INPUT, { .off = OFFSET(discard) },
2946 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
2947 OPT_OUTPUT, { .off = OFFSET(disposition) },
2948 "disposition", "" },
2951 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2952 "set the number of video frames to output", "number" },
2953 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2954 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2955 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2956 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2957 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2958 "set frame size (WxH or abbreviation)", "size" },
2959 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2960 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2961 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2962 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2963 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2964 "set pixel format", "format" },
2965 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2966 "set the number of bits per raw sample", "number" },
2967 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2968 "deprecated use -g 1" },
2969 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2971 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2972 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2973 "rate control override for specific intervals", "override" },
2974 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2975 OPT_OUTPUT, { .func_arg = opt_video_codec },
2976 "force video codec ('copy' to copy stream)", "codec" },
2977 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2979 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2981 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2982 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2983 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2984 "select the pass number (1 to 3)", "n" },
2985 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2986 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2987 "select two pass log file name prefix", "prefix" },
2988 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2989 "this option is deprecated, use the yadif filter instead" },
2990 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2991 "calculate PSNR of compressed frames" },
2992 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2993 "dump video coding statistics to file" },
2994 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2995 "dump video coding statistics to file", "file" },
2996 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2997 "set video filters", "filter_graph" },
2998 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2999 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3000 "specify intra matrix coeffs", "matrix" },
3001 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3002 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3003 "specify inter matrix coeffs", "matrix" },
3004 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3005 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3006 "specify intra matrix coeffs", "matrix" },
3007 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3008 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3009 "top=1/bottom=0/auto=-1 field first", "" },
3010 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3011 OPT_OUTPUT, { .func_arg = opt_old2new },
3012 "force video tag/fourcc", "fourcc/tag" },
3013 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3014 "show QP histogram" },
3015 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3016 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3017 "force the selected framerate, disable the best supported framerate selection" },
3018 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3019 OPT_OUTPUT, { .func_arg = opt_streamid },
3020 "set the value of an outfile streamid", "streamIndex:value" },
3021 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3022 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3023 "force key frames at specified timestamps", "timestamps" },
3024 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3025 "audio bitrate (please use -b:a)", "bitrate" },
3026 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3027 "video bitrate (please use -b:v)", "bitrate" },
3028 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3029 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3030 "use HW accelerated decoding", "hwaccel name" },
3031 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3032 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3033 "select a device for HW acceleration" "devicename" },
3035 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3039 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3040 "set the number of audio frames to output", "number" },
3041 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3042 "set audio quality (codec-specific)", "quality", },
3043 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3044 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3045 "set audio sampling rate (in Hz)", "rate" },
3046 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3047 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3048 "set number of audio channels", "channels" },
3049 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3051 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3052 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3053 "force audio codec ('copy' to copy stream)", "codec" },
3054 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3055 OPT_OUTPUT, { .func_arg = opt_old2new },
3056 "force audio tag/fourcc", "fourcc/tag" },
3057 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3058 "change audio volume (256=normal)" , "volume" },
3059 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3060 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3061 "set sample format", "format" },
3062 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3063 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3064 "set channel layout", "layout" },
3065 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3066 "set audio filters", "filter_graph" },
3067 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3068 "set the maximum number of channels to try to guess the channel layout" },
3070 /* subtitle options */
3071 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3072 "disable subtitle" },
3073 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3074 "force subtitle codec ('copy' to copy stream)", "codec" },
3075 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3076 , "force subtitle tag/fourcc", "fourcc/tag" },
3077 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3078 "fix subtitles duration" },
3079 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3080 "set canvas size (WxH or abbreviation)", "size" },
3083 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3084 "deprecated, use -channel", "channel" },
3085 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3086 "deprecated, use -standard", "standard" },
3087 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3090 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3091 "set the maximum demux-decode delay", "seconds" },
3092 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3093 "set the initial demux-decode delay", "seconds" },
3094 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3095 "override the options from ffserver", "" },
3096 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3097 "specify a file in which to print sdp information", "file" },
3099 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3100 "A comma-separated list of bitstream filters", "bitstream_filters" },
3101 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3102 "deprecated", "audio bitstream_filters" },
3103 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3104 "deprecated", "video bitstream_filters" },
3106 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3107 "set the audio options to the indicated preset", "preset" },
3108 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3109 "set the video options to the indicated preset", "preset" },
3110 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3111 "set the subtitle options to the indicated preset", "preset" },
3112 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3113 "set options from indicated preset file", "filename" },
3114 /* data codec support */
3115 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3116 "force data codec ('copy' to copy stream)", "codec" },
3117 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },