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 arg metadata string to parse
372 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
373 * @param index for type c/p, chapter/program index is written here
374 * @param stream_spec for type s, the stream specifier is written here
376 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
384 if (*(++arg) && *arg != ':') {
385 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
388 *stream_spec = *arg == ':' ? arg + 1 : "";
393 *index = strtol(++arg, NULL, 0);
396 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
403 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
405 AVDictionary **meta_in = NULL;
406 AVDictionary **meta_out = NULL;
408 char type_in, type_out;
409 const char *istream_spec = NULL, *ostream_spec = NULL;
410 int idx_in = 0, idx_out = 0;
412 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
413 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
416 if (type_out == 'g' || !*outspec)
417 o->metadata_global_manual = 1;
418 if (type_out == 's' || !*outspec)
419 o->metadata_streams_manual = 1;
420 if (type_out == 'c' || !*outspec)
421 o->metadata_chapters_manual = 1;
425 if (type_in == 'g' || type_out == 'g')
426 o->metadata_global_manual = 1;
427 if (type_in == 's' || type_out == 's')
428 o->metadata_streams_manual = 1;
429 if (type_in == 'c' || type_out == 'c')
430 o->metadata_chapters_manual = 1;
432 /* ic is NULL when just disabling automatic mappings */
436 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
437 if ((index) < 0 || (index) >= (nb_elems)) {\
438 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
443 #define SET_DICT(type, meta, context, index)\
446 meta = &context->metadata;\
449 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
450 meta = &context->chapters[index]->metadata;\
453 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
454 meta = &context->programs[index]->metadata;\
456 default: av_assert0(0);\
461 SET_DICT(type_in, meta_in, ic, idx_in);
462 SET_DICT(type_out, meta_out, oc, idx_out);
464 /* for input streams choose first matching stream */
465 if (type_in == 's') {
466 for (i = 0; i < ic->nb_streams; i++) {
467 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
468 meta_in = &ic->streams[i]->metadata;
474 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
479 if (type_out == 's') {
480 for (i = 0; i < oc->nb_streams; i++) {
481 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
482 meta_out = &oc->streams[i]->metadata;
483 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
488 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
493 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
495 OptionsContext *o = optctx;
497 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
498 struct tm time = *gmtime((time_t*)&recording_timestamp);
499 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
500 parse_option(o, "metadata", buf, options);
502 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
503 "tag instead.\n", opt);
507 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
509 const AVCodecDescriptor *desc;
510 const char *codec_string = encoder ? "encoder" : "decoder";
514 avcodec_find_encoder_by_name(name) :
515 avcodec_find_decoder_by_name(name);
517 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
518 codec = encoder ? avcodec_find_encoder(desc->id) :
519 avcodec_find_decoder(desc->id);
521 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
522 codec_string, codec->name, desc->name);
526 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
529 if (codec->type != type) {
530 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
536 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
538 char *codec_name = NULL;
540 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
542 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
543 st->codec->codec_id = codec->id;
546 return avcodec_find_decoder(st->codec->codec_id);
549 /* Add all the streams from the given input file to the global
550 * list of input streams. */
551 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
554 char *next, *codec_tag = NULL;
556 for (i = 0; i < ic->nb_streams; i++) {
557 AVStream *st = ic->streams[i];
558 AVCodecContext *dec = st->codec;
559 InputStream *ist = av_mallocz(sizeof(*ist));
560 char *framerate = NULL;
565 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
566 input_streams[nb_input_streams - 1] = ist;
569 ist->file_index = nb_input_files;
571 st->discard = AVDISCARD_ALL;
572 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
575 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
577 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
579 uint32_t tag = strtol(codec_tag, &next, 0);
581 tag = AV_RL32(codec_tag);
582 st->codec->codec_tag = tag;
585 ist->dec = choose_decoder(o, ic, st);
587 ist->reinit_filters = -1;
588 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
590 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
592 switch (dec->codec_type) {
593 case AVMEDIA_TYPE_VIDEO:
595 ist->dec = avcodec_find_decoder(dec->codec_id);
597 dec->flags |= CODEC_FLAG_EMU_EDGE;
600 ist->resample_height = dec->height;
601 ist->resample_width = dec->width;
602 ist->resample_pix_fmt = dec->pix_fmt;
604 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
605 if (framerate && av_parse_video_rate(&ist->framerate,
607 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
612 ist->top_field_first = -1;
613 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
616 case AVMEDIA_TYPE_AUDIO:
617 guess_input_channel_layout(ist);
619 ist->resample_sample_fmt = dec->sample_fmt;
620 ist->resample_sample_rate = dec->sample_rate;
621 ist->resample_channels = dec->channels;
622 ist->resample_channel_layout = dec->channel_layout;
625 case AVMEDIA_TYPE_DATA:
626 case AVMEDIA_TYPE_SUBTITLE:
628 ist->dec = avcodec_find_decoder(dec->codec_id);
629 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
631 case AVMEDIA_TYPE_ATTACHMENT:
632 case AVMEDIA_TYPE_UNKNOWN:
640 static void assert_file_overwrite(const char *filename)
642 if ((!file_overwrite || no_file_overwrite) &&
643 (strchr(filename, ':') == NULL || filename[1] == ':' ||
644 av_strstart(filename, "file:", NULL))) {
645 if (avio_check(filename, 0) == 0) {
646 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
647 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
650 signal(SIGINT, SIG_DFL);
652 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
658 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
665 static void dump_attachment(AVStream *st, const char *filename)
668 AVIOContext *out = NULL;
669 AVDictionaryEntry *e;
671 if (!st->codec->extradata_size) {
672 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
673 nb_input_files - 1, st->index);
676 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
679 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
680 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
684 assert_file_overwrite(filename);
686 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
687 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
692 avio_write(out, st->codec->extradata, st->codec->extradata_size);
697 static int opt_input_file(void *optctx, const char *opt, const char *filename)
699 OptionsContext *o = optctx;
701 AVInputFormat *file_iformat = NULL;
706 int orig_nb_streams; // number of streams before avformat_find_stream_info
707 char * video_codec_name = NULL;
708 char * audio_codec_name = NULL;
709 char *subtitle_codec_name = NULL;
712 if (!(file_iformat = av_find_input_format(o->format))) {
713 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
718 if (!strcmp(filename, "-"))
721 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
722 strcmp(filename, "/dev/stdin");
724 /* get default parameters from command line */
725 ic = avformat_alloc_context();
727 print_error(filename, AVERROR(ENOMEM));
730 if (o->nb_audio_sample_rate) {
731 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
732 av_dict_set(&format_opts, "sample_rate", buf, 0);
734 if (o->nb_audio_channels) {
735 /* because we set audio_channels based on both the "ac" and
736 * "channel_layout" options, we need to check that the specified
737 * demuxer actually has the "channels" option before setting it */
738 if (file_iformat && file_iformat->priv_class &&
739 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
740 AV_OPT_SEARCH_FAKE_OBJ)) {
741 snprintf(buf, sizeof(buf), "%d",
742 o->audio_channels[o->nb_audio_channels - 1].u.i);
743 av_dict_set(&format_opts, "channels", buf, 0);
746 if (o->nb_frame_rates) {
747 /* set the format-level framerate option;
748 * this is important for video grabbers, e.g. x11 */
749 if (file_iformat && file_iformat->priv_class &&
750 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
751 AV_OPT_SEARCH_FAKE_OBJ)) {
752 av_dict_set(&format_opts, "framerate",
753 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
756 if (o->nb_frame_sizes) {
757 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
759 if (o->nb_frame_pix_fmts)
760 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
762 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
763 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
764 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
766 ic->video_codec_id = video_codec_name ?
767 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
768 ic->audio_codec_id = audio_codec_name ?
769 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
770 ic->subtitle_codec_id= subtitle_codec_name ?
771 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
772 ic->flags |= AVFMT_FLAG_NONBLOCK;
773 ic->interrupt_callback = int_cb;
775 /* open the input file with generic avformat function */
776 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
778 print_error(filename, err);
781 assert_avoptions(format_opts);
783 /* apply forced codec ids */
784 for (i = 0; i < ic->nb_streams; i++)
785 choose_decoder(o, ic, ic->streams[i]);
787 /* Set AVCodecContext options for avformat_find_stream_info */
788 opts = setup_find_stream_info_opts(ic, codec_opts);
789 orig_nb_streams = ic->nb_streams;
791 /* If not enough info to get the stream parameters, we decode the
792 first frames to get it. (used in mpeg case for example) */
793 ret = avformat_find_stream_info(ic, opts);
795 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
796 avformat_close_input(&ic);
800 timestamp = o->start_time;
801 /* add the stream start time */
802 if (ic->start_time != AV_NOPTS_VALUE)
803 timestamp += ic->start_time;
805 /* if seeking requested, we execute it */
806 if (o->start_time != 0) {
807 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
809 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
810 filename, (double)timestamp / AV_TIME_BASE);
814 /* update the current parameters so that they match the one of the input stream */
815 add_input_streams(o, ic);
817 /* dump the file content */
818 av_dump_format(ic, nb_input_files, filename, 0);
820 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
821 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
824 input_files[nb_input_files - 1]->ctx = ic;
825 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
826 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
827 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
828 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
830 for (i = 0; i < o->nb_dump_attachment; i++) {
833 for (j = 0; j < ic->nb_streams; j++) {
834 AVStream *st = ic->streams[j];
836 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
837 dump_attachment(st, o->dump_attachment[i].u.str);
841 for (i = 0; i < orig_nb_streams; i++)
842 av_dict_free(&opts[i]);
849 static uint8_t *get_line(AVIOContext *s)
855 if (avio_open_dyn_buf(&line) < 0) {
856 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
860 while ((c = avio_r8(s)) && c != '\n')
863 avio_close_dyn_buf(line, &buf);
868 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
872 const char *base[3] = { getenv("AVCONV_DATADIR"),
877 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
881 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
882 i != 1 ? "" : "/.avconv", codec_name, preset_name);
883 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
886 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
887 i != 1 ? "" : "/.avconv", preset_name);
888 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
894 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
896 char *codec_name = NULL;
898 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
900 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
901 NULL, ost->st->codec->codec_type);
902 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
903 } else if (!strcmp(codec_name, "copy"))
904 ost->stream_copy = 1;
906 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
907 ost->st->codec->codec_id = ost->enc->id;
911 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
914 AVStream *st = avformat_new_stream(oc, NULL);
915 int idx = oc->nb_streams - 1, ret = 0;
916 char *bsf = NULL, *next, *codec_tag = NULL;
917 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
921 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
925 if (oc->nb_streams - 1 < o->nb_streamid_map)
926 st->id = o->streamid_map[oc->nb_streams - 1];
928 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
929 nb_output_streams + 1);
930 if (!(ost = av_mallocz(sizeof(*ost))))
932 output_streams[nb_output_streams - 1] = ost;
934 ost->file_index = nb_output_files;
937 st->codec->codec_type = type;
938 choose_encoder(o, oc, ost);
940 AVIOContext *s = NULL;
941 char *buf = NULL, *arg = NULL, *preset = NULL;
943 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
945 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
946 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
949 if (!buf[0] || buf[0] == '#') {
953 if (!(arg = strchr(buf, '='))) {
954 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
958 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
960 } while (!s->eof_reached);
964 av_log(NULL, AV_LOG_FATAL,
965 "Preset %s specified for stream %d:%d, but could not be opened.\n",
966 preset, ost->file_index, ost->index);
971 avcodec_get_context_defaults3(st->codec, ost->enc);
972 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
974 ost->max_frames = INT64_MAX;
975 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
977 ost->copy_prior_start = -1;
978 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
980 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
982 if (next = strchr(bsf, ','))
984 if (!(bsfc = av_bitstream_filter_init(bsf))) {
985 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
989 bsfc_prev->next = bsfc;
991 ost->bitstream_filters = bsfc;
997 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
999 uint32_t tag = strtol(codec_tag, &next, 0);
1001 tag = AV_RL32(codec_tag);
1002 st->codec->codec_tag = tag;
1005 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1007 st->codec->flags |= CODEC_FLAG_QSCALE;
1008 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1011 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1012 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1014 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1015 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1016 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1018 ost->source_index = source_index;
1019 if (source_index >= 0) {
1020 ost->sync_ist = input_streams[source_index];
1021 input_streams[source_index]->discard = 0;
1022 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1028 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1031 const char *p = str;
1038 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1045 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1049 AVCodecContext *video_enc;
1050 char *frame_rate = NULL;
1052 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1054 video_enc = st->codec;
1056 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1057 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1058 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1062 if (!ost->stream_copy) {
1063 const char *p = NULL;
1064 char *frame_size = NULL;
1065 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1066 char *intra_matrix = NULL, *inter_matrix = NULL;
1067 const char *filters = "null";
1071 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1072 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1073 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1077 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1078 if (frame_aspect_ratio) {
1080 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1081 q.num <= 0 || q.den <= 0) {
1082 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1085 ost->frame_aspect_ratio = av_q2d(q);
1088 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1089 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1090 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1091 ost->keep_pix_fmt = 1;
1092 if (!*++frame_pix_fmt)
1093 frame_pix_fmt = NULL;
1095 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1096 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1099 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1102 video_enc->gop_size = 0;
1103 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1105 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1106 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1109 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1111 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1113 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1114 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1117 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1120 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1121 for (i = 0; p; i++) {
1123 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1125 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1128 /* FIXME realloc failure */
1129 video_enc->rc_override =
1130 av_realloc(video_enc->rc_override,
1131 sizeof(RcOverride) * (i + 1));
1132 video_enc->rc_override[i].start_frame = start;
1133 video_enc->rc_override[i].end_frame = end;
1135 video_enc->rc_override[i].qscale = q;
1136 video_enc->rc_override[i].quality_factor = 1.0;
1139 video_enc->rc_override[i].qscale = 0;
1140 video_enc->rc_override[i].quality_factor = -q/100.0;
1145 video_enc->rc_override_count = i;
1146 if (!video_enc->rc_initial_buffer_occupancy)
1147 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1148 video_enc->intra_dc_precision = intra_dc_precision - 8;
1151 video_enc->flags|= CODEC_FLAG_PSNR;
1154 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1157 video_enc->flags |= CODEC_FLAG_PASS1;
1160 video_enc->flags |= CODEC_FLAG_PASS2;
1164 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1165 if (ost->logfile_prefix &&
1166 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1169 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1170 if (ost->forced_keyframes)
1171 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1173 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1175 ost->top_field_first = -1;
1176 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1178 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1179 ost->avfilter = av_strdup(filters);
1181 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1187 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1192 AVCodecContext *audio_enc;
1194 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1197 audio_enc = st->codec;
1198 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1200 if (!ost->stream_copy) {
1201 char *sample_fmt = NULL;
1202 const char *filters = "anull";
1204 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1206 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1208 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1209 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1213 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1215 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1217 av_assert1(filters);
1218 ost->avfilter = av_strdup(filters);
1220 /* check for channel mapping for this audio stream */
1221 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1222 AudioChannelMap *map = &o->audio_channel_maps[n];
1223 InputStream *ist = input_streams[ost->source_index];
1224 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1225 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1226 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1227 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1228 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1230 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1231 ost->file_index, ost->st->index);
1239 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1243 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1244 if (!ost->stream_copy) {
1245 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1252 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1254 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1255 ost->stream_copy = 1;
1259 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1263 AVCodecContext *subtitle_enc;
1265 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1267 subtitle_enc = st->codec;
1269 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1271 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1273 if (!ost->stream_copy) {
1274 char *frame_size = NULL;
1276 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1277 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1278 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1286 /* arg format is "output-stream-index:streamid-value". */
1287 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1289 OptionsContext *o = optctx;
1294 av_strlcpy(idx_str, arg, sizeof(idx_str));
1295 p = strchr(idx_str, ':');
1297 av_log(NULL, AV_LOG_FATAL,
1298 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1303 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1304 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1305 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1309 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1311 AVFormatContext *is = ifile->ctx;
1312 AVFormatContext *os = ofile->ctx;
1316 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1318 return AVERROR(ENOMEM);
1321 for (i = 0; i < is->nb_chapters; i++) {
1322 AVChapter *in_ch = is->chapters[i], *out_ch;
1323 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1324 AV_TIME_BASE_Q, in_ch->time_base);
1325 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1326 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1329 if (in_ch->end < ts_off)
1331 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1334 out_ch = av_mallocz(sizeof(AVChapter));
1336 return AVERROR(ENOMEM);
1338 out_ch->id = in_ch->id;
1339 out_ch->time_base = in_ch->time_base;
1340 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1341 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1344 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1346 os->chapters[os->nb_chapters++] = out_ch;
1351 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1354 AVFormatContext *ic = avformat_alloc_context();
1356 ic->interrupt_callback = int_cb;
1357 err = avformat_open_input(&ic, filename, NULL, NULL);
1360 /* copy stream format */
1361 for(i=0;i<ic->nb_streams;i++) {
1365 AVCodecContext *avctx;
1367 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1368 ost = new_output_stream(o, s, codec->type, -1);
1373 // FIXME: a more elegant solution is needed
1374 memcpy(st, ic->streams[i], sizeof(AVStream));
1376 st->info = av_malloc(sizeof(*st->info));
1377 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1379 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1381 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1382 choose_sample_fmt(st, codec);
1383 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1384 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1387 /* ffserver seeking with date=... needs a date reference */
1388 err = parse_option(o, "metadata", "creation_time=now", options);
1390 avformat_close_input(&ic);
1394 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1395 AVFormatContext *oc)
1399 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1400 ofilter->out_tmp->pad_idx)) {
1401 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1402 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1404 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1409 ost->source_index = -1;
1410 ost->filter = ofilter;
1414 if (ost->stream_copy) {
1415 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1416 "which is fed from a complex filtergraph. Filtering and streamcopy "
1417 "cannot be used together.\n", ost->file_index, ost->index);
1421 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1422 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1425 avfilter_inout_free(&ofilter->out_tmp);
1428 static int configure_complex_filters(void)
1432 for (i = 0; i < nb_filtergraphs; i++)
1433 if (!filtergraphs[i]->graph &&
1434 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1439 void opt_output_file(void *optctx, const char *filename)
1441 OptionsContext *o = optctx;
1442 AVFormatContext *oc;
1444 AVOutputFormat *file_oformat;
1448 if (configure_complex_filters() < 0) {
1449 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1453 if (!strcmp(filename, "-"))
1456 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1458 print_error(filename, err);
1461 file_oformat= oc->oformat;
1462 oc->interrupt_callback = int_cb;
1464 /* create streams for all unlabeled output pads */
1465 for (i = 0; i < nb_filtergraphs; i++) {
1466 FilterGraph *fg = filtergraphs[i];
1467 for (j = 0; j < fg->nb_outputs; j++) {
1468 OutputFilter *ofilter = fg->outputs[j];
1470 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1473 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1474 ofilter->out_tmp->pad_idx)) {
1475 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1476 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1477 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1479 init_output_filter(ofilter, o, oc);
1483 if (!strcmp(file_oformat->name, "ffm") &&
1484 av_strstart(filename, "http:", NULL)) {
1486 /* special case for files sent to ffserver: we get the stream
1487 parameters from ffserver */
1488 int err = read_ffserver_streams(o, oc, filename);
1490 print_error(filename, err);
1493 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1494 ost = output_streams[j];
1495 for (i = 0; i < nb_input_streams; i++) {
1496 ist = input_streams[i];
1497 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1499 ost->source_index= i;
1500 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1501 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1503 ist->st->discard = AVDISCARD_NONE;
1508 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));
1512 } else if (!o->nb_stream_maps) {
1513 char *subtitle_codec_name = NULL;
1514 /* pick the "best" stream of each type */
1516 /* video: highest resolution */
1517 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1518 int area = 0, idx = -1;
1519 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1520 for (i = 0; i < nb_input_streams; i++) {
1522 ist = input_streams[i];
1523 new_area = ist->st->codec->width * ist->st->codec->height;
1524 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1526 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1528 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1535 new_video_stream(o, oc, idx);
1538 /* audio: most channels */
1539 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1540 int channels = 0, idx = -1;
1541 for (i = 0; i < nb_input_streams; i++) {
1542 ist = input_streams[i];
1543 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1544 ist->st->codec->channels > channels) {
1545 channels = ist->st->codec->channels;
1550 new_audio_stream(o, oc, idx);
1553 /* subtitles: pick first */
1554 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1555 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1556 for (i = 0; i < nb_input_streams; i++)
1557 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1558 new_subtitle_stream(o, oc, i);
1562 /* do something with data? */
1564 for (i = 0; i < o->nb_stream_maps; i++) {
1565 StreamMap *map = &o->stream_maps[i];
1566 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1571 if (map->linklabel) {
1573 OutputFilter *ofilter = NULL;
1576 for (j = 0; j < nb_filtergraphs; j++) {
1577 fg = filtergraphs[j];
1578 for (k = 0; k < fg->nb_outputs; k++) {
1579 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1580 if (out && !strcmp(out->name, map->linklabel)) {
1581 ofilter = fg->outputs[k];
1588 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1589 "in any defined filter graph.\n", map->linklabel);
1592 init_output_filter(ofilter, o, oc);
1594 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1595 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1597 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1599 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1601 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1604 switch (ist->st->codec->codec_type) {
1605 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1606 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1607 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1608 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1609 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1611 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1612 map->file_index, map->stream_index);
1620 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1621 AVDictionaryEntry *e;
1622 ost = output_streams[i];
1624 if ( ost->stream_copy
1625 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1626 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1627 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1631 /* handle attached files */
1632 for (i = 0; i < o->nb_attachments; i++) {
1634 uint8_t *attachment;
1638 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1639 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1643 if ((len = avio_size(pb)) <= 0) {
1644 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1648 if (!(attachment = av_malloc(len))) {
1649 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1653 avio_read(pb, attachment, len);
1655 ost = new_attachment_stream(o, oc, -1);
1656 ost->stream_copy = 0;
1657 ost->attachment_filename = o->attachments[i];
1658 ost->st->codec->extradata = attachment;
1659 ost->st->codec->extradata_size = len;
1661 p = strrchr(o->attachments[i], '/');
1662 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1666 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1667 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1670 output_files[nb_output_files - 1]->ctx = oc;
1671 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1672 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1673 if (o->recording_time != INT64_MAX)
1674 oc->duration = o->recording_time;
1675 output_files[nb_output_files - 1]->start_time = o->start_time;
1676 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1677 output_files[nb_output_files - 1]->shortest = o->shortest;
1678 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1680 /* check filename in case of an image number is expected */
1681 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1682 if (!av_filename_number_test(oc->filename)) {
1683 print_error(oc->filename, AVERROR(EINVAL));
1688 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1689 /* test if it already exists to avoid losing precious files */
1690 assert_file_overwrite(filename);
1693 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1694 &oc->interrupt_callback,
1695 &output_files[nb_output_files - 1]->opts)) < 0) {
1696 print_error(filename, err);
1701 if (o->mux_preload) {
1703 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1704 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1706 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1709 for (i = 0; i < o->nb_metadata_map; i++) {
1711 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1713 if (in_file_index >= nb_input_files) {
1714 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1717 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1718 in_file_index >= 0 ?
1719 input_files[in_file_index]->ctx : NULL, o);
1723 if (o->chapters_input_file >= nb_input_files) {
1724 if (o->chapters_input_file == INT_MAX) {
1725 /* copy chapters from the first input file that has them*/
1726 o->chapters_input_file = -1;
1727 for (i = 0; i < nb_input_files; i++)
1728 if (input_files[i]->ctx->nb_chapters) {
1729 o->chapters_input_file = i;
1733 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1734 o->chapters_input_file);
1738 if (o->chapters_input_file >= 0)
1739 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1740 !o->metadata_chapters_manual);
1742 /* copy global metadata by default */
1743 if (!o->metadata_global_manual && nb_input_files){
1744 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1745 AV_DICT_DONT_OVERWRITE);
1746 if(o->recording_time != INT64_MAX)
1747 av_dict_set(&oc->metadata, "duration", NULL, 0);
1748 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1750 if (!o->metadata_streams_manual)
1751 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1753 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1755 ist = input_streams[output_streams[i]->source_index];
1756 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1759 /* process manually set metadata */
1760 for (i = 0; i < o->nb_metadata; i++) {
1763 const char *stream_spec;
1764 int index = 0, j, ret = 0;
1766 val = strchr(o->metadata[i].u.str, '=');
1768 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1769 o->metadata[i].u.str);
1774 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1776 for (j = 0; j < oc->nb_streams; j++) {
1777 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1778 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1789 if (index < 0 || index >= oc->nb_chapters) {
1790 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1793 m = &oc->chapters[index]->metadata;
1796 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1799 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1803 reset_options(o, 0);
1806 static int opt_target(void *optctx, const char *opt, const char *arg)
1808 OptionsContext *o = optctx;
1809 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1810 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1812 if (!strncmp(arg, "pal-", 4)) {
1815 } else if (!strncmp(arg, "ntsc-", 5)) {
1818 } else if (!strncmp(arg, "film-", 5)) {
1822 /* Try to determine PAL/NTSC by peeking in the input files */
1823 if (nb_input_files) {
1825 for (j = 0; j < nb_input_files; j++) {
1826 for (i = 0; i < input_files[j]->nb_streams; i++) {
1827 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1828 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1830 fr = c->time_base.den * 1000 / c->time_base.num;
1834 } else if ((fr == 29970) || (fr == 23976)) {
1839 if (norm != UNKNOWN)
1843 if (norm != UNKNOWN)
1844 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1847 if (norm == UNKNOWN) {
1848 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1849 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1850 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1854 if (!strcmp(arg, "vcd")) {
1855 opt_video_codec(o, "c:v", "mpeg1video");
1856 opt_audio_codec(o, "c:a", "mp2");
1857 parse_option(o, "f", "vcd", options);
1859 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1860 parse_option(o, "r", frame_rates[norm], options);
1861 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1863 opt_default(NULL, "b:v", "1150000");
1864 opt_default(NULL, "maxrate", "1150000");
1865 opt_default(NULL, "minrate", "1150000");
1866 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1868 opt_default(NULL, "b:a", "224000");
1869 parse_option(o, "ar", "44100", options);
1870 parse_option(o, "ac", "2", options);
1872 opt_default(NULL, "packetsize", "2324");
1873 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1875 /* We have to offset the PTS, so that it is consistent with the SCR.
1876 SCR starts at 36000, but the first two packs contain only padding
1877 and the first pack from the other stream, respectively, may also have
1878 been written before.
1879 So the real data starts at SCR 36000+3*1200. */
1880 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1881 } else if (!strcmp(arg, "svcd")) {
1883 opt_video_codec(o, "c:v", "mpeg2video");
1884 opt_audio_codec(o, "c:a", "mp2");
1885 parse_option(o, "f", "svcd", options);
1887 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1888 parse_option(o, "r", frame_rates[norm], options);
1889 parse_option(o, "pix_fmt", "yuv420p", options);
1890 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1892 opt_default(NULL, "b:v", "2040000");
1893 opt_default(NULL, "maxrate", "2516000");
1894 opt_default(NULL, "minrate", "0"); // 1145000;
1895 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1896 opt_default(NULL, "scan_offset", "1");
1898 opt_default(NULL, "b:a", "224000");
1899 parse_option(o, "ar", "44100", options);
1901 opt_default(NULL, "packetsize", "2324");
1903 } else if (!strcmp(arg, "dvd")) {
1905 opt_video_codec(o, "c:v", "mpeg2video");
1906 opt_audio_codec(o, "c:a", "ac3");
1907 parse_option(o, "f", "dvd", options);
1909 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1910 parse_option(o, "r", frame_rates[norm], options);
1911 parse_option(o, "pix_fmt", "yuv420p", options);
1912 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1914 opt_default(NULL, "b:v", "6000000");
1915 opt_default(NULL, "maxrate", "9000000");
1916 opt_default(NULL, "minrate", "0"); // 1500000;
1917 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1919 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1920 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1922 opt_default(NULL, "b:a", "448000");
1923 parse_option(o, "ar", "48000", options);
1925 } else if (!strncmp(arg, "dv", 2)) {
1927 parse_option(o, "f", "dv", options);
1929 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1930 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1931 norm == PAL ? "yuv420p" : "yuv411p", options);
1932 parse_option(o, "r", frame_rates[norm], options);
1934 parse_option(o, "ar", "48000", options);
1935 parse_option(o, "ac", "2", options);
1938 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1939 return AVERROR(EINVAL);
1944 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1946 av_free (vstats_filename);
1947 vstats_filename = av_strdup (arg);
1951 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1954 time_t today2 = time(NULL);
1955 struct tm *today = localtime(&today2);
1957 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1959 return opt_vstats_file(NULL, opt, filename);
1962 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1964 OptionsContext *o = optctx;
1965 return parse_option(o, "frames:v", arg, options);
1968 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1970 OptionsContext *o = optctx;
1971 return parse_option(o, "frames:a", arg, options);
1974 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1976 OptionsContext *o = optctx;
1977 return parse_option(o, "frames:d", arg, options);
1980 static int opt_preset(void *optctx, const char *opt, const char *arg)
1982 OptionsContext *o = optctx;
1984 char filename[1000], line[1000], tmp_line[1000];
1985 const char *codec_name = NULL;
1989 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1991 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1992 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1993 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1995 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1999 while (fgets(line, sizeof(line), f)) {
2000 char *key = tmp_line, *value, *endptr;
2002 if (strcspn(line, "#\n\r") == 0)
2004 strcpy(tmp_line, line);
2005 if (!av_strtok(key, "=", &value) ||
2006 !av_strtok(value, "\r\n", &endptr)) {
2007 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2010 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2012 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2013 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2014 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2015 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2016 else if (opt_default(NULL, key, value) < 0) {
2017 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2018 filename, line, key, value);
2028 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2030 OptionsContext *o = optctx;
2031 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2032 int ret = parse_option(o, s, arg, options);
2037 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2039 OptionsContext *o = optctx;
2040 if(!strcmp(opt, "b")){
2041 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2042 return parse_option(o, "b:v", arg, options);
2044 return opt_default(optctx, opt, arg);
2047 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2049 OptionsContext *o = optctx;
2052 if(!strcmp(opt, "qscale")){
2053 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2054 return parse_option(o, "q:v", arg, options);
2056 s = av_asprintf("q%s", opt + 6);
2057 ret = parse_option(o, s, arg, options);
2062 static int opt_profile(void *optctx, const char *opt, const char *arg)
2064 OptionsContext *o = optctx;
2065 if(!strcmp(opt, "profile")){
2066 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2067 return parse_option(o, "profile:v", arg, options);
2069 return opt_default(optctx, opt, arg);
2073 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2075 OptionsContext *o = optctx;
2076 return parse_option(o, "filter:v", arg, options);
2079 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2081 OptionsContext *o = optctx;
2082 return parse_option(o, "filter:a", arg, options);
2085 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2087 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2088 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2089 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2090 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2092 if (video_sync_method == VSYNC_AUTO)
2093 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2097 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2099 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2104 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2106 OptionsContext *o = optctx;
2107 char *tcr = av_asprintf("timecode=%s", arg);
2108 int ret = parse_option(o, "metadata:g", tcr, options);
2110 ret = opt_default(optctx, "gop_timecode", arg);
2115 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2117 OptionsContext *o = optctx;
2118 char layout_str[32];
2121 int ret, channels, ac_str_size;
2124 layout = av_get_channel_layout(arg);
2126 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2127 return AVERROR(EINVAL);
2129 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2130 ret = opt_default(NULL, opt, layout_str);
2134 /* set 'ac' option based on channel layout */
2135 channels = av_get_channel_layout_nb_channels(layout);
2136 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2137 stream_str = strchr(opt, ':');
2138 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2139 ac_str = av_mallocz(ac_str_size);
2141 return AVERROR(ENOMEM);
2142 av_strlcpy(ac_str, "ac", 3);
2144 av_strlcat(ac_str, stream_str, ac_str_size);
2145 ret = parse_option(o, ac_str, layout_str, options);
2151 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2153 OptionsContext *o = optctx;
2154 return parse_option(o, "q:a", arg, options);
2157 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2159 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2160 &nb_filtergraphs, nb_filtergraphs + 1);
2161 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2162 return AVERROR(ENOMEM);
2163 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2164 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2168 void show_help_default(const char *opt, const char *arg)
2170 /* per-file options have at least one of those set */
2171 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2172 int show_advanced = 0, show_avoptions = 0;
2175 if (!strcmp(opt, "long"))
2177 else if (!strcmp(opt, "full"))
2178 show_advanced = show_avoptions = 1;
2180 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2185 printf("Getting help:\n"
2186 " -h -- print basic options\n"
2187 " -h long -- print more options\n"
2188 " -h full -- print all options (including all format and codec specific options, very long)\n"
2189 " See man %s for detailed description of the options.\n"
2190 "\n", program_name);
2192 show_help_options(options, "Print help / information / capabilities:",
2195 show_help_options(options, "Global options (affect whole program "
2196 "instead of just one file:",
2197 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2199 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2200 per_file | OPT_EXIT, 0);
2202 show_help_options(options, "Per-file main options:", 0,
2203 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2204 OPT_EXIT, per_file);
2206 show_help_options(options, "Advanced per-file options:",
2207 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2209 show_help_options(options, "Video options:",
2210 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2212 show_help_options(options, "Advanced Video options:",
2213 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2215 show_help_options(options, "Audio options:",
2216 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2218 show_help_options(options, "Advanced Audio options:",
2219 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2220 show_help_options(options, "Subtitle options:",
2221 OPT_SUBTITLE, 0, 0);
2224 if (show_avoptions) {
2225 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2226 show_help_children(avcodec_get_class(), flags);
2227 show_help_children(avformat_get_class(), flags);
2228 show_help_children(sws_get_class(), flags);
2229 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2230 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2234 void show_usage(void)
2236 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2237 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2238 av_log(NULL, AV_LOG_INFO, "\n");
2242 static int opt_progress(void *optctx, const char *opt, const char *arg)
2244 AVIOContext *avio = NULL;
2247 if (!strcmp(arg, "-"))
2249 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2251 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2252 arg, av_err2str(ret));
2255 progress_avio = avio;
2259 #define OFFSET(x) offsetof(OptionsContext, x)
2260 const OptionDef options[] = {
2262 #include "cmdutils_common_opts.h"
2263 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2264 "force format", "fmt" },
2265 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2266 "input file name", "filename" },
2267 { "y", OPT_BOOL, { &file_overwrite },
2268 "overwrite output files" },
2269 { "n", OPT_BOOL, { &no_file_overwrite },
2270 "do not overwrite output files" },
2271 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2272 "codec name", "codec" },
2273 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2274 "codec name", "codec" },
2275 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2276 "preset name", "preset" },
2277 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2278 "set input stream mapping",
2279 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2280 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2281 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2282 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2283 "set metadata information of outfile from infile",
2284 "outfile[,metadata]:infile[,metadata]" },
2285 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2286 "set chapters mapping", "input_file_index" },
2287 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2288 "record or transcode \"duration\" seconds of audio/video",
2290 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2291 "set the limit file size in bytes", "limit_size" },
2292 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2293 "set the start time offset", "time_off" },
2294 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2295 "set the input ts offset", "time_off" },
2296 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2297 "set the input ts scale", "scale" },
2298 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2299 "set the recording timestamp ('now' to set the current time)", "time" },
2300 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2301 "add metadata", "string=string" },
2302 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2303 "set the number of data frames to record", "number" },
2304 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2305 "add timings for benchmarking" },
2306 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2307 "add timings for each task" },
2308 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2309 "write program-readable progress information", "url" },
2310 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2311 "enable or disable interaction on standard input" },
2312 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2313 "set max runtime in seconds", "limit" },
2314 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2315 "dump each input packet" },
2316 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2317 "when dumping packets, also dump the payload" },
2318 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2319 "read input at native frame rate", "" },
2320 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2321 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2322 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2323 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2324 "video sync method", "" },
2325 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2326 "audio sync method", "" },
2327 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2328 "audio drift threshold", "threshold" },
2329 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2330 "copy timestamps" },
2331 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2332 "copy input stream time base when stream copying", "mode" },
2333 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2334 "finish encoding within shortest input" },
2335 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2336 "timestamp discontinuity delta threshold", "threshold" },
2337 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2338 "timestamp error delta threshold", "threshold" },
2339 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2340 "exit on error", "error" },
2341 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2342 "copy initial non-keyframes" },
2343 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2344 "copy or discard frames before start time" },
2345 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2346 "set the number of frames to record", "number" },
2347 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2348 "force codec tag/fourcc", "fourcc/tag" },
2349 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2350 "use fixed quality scale (VBR)", "q" },
2351 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2352 "use fixed quality scale (VBR)", "q" },
2353 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2354 "set profile", "profile" },
2355 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2356 "set stream filterchain", "filter_list" },
2357 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2358 "reinit filtergraph on input parameter changes", "" },
2359 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2360 "create a complex filtergraph", "graph_description" },
2361 { "stats", OPT_BOOL, { &print_stats },
2362 "print progress report during encoding", },
2363 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2364 "add an attachment to the output file", "filename" },
2365 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2366 "extract an attachment into a file", "filename" },
2367 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2368 "print timestamp debugging info" },
2371 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2372 "set the number of video frames to record", "number" },
2373 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2374 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2375 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2376 "set frame size (WxH or abbreviation)", "size" },
2377 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2378 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2379 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2380 "set pixel format", "format" },
2381 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2382 "set the number of bits per raw sample", "number" },
2383 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2384 "Removed, use the crop filter instead", "size" },
2385 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2386 "Removed, use the crop filter instead", "size" },
2387 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2388 "Removed, use the crop filter instead", "size" },
2389 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2390 "Removed, use the crop filter instead", "size" },
2391 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2392 "Removed, use the pad filter instead", "size" },
2393 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2394 "Removed, use the pad filter instead", "size" },
2395 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2396 "Removed, use the pad filter instead", "size" },
2397 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2398 "Removed, use the pad filter instead", "size" },
2399 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2400 "Removed, use the pad filter instead", "color" },
2401 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2402 "deprecated use -g 1" },
2403 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2405 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2406 "discard threshold", "n" },
2407 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2408 "rate control override for specific intervals", "override" },
2409 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2410 "force video codec ('copy' to copy stream)", "codec" },
2411 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2413 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2415 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2416 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2417 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2418 "select the pass number (1 to 3)", "n" },
2419 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2420 "select two pass log file name prefix", "prefix" },
2421 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2422 "this option is deprecated, use the yadif filter instead" },
2423 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2424 "calculate PSNR of compressed frames" },
2425 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2426 "dump video coding statistics to file" },
2427 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2428 "dump video coding statistics to file", "file" },
2429 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2430 "video filters", "filter list" },
2431 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2432 "specify intra matrix coeffs", "matrix" },
2433 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2434 "specify inter matrix coeffs", "matrix" },
2435 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2436 "top=1/bottom=0/auto=-1 field first", "" },
2437 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2438 "intra_dc_precision", "precision" },
2439 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2440 "force video tag/fourcc", "fourcc/tag" },
2441 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2442 "show QP histogram" },
2443 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2444 "force the selected framerate, disable the best supported framerate selection" },
2445 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2446 "set the value of an outfile streamid", "streamIndex:value" },
2447 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2448 { .off = OFFSET(forced_key_frames) },
2449 "force key frames at specified timestamps", "timestamps" },
2450 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2451 "video bitrate (please use -b:v)", "bitrate" },
2454 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2455 "set the number of audio frames to record", "number" },
2456 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2457 "set audio quality (codec-specific)", "quality", },
2458 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2459 "set audio sampling rate (in Hz)", "rate" },
2460 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2461 "set number of audio channels", "channels" },
2462 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2464 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2465 "force audio codec ('copy' to copy stream)", "codec" },
2466 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2467 "force audio tag/fourcc", "fourcc/tag" },
2468 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2469 "change audio volume (256=normal)" , "volume" },
2470 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2471 "set sample format", "format" },
2472 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2473 "set channel layout", "layout" },
2474 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2475 "audio filters", "filter list" },
2477 /* subtitle options */
2478 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2479 "disable subtitle" },
2480 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2481 "force subtitle codec ('copy' to copy stream)", "codec" },
2482 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2483 , "force subtitle tag/fourcc", "fourcc/tag" },
2484 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2485 "fix subtitles duration" },
2488 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2489 "deprecated, use -channel", "channel" },
2490 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2491 "deprecated, use -standard", "standard" },
2492 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2495 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2496 "set the maximum demux-decode delay", "seconds" },
2497 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2498 "set the initial demux-decode delay", "seconds" },
2500 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2501 "A comma-separated list of bitstream filters", "bitstream_filters" },
2502 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2503 "deprecated", "audio bitstream_filters" },
2504 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2505 "deprecated", "video bitstream_filters" },
2507 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2508 "set the audio options to the indicated preset", "preset" },
2509 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2510 "set the video options to the indicated preset", "preset" },
2511 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2512 "set the subtitle options to the indicated preset", "preset" },
2513 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2514 "set options from indicated preset file", "filename" },
2515 /* data codec support */
2516 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2517 "force data codec ('copy' to copy stream)", "codec" },
2518 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2521 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2522 "generic catch all option", "" },