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/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/avutil.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_WARNING, "Ignoring option '%s'\n", opt);
166 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
168 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
169 return opt_default(optctx, "channel", arg);
172 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
174 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
175 return opt_default(optctx, "standard", arg);
178 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
180 OptionsContext *o = optctx;
181 return parse_option(o, "codec:a", arg, options);
184 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
186 OptionsContext *o = optctx;
187 return parse_option(o, "codec:v", arg, options);
190 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
192 OptionsContext *o = optctx;
193 return parse_option(o, "codec:s", arg, options);
196 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
198 OptionsContext *o = optctx;
199 return parse_option(o, "codec:d", arg, options);
202 static int opt_map(void *optctx, const char *opt, const char *arg)
204 OptionsContext *o = optctx;
206 int i, negative = 0, file_idx;
207 int sync_file_idx = -1, sync_stream_idx = 0;
215 map = av_strdup(arg);
217 /* parse sync stream first, just pick first matching stream */
218 if (sync = strchr(map, ',')) {
220 sync_file_idx = strtol(sync + 1, &sync, 0);
221 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
222 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
227 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
228 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
229 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
233 if (i == input_files[sync_file_idx]->nb_streams) {
234 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
235 "match any streams.\n", arg);
242 /* this mapping refers to lavfi output */
243 const char *c = map + 1;
244 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
245 &o->nb_stream_maps, o->nb_stream_maps + 1);
246 m = &o->stream_maps[o->nb_stream_maps - 1];
247 m->linklabel = av_get_token(&c, "]");
249 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
253 file_idx = strtol(map, &p, 0);
254 if (file_idx >= nb_input_files || file_idx < 0) {
255 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
259 /* disable some already defined maps */
260 for (i = 0; i < o->nb_stream_maps; i++) {
261 m = &o->stream_maps[i];
262 if (file_idx == m->file_index &&
263 check_stream_specifier(input_files[m->file_index]->ctx,
264 input_files[m->file_index]->ctx->streams[m->stream_index],
265 *p == ':' ? p + 1 : p) > 0)
269 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
270 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
271 *p == ':' ? p + 1 : p) <= 0)
273 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
274 &o->nb_stream_maps, o->nb_stream_maps + 1);
275 m = &o->stream_maps[o->nb_stream_maps - 1];
277 m->file_index = file_idx;
280 if (sync_file_idx >= 0) {
281 m->sync_file_index = sync_file_idx;
282 m->sync_stream_index = sync_stream_idx;
284 m->sync_file_index = file_idx;
285 m->sync_stream_index = i;
291 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
299 static int opt_attach(void *optctx, const char *opt, const char *arg)
301 OptionsContext *o = optctx;
302 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
303 &o->nb_attachments, o->nb_attachments + 1);
304 o->attachments[o->nb_attachments - 1] = arg;
308 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
310 OptionsContext *o = optctx;
315 o->audio_channel_maps =
316 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
317 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
318 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
320 /* muted channel syntax */
321 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
322 if ((n == 1 || n == 3) && m->channel_idx == -1) {
323 m->file_idx = m->stream_idx = -1;
325 m->ofile_idx = m->ostream_idx = -1;
330 n = sscanf(arg, "%d.%d.%d:%d.%d",
331 &m->file_idx, &m->stream_idx, &m->channel_idx,
332 &m->ofile_idx, &m->ostream_idx);
334 if (n != 3 && n != 5) {
335 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
336 "[file.stream.channel|-1][:syncfile:syncstream]\n");
340 if (n != 5) // only file.stream.channel specified
341 m->ofile_idx = m->ostream_idx = -1;
344 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
345 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
349 if (m->stream_idx < 0 ||
350 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
351 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
352 m->file_idx, m->stream_idx);
355 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
356 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
357 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
358 m->file_idx, m->stream_idx);
361 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
362 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
363 m->file_idx, m->stream_idx, m->channel_idx);
370 * Parse a metadata specifier passed as 'arg' parameter.
371 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
372 * @param index for type c/p, chapter/program index is written here
373 * @param stream_spec for type s, the stream specifier is written here
375 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
383 if (*(++arg) && *arg != ':') {
384 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
387 *stream_spec = *arg == ':' ? arg + 1 : "";
392 *index = strtol(++arg, NULL, 0);
395 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
402 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
404 AVDictionary **meta_in = NULL;
405 AVDictionary **meta_out = NULL;
407 char type_in, type_out;
408 const char *istream_spec = NULL, *ostream_spec = NULL;
409 int idx_in = 0, idx_out = 0;
411 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
412 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
415 if (type_out == 'g' || !*outspec)
416 o->metadata_global_manual = 1;
417 if (type_out == 's' || !*outspec)
418 o->metadata_streams_manual = 1;
419 if (type_out == 'c' || !*outspec)
420 o->metadata_chapters_manual = 1;
424 if (type_in == 'g' || type_out == 'g')
425 o->metadata_global_manual = 1;
426 if (type_in == 's' || type_out == 's')
427 o->metadata_streams_manual = 1;
428 if (type_in == 'c' || type_out == 'c')
429 o->metadata_chapters_manual = 1;
431 /* ic is NULL when just disabling automatic mappings */
435 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
436 if ((index) < 0 || (index) >= (nb_elems)) {\
437 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
442 #define SET_DICT(type, meta, context, index)\
445 meta = &context->metadata;\
448 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
449 meta = &context->chapters[index]->metadata;\
452 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
453 meta = &context->programs[index]->metadata;\
455 default: av_assert0(0);\
460 SET_DICT(type_in, meta_in, ic, idx_in);
461 SET_DICT(type_out, meta_out, oc, idx_out);
463 /* for input streams choose first matching stream */
464 if (type_in == 's') {
465 for (i = 0; i < ic->nb_streams; i++) {
466 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
467 meta_in = &ic->streams[i]->metadata;
473 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
478 if (type_out == 's') {
479 for (i = 0; i < oc->nb_streams; i++) {
480 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
481 meta_out = &oc->streams[i]->metadata;
482 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
487 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
492 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
494 OptionsContext *o = optctx;
496 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
497 struct tm time = *gmtime((time_t*)&recording_timestamp);
498 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
499 parse_option(o, "metadata", buf, options);
501 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
502 "tag instead.\n", opt);
506 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
508 const AVCodecDescriptor *desc;
509 const char *codec_string = encoder ? "encoder" : "decoder";
513 avcodec_find_encoder_by_name(name) :
514 avcodec_find_decoder_by_name(name);
516 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
517 codec = encoder ? avcodec_find_encoder(desc->id) :
518 avcodec_find_decoder(desc->id);
520 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
521 codec_string, codec->name, desc->name);
525 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
528 if (codec->type != type) {
529 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
535 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
537 char *codec_name = NULL;
539 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
541 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
542 st->codec->codec_id = codec->id;
545 return avcodec_find_decoder(st->codec->codec_id);
548 /* Add all the streams from the given input file to the global
549 * list of input streams. */
550 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
553 char *next, *codec_tag = NULL;
555 for (i = 0; i < ic->nb_streams; i++) {
556 AVStream *st = ic->streams[i];
557 AVCodecContext *dec = st->codec;
558 InputStream *ist = av_mallocz(sizeof(*ist));
559 char *framerate = NULL;
564 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
565 input_streams[nb_input_streams - 1] = ist;
568 ist->file_index = nb_input_files;
570 st->discard = AVDISCARD_ALL;
571 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
574 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
576 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
578 uint32_t tag = strtol(codec_tag, &next, 0);
580 tag = AV_RL32(codec_tag);
581 st->codec->codec_tag = tag;
584 ist->dec = choose_decoder(o, ic, st);
586 ist->reinit_filters = -1;
587 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
589 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
591 switch (dec->codec_type) {
592 case AVMEDIA_TYPE_VIDEO:
594 ist->dec = avcodec_find_decoder(dec->codec_id);
596 dec->flags |= CODEC_FLAG_EMU_EDGE;
599 ist->resample_height = dec->height;
600 ist->resample_width = dec->width;
601 ist->resample_pix_fmt = dec->pix_fmt;
603 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
604 if (framerate && av_parse_video_rate(&ist->framerate,
606 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
611 ist->top_field_first = -1;
612 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
615 case AVMEDIA_TYPE_AUDIO:
616 guess_input_channel_layout(ist);
618 ist->resample_sample_fmt = dec->sample_fmt;
619 ist->resample_sample_rate = dec->sample_rate;
620 ist->resample_channels = dec->channels;
621 ist->resample_channel_layout = dec->channel_layout;
624 case AVMEDIA_TYPE_DATA:
625 case AVMEDIA_TYPE_SUBTITLE:
627 ist->dec = avcodec_find_decoder(dec->codec_id);
628 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
630 case AVMEDIA_TYPE_ATTACHMENT:
631 case AVMEDIA_TYPE_UNKNOWN:
639 static void assert_file_overwrite(const char *filename)
641 if ((!file_overwrite || no_file_overwrite) &&
642 (strchr(filename, ':') == NULL || filename[1] == ':' ||
643 av_strstart(filename, "file:", NULL))) {
644 if (avio_check(filename, 0) == 0) {
645 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
646 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
649 signal(SIGINT, SIG_DFL);
651 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
657 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
664 static void dump_attachment(AVStream *st, const char *filename)
667 AVIOContext *out = NULL;
668 AVDictionaryEntry *e;
670 if (!st->codec->extradata_size) {
671 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
672 nb_input_files - 1, st->index);
675 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
678 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
679 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
683 assert_file_overwrite(filename);
685 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
686 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
691 avio_write(out, st->codec->extradata, st->codec->extradata_size);
696 static int opt_input_file(void *optctx, const char *opt, const char *filename)
698 OptionsContext *o = optctx;
700 AVInputFormat *file_iformat = NULL;
705 int orig_nb_streams; // number of streams before avformat_find_stream_info
706 char * video_codec_name = NULL;
707 char * audio_codec_name = NULL;
708 char *subtitle_codec_name = NULL;
711 if (!(file_iformat = av_find_input_format(o->format))) {
712 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
717 if (!strcmp(filename, "-"))
720 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
721 strcmp(filename, "/dev/stdin");
723 /* get default parameters from command line */
724 ic = avformat_alloc_context();
726 print_error(filename, AVERROR(ENOMEM));
729 if (o->nb_audio_sample_rate) {
730 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
731 av_dict_set(&format_opts, "sample_rate", buf, 0);
733 if (o->nb_audio_channels) {
734 /* because we set audio_channels based on both the "ac" and
735 * "channel_layout" options, we need to check that the specified
736 * demuxer actually has the "channels" option before setting it */
737 if (file_iformat && file_iformat->priv_class &&
738 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
739 AV_OPT_SEARCH_FAKE_OBJ)) {
740 snprintf(buf, sizeof(buf), "%d",
741 o->audio_channels[o->nb_audio_channels - 1].u.i);
742 av_dict_set(&format_opts, "channels", buf, 0);
745 if (o->nb_frame_rates) {
746 /* set the format-level framerate option;
747 * this is important for video grabbers, e.g. x11 */
748 if (file_iformat && file_iformat->priv_class &&
749 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
750 AV_OPT_SEARCH_FAKE_OBJ)) {
751 av_dict_set(&format_opts, "framerate",
752 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
755 if (o->nb_frame_sizes) {
756 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
758 if (o->nb_frame_pix_fmts)
759 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
761 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
762 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
763 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
765 ic->video_codec_id = video_codec_name ?
766 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
767 ic->audio_codec_id = audio_codec_name ?
768 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
769 ic->subtitle_codec_id= subtitle_codec_name ?
770 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
771 ic->flags |= AVFMT_FLAG_NONBLOCK;
772 ic->interrupt_callback = int_cb;
774 /* open the input file with generic avformat function */
775 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
777 print_error(filename, err);
780 assert_avoptions(format_opts);
782 /* apply forced codec ids */
783 for (i = 0; i < ic->nb_streams; i++)
784 choose_decoder(o, ic, ic->streams[i]);
786 /* Set AVCodecContext options for avformat_find_stream_info */
787 opts = setup_find_stream_info_opts(ic, codec_opts);
788 orig_nb_streams = ic->nb_streams;
790 /* If not enough info to get the stream parameters, we decode the
791 first frames to get it. (used in mpeg case for example) */
792 ret = avformat_find_stream_info(ic, opts);
794 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
795 avformat_close_input(&ic);
799 timestamp = o->start_time;
800 /* add the stream start time */
801 if (ic->start_time != AV_NOPTS_VALUE)
802 timestamp += ic->start_time;
804 /* if seeking requested, we execute it */
805 if (o->start_time != 0) {
806 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
808 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
809 filename, (double)timestamp / AV_TIME_BASE);
813 /* update the current parameters so that they match the one of the input stream */
814 add_input_streams(o, ic);
816 /* dump the file content */
817 av_dump_format(ic, nb_input_files, filename, 0);
819 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
820 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
823 input_files[nb_input_files - 1]->ctx = ic;
824 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
825 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
826 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
827 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
829 for (i = 0; i < o->nb_dump_attachment; i++) {
832 for (j = 0; j < ic->nb_streams; j++) {
833 AVStream *st = ic->streams[j];
835 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
836 dump_attachment(st, o->dump_attachment[i].u.str);
840 for (i = 0; i < orig_nb_streams; i++)
841 av_dict_free(&opts[i]);
848 static uint8_t *get_line(AVIOContext *s)
854 if (avio_open_dyn_buf(&line) < 0) {
855 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
859 while ((c = avio_r8(s)) && c != '\n')
862 avio_close_dyn_buf(line, &buf);
867 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
871 const char *base[3] = { getenv("AVCONV_DATADIR"),
876 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
880 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
881 i != 1 ? "" : "/.avconv", codec_name, preset_name);
882 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
885 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
886 i != 1 ? "" : "/.avconv", preset_name);
887 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
893 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
895 char *codec_name = NULL;
897 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
899 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
900 NULL, ost->st->codec->codec_type);
901 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
902 } else if (!strcmp(codec_name, "copy"))
903 ost->stream_copy = 1;
905 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
906 ost->st->codec->codec_id = ost->enc->id;
910 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
913 AVStream *st = avformat_new_stream(oc, NULL);
914 int idx = oc->nb_streams - 1, ret = 0;
915 char *bsf = NULL, *next, *codec_tag = NULL;
916 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
920 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
924 if (oc->nb_streams - 1 < o->nb_streamid_map)
925 st->id = o->streamid_map[oc->nb_streams - 1];
927 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
928 nb_output_streams + 1);
929 if (!(ost = av_mallocz(sizeof(*ost))))
931 output_streams[nb_output_streams - 1] = ost;
933 ost->file_index = nb_output_files;
936 st->codec->codec_type = type;
937 choose_encoder(o, oc, ost);
939 AVIOContext *s = NULL;
940 char *buf = NULL, *arg = NULL, *preset = NULL;
942 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
944 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
945 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
948 if (!buf[0] || buf[0] == '#') {
952 if (!(arg = strchr(buf, '='))) {
953 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
957 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
959 } while (!s->eof_reached);
963 av_log(NULL, AV_LOG_FATAL,
964 "Preset %s specified for stream %d:%d, but could not be opened.\n",
965 preset, ost->file_index, ost->index);
970 avcodec_get_context_defaults3(st->codec, ost->enc);
971 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
973 ost->max_frames = INT64_MAX;
974 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
976 ost->copy_prior_start = -1;
977 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
979 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
981 if (next = strchr(bsf, ','))
983 if (!(bsfc = av_bitstream_filter_init(bsf))) {
984 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
988 bsfc_prev->next = bsfc;
990 ost->bitstream_filters = bsfc;
996 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
998 uint32_t tag = strtol(codec_tag, &next, 0);
1000 tag = AV_RL32(codec_tag);
1001 st->codec->codec_tag = tag;
1004 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1006 st->codec->flags |= CODEC_FLAG_QSCALE;
1007 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1010 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1011 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1013 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1014 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1015 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1017 ost->source_index = source_index;
1018 if (source_index >= 0) {
1019 ost->sync_ist = input_streams[source_index];
1020 input_streams[source_index]->discard = 0;
1021 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1027 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1030 const char *p = str;
1037 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1044 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1048 AVCodecContext *video_enc;
1049 char *frame_rate = NULL;
1051 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1053 video_enc = st->codec;
1055 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1056 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1057 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1061 if (!ost->stream_copy) {
1062 const char *p = NULL;
1063 char *frame_size = NULL;
1064 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1065 char *intra_matrix = NULL, *inter_matrix = NULL;
1066 const char *filters = "null";
1070 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1071 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1072 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1076 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1077 if (frame_aspect_ratio) {
1079 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1080 q.num <= 0 || q.den <= 0) {
1081 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1084 ost->frame_aspect_ratio = av_q2d(q);
1087 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1088 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1089 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1090 ost->keep_pix_fmt = 1;
1091 if (!*++frame_pix_fmt)
1092 frame_pix_fmt = NULL;
1094 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1095 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1098 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1101 video_enc->gop_size = 0;
1102 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1104 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1105 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1108 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1110 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1112 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1113 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1116 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1119 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1120 for (i = 0; p; i++) {
1122 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1124 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1127 /* FIXME realloc failure */
1128 video_enc->rc_override =
1129 av_realloc(video_enc->rc_override,
1130 sizeof(RcOverride) * (i + 1));
1131 video_enc->rc_override[i].start_frame = start;
1132 video_enc->rc_override[i].end_frame = end;
1134 video_enc->rc_override[i].qscale = q;
1135 video_enc->rc_override[i].quality_factor = 1.0;
1138 video_enc->rc_override[i].qscale = 0;
1139 video_enc->rc_override[i].quality_factor = -q/100.0;
1144 video_enc->rc_override_count = i;
1145 if (!video_enc->rc_initial_buffer_occupancy)
1146 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1147 video_enc->intra_dc_precision = intra_dc_precision - 8;
1150 video_enc->flags|= CODEC_FLAG_PSNR;
1153 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1156 video_enc->flags |= CODEC_FLAG_PASS1;
1159 video_enc->flags |= CODEC_FLAG_PASS2;
1163 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1164 if (ost->logfile_prefix &&
1165 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1168 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1169 if (ost->forced_keyframes)
1170 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1172 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1174 ost->top_field_first = -1;
1175 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1177 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1178 ost->avfilter = av_strdup(filters);
1180 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1186 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1191 AVCodecContext *audio_enc;
1193 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1196 audio_enc = st->codec;
1197 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1199 if (!ost->stream_copy) {
1200 char *sample_fmt = NULL;
1201 const char *filters = "anull";
1203 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1205 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1207 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1208 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1212 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1214 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1216 av_assert1(filters);
1217 ost->avfilter = av_strdup(filters);
1219 /* check for channel mapping for this audio stream */
1220 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1221 AudioChannelMap *map = &o->audio_channel_maps[n];
1222 InputStream *ist = input_streams[ost->source_index];
1223 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1224 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1225 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1226 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1227 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1229 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1230 ost->file_index, ost->st->index);
1238 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1242 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1243 if (!ost->stream_copy) {
1244 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1251 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1253 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1254 ost->stream_copy = 1;
1258 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1262 AVCodecContext *subtitle_enc;
1264 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1266 subtitle_enc = st->codec;
1268 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1270 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1272 if (!ost->stream_copy) {
1273 char *frame_size = NULL;
1275 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1276 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1277 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1285 /* arg format is "output-stream-index:streamid-value". */
1286 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1288 OptionsContext *o = optctx;
1293 av_strlcpy(idx_str, arg, sizeof(idx_str));
1294 p = strchr(idx_str, ':');
1296 av_log(NULL, AV_LOG_FATAL,
1297 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1302 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1303 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1304 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1308 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1310 AVFormatContext *is = ifile->ctx;
1311 AVFormatContext *os = ofile->ctx;
1315 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1317 return AVERROR(ENOMEM);
1320 for (i = 0; i < is->nb_chapters; i++) {
1321 AVChapter *in_ch = is->chapters[i], *out_ch;
1322 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1323 AV_TIME_BASE_Q, in_ch->time_base);
1324 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1325 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1328 if (in_ch->end < ts_off)
1330 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1333 out_ch = av_mallocz(sizeof(AVChapter));
1335 return AVERROR(ENOMEM);
1337 out_ch->id = in_ch->id;
1338 out_ch->time_base = in_ch->time_base;
1339 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1340 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1343 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1345 os->chapters[os->nb_chapters++] = out_ch;
1350 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1353 AVFormatContext *ic = avformat_alloc_context();
1355 ic->interrupt_callback = int_cb;
1356 err = avformat_open_input(&ic, filename, NULL, NULL);
1359 /* copy stream format */
1360 for(i=0;i<ic->nb_streams;i++) {
1364 AVCodecContext *avctx;
1366 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1367 ost = new_output_stream(o, s, codec->type, -1);
1372 // FIXME: a more elegant solution is needed
1373 memcpy(st, ic->streams[i], sizeof(AVStream));
1375 st->info = av_malloc(sizeof(*st->info));
1376 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1378 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1380 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1381 choose_sample_fmt(st, codec);
1382 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1383 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1386 /* ffserver seeking with date=... needs a date reference */
1387 err = parse_option(o, "metadata", "creation_time=now", options);
1389 avformat_close_input(&ic);
1393 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1394 AVFormatContext *oc)
1398 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1399 ofilter->out_tmp->pad_idx)) {
1400 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1401 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1403 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1408 ost->source_index = -1;
1409 ost->filter = ofilter;
1413 if (ost->stream_copy) {
1414 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1415 "which is fed from a complex filtergraph. Filtering and streamcopy "
1416 "cannot be used together.\n", ost->file_index, ost->index);
1420 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1421 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1424 avfilter_inout_free(&ofilter->out_tmp);
1427 static int configure_complex_filters(void)
1431 for (i = 0; i < nb_filtergraphs; i++)
1432 if (!filtergraphs[i]->graph &&
1433 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1438 void opt_output_file(void *optctx, const char *filename)
1440 OptionsContext *o = optctx;
1441 AVFormatContext *oc;
1443 AVOutputFormat *file_oformat;
1447 if (configure_complex_filters() < 0) {
1448 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1452 if (!strcmp(filename, "-"))
1455 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1457 print_error(filename, err);
1460 file_oformat= oc->oformat;
1461 oc->interrupt_callback = int_cb;
1463 /* create streams for all unlabeled output pads */
1464 for (i = 0; i < nb_filtergraphs; i++) {
1465 FilterGraph *fg = filtergraphs[i];
1466 for (j = 0; j < fg->nb_outputs; j++) {
1467 OutputFilter *ofilter = fg->outputs[j];
1469 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1472 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1473 ofilter->out_tmp->pad_idx)) {
1474 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1475 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1476 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1478 init_output_filter(ofilter, o, oc);
1482 if (!strcmp(file_oformat->name, "ffm") &&
1483 av_strstart(filename, "http:", NULL)) {
1485 /* special case for files sent to ffserver: we get the stream
1486 parameters from ffserver */
1487 int err = read_ffserver_streams(o, oc, filename);
1489 print_error(filename, err);
1492 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1493 ost = output_streams[j];
1494 for (i = 0; i < nb_input_streams; i++) {
1495 ist = input_streams[i];
1496 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1498 ost->source_index= i;
1499 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1500 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1502 ist->st->discard = AVDISCARD_NONE;
1507 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));
1511 } else if (!o->nb_stream_maps) {
1512 char *subtitle_codec_name = NULL;
1513 /* pick the "best" stream of each type */
1515 /* video: highest resolution */
1516 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1517 int area = 0, idx = -1;
1518 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1519 for (i = 0; i < nb_input_streams; i++) {
1521 ist = input_streams[i];
1522 new_area = ist->st->codec->width * ist->st->codec->height;
1523 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1525 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1527 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1534 new_video_stream(o, oc, idx);
1537 /* audio: most channels */
1538 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1539 int channels = 0, idx = -1;
1540 for (i = 0; i < nb_input_streams; i++) {
1541 ist = input_streams[i];
1542 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1543 ist->st->codec->channels > channels) {
1544 channels = ist->st->codec->channels;
1549 new_audio_stream(o, oc, idx);
1552 /* subtitles: pick first */
1553 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1554 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1555 for (i = 0; i < nb_input_streams; i++)
1556 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1557 new_subtitle_stream(o, oc, i);
1561 /* do something with data? */
1563 for (i = 0; i < o->nb_stream_maps; i++) {
1564 StreamMap *map = &o->stream_maps[i];
1565 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1570 if (map->linklabel) {
1572 OutputFilter *ofilter = NULL;
1575 for (j = 0; j < nb_filtergraphs; j++) {
1576 fg = filtergraphs[j];
1577 for (k = 0; k < fg->nb_outputs; k++) {
1578 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1579 if (out && !strcmp(out->name, map->linklabel)) {
1580 ofilter = fg->outputs[k];
1587 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1588 "in any defined filter graph.\n", map->linklabel);
1591 init_output_filter(ofilter, o, oc);
1593 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1594 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1596 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1598 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1600 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1603 switch (ist->st->codec->codec_type) {
1604 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1605 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1606 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1607 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1608 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1610 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1611 map->file_index, map->stream_index);
1619 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1620 AVDictionaryEntry *e;
1621 ost = output_streams[i];
1623 if ( ost->stream_copy
1624 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1625 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1626 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1630 /* handle attached files */
1631 for (i = 0; i < o->nb_attachments; i++) {
1633 uint8_t *attachment;
1637 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1638 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1642 if ((len = avio_size(pb)) <= 0) {
1643 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1647 if (!(attachment = av_malloc(len))) {
1648 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1652 avio_read(pb, attachment, len);
1654 ost = new_attachment_stream(o, oc, -1);
1655 ost->stream_copy = 0;
1656 ost->attachment_filename = o->attachments[i];
1657 ost->st->codec->extradata = attachment;
1658 ost->st->codec->extradata_size = len;
1660 p = strrchr(o->attachments[i], '/');
1661 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1665 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1666 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1669 output_files[nb_output_files - 1]->ctx = oc;
1670 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1671 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1672 if (o->recording_time != INT64_MAX)
1673 oc->duration = o->recording_time;
1674 output_files[nb_output_files - 1]->start_time = o->start_time;
1675 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1676 output_files[nb_output_files - 1]->shortest = o->shortest;
1677 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1679 /* check filename in case of an image number is expected */
1680 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1681 if (!av_filename_number_test(oc->filename)) {
1682 print_error(oc->filename, AVERROR(EINVAL));
1687 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1688 /* test if it already exists to avoid losing precious files */
1689 assert_file_overwrite(filename);
1692 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1693 &oc->interrupt_callback,
1694 &output_files[nb_output_files - 1]->opts)) < 0) {
1695 print_error(filename, err);
1700 if (o->mux_preload) {
1702 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1703 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1705 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1708 for (i = 0; i < o->nb_metadata_map; i++) {
1710 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1712 if (in_file_index >= nb_input_files) {
1713 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1716 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1717 in_file_index >= 0 ?
1718 input_files[in_file_index]->ctx : NULL, o);
1722 if (o->chapters_input_file >= nb_input_files) {
1723 if (o->chapters_input_file == INT_MAX) {
1724 /* copy chapters from the first input file that has them*/
1725 o->chapters_input_file = -1;
1726 for (i = 0; i < nb_input_files; i++)
1727 if (input_files[i]->ctx->nb_chapters) {
1728 o->chapters_input_file = i;
1732 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1733 o->chapters_input_file);
1737 if (o->chapters_input_file >= 0)
1738 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1739 !o->metadata_chapters_manual);
1741 /* copy global metadata by default */
1742 if (!o->metadata_global_manual && nb_input_files){
1743 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1744 AV_DICT_DONT_OVERWRITE);
1745 if(o->recording_time != INT64_MAX)
1746 av_dict_set(&oc->metadata, "duration", NULL, 0);
1747 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1749 if (!o->metadata_streams_manual)
1750 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1752 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1754 ist = input_streams[output_streams[i]->source_index];
1755 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1758 /* process manually set metadata */
1759 for (i = 0; i < o->nb_metadata; i++) {
1762 const char *stream_spec;
1763 int index = 0, j, ret = 0;
1765 val = strchr(o->metadata[i].u.str, '=');
1767 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1768 o->metadata[i].u.str);
1773 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1775 for (j = 0; j < oc->nb_streams; j++) {
1776 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1777 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1788 if (index < 0 || index >= oc->nb_chapters) {
1789 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1792 m = &oc->chapters[index]->metadata;
1795 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1798 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1802 reset_options(o, 0);
1805 static int opt_target(void *optctx, const char *opt, const char *arg)
1807 OptionsContext *o = optctx;
1808 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1809 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1811 if (!strncmp(arg, "pal-", 4)) {
1814 } else if (!strncmp(arg, "ntsc-", 5)) {
1817 } else if (!strncmp(arg, "film-", 5)) {
1821 /* Try to determine PAL/NTSC by peeking in the input files */
1822 if (nb_input_files) {
1824 for (j = 0; j < nb_input_files; j++) {
1825 for (i = 0; i < input_files[j]->nb_streams; i++) {
1826 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1827 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1829 fr = c->time_base.den * 1000 / c->time_base.num;
1833 } else if ((fr == 29970) || (fr == 23976)) {
1838 if (norm != UNKNOWN)
1842 if (norm != UNKNOWN)
1843 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1846 if (norm == UNKNOWN) {
1847 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1848 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1849 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1853 if (!strcmp(arg, "vcd")) {
1854 opt_video_codec(o, "c:v", "mpeg1video");
1855 opt_audio_codec(o, "c:a", "mp2");
1856 parse_option(o, "f", "vcd", options);
1858 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1859 parse_option(o, "r", frame_rates[norm], options);
1860 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1862 opt_default(NULL, "b:v", "1150000");
1863 opt_default(NULL, "maxrate", "1150000");
1864 opt_default(NULL, "minrate", "1150000");
1865 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1867 opt_default(NULL, "b:a", "224000");
1868 parse_option(o, "ar", "44100", options);
1869 parse_option(o, "ac", "2", options);
1871 opt_default(NULL, "packetsize", "2324");
1872 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1874 /* We have to offset the PTS, so that it is consistent with the SCR.
1875 SCR starts at 36000, but the first two packs contain only padding
1876 and the first pack from the other stream, respectively, may also have
1877 been written before.
1878 So the real data starts at SCR 36000+3*1200. */
1879 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1880 } else if (!strcmp(arg, "svcd")) {
1882 opt_video_codec(o, "c:v", "mpeg2video");
1883 opt_audio_codec(o, "c:a", "mp2");
1884 parse_option(o, "f", "svcd", options);
1886 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1887 parse_option(o, "r", frame_rates[norm], options);
1888 parse_option(o, "pix_fmt", "yuv420p", options);
1889 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1891 opt_default(NULL, "b:v", "2040000");
1892 opt_default(NULL, "maxrate", "2516000");
1893 opt_default(NULL, "minrate", "0"); // 1145000;
1894 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1895 opt_default(NULL, "scan_offset", "1");
1897 opt_default(NULL, "b:a", "224000");
1898 parse_option(o, "ar", "44100", options);
1900 opt_default(NULL, "packetsize", "2324");
1902 } else if (!strcmp(arg, "dvd")) {
1904 opt_video_codec(o, "c:v", "mpeg2video");
1905 opt_audio_codec(o, "c:a", "ac3");
1906 parse_option(o, "f", "dvd", options);
1908 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1909 parse_option(o, "r", frame_rates[norm], options);
1910 parse_option(o, "pix_fmt", "yuv420p", options);
1911 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1913 opt_default(NULL, "b:v", "6000000");
1914 opt_default(NULL, "maxrate", "9000000");
1915 opt_default(NULL, "minrate", "0"); // 1500000;
1916 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1918 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1919 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1921 opt_default(NULL, "b:a", "448000");
1922 parse_option(o, "ar", "48000", options);
1924 } else if (!strncmp(arg, "dv", 2)) {
1926 parse_option(o, "f", "dv", options);
1928 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1929 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1930 norm == PAL ? "yuv420p" : "yuv411p", options);
1931 parse_option(o, "r", frame_rates[norm], options);
1933 parse_option(o, "ar", "48000", options);
1934 parse_option(o, "ac", "2", options);
1937 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1938 return AVERROR(EINVAL);
1943 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1945 av_free (vstats_filename);
1946 vstats_filename = av_strdup (arg);
1950 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1953 time_t today2 = time(NULL);
1954 struct tm *today = localtime(&today2);
1956 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1958 return opt_vstats_file(NULL, opt, filename);
1961 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1963 OptionsContext *o = optctx;
1964 return parse_option(o, "frames:v", arg, options);
1967 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1969 OptionsContext *o = optctx;
1970 return parse_option(o, "frames:a", arg, options);
1973 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1975 OptionsContext *o = optctx;
1976 return parse_option(o, "frames:d", arg, options);
1979 static int opt_preset(void *optctx, const char *opt, const char *arg)
1981 OptionsContext *o = optctx;
1983 char filename[1000], line[1000], tmp_line[1000];
1984 const char *codec_name = NULL;
1988 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1990 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1991 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1992 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1994 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1998 while (fgets(line, sizeof(line), f)) {
1999 char *key = tmp_line, *value, *endptr;
2001 if (strcspn(line, "#\n\r") == 0)
2003 strcpy(tmp_line, line);
2004 if (!av_strtok(key, "=", &value) ||
2005 !av_strtok(value, "\r\n", &endptr)) {
2006 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2009 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2011 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2012 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2013 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2014 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2015 else if (opt_default(NULL, key, value) < 0) {
2016 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2017 filename, line, key, value);
2027 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2029 OptionsContext *o = optctx;
2030 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2031 int ret = parse_option(o, s, arg, options);
2036 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2038 OptionsContext *o = optctx;
2039 if(!strcmp(opt, "b")){
2040 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2041 return parse_option(o, "b:v", arg, options);
2043 return opt_default(optctx, opt, arg);
2046 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2048 OptionsContext *o = optctx;
2051 if(!strcmp(opt, "qscale")){
2052 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2053 return parse_option(o, "q:v", arg, options);
2055 s = av_asprintf("q%s", opt + 6);
2056 ret = parse_option(o, s, arg, options);
2061 static int opt_profile(void *optctx, const char *opt, const char *arg)
2063 OptionsContext *o = optctx;
2064 if(!strcmp(opt, "profile")){
2065 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2066 return parse_option(o, "profile:v", arg, options);
2068 return opt_default(optctx, opt, arg);
2072 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2074 OptionsContext *o = optctx;
2075 return parse_option(o, "filter:v", arg, options);
2078 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2080 OptionsContext *o = optctx;
2081 return parse_option(o, "filter:a", arg, options);
2084 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2086 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2087 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2088 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2089 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2091 if (video_sync_method == VSYNC_AUTO)
2092 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2096 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2098 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2103 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2105 OptionsContext *o = optctx;
2106 char *tcr = av_asprintf("timecode=%s", arg);
2107 int ret = parse_option(o, "metadata:g", tcr, options);
2109 ret = opt_default(optctx, "gop_timecode", arg);
2114 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2116 OptionsContext *o = optctx;
2117 char layout_str[32];
2120 int ret, channels, ac_str_size;
2123 layout = av_get_channel_layout(arg);
2125 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2126 return AVERROR(EINVAL);
2128 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2129 ret = opt_default(NULL, opt, layout_str);
2133 /* set 'ac' option based on channel layout */
2134 channels = av_get_channel_layout_nb_channels(layout);
2135 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2136 stream_str = strchr(opt, ':');
2137 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2138 ac_str = av_mallocz(ac_str_size);
2140 return AVERROR(ENOMEM);
2141 av_strlcpy(ac_str, "ac", 3);
2143 av_strlcat(ac_str, stream_str, ac_str_size);
2144 ret = parse_option(o, ac_str, layout_str, options);
2150 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2152 OptionsContext *o = optctx;
2153 return parse_option(o, "q:a", arg, options);
2156 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2158 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2159 &nb_filtergraphs, nb_filtergraphs + 1);
2160 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2161 return AVERROR(ENOMEM);
2162 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2163 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2167 void show_help_default(const char *opt, const char *arg)
2169 /* per-file options have at least one of those set */
2170 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2171 int show_advanced = 0, show_avoptions = 0;
2174 if (!strcmp(opt, "long"))
2176 else if (!strcmp(opt, "full"))
2177 show_advanced = show_avoptions = 1;
2179 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2184 printf("Getting help:\n"
2185 " -h -- print basic options\n"
2186 " -h long -- print more options\n"
2187 " -h full -- print all options (including all format and codec specific options, very long)\n"
2188 " See man %s for detailed description of the options.\n"
2189 "\n", program_name);
2191 show_help_options(options, "Print help / information / capabilities:",
2194 show_help_options(options, "Global options (affect whole program "
2195 "instead of just one file:",
2196 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2198 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2199 per_file | OPT_EXIT, 0);
2201 show_help_options(options, "Per-file main options:", 0,
2202 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2203 OPT_EXIT, per_file);
2205 show_help_options(options, "Advanced per-file options:",
2206 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2208 show_help_options(options, "Video options:",
2209 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2211 show_help_options(options, "Advanced Video options:",
2212 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2214 show_help_options(options, "Audio options:",
2215 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2217 show_help_options(options, "Advanced Audio options:",
2218 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2219 show_help_options(options, "Subtitle options:",
2220 OPT_SUBTITLE, 0, 0);
2223 if (show_avoptions) {
2224 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2225 show_help_children(avcodec_get_class(), flags);
2226 show_help_children(avformat_get_class(), flags);
2227 show_help_children(sws_get_class(), flags);
2228 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2229 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2233 void show_usage(void)
2235 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2236 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2237 av_log(NULL, AV_LOG_INFO, "\n");
2241 static int opt_progress(void *optctx, const char *opt, const char *arg)
2243 AVIOContext *avio = NULL;
2246 if (!strcmp(arg, "-"))
2248 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2250 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2251 arg, av_err2str(ret));
2254 progress_avio = avio;
2258 #define OFFSET(x) offsetof(OptionsContext, x)
2259 const OptionDef options[] = {
2261 #include "cmdutils_common_opts.h"
2262 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2263 "force format", "fmt" },
2264 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2265 "input file name", "filename" },
2266 { "y", OPT_BOOL, { &file_overwrite },
2267 "overwrite output files" },
2268 { "n", OPT_BOOL, { &no_file_overwrite },
2269 "do not overwrite output files" },
2270 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2271 "codec name", "codec" },
2272 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2273 "codec name", "codec" },
2274 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2275 "preset name", "preset" },
2276 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2277 "set input stream mapping",
2278 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2279 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2280 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2281 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2282 "set metadata information of outfile from infile",
2283 "outfile[,metadata]:infile[,metadata]" },
2284 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2285 "set chapters mapping", "input_file_index" },
2286 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2287 "record or transcode \"duration\" seconds of audio/video",
2289 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2290 "set the limit file size in bytes", "limit_size" },
2291 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2292 "set the start time offset", "time_off" },
2293 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2294 "set the input ts offset", "time_off" },
2295 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2296 "set the input ts scale", "scale" },
2297 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2298 "set the recording timestamp ('now' to set the current time)", "time" },
2299 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2300 "add metadata", "string=string" },
2301 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2302 "set the number of data frames to record", "number" },
2303 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2304 "add timings for benchmarking" },
2305 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2306 "add timings for each task" },
2307 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2308 "write program-readable progress information", "url" },
2309 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2310 "enable or disable interaction on standard input" },
2311 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2312 "set max runtime in seconds", "limit" },
2313 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2314 "dump each input packet" },
2315 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2316 "when dumping packets, also dump the payload" },
2317 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2318 "read input at native frame rate", "" },
2319 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2320 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2321 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2322 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2323 "video sync method", "" },
2324 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2325 "audio sync method", "" },
2326 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2327 "audio drift threshold", "threshold" },
2328 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2329 "copy timestamps" },
2330 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2331 "copy input stream time base when stream copying", "mode" },
2332 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2333 "finish encoding within shortest input" },
2334 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2335 "timestamp discontinuity delta threshold", "threshold" },
2336 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2337 "timestamp error delta threshold", "threshold" },
2338 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2339 "exit on error", "error" },
2340 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2341 "copy initial non-keyframes" },
2342 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2343 "copy or discard frames before start time" },
2344 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2345 "set the number of frames to record", "number" },
2346 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2347 "force codec tag/fourcc", "fourcc/tag" },
2348 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2349 "use fixed quality scale (VBR)", "q" },
2350 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2351 "use fixed quality scale (VBR)", "q" },
2352 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2353 "set profile", "profile" },
2354 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2355 "set stream filterchain", "filter_list" },
2356 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2357 "reinit filtergraph on input parameter changes", "" },
2358 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2359 "create a complex filtergraph", "graph_description" },
2360 { "stats", OPT_BOOL, { &print_stats },
2361 "print progress report during encoding", },
2362 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2363 "add an attachment to the output file", "filename" },
2364 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2365 "extract an attachment into a file", "filename" },
2366 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2367 "print timestamp debugging info" },
2370 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2371 "set the number of video frames to record", "number" },
2372 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2373 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2374 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2375 "set frame size (WxH or abbreviation)", "size" },
2376 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2377 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2378 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2379 "set pixel format", "format" },
2380 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2381 "set the number of bits per raw sample", "number" },
2382 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2383 "Removed, use the crop filter instead", "size" },
2384 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2385 "Removed, use the crop filter instead", "size" },
2386 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2387 "Removed, use the crop filter instead", "size" },
2388 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2389 "Removed, use the crop filter instead", "size" },
2390 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2391 "Removed, use the pad filter instead", "size" },
2392 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2393 "Removed, use the pad filter instead", "size" },
2394 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2395 "Removed, use the pad filter instead", "size" },
2396 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2397 "Removed, use the pad filter instead", "size" },
2398 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2399 "Removed, use the pad filter instead", "color" },
2400 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2401 "deprecated use -g 1" },
2402 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2404 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2405 "discard threshold", "n" },
2406 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2407 "rate control override for specific intervals", "override" },
2408 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2409 "force video codec ('copy' to copy stream)", "codec" },
2410 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2412 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2414 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2415 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2416 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2417 "select the pass number (1 to 3)", "n" },
2418 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2419 "select two pass log file name prefix", "prefix" },
2420 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2421 "this option is deprecated, use the yadif filter instead" },
2422 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2423 "calculate PSNR of compressed frames" },
2424 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2425 "dump video coding statistics to file" },
2426 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2427 "dump video coding statistics to file", "file" },
2428 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2429 "video filters", "filter list" },
2430 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2431 "specify intra matrix coeffs", "matrix" },
2432 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2433 "specify inter matrix coeffs", "matrix" },
2434 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2435 "top=1/bottom=0/auto=-1 field first", "" },
2436 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2437 "intra_dc_precision", "precision" },
2438 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2439 "force video tag/fourcc", "fourcc/tag" },
2440 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2441 "show QP histogram" },
2442 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2443 "force the selected framerate, disable the best supported framerate selection" },
2444 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2445 "set the value of an outfile streamid", "streamIndex:value" },
2446 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2447 { .off = OFFSET(forced_key_frames) },
2448 "force key frames at specified timestamps", "timestamps" },
2449 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2450 "video bitrate (please use -b:v)", "bitrate" },
2453 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2454 "set the number of audio frames to record", "number" },
2455 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2456 "set audio quality (codec-specific)", "quality", },
2457 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2458 "set audio sampling rate (in Hz)", "rate" },
2459 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2460 "set number of audio channels", "channels" },
2461 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2463 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2464 "force audio codec ('copy' to copy stream)", "codec" },
2465 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2466 "force audio tag/fourcc", "fourcc/tag" },
2467 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2468 "change audio volume (256=normal)" , "volume" },
2469 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2470 "set sample format", "format" },
2471 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2472 "set channel layout", "layout" },
2473 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2474 "audio filters", "filter list" },
2476 /* subtitle options */
2477 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2478 "disable subtitle" },
2479 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2480 "force subtitle codec ('copy' to copy stream)", "codec" },
2481 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2482 , "force subtitle tag/fourcc", "fourcc/tag" },
2483 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2484 "fix subtitles duration" },
2487 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2488 "deprecated, use -channel", "channel" },
2489 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2490 "deprecated, use -standard", "standard" },
2491 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2494 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2495 "set the maximum demux-decode delay", "seconds" },
2496 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2497 "set the initial demux-decode delay", "seconds" },
2499 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2500 "A comma-separated list of bitstream filters", "bitstream_filters" },
2501 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2502 "deprecated", "audio bitstream_filters" },
2503 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2504 "deprecated", "video bitstream_filters" },
2506 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2507 "set the audio options to the indicated preset", "preset" },
2508 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2509 "set the video options to the indicated preset", "preset" },
2510 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2511 "set the subtitle options to the indicated preset", "preset" },
2512 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2513 "set options from indicated preset file", "filename" },
2514 /* data codec support */
2515 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2516 "force data codec ('copy' to copy stream)", "codec" },
2517 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2520 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2521 "generic catch all option", "" },