2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 for (i = 0; i < o->nb_ ## name; i++) {\
61 char *spec = o->name[i].specifier;\
62 if (!strcmp(spec, mediatype))\
63 outvar = o->name[i].u.type;\
66 char *vstats_filename;
68 float audio_drift_threshold = 0.1;
69 float dts_delta_threshold = 10;
70 float dts_error_threshold = 3600*30;
72 int audio_volume = 256;
73 int audio_sync_method = 0;
74 int video_sync_method = VSYNC_AUTO;
75 int do_deinterlace = 0;
77 int do_benchmark_all = 0;
83 int exit_on_error = 0;
86 int stdin_interaction = 1;
87 int frame_bits_per_raw_sample = 0;
90 static int intra_only = 0;
91 static int file_overwrite = 0;
92 static int no_file_overwrite = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int do_psnr = 0;
96 static int input_sync;
98 void reset_options(OptionsContext *o, int is_input)
100 const OptionDef *po = options;
101 OptionsContext bak= *o;
104 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
106 void *dst = (uint8_t*)o + po->u.off;
108 if (po->flags & OPT_SPEC) {
109 SpecifierOpt **so = dst;
110 int i, *count = (int*)(so + 1);
111 for (i = 0; i < *count; i++) {
112 av_freep(&(*so)[i].specifier);
113 if (po->flags & OPT_STRING)
114 av_freep(&(*so)[i].u.str);
118 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
123 for (i = 0; i < o->nb_stream_maps; i++)
124 av_freep(&o->stream_maps[i].linklabel);
125 av_freep(&o->stream_maps);
126 av_freep(&o->audio_channel_maps);
127 av_freep(&o->streamid_map);
129 memset(o, 0, sizeof(*o));
132 o->recording_time = bak.recording_time;
133 if (o->recording_time != INT64_MAX)
134 av_log(NULL, AV_LOG_WARNING,
135 "-t is not an input option, keeping it for the next output;"
136 " consider fixing your command line.\n");
138 o->recording_time = INT64_MAX;
139 o->mux_max_delay = 0.7;
140 o->limit_filesize = UINT64_MAX;
141 o->chapters_input_file = INT_MAX;
148 static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
150 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
151 return AVERROR(EINVAL);
154 static int opt_pad(void *optctx, const char *opt, const char *arg)
156 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
160 static int opt_sameq(void *optctx, const char *opt, const char *arg)
162 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
163 "If you are looking for an option to preserve the quality (which is not "
164 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
166 return AVERROR(EINVAL);
169 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
171 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
172 return opt_default(optctx, "channel", arg);
175 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
177 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
178 return opt_default(optctx, "standard", arg);
181 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
183 OptionsContext *o = optctx;
184 return parse_option(o, "codec:a", arg, options);
187 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
189 OptionsContext *o = optctx;
190 return parse_option(o, "codec:v", arg, options);
193 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
195 OptionsContext *o = optctx;
196 return parse_option(o, "codec:s", arg, options);
199 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
201 OptionsContext *o = optctx;
202 return parse_option(o, "codec:d", arg, options);
205 static int opt_map(void *optctx, const char *opt, const char *arg)
207 OptionsContext *o = optctx;
209 int i, negative = 0, file_idx;
210 int sync_file_idx = -1, sync_stream_idx = 0;
218 map = av_strdup(arg);
220 /* parse sync stream first, just pick first matching stream */
221 if (sync = strchr(map, ',')) {
223 sync_file_idx = strtol(sync + 1, &sync, 0);
224 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
225 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
230 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
231 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
232 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
236 if (i == input_files[sync_file_idx]->nb_streams) {
237 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
238 "match any streams.\n", arg);
245 /* this mapping refers to lavfi output */
246 const char *c = map + 1;
247 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
248 &o->nb_stream_maps, o->nb_stream_maps + 1);
249 m = &o->stream_maps[o->nb_stream_maps - 1];
250 m->linklabel = av_get_token(&c, "]");
252 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
256 file_idx = strtol(map, &p, 0);
257 if (file_idx >= nb_input_files || file_idx < 0) {
258 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
262 /* disable some already defined maps */
263 for (i = 0; i < o->nb_stream_maps; i++) {
264 m = &o->stream_maps[i];
265 if (file_idx == m->file_index &&
266 check_stream_specifier(input_files[m->file_index]->ctx,
267 input_files[m->file_index]->ctx->streams[m->stream_index],
268 *p == ':' ? p + 1 : p) > 0)
272 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
273 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
274 *p == ':' ? p + 1 : p) <= 0)
276 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
277 &o->nb_stream_maps, o->nb_stream_maps + 1);
278 m = &o->stream_maps[o->nb_stream_maps - 1];
280 m->file_index = file_idx;
283 if (sync_file_idx >= 0) {
284 m->sync_file_index = sync_file_idx;
285 m->sync_stream_index = sync_stream_idx;
287 m->sync_file_index = file_idx;
288 m->sync_stream_index = i;
294 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
302 static int opt_attach(void *optctx, const char *opt, const char *arg)
304 OptionsContext *o = optctx;
305 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
306 &o->nb_attachments, o->nb_attachments + 1);
307 o->attachments[o->nb_attachments - 1] = arg;
311 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
313 OptionsContext *o = optctx;
318 o->audio_channel_maps =
319 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
320 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
321 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
323 /* muted channel syntax */
324 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
325 if ((n == 1 || n == 3) && m->channel_idx == -1) {
326 m->file_idx = m->stream_idx = -1;
328 m->ofile_idx = m->ostream_idx = -1;
333 n = sscanf(arg, "%d.%d.%d:%d.%d",
334 &m->file_idx, &m->stream_idx, &m->channel_idx,
335 &m->ofile_idx, &m->ostream_idx);
337 if (n != 3 && n != 5) {
338 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
339 "[file.stream.channel|-1][:syncfile:syncstream]\n");
343 if (n != 5) // only file.stream.channel specified
344 m->ofile_idx = m->ostream_idx = -1;
347 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
348 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
352 if (m->stream_idx < 0 ||
353 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
354 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
355 m->file_idx, m->stream_idx);
358 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
359 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
360 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
361 m->file_idx, m->stream_idx);
364 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
365 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
366 m->file_idx, m->stream_idx, m->channel_idx);
373 * Parse a metadata specifier passed as 'arg' parameter.
374 * @param arg metadata string to parse
375 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
376 * @param index for type c/p, chapter/program index is written here
377 * @param stream_spec for type s, the stream specifier is written here
379 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
387 if (*(++arg) && *arg != ':') {
388 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
391 *stream_spec = *arg == ':' ? arg + 1 : "";
396 *index = strtol(++arg, NULL, 0);
399 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
406 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
408 AVDictionary **meta_in = NULL;
409 AVDictionary **meta_out = NULL;
411 char type_in, type_out;
412 const char *istream_spec = NULL, *ostream_spec = NULL;
413 int idx_in = 0, idx_out = 0;
415 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
416 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
419 if (type_out == 'g' || !*outspec)
420 o->metadata_global_manual = 1;
421 if (type_out == 's' || !*outspec)
422 o->metadata_streams_manual = 1;
423 if (type_out == 'c' || !*outspec)
424 o->metadata_chapters_manual = 1;
428 if (type_in == 'g' || type_out == 'g')
429 o->metadata_global_manual = 1;
430 if (type_in == 's' || type_out == 's')
431 o->metadata_streams_manual = 1;
432 if (type_in == 'c' || type_out == 'c')
433 o->metadata_chapters_manual = 1;
435 /* ic is NULL when just disabling automatic mappings */
439 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
440 if ((index) < 0 || (index) >= (nb_elems)) {\
441 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
446 #define SET_DICT(type, meta, context, index)\
449 meta = &context->metadata;\
452 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
453 meta = &context->chapters[index]->metadata;\
456 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
457 meta = &context->programs[index]->metadata;\
460 break; /* handled separately below */ \
461 default: av_assert0(0);\
464 SET_DICT(type_in, meta_in, ic, idx_in);
465 SET_DICT(type_out, meta_out, oc, idx_out);
467 /* for input streams choose first matching stream */
468 if (type_in == 's') {
469 for (i = 0; i < ic->nb_streams; i++) {
470 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
471 meta_in = &ic->streams[i]->metadata;
477 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
482 if (type_out == 's') {
483 for (i = 0; i < oc->nb_streams; i++) {
484 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
485 meta_out = &oc->streams[i]->metadata;
486 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
491 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
496 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
498 OptionsContext *o = optctx;
500 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
501 struct tm time = *gmtime((time_t*)&recording_timestamp);
502 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
503 parse_option(o, "metadata", buf, options);
505 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
506 "tag instead.\n", opt);
510 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
512 const AVCodecDescriptor *desc;
513 const char *codec_string = encoder ? "encoder" : "decoder";
517 avcodec_find_encoder_by_name(name) :
518 avcodec_find_decoder_by_name(name);
520 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
521 codec = encoder ? avcodec_find_encoder(desc->id) :
522 avcodec_find_decoder(desc->id);
524 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
525 codec_string, codec->name, desc->name);
529 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
532 if (codec->type != type) {
533 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
539 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
541 char *codec_name = NULL;
543 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
545 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
546 st->codec->codec_id = codec->id;
549 return avcodec_find_decoder(st->codec->codec_id);
552 /* Add all the streams from the given input file to the global
553 * list of input streams. */
554 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
557 char *next, *codec_tag = NULL;
559 for (i = 0; i < ic->nb_streams; i++) {
560 AVStream *st = ic->streams[i];
561 AVCodecContext *dec = st->codec;
562 InputStream *ist = av_mallocz(sizeof(*ist));
563 char *framerate = NULL;
568 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
569 input_streams[nb_input_streams - 1] = ist;
572 ist->file_index = nb_input_files;
574 st->discard = AVDISCARD_ALL;
575 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
578 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
580 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
582 uint32_t tag = strtol(codec_tag, &next, 0);
584 tag = AV_RL32(codec_tag);
585 st->codec->codec_tag = tag;
588 ist->dec = choose_decoder(o, ic, st);
590 ist->reinit_filters = -1;
591 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
593 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
595 switch (dec->codec_type) {
596 case AVMEDIA_TYPE_VIDEO:
598 ist->dec = avcodec_find_decoder(dec->codec_id);
600 dec->flags |= CODEC_FLAG_EMU_EDGE;
603 ist->resample_height = dec->height;
604 ist->resample_width = dec->width;
605 ist->resample_pix_fmt = dec->pix_fmt;
607 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
608 if (framerate && av_parse_video_rate(&ist->framerate,
610 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
615 ist->top_field_first = -1;
616 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
619 case AVMEDIA_TYPE_AUDIO:
620 guess_input_channel_layout(ist);
622 ist->resample_sample_fmt = dec->sample_fmt;
623 ist->resample_sample_rate = dec->sample_rate;
624 ist->resample_channels = dec->channels;
625 ist->resample_channel_layout = dec->channel_layout;
628 case AVMEDIA_TYPE_DATA:
629 case AVMEDIA_TYPE_SUBTITLE:
631 ist->dec = avcodec_find_decoder(dec->codec_id);
632 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
634 case AVMEDIA_TYPE_ATTACHMENT:
635 case AVMEDIA_TYPE_UNKNOWN:
643 static void assert_file_overwrite(const char *filename)
645 if ((!file_overwrite || no_file_overwrite) &&
646 (strchr(filename, ':') == NULL || filename[1] == ':' ||
647 av_strstart(filename, "file:", NULL))) {
648 if (avio_check(filename, 0) == 0) {
649 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
650 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
653 signal(SIGINT, SIG_DFL);
655 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
661 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
668 static void dump_attachment(AVStream *st, const char *filename)
671 AVIOContext *out = NULL;
672 AVDictionaryEntry *e;
674 if (!st->codec->extradata_size) {
675 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
676 nb_input_files - 1, st->index);
679 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
682 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
683 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
687 assert_file_overwrite(filename);
689 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
690 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
695 avio_write(out, st->codec->extradata, st->codec->extradata_size);
700 static int opt_input_file(void *optctx, const char *opt, const char *filename)
702 OptionsContext *o = optctx;
704 AVInputFormat *file_iformat = NULL;
709 int orig_nb_streams; // number of streams before avformat_find_stream_info
710 char * video_codec_name = NULL;
711 char * audio_codec_name = NULL;
712 char *subtitle_codec_name = NULL;
715 if (!(file_iformat = av_find_input_format(o->format))) {
716 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
721 if (!strcmp(filename, "-"))
724 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
725 strcmp(filename, "/dev/stdin");
727 /* get default parameters from command line */
728 ic = avformat_alloc_context();
730 print_error(filename, AVERROR(ENOMEM));
733 if (o->nb_audio_sample_rate) {
734 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
735 av_dict_set(&format_opts, "sample_rate", buf, 0);
737 if (o->nb_audio_channels) {
738 /* because we set audio_channels based on both the "ac" and
739 * "channel_layout" options, we need to check that the specified
740 * demuxer actually has the "channels" option before setting it */
741 if (file_iformat && file_iformat->priv_class &&
742 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
743 AV_OPT_SEARCH_FAKE_OBJ)) {
744 snprintf(buf, sizeof(buf), "%d",
745 o->audio_channels[o->nb_audio_channels - 1].u.i);
746 av_dict_set(&format_opts, "channels", buf, 0);
749 if (o->nb_frame_rates) {
750 /* set the format-level framerate option;
751 * this is important for video grabbers, e.g. x11 */
752 if (file_iformat && file_iformat->priv_class &&
753 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
754 AV_OPT_SEARCH_FAKE_OBJ)) {
755 av_dict_set(&format_opts, "framerate",
756 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
759 if (o->nb_frame_sizes) {
760 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
762 if (o->nb_frame_pix_fmts)
763 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
765 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
766 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
767 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
769 ic->video_codec_id = video_codec_name ?
770 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
771 ic->audio_codec_id = audio_codec_name ?
772 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
773 ic->subtitle_codec_id= subtitle_codec_name ?
774 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
775 ic->flags |= AVFMT_FLAG_NONBLOCK;
776 ic->interrupt_callback = int_cb;
778 /* open the input file with generic avformat function */
779 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
781 print_error(filename, err);
784 assert_avoptions(format_opts);
786 /* apply forced codec ids */
787 for (i = 0; i < ic->nb_streams; i++)
788 choose_decoder(o, ic, ic->streams[i]);
790 /* Set AVCodecContext options for avformat_find_stream_info */
791 opts = setup_find_stream_info_opts(ic, codec_opts);
792 orig_nb_streams = ic->nb_streams;
794 /* If not enough info to get the stream parameters, we decode the
795 first frames to get it. (used in mpeg case for example) */
796 ret = avformat_find_stream_info(ic, opts);
798 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
799 avformat_close_input(&ic);
803 timestamp = o->start_time;
804 /* add the stream start time */
805 if (ic->start_time != AV_NOPTS_VALUE)
806 timestamp += ic->start_time;
808 /* if seeking requested, we execute it */
809 if (o->start_time != 0) {
810 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
812 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
813 filename, (double)timestamp / AV_TIME_BASE);
817 /* update the current parameters so that they match the one of the input stream */
818 add_input_streams(o, ic);
820 /* dump the file content */
821 av_dump_format(ic, nb_input_files, filename, 0);
823 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
824 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
827 input_files[nb_input_files - 1]->ctx = ic;
828 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
829 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
830 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
831 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
833 for (i = 0; i < o->nb_dump_attachment; i++) {
836 for (j = 0; j < ic->nb_streams; j++) {
837 AVStream *st = ic->streams[j];
839 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
840 dump_attachment(st, o->dump_attachment[i].u.str);
844 for (i = 0; i < orig_nb_streams; i++)
845 av_dict_free(&opts[i]);
852 static uint8_t *get_line(AVIOContext *s)
858 if (avio_open_dyn_buf(&line) < 0) {
859 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
863 while ((c = avio_r8(s)) && c != '\n')
866 avio_close_dyn_buf(line, &buf);
871 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
875 const char *base[3] = { getenv("AVCONV_DATADIR"),
880 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
884 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
885 i != 1 ? "" : "/.avconv", codec_name, preset_name);
886 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
889 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
890 i != 1 ? "" : "/.avconv", preset_name);
891 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
897 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
899 char *codec_name = NULL;
901 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
903 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
904 NULL, ost->st->codec->codec_type);
905 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
906 } else if (!strcmp(codec_name, "copy"))
907 ost->stream_copy = 1;
909 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
910 ost->st->codec->codec_id = ost->enc->id;
914 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
917 AVStream *st = avformat_new_stream(oc, NULL);
918 int idx = oc->nb_streams - 1, ret = 0;
919 char *bsf = NULL, *next, *codec_tag = NULL;
920 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
924 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
928 if (oc->nb_streams - 1 < o->nb_streamid_map)
929 st->id = o->streamid_map[oc->nb_streams - 1];
931 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
932 nb_output_streams + 1);
933 if (!(ost = av_mallocz(sizeof(*ost))))
935 output_streams[nb_output_streams - 1] = ost;
937 ost->file_index = nb_output_files;
940 st->codec->codec_type = type;
941 choose_encoder(o, oc, ost);
943 AVIOContext *s = NULL;
944 char *buf = NULL, *arg = NULL, *preset = NULL;
946 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
948 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
949 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
952 if (!buf[0] || buf[0] == '#') {
956 if (!(arg = strchr(buf, '='))) {
957 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
961 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
963 } while (!s->eof_reached);
967 av_log(NULL, AV_LOG_FATAL,
968 "Preset %s specified for stream %d:%d, but could not be opened.\n",
969 preset, ost->file_index, ost->index);
974 avcodec_get_context_defaults3(st->codec, ost->enc);
975 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
977 ost->max_frames = INT64_MAX;
978 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
980 ost->copy_prior_start = -1;
981 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
983 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
985 if (next = strchr(bsf, ','))
987 if (!(bsfc = av_bitstream_filter_init(bsf))) {
988 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
992 bsfc_prev->next = bsfc;
994 ost->bitstream_filters = bsfc;
1000 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1002 uint32_t tag = strtol(codec_tag, &next, 0);
1004 tag = AV_RL32(codec_tag);
1005 st->codec->codec_tag = tag;
1008 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1010 st->codec->flags |= CODEC_FLAG_QSCALE;
1011 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1014 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1015 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1017 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1018 av_opt_get_int (swr_opts, "filter_type" , 0, &ost->swr_filter_type);
1019 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1020 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1022 ost->source_index = source_index;
1023 if (source_index >= 0) {
1024 ost->sync_ist = input_streams[source_index];
1025 input_streams[source_index]->discard = 0;
1026 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1032 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1035 const char *p = str;
1042 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1049 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1053 AVCodecContext *video_enc;
1054 char *frame_rate = NULL;
1056 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1058 video_enc = st->codec;
1060 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1061 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1062 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1066 if (!ost->stream_copy) {
1067 const char *p = NULL;
1068 char *frame_size = NULL;
1069 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1070 char *intra_matrix = NULL, *inter_matrix = NULL;
1071 const char *filters = "null";
1075 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1076 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1077 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1081 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1082 if (frame_aspect_ratio) {
1084 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1085 q.num <= 0 || q.den <= 0) {
1086 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1089 ost->frame_aspect_ratio = av_q2d(q);
1092 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1093 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1094 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1095 ost->keep_pix_fmt = 1;
1096 if (!*++frame_pix_fmt)
1097 frame_pix_fmt = NULL;
1099 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1100 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1103 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1106 video_enc->gop_size = 0;
1107 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1109 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1110 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1113 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1115 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1117 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1118 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1121 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1124 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1125 for (i = 0; p; i++) {
1127 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1129 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1132 /* FIXME realloc failure */
1133 video_enc->rc_override =
1134 av_realloc(video_enc->rc_override,
1135 sizeof(RcOverride) * (i + 1));
1136 video_enc->rc_override[i].start_frame = start;
1137 video_enc->rc_override[i].end_frame = end;
1139 video_enc->rc_override[i].qscale = q;
1140 video_enc->rc_override[i].quality_factor = 1.0;
1143 video_enc->rc_override[i].qscale = 0;
1144 video_enc->rc_override[i].quality_factor = -q/100.0;
1149 video_enc->rc_override_count = i;
1150 if (!video_enc->rc_initial_buffer_occupancy)
1151 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1152 video_enc->intra_dc_precision = intra_dc_precision - 8;
1155 video_enc->flags|= CODEC_FLAG_PSNR;
1158 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1161 video_enc->flags |= CODEC_FLAG_PASS1;
1164 video_enc->flags |= CODEC_FLAG_PASS2;
1168 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1169 if (ost->logfile_prefix &&
1170 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1173 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1174 if (ost->forced_keyframes)
1175 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1177 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1179 ost->top_field_first = -1;
1180 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1182 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1183 ost->avfilter = av_strdup(filters);
1185 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1191 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1196 AVCodecContext *audio_enc;
1198 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1201 audio_enc = st->codec;
1202 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1204 if (!ost->stream_copy) {
1205 char *sample_fmt = NULL;
1206 const char *filters = "anull";
1208 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1210 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1212 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1213 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1217 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1219 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1221 av_assert1(filters);
1222 ost->avfilter = av_strdup(filters);
1224 /* check for channel mapping for this audio stream */
1225 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1226 AudioChannelMap *map = &o->audio_channel_maps[n];
1227 InputStream *ist = input_streams[ost->source_index];
1228 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1229 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1230 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1231 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1232 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1234 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1235 ost->file_index, ost->st->index);
1243 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1247 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1248 if (!ost->stream_copy) {
1249 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1256 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1258 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1259 ost->stream_copy = 1;
1263 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1267 AVCodecContext *subtitle_enc;
1269 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1271 subtitle_enc = st->codec;
1273 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1275 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1277 if (!ost->stream_copy) {
1278 char *frame_size = NULL;
1280 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1281 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1282 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1290 /* arg format is "output-stream-index:streamid-value". */
1291 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1293 OptionsContext *o = optctx;
1298 av_strlcpy(idx_str, arg, sizeof(idx_str));
1299 p = strchr(idx_str, ':');
1301 av_log(NULL, AV_LOG_FATAL,
1302 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1307 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1308 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1309 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1313 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1315 AVFormatContext *is = ifile->ctx;
1316 AVFormatContext *os = ofile->ctx;
1320 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1322 return AVERROR(ENOMEM);
1325 for (i = 0; i < is->nb_chapters; i++) {
1326 AVChapter *in_ch = is->chapters[i], *out_ch;
1327 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1328 AV_TIME_BASE_Q, in_ch->time_base);
1329 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1330 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1333 if (in_ch->end < ts_off)
1335 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1338 out_ch = av_mallocz(sizeof(AVChapter));
1340 return AVERROR(ENOMEM);
1342 out_ch->id = in_ch->id;
1343 out_ch->time_base = in_ch->time_base;
1344 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1345 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1348 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1350 os->chapters[os->nb_chapters++] = out_ch;
1355 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1358 AVFormatContext *ic = avformat_alloc_context();
1360 ic->interrupt_callback = int_cb;
1361 err = avformat_open_input(&ic, filename, NULL, NULL);
1364 /* copy stream format */
1365 for(i=0;i<ic->nb_streams;i++) {
1369 AVCodecContext *avctx;
1371 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1372 ost = new_output_stream(o, s, codec->type, -1);
1377 // FIXME: a more elegant solution is needed
1378 memcpy(st, ic->streams[i], sizeof(AVStream));
1380 st->info = av_malloc(sizeof(*st->info));
1381 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1383 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1385 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1386 choose_sample_fmt(st, codec);
1387 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1388 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1391 /* ffserver seeking with date=... needs a date reference */
1392 err = parse_option(o, "metadata", "creation_time=now", options);
1394 avformat_close_input(&ic);
1398 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1399 AVFormatContext *oc)
1403 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1404 ofilter->out_tmp->pad_idx)) {
1405 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1406 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1408 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1413 ost->source_index = -1;
1414 ost->filter = ofilter;
1418 if (ost->stream_copy) {
1419 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1420 "which is fed from a complex filtergraph. Filtering and streamcopy "
1421 "cannot be used together.\n", ost->file_index, ost->index);
1425 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1426 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1429 avfilter_inout_free(&ofilter->out_tmp);
1432 static int configure_complex_filters(void)
1436 for (i = 0; i < nb_filtergraphs; i++)
1437 if (!filtergraphs[i]->graph &&
1438 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1443 void opt_output_file(void *optctx, const char *filename)
1445 OptionsContext *o = optctx;
1446 AVFormatContext *oc;
1448 AVOutputFormat *file_oformat;
1452 if (configure_complex_filters() < 0) {
1453 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1457 if (!strcmp(filename, "-"))
1460 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1462 print_error(filename, err);
1465 file_oformat= oc->oformat;
1466 oc->interrupt_callback = int_cb;
1468 /* create streams for all unlabeled output pads */
1469 for (i = 0; i < nb_filtergraphs; i++) {
1470 FilterGraph *fg = filtergraphs[i];
1471 for (j = 0; j < fg->nb_outputs; j++) {
1472 OutputFilter *ofilter = fg->outputs[j];
1474 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1477 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1478 ofilter->out_tmp->pad_idx)) {
1479 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1480 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1481 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1483 init_output_filter(ofilter, o, oc);
1487 if (!strcmp(file_oformat->name, "ffm") &&
1488 av_strstart(filename, "http:", NULL)) {
1490 /* special case for files sent to ffserver: we get the stream
1491 parameters from ffserver */
1492 int err = read_ffserver_streams(o, oc, filename);
1494 print_error(filename, err);
1497 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1498 ost = output_streams[j];
1499 for (i = 0; i < nb_input_streams; i++) {
1500 ist = input_streams[i];
1501 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1503 ost->source_index= i;
1504 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1505 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1507 ist->st->discard = AVDISCARD_NONE;
1512 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));
1516 } else if (!o->nb_stream_maps) {
1517 char *subtitle_codec_name = NULL;
1518 /* pick the "best" stream of each type */
1520 /* video: highest resolution */
1521 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1522 int area = 0, idx = -1;
1523 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1524 for (i = 0; i < nb_input_streams; i++) {
1526 ist = input_streams[i];
1527 new_area = ist->st->codec->width * ist->st->codec->height;
1528 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1530 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1532 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1539 new_video_stream(o, oc, idx);
1542 /* audio: most channels */
1543 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1544 int channels = 0, idx = -1;
1545 for (i = 0; i < nb_input_streams; i++) {
1546 ist = input_streams[i];
1547 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1548 ist->st->codec->channels > channels) {
1549 channels = ist->st->codec->channels;
1554 new_audio_stream(o, oc, idx);
1557 /* subtitles: pick first */
1558 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1559 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1560 for (i = 0; i < nb_input_streams; i++)
1561 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1562 new_subtitle_stream(o, oc, i);
1566 /* do something with data? */
1568 for (i = 0; i < o->nb_stream_maps; i++) {
1569 StreamMap *map = &o->stream_maps[i];
1570 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1575 if (map->linklabel) {
1577 OutputFilter *ofilter = NULL;
1580 for (j = 0; j < nb_filtergraphs; j++) {
1581 fg = filtergraphs[j];
1582 for (k = 0; k < fg->nb_outputs; k++) {
1583 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1584 if (out && !strcmp(out->name, map->linklabel)) {
1585 ofilter = fg->outputs[k];
1592 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1593 "in any defined filter graph.\n", map->linklabel);
1596 init_output_filter(ofilter, o, oc);
1598 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1599 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1601 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1603 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1605 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1608 switch (ist->st->codec->codec_type) {
1609 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1610 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1611 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1612 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1613 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1615 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1616 map->file_index, map->stream_index);
1624 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1625 AVDictionaryEntry *e;
1626 ost = output_streams[i];
1628 if ( ost->stream_copy
1629 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1630 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1631 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1635 /* handle attached files */
1636 for (i = 0; i < o->nb_attachments; i++) {
1638 uint8_t *attachment;
1642 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1643 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1647 if ((len = avio_size(pb)) <= 0) {
1648 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1652 if (!(attachment = av_malloc(len))) {
1653 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1657 avio_read(pb, attachment, len);
1659 ost = new_attachment_stream(o, oc, -1);
1660 ost->stream_copy = 0;
1661 ost->attachment_filename = o->attachments[i];
1662 ost->st->codec->extradata = attachment;
1663 ost->st->codec->extradata_size = len;
1665 p = strrchr(o->attachments[i], '/');
1666 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1670 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1671 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1674 output_files[nb_output_files - 1]->ctx = oc;
1675 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1676 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1677 if (o->recording_time != INT64_MAX)
1678 oc->duration = o->recording_time;
1679 output_files[nb_output_files - 1]->start_time = o->start_time;
1680 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1681 output_files[nb_output_files - 1]->shortest = o->shortest;
1682 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1684 /* check filename in case of an image number is expected */
1685 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1686 if (!av_filename_number_test(oc->filename)) {
1687 print_error(oc->filename, AVERROR(EINVAL));
1692 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1693 /* test if it already exists to avoid losing precious files */
1694 assert_file_overwrite(filename);
1697 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1698 &oc->interrupt_callback,
1699 &output_files[nb_output_files - 1]->opts)) < 0) {
1700 print_error(filename, err);
1705 if (o->mux_preload) {
1707 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1708 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1710 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1713 for (i = 0; i < o->nb_metadata_map; i++) {
1715 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1717 if (in_file_index >= nb_input_files) {
1718 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1721 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1722 in_file_index >= 0 ?
1723 input_files[in_file_index]->ctx : NULL, o);
1727 if (o->chapters_input_file >= nb_input_files) {
1728 if (o->chapters_input_file == INT_MAX) {
1729 /* copy chapters from the first input file that has them*/
1730 o->chapters_input_file = -1;
1731 for (i = 0; i < nb_input_files; i++)
1732 if (input_files[i]->ctx->nb_chapters) {
1733 o->chapters_input_file = i;
1737 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1738 o->chapters_input_file);
1742 if (o->chapters_input_file >= 0)
1743 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1744 !o->metadata_chapters_manual);
1746 /* copy global metadata by default */
1747 if (!o->metadata_global_manual && nb_input_files){
1748 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1749 AV_DICT_DONT_OVERWRITE);
1750 if(o->recording_time != INT64_MAX)
1751 av_dict_set(&oc->metadata, "duration", NULL, 0);
1752 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1754 if (!o->metadata_streams_manual)
1755 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1757 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1759 ist = input_streams[output_streams[i]->source_index];
1760 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1763 /* process manually set metadata */
1764 for (i = 0; i < o->nb_metadata; i++) {
1767 const char *stream_spec;
1768 int index = 0, j, ret = 0;
1770 val = strchr(o->metadata[i].u.str, '=');
1772 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1773 o->metadata[i].u.str);
1778 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1780 for (j = 0; j < oc->nb_streams; j++) {
1781 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1782 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1793 if (index < 0 || index >= oc->nb_chapters) {
1794 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1797 m = &oc->chapters[index]->metadata;
1800 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1803 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1807 reset_options(o, 0);
1810 static int opt_target(void *optctx, const char *opt, const char *arg)
1812 OptionsContext *o = optctx;
1813 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1814 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1816 if (!strncmp(arg, "pal-", 4)) {
1819 } else if (!strncmp(arg, "ntsc-", 5)) {
1822 } else if (!strncmp(arg, "film-", 5)) {
1826 /* Try to determine PAL/NTSC by peeking in the input files */
1827 if (nb_input_files) {
1829 for (j = 0; j < nb_input_files; j++) {
1830 for (i = 0; i < input_files[j]->nb_streams; i++) {
1831 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1832 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1834 fr = c->time_base.den * 1000 / c->time_base.num;
1838 } else if ((fr == 29970) || (fr == 23976)) {
1843 if (norm != UNKNOWN)
1847 if (norm != UNKNOWN)
1848 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1851 if (norm == UNKNOWN) {
1852 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1853 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1854 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1858 if (!strcmp(arg, "vcd")) {
1859 opt_video_codec(o, "c:v", "mpeg1video");
1860 opt_audio_codec(o, "c:a", "mp2");
1861 parse_option(o, "f", "vcd", options);
1863 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1864 parse_option(o, "r", frame_rates[norm], options);
1865 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1867 opt_default(NULL, "b:v", "1150000");
1868 opt_default(NULL, "maxrate", "1150000");
1869 opt_default(NULL, "minrate", "1150000");
1870 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1872 opt_default(NULL, "b:a", "224000");
1873 parse_option(o, "ar", "44100", options);
1874 parse_option(o, "ac", "2", options);
1876 opt_default(NULL, "packetsize", "2324");
1877 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1879 /* We have to offset the PTS, so that it is consistent with the SCR.
1880 SCR starts at 36000, but the first two packs contain only padding
1881 and the first pack from the other stream, respectively, may also have
1882 been written before.
1883 So the real data starts at SCR 36000+3*1200. */
1884 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1885 } else if (!strcmp(arg, "svcd")) {
1887 opt_video_codec(o, "c:v", "mpeg2video");
1888 opt_audio_codec(o, "c:a", "mp2");
1889 parse_option(o, "f", "svcd", options);
1891 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1892 parse_option(o, "r", frame_rates[norm], options);
1893 parse_option(o, "pix_fmt", "yuv420p", options);
1894 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1896 opt_default(NULL, "b:v", "2040000");
1897 opt_default(NULL, "maxrate", "2516000");
1898 opt_default(NULL, "minrate", "0"); // 1145000;
1899 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1900 opt_default(NULL, "scan_offset", "1");
1902 opt_default(NULL, "b:a", "224000");
1903 parse_option(o, "ar", "44100", options);
1905 opt_default(NULL, "packetsize", "2324");
1907 } else if (!strcmp(arg, "dvd")) {
1909 opt_video_codec(o, "c:v", "mpeg2video");
1910 opt_audio_codec(o, "c:a", "ac3");
1911 parse_option(o, "f", "dvd", options);
1913 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1914 parse_option(o, "r", frame_rates[norm], options);
1915 parse_option(o, "pix_fmt", "yuv420p", options);
1916 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1918 opt_default(NULL, "b:v", "6000000");
1919 opt_default(NULL, "maxrate", "9000000");
1920 opt_default(NULL, "minrate", "0"); // 1500000;
1921 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1923 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1924 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1926 opt_default(NULL, "b:a", "448000");
1927 parse_option(o, "ar", "48000", options);
1929 } else if (!strncmp(arg, "dv", 2)) {
1931 parse_option(o, "f", "dv", options);
1933 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1934 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1935 norm == PAL ? "yuv420p" : "yuv411p", options);
1936 parse_option(o, "r", frame_rates[norm], options);
1938 parse_option(o, "ar", "48000", options);
1939 parse_option(o, "ac", "2", options);
1942 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1943 return AVERROR(EINVAL);
1948 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1950 av_free (vstats_filename);
1951 vstats_filename = av_strdup (arg);
1955 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1958 time_t today2 = time(NULL);
1959 struct tm *today = localtime(&today2);
1961 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1963 return opt_vstats_file(NULL, opt, filename);
1966 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1968 OptionsContext *o = optctx;
1969 return parse_option(o, "frames:v", arg, options);
1972 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1974 OptionsContext *o = optctx;
1975 return parse_option(o, "frames:a", arg, options);
1978 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1980 OptionsContext *o = optctx;
1981 return parse_option(o, "frames:d", arg, options);
1984 static int opt_preset(void *optctx, const char *opt, const char *arg)
1986 OptionsContext *o = optctx;
1988 char filename[1000], line[1000], tmp_line[1000];
1989 const char *codec_name = NULL;
1993 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1995 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1996 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1997 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1999 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2003 while (fgets(line, sizeof(line), f)) {
2004 char *key = tmp_line, *value, *endptr;
2006 if (strcspn(line, "#\n\r") == 0)
2008 strcpy(tmp_line, line);
2009 if (!av_strtok(key, "=", &value) ||
2010 !av_strtok(value, "\r\n", &endptr)) {
2011 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2014 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2016 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2017 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2018 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2019 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2020 else if (opt_default(NULL, key, value) < 0) {
2021 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2022 filename, line, key, value);
2032 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2034 OptionsContext *o = optctx;
2035 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2036 int ret = parse_option(o, s, arg, options);
2041 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2043 OptionsContext *o = optctx;
2044 if(!strcmp(opt, "b")){
2045 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2046 return parse_option(o, "b:v", arg, options);
2048 return opt_default(optctx, opt, arg);
2051 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2053 OptionsContext *o = optctx;
2056 if(!strcmp(opt, "qscale")){
2057 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2058 return parse_option(o, "q:v", arg, options);
2060 s = av_asprintf("q%s", opt + 6);
2061 ret = parse_option(o, s, arg, options);
2066 static int opt_profile(void *optctx, const char *opt, const char *arg)
2068 OptionsContext *o = optctx;
2069 if(!strcmp(opt, "profile")){
2070 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2071 return parse_option(o, "profile:v", arg, options);
2073 return opt_default(optctx, opt, arg);
2077 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2079 OptionsContext *o = optctx;
2080 return parse_option(o, "filter:v", arg, options);
2083 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2085 OptionsContext *o = optctx;
2086 return parse_option(o, "filter:a", arg, options);
2089 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2091 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2092 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2093 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2094 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2096 if (video_sync_method == VSYNC_AUTO)
2097 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2101 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2103 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2108 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2110 OptionsContext *o = optctx;
2111 char *tcr = av_asprintf("timecode=%s", arg);
2112 int ret = parse_option(o, "metadata:g", tcr, options);
2114 ret = opt_default(optctx, "gop_timecode", arg);
2119 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2121 OptionsContext *o = optctx;
2122 char layout_str[32];
2125 int ret, channels, ac_str_size;
2128 layout = av_get_channel_layout(arg);
2130 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2131 return AVERROR(EINVAL);
2133 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2134 ret = opt_default(NULL, opt, layout_str);
2138 /* set 'ac' option based on channel layout */
2139 channels = av_get_channel_layout_nb_channels(layout);
2140 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2141 stream_str = strchr(opt, ':');
2142 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2143 ac_str = av_mallocz(ac_str_size);
2145 return AVERROR(ENOMEM);
2146 av_strlcpy(ac_str, "ac", 3);
2148 av_strlcat(ac_str, stream_str, ac_str_size);
2149 ret = parse_option(o, ac_str, layout_str, options);
2155 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2157 OptionsContext *o = optctx;
2158 return parse_option(o, "q:a", arg, options);
2161 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2163 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2164 &nb_filtergraphs, nb_filtergraphs + 1);
2165 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2166 return AVERROR(ENOMEM);
2167 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2168 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2172 void show_help_default(const char *opt, const char *arg)
2174 /* per-file options have at least one of those set */
2175 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2176 int show_advanced = 0, show_avoptions = 0;
2179 if (!strcmp(opt, "long"))
2181 else if (!strcmp(opt, "full"))
2182 show_advanced = show_avoptions = 1;
2184 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2189 printf("Getting help:\n"
2190 " -h -- print basic options\n"
2191 " -h long -- print more options\n"
2192 " -h full -- print all options (including all format and codec specific options, very long)\n"
2193 " See man %s for detailed description of the options.\n"
2194 "\n", program_name);
2196 show_help_options(options, "Print help / information / capabilities:",
2199 show_help_options(options, "Global options (affect whole program "
2200 "instead of just one file:",
2201 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2203 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2204 per_file | OPT_EXIT, 0);
2206 show_help_options(options, "Per-file main options:", 0,
2207 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2208 OPT_EXIT, per_file);
2210 show_help_options(options, "Advanced per-file options:",
2211 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2213 show_help_options(options, "Video options:",
2214 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2216 show_help_options(options, "Advanced Video options:",
2217 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2219 show_help_options(options, "Audio options:",
2220 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2222 show_help_options(options, "Advanced Audio options:",
2223 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2224 show_help_options(options, "Subtitle options:",
2225 OPT_SUBTITLE, 0, 0);
2228 if (show_avoptions) {
2229 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2230 show_help_children(avcodec_get_class(), flags);
2231 show_help_children(avformat_get_class(), flags);
2232 show_help_children(sws_get_class(), flags);
2233 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2234 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2238 void show_usage(void)
2240 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2241 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2242 av_log(NULL, AV_LOG_INFO, "\n");
2246 static int opt_progress(void *optctx, const char *opt, const char *arg)
2248 AVIOContext *avio = NULL;
2251 if (!strcmp(arg, "-"))
2253 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2255 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2256 arg, av_err2str(ret));
2259 progress_avio = avio;
2263 #define OFFSET(x) offsetof(OptionsContext, x)
2264 const OptionDef options[] = {
2266 #include "cmdutils_common_opts.h"
2267 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2268 "force format", "fmt" },
2269 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2270 "input file name", "filename" },
2271 { "y", OPT_BOOL, { &file_overwrite },
2272 "overwrite output files" },
2273 { "n", OPT_BOOL, { &no_file_overwrite },
2274 "do not overwrite output files" },
2275 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2276 "codec name", "codec" },
2277 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2278 "codec name", "codec" },
2279 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2280 "preset name", "preset" },
2281 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2282 "set input stream mapping",
2283 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2284 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2285 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2286 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2287 "set metadata information of outfile from infile",
2288 "outfile[,metadata]:infile[,metadata]" },
2289 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2290 "set chapters mapping", "input_file_index" },
2291 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2292 "record or transcode \"duration\" seconds of audio/video",
2294 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2295 "set the limit file size in bytes", "limit_size" },
2296 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2297 "set the start time offset", "time_off" },
2298 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2299 "set the input ts offset", "time_off" },
2300 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2301 "set the input ts scale", "scale" },
2302 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2303 "set the recording timestamp ('now' to set the current time)", "time" },
2304 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2305 "add metadata", "string=string" },
2306 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2307 "set the number of data frames to record", "number" },
2308 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2309 "add timings for benchmarking" },
2310 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2311 "add timings for each task" },
2312 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2313 "write program-readable progress information", "url" },
2314 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2315 "enable or disable interaction on standard input" },
2316 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2317 "set max runtime in seconds", "limit" },
2318 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2319 "dump each input packet" },
2320 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2321 "when dumping packets, also dump the payload" },
2322 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2323 "read input at native frame rate", "" },
2324 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2325 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2326 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2327 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2328 "video sync method", "" },
2329 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2330 "audio sync method", "" },
2331 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2332 "audio drift threshold", "threshold" },
2333 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2334 "copy timestamps" },
2335 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2336 "copy input stream time base when stream copying", "mode" },
2337 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2338 "finish encoding within shortest input" },
2339 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2340 "timestamp discontinuity delta threshold", "threshold" },
2341 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2342 "timestamp error delta threshold", "threshold" },
2343 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2344 "exit on error", "error" },
2345 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2346 "copy initial non-keyframes" },
2347 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2348 "copy or discard frames before start time" },
2349 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2350 "set the number of frames to record", "number" },
2351 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2352 "force codec tag/fourcc", "fourcc/tag" },
2353 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2354 "use fixed quality scale (VBR)", "q" },
2355 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2356 "use fixed quality scale (VBR)", "q" },
2357 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2358 "set profile", "profile" },
2359 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2360 "set stream filterchain", "filter_list" },
2361 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2362 "reinit filtergraph on input parameter changes", "" },
2363 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2364 "create a complex filtergraph", "graph_description" },
2365 { "stats", OPT_BOOL, { &print_stats },
2366 "print progress report during encoding", },
2367 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2368 "add an attachment to the output file", "filename" },
2369 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2370 "extract an attachment into a file", "filename" },
2371 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2372 "print timestamp debugging info" },
2375 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2376 "set the number of video frames to record", "number" },
2377 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2378 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2379 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2380 "set frame size (WxH or abbreviation)", "size" },
2381 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2382 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2383 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2384 "set pixel format", "format" },
2385 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2386 "set the number of bits per raw sample", "number" },
2387 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2388 "Removed, use the crop filter instead", "size" },
2389 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2390 "Removed, use the crop filter instead", "size" },
2391 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2392 "Removed, use the crop filter instead", "size" },
2393 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2394 "Removed, use the crop filter instead", "size" },
2395 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2396 "Removed, use the pad filter instead", "size" },
2397 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2398 "Removed, use the pad filter instead", "size" },
2399 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2400 "Removed, use the pad filter instead", "size" },
2401 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2402 "Removed, use the pad filter instead", "size" },
2403 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2404 "Removed, use the pad filter instead", "color" },
2405 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2406 "deprecated use -g 1" },
2407 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2409 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2410 "discard threshold", "n" },
2411 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2412 "rate control override for specific intervals", "override" },
2413 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2414 "force video codec ('copy' to copy stream)", "codec" },
2415 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2417 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2419 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2420 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2421 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2422 "select the pass number (1 to 3)", "n" },
2423 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2424 "select two pass log file name prefix", "prefix" },
2425 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2426 "this option is deprecated, use the yadif filter instead" },
2427 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2428 "calculate PSNR of compressed frames" },
2429 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2430 "dump video coding statistics to file" },
2431 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2432 "dump video coding statistics to file", "file" },
2433 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2434 "video filters", "filter list" },
2435 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2436 "specify intra matrix coeffs", "matrix" },
2437 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2438 "specify inter matrix coeffs", "matrix" },
2439 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2440 "top=1/bottom=0/auto=-1 field first", "" },
2441 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2442 "intra_dc_precision", "precision" },
2443 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2444 "force video tag/fourcc", "fourcc/tag" },
2445 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2446 "show QP histogram" },
2447 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2448 "force the selected framerate, disable the best supported framerate selection" },
2449 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2450 "set the value of an outfile streamid", "streamIndex:value" },
2451 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2452 { .off = OFFSET(forced_key_frames) },
2453 "force key frames at specified timestamps", "timestamps" },
2454 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2455 "video bitrate (please use -b:v)", "bitrate" },
2458 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2459 "set the number of audio frames to record", "number" },
2460 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2461 "set audio quality (codec-specific)", "quality", },
2462 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2463 "set audio sampling rate (in Hz)", "rate" },
2464 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2465 "set number of audio channels", "channels" },
2466 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2468 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2469 "force audio codec ('copy' to copy stream)", "codec" },
2470 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2471 "force audio tag/fourcc", "fourcc/tag" },
2472 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2473 "change audio volume (256=normal)" , "volume" },
2474 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2475 "set sample format", "format" },
2476 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2477 "set channel layout", "layout" },
2478 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2479 "audio filters", "filter list" },
2481 /* subtitle options */
2482 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2483 "disable subtitle" },
2484 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2485 "force subtitle codec ('copy' to copy stream)", "codec" },
2486 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2487 , "force subtitle tag/fourcc", "fourcc/tag" },
2488 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2489 "fix subtitles duration" },
2492 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2493 "deprecated, use -channel", "channel" },
2494 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2495 "deprecated, use -standard", "standard" },
2496 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2499 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2500 "set the maximum demux-decode delay", "seconds" },
2501 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2502 "set the initial demux-decode delay", "seconds" },
2504 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2505 "A comma-separated list of bitstream filters", "bitstream_filters" },
2506 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2507 "deprecated", "audio bitstream_filters" },
2508 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2509 "deprecated", "video bitstream_filters" },
2511 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2512 "set the audio options to the indicated preset", "preset" },
2513 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2514 "set the video options to the indicated preset", "preset" },
2515 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2516 "set the subtitle options to the indicated preset", "preset" },
2517 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2518 "set options from indicated preset file", "filename" },
2519 /* data codec support */
2520 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2521 "force data codec ('copy' to copy stream)", "codec" },
2522 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2525 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2526 "generic catch all option", "" },