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 in arg.
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 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
432 if ((index) < 0 || (index) >= (nb_elems)) {\
433 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
438 #define SET_DICT(type, meta, context, index)\
441 meta = &context->metadata;\
444 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
445 meta = &context->chapters[index]->metadata;\
448 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
449 meta = &context->programs[index]->metadata;\
451 default: av_assert0(0);\
456 SET_DICT(type_in, meta_in, ic, idx_in);
457 SET_DICT(type_out, meta_out, oc, idx_out);
459 /* for input streams choose first matching stream */
460 if (type_in == 's') {
461 for (i = 0; i < ic->nb_streams; i++) {
462 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
463 meta_in = &ic->streams[i]->metadata;
469 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
474 if (type_out == 's') {
475 for (i = 0; i < oc->nb_streams; i++) {
476 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
477 meta_out = &oc->streams[i]->metadata;
478 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
483 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
488 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
490 OptionsContext *o = optctx;
492 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
493 struct tm time = *gmtime((time_t*)&recording_timestamp);
494 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
495 parse_option(o, "metadata", buf, options);
497 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
498 "tag instead.\n", opt);
502 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
504 const AVCodecDescriptor *desc;
505 const char *codec_string = encoder ? "encoder" : "decoder";
509 avcodec_find_encoder_by_name(name) :
510 avcodec_find_decoder_by_name(name);
512 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
513 codec = encoder ? avcodec_find_encoder(desc->id) :
514 avcodec_find_decoder(desc->id);
516 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
517 codec_string, codec->name, desc->name);
521 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
524 if (codec->type != type) {
525 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
531 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
533 char *codec_name = NULL;
535 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
537 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
538 st->codec->codec_id = codec->id;
541 return avcodec_find_decoder(st->codec->codec_id);
545 * Add all the streams from the given input file to the global
546 * list of input streams.
548 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
551 char *next, *codec_tag = NULL;
553 for (i = 0; i < ic->nb_streams; i++) {
554 AVStream *st = ic->streams[i];
555 AVCodecContext *dec = st->codec;
556 InputStream *ist = av_mallocz(sizeof(*ist));
557 char *framerate = NULL;
562 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
563 input_streams[nb_input_streams - 1] = ist;
566 ist->file_index = nb_input_files;
568 st->discard = AVDISCARD_ALL;
569 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
572 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
574 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
576 uint32_t tag = strtol(codec_tag, &next, 0);
578 tag = AV_RL32(codec_tag);
579 st->codec->codec_tag = tag;
582 ist->dec = choose_decoder(o, ic, st);
584 switch (dec->codec_type) {
585 case AVMEDIA_TYPE_VIDEO:
587 ist->dec = avcodec_find_decoder(dec->codec_id);
589 dec->flags |= CODEC_FLAG_EMU_EDGE;
592 ist->resample_height = dec->height;
593 ist->resample_width = dec->width;
594 ist->resample_pix_fmt = dec->pix_fmt;
596 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
597 if (framerate && av_parse_video_rate(&ist->framerate,
599 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
604 ist->top_field_first = -1;
605 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
608 case AVMEDIA_TYPE_AUDIO:
609 guess_input_channel_layout(ist);
611 ist->resample_sample_fmt = dec->sample_fmt;
612 ist->resample_sample_rate = dec->sample_rate;
613 ist->resample_channels = dec->channels;
614 ist->resample_channel_layout = dec->channel_layout;
617 case AVMEDIA_TYPE_DATA:
618 case AVMEDIA_TYPE_SUBTITLE:
620 ist->dec = avcodec_find_decoder(dec->codec_id);
621 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
623 case AVMEDIA_TYPE_ATTACHMENT:
624 case AVMEDIA_TYPE_UNKNOWN:
632 static void assert_file_overwrite(const char *filename)
634 if ((!file_overwrite || no_file_overwrite) &&
635 (strchr(filename, ':') == NULL || filename[1] == ':' ||
636 av_strstart(filename, "file:", NULL))) {
637 if (avio_check(filename, 0) == 0) {
638 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
639 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
642 signal(SIGINT, SIG_DFL);
644 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
650 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
657 static void dump_attachment(AVStream *st, const char *filename)
660 AVIOContext *out = NULL;
661 AVDictionaryEntry *e;
663 if (!st->codec->extradata_size) {
664 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
665 nb_input_files - 1, st->index);
668 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
671 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
672 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
676 assert_file_overwrite(filename);
678 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
679 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
684 avio_write(out, st->codec->extradata, st->codec->extradata_size);
689 static int opt_input_file(void *optctx, const char *opt, const char *filename)
691 OptionsContext *o = optctx;
693 AVInputFormat *file_iformat = NULL;
698 int orig_nb_streams; // number of streams before avformat_find_stream_info
699 char * video_codec_name = NULL;
700 char * audio_codec_name = NULL;
701 char *subtitle_codec_name = NULL;
704 if (!(file_iformat = av_find_input_format(o->format))) {
705 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
710 if (!strcmp(filename, "-"))
713 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
714 strcmp(filename, "/dev/stdin");
716 /* get default parameters from command line */
717 ic = avformat_alloc_context();
719 print_error(filename, AVERROR(ENOMEM));
722 if (o->nb_audio_sample_rate) {
723 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
724 av_dict_set(&format_opts, "sample_rate", buf, 0);
726 if (o->nb_audio_channels) {
727 /* because we set audio_channels based on both the "ac" and
728 * "channel_layout" options, we need to check that the specified
729 * demuxer actually has the "channels" option before setting it */
730 if (file_iformat && file_iformat->priv_class &&
731 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
732 AV_OPT_SEARCH_FAKE_OBJ)) {
733 snprintf(buf, sizeof(buf), "%d",
734 o->audio_channels[o->nb_audio_channels - 1].u.i);
735 av_dict_set(&format_opts, "channels", buf, 0);
738 if (o->nb_frame_rates) {
739 /* set the format-level framerate option;
740 * this is important for video grabbers, e.g. x11 */
741 if (file_iformat && file_iformat->priv_class &&
742 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
743 AV_OPT_SEARCH_FAKE_OBJ)) {
744 av_dict_set(&format_opts, "framerate",
745 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
748 if (o->nb_frame_sizes) {
749 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
751 if (o->nb_frame_pix_fmts)
752 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
754 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
755 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
756 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
758 ic->video_codec_id = video_codec_name ?
759 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
760 ic->audio_codec_id = audio_codec_name ?
761 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
762 ic->subtitle_codec_id= subtitle_codec_name ?
763 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
764 ic->flags |= AVFMT_FLAG_NONBLOCK;
765 ic->interrupt_callback = int_cb;
767 /* open the input file with generic avformat function */
768 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
770 print_error(filename, err);
773 assert_avoptions(format_opts);
775 /* apply forced codec ids */
776 for (i = 0; i < ic->nb_streams; i++)
777 choose_decoder(o, ic, ic->streams[i]);
779 /* Set AVCodecContext options for avformat_find_stream_info */
780 opts = setup_find_stream_info_opts(ic, codec_opts);
781 orig_nb_streams = ic->nb_streams;
783 /* If not enough info to get the stream parameters, we decode the
784 first frames to get it. (used in mpeg case for example) */
785 ret = avformat_find_stream_info(ic, opts);
787 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
788 avformat_close_input(&ic);
792 timestamp = o->start_time;
793 /* add the stream start time */
794 if (ic->start_time != AV_NOPTS_VALUE)
795 timestamp += ic->start_time;
797 /* if seeking requested, we execute it */
798 if (o->start_time != 0) {
799 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
801 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
802 filename, (double)timestamp / AV_TIME_BASE);
806 /* update the current parameters so that they match the one of the input stream */
807 add_input_streams(o, ic);
809 /* dump the file content */
810 av_dump_format(ic, nb_input_files, filename, 0);
812 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
813 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
816 input_files[nb_input_files - 1]->ctx = ic;
817 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
818 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
819 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
820 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
822 for (i = 0; i < o->nb_dump_attachment; i++) {
825 for (j = 0; j < ic->nb_streams; j++) {
826 AVStream *st = ic->streams[j];
828 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
829 dump_attachment(st, o->dump_attachment[i].u.str);
833 for (i = 0; i < orig_nb_streams; i++)
834 av_dict_free(&opts[i]);
841 static uint8_t *get_line(AVIOContext *s)
847 if (avio_open_dyn_buf(&line) < 0) {
848 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
852 while ((c = avio_r8(s)) && c != '\n')
855 avio_close_dyn_buf(line, &buf);
860 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
864 const char *base[3] = { getenv("AVCONV_DATADIR"),
869 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
873 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
874 i != 1 ? "" : "/.avconv", codec_name, preset_name);
875 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
878 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
879 i != 1 ? "" : "/.avconv", preset_name);
880 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
886 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
888 char *codec_name = NULL;
890 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
892 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
893 NULL, ost->st->codec->codec_type);
894 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
895 } else if (!strcmp(codec_name, "copy"))
896 ost->stream_copy = 1;
898 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
899 ost->st->codec->codec_id = ost->enc->id;
903 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
906 AVStream *st = avformat_new_stream(oc, NULL);
907 int idx = oc->nb_streams - 1, ret = 0;
908 char *bsf = NULL, *next, *codec_tag = NULL;
909 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
911 char *buf = NULL, *arg = NULL, *preset = NULL;
912 AVIOContext *s = NULL;
915 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
919 if (oc->nb_streams - 1 < o->nb_streamid_map)
920 st->id = o->streamid_map[oc->nb_streams - 1];
922 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
923 nb_output_streams + 1);
924 if (!(ost = av_mallocz(sizeof(*ost))))
926 output_streams[nb_output_streams - 1] = ost;
928 ost->file_index = nb_output_files;
931 st->codec->codec_type = type;
932 choose_encoder(o, oc, ost);
934 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
937 avcodec_get_context_defaults3(st->codec, ost->enc);
938 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
940 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
941 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
944 if (!buf[0] || buf[0] == '#') {
948 if (!(arg = strchr(buf, '='))) {
949 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
953 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
955 } while (!s->eof_reached);
959 av_log(NULL, AV_LOG_FATAL,
960 "Preset %s specified for stream %d:%d, but could not be opened.\n",
961 preset, ost->file_index, ost->index);
965 ost->max_frames = INT64_MAX;
966 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
968 ost->copy_prior_start = -1;
969 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
971 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
973 if (next = strchr(bsf, ','))
975 if (!(bsfc = av_bitstream_filter_init(bsf))) {
976 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
980 bsfc_prev->next = bsfc;
982 ost->bitstream_filters = bsfc;
988 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
990 uint32_t tag = strtol(codec_tag, &next, 0);
992 tag = AV_RL32(codec_tag);
993 st->codec->codec_tag = tag;
996 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
998 st->codec->flags |= CODEC_FLAG_QSCALE;
999 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1002 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1003 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1005 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1006 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1007 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1009 ost->source_index = source_index;
1010 if (source_index >= 0) {
1011 ost->sync_ist = input_streams[source_index];
1012 input_streams[source_index]->discard = 0;
1013 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1019 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1022 const char *p = str;
1029 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1036 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1040 AVCodecContext *video_enc;
1041 char *frame_rate = NULL;
1043 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1045 video_enc = st->codec;
1047 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1048 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1049 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1053 if (!ost->stream_copy) {
1054 const char *p = NULL;
1055 char *frame_size = NULL;
1056 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1057 char *intra_matrix = NULL, *inter_matrix = NULL;
1058 const char *filters = "null";
1062 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1063 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1064 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1068 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1069 if (frame_aspect_ratio) {
1071 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1072 q.num <= 0 || q.den <= 0) {
1073 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1076 ost->frame_aspect_ratio = av_q2d(q);
1079 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1080 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1081 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1082 ost->keep_pix_fmt = 1;
1083 if (!*++frame_pix_fmt)
1084 frame_pix_fmt = NULL;
1086 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1087 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1090 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1093 video_enc->gop_size = 0;
1094 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1096 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1097 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1100 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1102 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1104 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1105 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1108 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1111 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1112 for (i = 0; p; i++) {
1114 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1116 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1119 /* FIXME realloc failure */
1120 video_enc->rc_override =
1121 av_realloc(video_enc->rc_override,
1122 sizeof(RcOverride) * (i + 1));
1123 video_enc->rc_override[i].start_frame = start;
1124 video_enc->rc_override[i].end_frame = end;
1126 video_enc->rc_override[i].qscale = q;
1127 video_enc->rc_override[i].quality_factor = 1.0;
1130 video_enc->rc_override[i].qscale = 0;
1131 video_enc->rc_override[i].quality_factor = -q/100.0;
1136 video_enc->rc_override_count = i;
1137 if (!video_enc->rc_initial_buffer_occupancy)
1138 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1139 video_enc->intra_dc_precision = intra_dc_precision - 8;
1142 video_enc->flags|= CODEC_FLAG_PSNR;
1145 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1148 video_enc->flags |= CODEC_FLAG_PASS1;
1151 video_enc->flags |= CODEC_FLAG_PASS2;
1155 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1156 if (ost->logfile_prefix &&
1157 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1160 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1161 if (ost->forced_keyframes)
1162 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1164 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1166 ost->top_field_first = -1;
1167 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1169 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1170 ost->avfilter = av_strdup(filters);
1172 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1178 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1183 AVCodecContext *audio_enc;
1185 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1188 audio_enc = st->codec;
1189 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1191 if (!ost->stream_copy) {
1192 char *sample_fmt = NULL;
1193 const char *filters = "anull";
1195 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1197 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1199 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1200 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1204 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1206 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1208 av_assert1(filters);
1209 ost->avfilter = av_strdup(filters);
1211 /* check for channel mapping for this audio stream */
1212 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1213 AudioChannelMap *map = &o->audio_channel_maps[n];
1214 InputStream *ist = input_streams[ost->source_index];
1215 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1216 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1217 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1218 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1219 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1221 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1222 ost->file_index, ost->st->index);
1230 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1234 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1235 if (!ost->stream_copy) {
1236 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1243 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1245 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1246 ost->stream_copy = 1;
1250 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1254 AVCodecContext *subtitle_enc;
1256 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1258 subtitle_enc = st->codec;
1260 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1262 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1264 if (!ost->stream_copy) {
1265 char *frame_size = NULL;
1267 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1268 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1269 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1277 /* arg format is "output-stream-index:streamid-value". */
1278 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1280 OptionsContext *o = optctx;
1285 av_strlcpy(idx_str, arg, sizeof(idx_str));
1286 p = strchr(idx_str, ':');
1288 av_log(NULL, AV_LOG_FATAL,
1289 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1294 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1295 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1296 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1300 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1302 AVFormatContext *is = ifile->ctx;
1303 AVFormatContext *os = ofile->ctx;
1307 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1309 return AVERROR(ENOMEM);
1312 for (i = 0; i < is->nb_chapters; i++) {
1313 AVChapter *in_ch = is->chapters[i], *out_ch;
1314 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1315 AV_TIME_BASE_Q, in_ch->time_base);
1316 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1317 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1320 if (in_ch->end < ts_off)
1322 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1325 out_ch = av_mallocz(sizeof(AVChapter));
1327 return AVERROR(ENOMEM);
1329 out_ch->id = in_ch->id;
1330 out_ch->time_base = in_ch->time_base;
1331 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1332 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1335 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1337 os->chapters[os->nb_chapters++] = out_ch;
1342 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1345 AVFormatContext *ic = avformat_alloc_context();
1347 ic->interrupt_callback = int_cb;
1348 err = avformat_open_input(&ic, filename, NULL, NULL);
1351 /* copy stream format */
1352 for(i=0;i<ic->nb_streams;i++) {
1356 AVCodecContext *avctx;
1358 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1359 ost = new_output_stream(o, s, codec->type, -1);
1364 // FIXME: a more elegant solution is needed
1365 memcpy(st, ic->streams[i], sizeof(AVStream));
1367 st->info = av_malloc(sizeof(*st->info));
1368 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1370 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1372 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1373 choose_sample_fmt(st, codec);
1374 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1375 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1378 /* ffserver seeking with date=... needs a date reference */
1379 err = parse_option(o, "metadata", "creation_time=now", options);
1381 avformat_close_input(&ic);
1385 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1386 AVFormatContext *oc)
1390 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1391 ofilter->out_tmp->pad_idx)) {
1392 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1393 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1395 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1400 ost->source_index = -1;
1401 ost->filter = ofilter;
1405 if (ost->stream_copy) {
1406 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1407 "which is fed from a complex filtergraph. Filtering and streamcopy "
1408 "cannot be used together.\n", ost->file_index, ost->index);
1412 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1413 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1416 avfilter_inout_free(&ofilter->out_tmp);
1419 static int configure_complex_filters(void)
1423 for (i = 0; i < nb_filtergraphs; i++)
1424 if (!filtergraphs[i]->graph &&
1425 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1430 void opt_output_file(void *optctx, const char *filename)
1432 OptionsContext *o = optctx;
1433 AVFormatContext *oc;
1435 AVOutputFormat *file_oformat;
1439 if (configure_complex_filters() < 0) {
1440 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1444 if (!strcmp(filename, "-"))
1447 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1449 print_error(filename, err);
1452 file_oformat= oc->oformat;
1453 oc->interrupt_callback = int_cb;
1455 /* create streams for all unlabeled output pads */
1456 for (i = 0; i < nb_filtergraphs; i++) {
1457 FilterGraph *fg = filtergraphs[i];
1458 for (j = 0; j < fg->nb_outputs; j++) {
1459 OutputFilter *ofilter = fg->outputs[j];
1461 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1464 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1465 ofilter->out_tmp->pad_idx)) {
1466 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1467 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1468 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1470 init_output_filter(ofilter, o, oc);
1474 if (!strcmp(file_oformat->name, "ffm") &&
1475 av_strstart(filename, "http:", NULL)) {
1477 /* special case for files sent to ffserver: we get the stream
1478 parameters from ffserver */
1479 int err = read_ffserver_streams(o, oc, filename);
1481 print_error(filename, err);
1484 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1485 ost = output_streams[j];
1486 for (i = 0; i < nb_input_streams; i++) {
1487 ist = input_streams[i];
1488 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1490 ost->source_index= i;
1491 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1492 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1494 ist->st->discard = AVDISCARD_NONE;
1499 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));
1503 } else if (!o->nb_stream_maps) {
1504 char *subtitle_codec_name = NULL;
1505 /* pick the "best" stream of each type */
1507 /* video: highest resolution */
1508 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1509 int area = 0, idx = -1;
1510 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1511 for (i = 0; i < nb_input_streams; i++) {
1513 ist = input_streams[i];
1514 new_area = ist->st->codec->width * ist->st->codec->height;
1515 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1517 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1519 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1526 new_video_stream(o, oc, idx);
1529 /* audio: most channels */
1530 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1531 int channels = 0, idx = -1;
1532 for (i = 0; i < nb_input_streams; i++) {
1533 ist = input_streams[i];
1534 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1535 ist->st->codec->channels > channels) {
1536 channels = ist->st->codec->channels;
1541 new_audio_stream(o, oc, idx);
1544 /* subtitles: pick first */
1545 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1546 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1547 for (i = 0; i < nb_input_streams; i++)
1548 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1549 new_subtitle_stream(o, oc, i);
1553 /* do something with data? */
1555 for (i = 0; i < o->nb_stream_maps; i++) {
1556 StreamMap *map = &o->stream_maps[i];
1557 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1562 if (map->linklabel) {
1564 OutputFilter *ofilter = NULL;
1567 for (j = 0; j < nb_filtergraphs; j++) {
1568 fg = filtergraphs[j];
1569 for (k = 0; k < fg->nb_outputs; k++) {
1570 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1571 if (out && !strcmp(out->name, map->linklabel)) {
1572 ofilter = fg->outputs[k];
1579 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1580 "in any defined filter graph.\n", map->linklabel);
1583 init_output_filter(ofilter, o, oc);
1585 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1586 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1588 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1590 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1592 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1595 switch (ist->st->codec->codec_type) {
1596 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1597 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1598 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1599 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1600 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1602 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1603 map->file_index, map->stream_index);
1611 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1612 AVDictionaryEntry *e;
1613 ost = output_streams[i];
1615 if ( ost->stream_copy
1616 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1617 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1618 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1622 /* handle attached files */
1623 for (i = 0; i < o->nb_attachments; i++) {
1625 uint8_t *attachment;
1629 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1630 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1634 if ((len = avio_size(pb)) <= 0) {
1635 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1639 if (!(attachment = av_malloc(len))) {
1640 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1644 avio_read(pb, attachment, len);
1646 ost = new_attachment_stream(o, oc, -1);
1647 ost->stream_copy = 0;
1648 ost->attachment_filename = o->attachments[i];
1649 ost->st->codec->extradata = attachment;
1650 ost->st->codec->extradata_size = len;
1652 p = strrchr(o->attachments[i], '/');
1653 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1657 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1658 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1661 output_files[nb_output_files - 1]->ctx = oc;
1662 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1663 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1664 if (o->recording_time != INT64_MAX)
1665 oc->duration = o->recording_time;
1666 output_files[nb_output_files - 1]->start_time = o->start_time;
1667 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1668 output_files[nb_output_files - 1]->shortest = o->shortest;
1669 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1671 /* check filename in case of an image number is expected */
1672 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1673 if (!av_filename_number_test(oc->filename)) {
1674 print_error(oc->filename, AVERROR(EINVAL));
1679 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1680 /* test if it already exists to avoid losing precious files */
1681 assert_file_overwrite(filename);
1684 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1685 &oc->interrupt_callback,
1686 &output_files[nb_output_files - 1]->opts)) < 0) {
1687 print_error(filename, err);
1692 if (o->mux_preload) {
1694 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1695 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1697 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1700 for (i = 0; i < o->nb_metadata_map; i++) {
1702 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1704 if (in_file_index >= nb_input_files) {
1705 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1708 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
1712 if (o->chapters_input_file >= nb_input_files) {
1713 if (o->chapters_input_file == INT_MAX) {
1714 /* copy chapters from the first input file that has them*/
1715 o->chapters_input_file = -1;
1716 for (i = 0; i < nb_input_files; i++)
1717 if (input_files[i]->ctx->nb_chapters) {
1718 o->chapters_input_file = i;
1722 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1723 o->chapters_input_file);
1727 if (o->chapters_input_file >= 0)
1728 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1729 !o->metadata_chapters_manual);
1731 /* copy global metadata by default */
1732 if (!o->metadata_global_manual && nb_input_files){
1733 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1734 AV_DICT_DONT_OVERWRITE);
1735 if(o->recording_time != INT64_MAX)
1736 av_dict_set(&oc->metadata, "duration", NULL, 0);
1737 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1739 if (!o->metadata_streams_manual)
1740 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1742 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1744 ist = input_streams[output_streams[i]->source_index];
1745 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1748 /* process manually set metadata */
1749 for (i = 0; i < o->nb_metadata; i++) {
1752 const char *stream_spec;
1753 int index = 0, j, ret = 0;
1755 val = strchr(o->metadata[i].u.str, '=');
1757 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1758 o->metadata[i].u.str);
1763 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1765 for (j = 0; j < oc->nb_streams; j++) {
1766 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1767 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1778 if (index < 0 || index >= oc->nb_chapters) {
1779 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1782 m = &oc->chapters[index]->metadata;
1785 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1788 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1792 reset_options(o, 0);
1795 static int opt_target(void *optctx, const char *opt, const char *arg)
1797 OptionsContext *o = optctx;
1798 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1799 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1801 if (!strncmp(arg, "pal-", 4)) {
1804 } else if (!strncmp(arg, "ntsc-", 5)) {
1807 } else if (!strncmp(arg, "film-", 5)) {
1811 /* Try to determine PAL/NTSC by peeking in the input files */
1812 if (nb_input_files) {
1814 for (j = 0; j < nb_input_files; j++) {
1815 for (i = 0; i < input_files[j]->nb_streams; i++) {
1816 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1817 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1819 fr = c->time_base.den * 1000 / c->time_base.num;
1823 } else if ((fr == 29970) || (fr == 23976)) {
1828 if (norm != UNKNOWN)
1832 if (norm != UNKNOWN)
1833 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1836 if (norm == UNKNOWN) {
1837 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1838 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1839 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1843 if (!strcmp(arg, "vcd")) {
1844 opt_video_codec(o, "c:v", "mpeg1video");
1845 opt_audio_codec(o, "c:a", "mp2");
1846 parse_option(o, "f", "vcd", options);
1848 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1849 parse_option(o, "r", frame_rates[norm], options);
1850 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1852 opt_default(NULL, "b:v", "1150000");
1853 opt_default(NULL, "maxrate", "1150000");
1854 opt_default(NULL, "minrate", "1150000");
1855 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1857 opt_default(NULL, "b:a", "224000");
1858 parse_option(o, "ar", "44100", options);
1859 parse_option(o, "ac", "2", options);
1861 opt_default(NULL, "packetsize", "2324");
1862 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1864 /* We have to offset the PTS, so that it is consistent with the SCR.
1865 SCR starts at 36000, but the first two packs contain only padding
1866 and the first pack from the other stream, respectively, may also have
1867 been written before.
1868 So the real data starts at SCR 36000+3*1200. */
1869 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1870 } else if (!strcmp(arg, "svcd")) {
1872 opt_video_codec(o, "c:v", "mpeg2video");
1873 opt_audio_codec(o, "c:a", "mp2");
1874 parse_option(o, "f", "svcd", options);
1876 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1877 parse_option(o, "r", frame_rates[norm], options);
1878 parse_option(o, "pix_fmt", "yuv420p", options);
1879 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1881 opt_default(NULL, "b:v", "2040000");
1882 opt_default(NULL, "maxrate", "2516000");
1883 opt_default(NULL, "minrate", "0"); // 1145000;
1884 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1885 opt_default(NULL, "scan_offset", "1");
1887 opt_default(NULL, "b:a", "224000");
1888 parse_option(o, "ar", "44100", options);
1890 opt_default(NULL, "packetsize", "2324");
1892 } else if (!strcmp(arg, "dvd")) {
1894 opt_video_codec(o, "c:v", "mpeg2video");
1895 opt_audio_codec(o, "c:a", "ac3");
1896 parse_option(o, "f", "dvd", options);
1898 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1899 parse_option(o, "r", frame_rates[norm], options);
1900 parse_option(o, "pix_fmt", "yuv420p", options);
1901 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1903 opt_default(NULL, "b:v", "6000000");
1904 opt_default(NULL, "maxrate", "9000000");
1905 opt_default(NULL, "minrate", "0"); // 1500000;
1906 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1908 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1909 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1911 opt_default(NULL, "b:a", "448000");
1912 parse_option(o, "ar", "48000", options);
1914 } else if (!strncmp(arg, "dv", 2)) {
1916 parse_option(o, "f", "dv", options);
1918 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1919 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1920 norm == PAL ? "yuv420p" : "yuv411p", options);
1921 parse_option(o, "r", frame_rates[norm], options);
1923 parse_option(o, "ar", "48000", options);
1924 parse_option(o, "ac", "2", options);
1927 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1928 return AVERROR(EINVAL);
1933 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1935 av_free (vstats_filename);
1936 vstats_filename = av_strdup (arg);
1940 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1943 time_t today2 = time(NULL);
1944 struct tm *today = localtime(&today2);
1946 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1948 return opt_vstats_file(NULL, opt, filename);
1951 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1953 OptionsContext *o = optctx;
1954 return parse_option(o, "frames:v", arg, options);
1957 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1959 OptionsContext *o = optctx;
1960 return parse_option(o, "frames:a", arg, options);
1963 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1965 OptionsContext *o = optctx;
1966 return parse_option(o, "frames:d", arg, options);
1969 static int opt_preset(void *optctx, const char *opt, const char *arg)
1971 OptionsContext *o = optctx;
1973 char filename[1000], line[1000], tmp_line[1000];
1974 const char *codec_name = NULL;
1978 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1980 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1981 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1982 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1984 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1988 while (fgets(line, sizeof(line), f)) {
1989 char *key = tmp_line, *value, *endptr;
1991 if (strcspn(line, "#\n\r") == 0)
1993 strcpy(tmp_line, line);
1994 if (!av_strtok(key, "=", &value) ||
1995 !av_strtok(value, "\r\n", &endptr)) {
1996 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1999 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2001 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2002 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2003 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2004 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2005 else if (opt_default(NULL, key, value) < 0) {
2006 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2007 filename, line, key, value);
2017 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2019 OptionsContext *o = optctx;
2020 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2021 int ret = parse_option(o, s, arg, options);
2026 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2028 OptionsContext *o = optctx;
2029 if(!strcmp(opt, "b")){
2030 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2031 return parse_option(o, "b:v", arg, options);
2033 return opt_default(optctx, opt, arg);
2036 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2038 OptionsContext *o = optctx;
2041 if(!strcmp(opt, "qscale")){
2042 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2043 return parse_option(o, "q:v", arg, options);
2045 s = av_asprintf("q%s", opt + 6);
2046 ret = parse_option(o, s, arg, options);
2051 static int opt_profile(void *optctx, const char *opt, const char *arg)
2053 OptionsContext *o = optctx;
2054 if(!strcmp(opt, "profile")){
2055 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2056 return parse_option(o, "profile:v", arg, options);
2058 return opt_default(optctx, opt, arg);
2062 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2064 OptionsContext *o = optctx;
2065 return parse_option(o, "filter:v", arg, options);
2068 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2070 OptionsContext *o = optctx;
2071 return parse_option(o, "filter:a", arg, options);
2074 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2076 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2077 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2078 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2079 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2081 if (video_sync_method == VSYNC_AUTO)
2082 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2086 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2088 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2093 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2095 OptionsContext *o = optctx;
2096 char *tcr = av_asprintf("timecode=%s", arg);
2097 int ret = parse_option(o, "metadata:g", tcr, options);
2099 ret = opt_default(optctx, "gop_timecode", arg);
2104 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2106 OptionsContext *o = optctx;
2107 char layout_str[32];
2110 int ret, channels, ac_str_size;
2113 layout = av_get_channel_layout(arg);
2115 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2116 return AVERROR(EINVAL);
2118 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2119 ret = opt_default(NULL, opt, layout_str);
2123 /* set 'ac' option based on channel layout */
2124 channels = av_get_channel_layout_nb_channels(layout);
2125 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2126 stream_str = strchr(opt, ':');
2127 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2128 ac_str = av_mallocz(ac_str_size);
2130 return AVERROR(ENOMEM);
2131 av_strlcpy(ac_str, "ac", 3);
2133 av_strlcat(ac_str, stream_str, ac_str_size);
2134 ret = parse_option(o, ac_str, layout_str, options);
2140 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2142 OptionsContext *o = optctx;
2143 return parse_option(o, "q:a", arg, options);
2146 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2148 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2149 &nb_filtergraphs, nb_filtergraphs + 1);
2150 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2151 return AVERROR(ENOMEM);
2152 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2153 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2157 void show_help_default(const char *opt, const char *arg)
2159 /* per-file options have at least one of those set */
2160 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2161 int show_advanced = 0, show_avoptions = 0;
2164 if (!strcmp(opt, "long"))
2166 else if (!strcmp(opt, "full"))
2167 show_advanced = show_avoptions = 1;
2169 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2174 printf("Getting help:\n"
2175 " -h -- print basic options\n"
2176 " -h long -- print more options\n"
2177 " -h full -- print all options (including all format and codec specific options, very long)\n"
2178 " See man %s for detailed description of the options.\n"
2179 "\n", program_name);
2181 show_help_options(options, "Print help / information / capabilities:",
2184 show_help_options(options, "Global options (affect whole program "
2185 "instead of just one file:",
2186 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2188 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2189 per_file | OPT_EXIT, 0);
2191 show_help_options(options, "Per-file main options:", 0,
2192 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2193 OPT_EXIT, per_file);
2195 show_help_options(options, "Advanced per-file options:",
2196 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2198 show_help_options(options, "Video options:",
2199 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2201 show_help_options(options, "Advanced Video options:",
2202 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2204 show_help_options(options, "Audio options:",
2205 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2207 show_help_options(options, "Advanced Audio options:",
2208 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2209 show_help_options(options, "Subtitle options:",
2210 OPT_SUBTITLE, 0, 0);
2213 if (show_avoptions) {
2214 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2215 show_help_children(avcodec_get_class(), flags);
2216 show_help_children(avformat_get_class(), flags);
2217 show_help_children(sws_get_class(), flags);
2218 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2219 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2223 void show_usage(void)
2225 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2226 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2227 av_log(NULL, AV_LOG_INFO, "\n");
2231 static int opt_progress(void *optctx, const char *opt, const char *arg)
2233 AVIOContext *avio = NULL;
2236 if (!strcmp(arg, "-"))
2238 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2240 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2241 arg, av_err2str(ret));
2244 progress_avio = avio;
2248 #define OFFSET(x) offsetof(OptionsContext, x)
2249 const OptionDef options[] = {
2251 #include "cmdutils_common_opts.h"
2252 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2253 "force format", "fmt" },
2254 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2255 "input file name", "filename" },
2256 { "y", OPT_BOOL, { &file_overwrite },
2257 "overwrite output files" },
2258 { "n", OPT_BOOL, { &no_file_overwrite },
2259 "do not overwrite output files" },
2260 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2261 "codec name", "codec" },
2262 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2263 "codec name", "codec" },
2264 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2265 "preset name", "preset" },
2266 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2267 "set input stream mapping",
2268 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2269 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2270 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2271 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2272 "set metadata information of outfile from infile",
2273 "outfile[,metadata]:infile[,metadata]" },
2274 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2275 "set chapters mapping", "input_file_index" },
2276 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2277 "record or transcode \"duration\" seconds of audio/video",
2279 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2280 "set the limit file size in bytes", "limit_size" },
2281 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2282 "set the start time offset", "time_off" },
2283 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2284 "set the input ts offset", "time_off" },
2285 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2286 "set the input ts scale", "scale" },
2287 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2288 "set the recording timestamp ('now' to set the current time)", "time" },
2289 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2290 "add metadata", "string=string" },
2291 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2292 "set the number of data frames to record", "number" },
2293 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2294 "add timings for benchmarking" },
2295 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2296 "add timings for each task" },
2297 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2298 "write program-readable progress information", "url" },
2299 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2300 "enable or disable interaction on standard input" },
2301 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2302 "set max runtime in seconds", "limit" },
2303 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2304 "dump each input packet" },
2305 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2306 "when dumping packets, also dump the payload" },
2307 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2308 "read input at native frame rate", "" },
2309 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2310 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2311 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2312 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2313 "video sync method", "" },
2314 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2315 "audio sync method", "" },
2316 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2317 "audio drift threshold", "threshold" },
2318 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2319 "copy timestamps" },
2320 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2321 "copy input stream time base when stream copying", "mode" },
2322 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2323 "finish encoding within shortest input" },
2324 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2325 "timestamp discontinuity delta threshold", "threshold" },
2326 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2327 "timestamp error delta threshold", "threshold" },
2328 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2329 "exit on error", "error" },
2330 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2331 "copy initial non-keyframes" },
2332 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2333 "copy or discard frames before start time" },
2334 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2335 "set the number of frames to record", "number" },
2336 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2337 "force codec tag/fourcc", "fourcc/tag" },
2338 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2339 "use fixed quality scale (VBR)", "q" },
2340 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2341 "use fixed quality scale (VBR)", "q" },
2342 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2343 "set profile", "profile" },
2344 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2345 "set stream filterchain", "filter_list" },
2346 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2347 "create a complex filtergraph", "graph_description" },
2348 { "stats", OPT_BOOL, { &print_stats },
2349 "print progress report during encoding", },
2350 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2351 "add an attachment to the output file", "filename" },
2352 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2353 "extract an attachment into a file", "filename" },
2354 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2355 "print timestamp debugging info" },
2358 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2359 "set the number of video frames to record", "number" },
2360 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2361 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2362 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2363 "set frame size (WxH or abbreviation)", "size" },
2364 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2365 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2366 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2367 "set pixel format", "format" },
2368 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2369 "set the number of bits per raw sample", "number" },
2370 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2371 "Removed, use the crop filter instead", "size" },
2372 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2373 "Removed, use the crop filter instead", "size" },
2374 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2375 "Removed, use the crop filter instead", "size" },
2376 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2377 "Removed, use the crop filter instead", "size" },
2378 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2379 "Removed, use the pad filter instead", "size" },
2380 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2381 "Removed, use the pad filter instead", "size" },
2382 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2383 "Removed, use the pad filter instead", "size" },
2384 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2385 "Removed, use the pad filter instead", "size" },
2386 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2387 "Removed, use the pad filter instead", "color" },
2388 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2389 "deprecated use -g 1" },
2390 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2392 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2393 "discard threshold", "n" },
2394 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2395 "rate control override for specific intervals", "override" },
2396 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2397 "force video codec ('copy' to copy stream)", "codec" },
2398 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2400 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2402 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2403 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2404 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2405 "select the pass number (1 to 3)", "n" },
2406 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2407 "select two pass log file name prefix", "prefix" },
2408 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2409 "this option is deprecated, use the yadif filter instead" },
2410 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2411 "calculate PSNR of compressed frames" },
2412 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2413 "dump video coding statistics to file" },
2414 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2415 "dump video coding statistics to file", "file" },
2416 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2417 "video filters", "filter list" },
2418 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2419 "specify intra matrix coeffs", "matrix" },
2420 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2421 "specify inter matrix coeffs", "matrix" },
2422 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2423 "top=1/bottom=0/auto=-1 field first", "" },
2424 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2425 "intra_dc_precision", "precision" },
2426 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2427 "force video tag/fourcc", "fourcc/tag" },
2428 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2429 "show QP histogram" },
2430 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2431 "force the selected framerate, disable the best supported framerate selection" },
2432 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2433 "set the value of an outfile streamid", "streamIndex:value" },
2434 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2435 { .off = OFFSET(forced_key_frames) },
2436 "force key frames at specified timestamps", "timestamps" },
2437 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2438 "video bitrate (please use -b:v)", "bitrate" },
2441 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2442 "set the number of audio frames to record", "number" },
2443 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2444 "set audio quality (codec-specific)", "quality", },
2445 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2446 "set audio sampling rate (in Hz)", "rate" },
2447 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2448 "set number of audio channels", "channels" },
2449 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2451 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2452 "force audio codec ('copy' to copy stream)", "codec" },
2453 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2454 "force audio tag/fourcc", "fourcc/tag" },
2455 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2456 "change audio volume (256=normal)" , "volume" },
2457 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2458 "set sample format", "format" },
2459 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2460 "set channel layout", "layout" },
2461 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2462 "audio filters", "filter list" },
2464 /* subtitle options */
2465 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2466 "disable subtitle" },
2467 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2468 "force subtitle codec ('copy' to copy stream)", "codec" },
2469 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2470 , "force subtitle tag/fourcc", "fourcc/tag" },
2471 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2472 "fix subtitles duration" },
2475 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2476 "deprecated, use -channel", "channel" },
2477 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2478 "deprecated, use -standard", "standard" },
2479 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2482 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2483 "set the maximum demux-decode delay", "seconds" },
2484 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2485 "set the initial demux-decode delay", "seconds" },
2487 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2488 "A comma-separated list of bitstream filters", "bitstream_filters" },
2489 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2490 "deprecated", "audio bitstream_filters" },
2491 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2492 "deprecated", "video bitstream_filters" },
2494 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2495 "set the audio options to the indicated preset", "preset" },
2496 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2497 "set the video options to the indicated preset", "preset" },
2498 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2499 "set the subtitle options to the indicated preset", "preset" },
2500 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2501 "set options from indicated preset file", "filename" },
2502 /* data codec support */
2503 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2504 "force data codec ('copy' to copy stream)", "codec" },
2505 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2508 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2509 "generic catch all option", "" },