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;
87 int stdin_interaction = 1;
88 int frame_bits_per_raw_sample = 0;
91 static int intra_only = 0;
92 static int file_overwrite = 0;
93 static int no_file_overwrite = 0;
94 static int video_discard = 0;
95 static int intra_dc_precision = 8;
96 static int do_psnr = 0;
97 static int input_sync;
99 void reset_options(OptionsContext *o, int is_input)
101 const OptionDef *po = options;
102 OptionsContext bak= *o;
105 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
107 void *dst = (uint8_t*)o + po->u.off;
109 if (po->flags & OPT_SPEC) {
110 SpecifierOpt **so = dst;
111 int i, *count = (int*)(so + 1);
112 for (i = 0; i < *count; i++) {
113 av_freep(&(*so)[i].specifier);
114 if (po->flags & OPT_STRING)
115 av_freep(&(*so)[i].u.str);
119 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
124 for (i = 0; i < o->nb_stream_maps; i++)
125 av_freep(&o->stream_maps[i].linklabel);
126 av_freep(&o->stream_maps);
127 av_freep(&o->audio_channel_maps);
128 av_freep(&o->streamid_map);
130 memset(o, 0, sizeof(*o));
133 o->recording_time = bak.recording_time;
134 if (o->recording_time != INT64_MAX)
135 av_log(NULL, AV_LOG_WARNING,
136 "-t is not an input option, keeping it for the next output;"
137 " consider fixing your command line.\n");
139 o->recording_time = INT64_MAX;
140 o->mux_max_delay = 0.7;
141 o->limit_filesize = UINT64_MAX;
142 o->chapters_input_file = INT_MAX;
149 static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
151 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
152 return AVERROR(EINVAL);
155 static int opt_pad(void *optctx, const char *opt, const char *arg)
157 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
161 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
163 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
164 return opt_default(optctx, "channel", arg);
167 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
169 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
170 return opt_default(optctx, "standard", arg);
173 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
175 OptionsContext *o = optctx;
176 return parse_option(o, "codec:a", arg, options);
179 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
181 OptionsContext *o = optctx;
182 return parse_option(o, "codec:v", arg, options);
185 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
187 OptionsContext *o = optctx;
188 return parse_option(o, "codec:s", arg, options);
191 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
193 OptionsContext *o = optctx;
194 return parse_option(o, "codec:d", arg, options);
197 static int opt_map(void *optctx, const char *opt, const char *arg)
199 OptionsContext *o = optctx;
201 int i, negative = 0, file_idx;
202 int sync_file_idx = -1, sync_stream_idx = 0;
210 map = av_strdup(arg);
212 /* parse sync stream first, just pick first matching stream */
213 if (sync = strchr(map, ',')) {
215 sync_file_idx = strtol(sync + 1, &sync, 0);
216 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
217 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
222 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
223 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
224 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
228 if (i == input_files[sync_file_idx]->nb_streams) {
229 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
230 "match any streams.\n", arg);
237 /* this mapping refers to lavfi output */
238 const char *c = map + 1;
239 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
240 &o->nb_stream_maps, o->nb_stream_maps + 1);
241 m = &o->stream_maps[o->nb_stream_maps - 1];
242 m->linklabel = av_get_token(&c, "]");
244 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
248 file_idx = strtol(map, &p, 0);
249 if (file_idx >= nb_input_files || file_idx < 0) {
250 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
254 /* disable some already defined maps */
255 for (i = 0; i < o->nb_stream_maps; i++) {
256 m = &o->stream_maps[i];
257 if (file_idx == m->file_index &&
258 check_stream_specifier(input_files[m->file_index]->ctx,
259 input_files[m->file_index]->ctx->streams[m->stream_index],
260 *p == ':' ? p + 1 : p) > 0)
264 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
265 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
266 *p == ':' ? p + 1 : p) <= 0)
268 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
269 &o->nb_stream_maps, o->nb_stream_maps + 1);
270 m = &o->stream_maps[o->nb_stream_maps - 1];
272 m->file_index = file_idx;
275 if (sync_file_idx >= 0) {
276 m->sync_file_index = sync_file_idx;
277 m->sync_stream_index = sync_stream_idx;
279 m->sync_file_index = file_idx;
280 m->sync_stream_index = i;
286 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
294 static int opt_attach(void *optctx, const char *opt, const char *arg)
296 OptionsContext *o = optctx;
297 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
298 &o->nb_attachments, o->nb_attachments + 1);
299 o->attachments[o->nb_attachments - 1] = arg;
303 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
305 OptionsContext *o = optctx;
310 o->audio_channel_maps =
311 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
312 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
313 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
315 /* muted channel syntax */
316 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
317 if ((n == 1 || n == 3) && m->channel_idx == -1) {
318 m->file_idx = m->stream_idx = -1;
320 m->ofile_idx = m->ostream_idx = -1;
325 n = sscanf(arg, "%d.%d.%d:%d.%d",
326 &m->file_idx, &m->stream_idx, &m->channel_idx,
327 &m->ofile_idx, &m->ostream_idx);
329 if (n != 3 && n != 5) {
330 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
331 "[file.stream.channel|-1][:syncfile:syncstream]\n");
335 if (n != 5) // only file.stream.channel specified
336 m->ofile_idx = m->ostream_idx = -1;
339 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
340 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
344 if (m->stream_idx < 0 ||
345 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
346 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
347 m->file_idx, m->stream_idx);
350 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
351 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
352 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
353 m->file_idx, m->stream_idx);
356 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
357 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
358 m->file_idx, m->stream_idx, m->channel_idx);
365 * Parse a metadata specifier in arg.
366 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
367 * @param index for type c/p, chapter/program index is written here
368 * @param stream_spec for type s, the stream specifier is written here
370 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
378 if (*(++arg) && *arg != ':') {
379 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
382 *stream_spec = *arg == ':' ? arg + 1 : "";
387 *index = strtol(++arg, NULL, 0);
390 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
397 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
399 AVDictionary **meta_in = NULL;
400 AVDictionary **meta_out = NULL;
402 char type_in, type_out;
403 const char *istream_spec = NULL, *ostream_spec = NULL;
404 int idx_in = 0, idx_out = 0;
406 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
407 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
410 if (type_out == 'g' || !*outspec)
411 o->metadata_global_manual = 1;
412 if (type_out == 's' || !*outspec)
413 o->metadata_streams_manual = 1;
414 if (type_out == 'c' || !*outspec)
415 o->metadata_chapters_manual = 1;
419 if (type_in == 'g' || type_out == 'g')
420 o->metadata_global_manual = 1;
421 if (type_in == 's' || type_out == 's')
422 o->metadata_streams_manual = 1;
423 if (type_in == 'c' || type_out == 'c')
424 o->metadata_chapters_manual = 1;
426 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
427 if ((index) < 0 || (index) >= (nb_elems)) {\
428 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
433 #define SET_DICT(type, meta, context, index)\
436 meta = &context->metadata;\
439 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
440 meta = &context->chapters[index]->metadata;\
443 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
444 meta = &context->programs[index]->metadata;\
446 default: av_assert0(0);\
451 SET_DICT(type_in, meta_in, ic, idx_in);
452 SET_DICT(type_out, meta_out, oc, idx_out);
454 /* for input streams choose first matching stream */
455 if (type_in == 's') {
456 for (i = 0; i < ic->nb_streams; i++) {
457 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
458 meta_in = &ic->streams[i]->metadata;
464 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
469 if (type_out == 's') {
470 for (i = 0; i < oc->nb_streams; i++) {
471 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
472 meta_out = &oc->streams[i]->metadata;
473 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
478 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
483 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
485 OptionsContext *o = optctx;
487 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
488 struct tm time = *gmtime((time_t*)&recording_timestamp);
489 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
490 parse_option(o, "metadata", buf, options);
492 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
493 "tag instead.\n", opt);
497 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
499 const AVCodecDescriptor *desc;
500 const char *codec_string = encoder ? "encoder" : "decoder";
504 avcodec_find_encoder_by_name(name) :
505 avcodec_find_decoder_by_name(name);
507 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
508 codec = encoder ? avcodec_find_encoder(desc->id) :
509 avcodec_find_decoder(desc->id);
511 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
512 codec_string, codec->name, desc->name);
516 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
519 if (codec->type != type) {
520 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
526 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
528 char *codec_name = NULL;
530 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
532 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
533 st->codec->codec_id = codec->id;
536 return avcodec_find_decoder(st->codec->codec_id);
540 * Add all the streams from the given input file to the global
541 * list of input streams.
543 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
546 char *next, *codec_tag = NULL;
548 for (i = 0; i < ic->nb_streams; i++) {
549 AVStream *st = ic->streams[i];
550 AVCodecContext *dec = st->codec;
551 InputStream *ist = av_mallocz(sizeof(*ist));
552 char *framerate = NULL;
557 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
558 input_streams[nb_input_streams - 1] = ist;
561 ist->file_index = nb_input_files;
563 st->discard = AVDISCARD_ALL;
564 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
567 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
569 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
571 uint32_t tag = strtol(codec_tag, &next, 0);
573 tag = AV_RL32(codec_tag);
574 st->codec->codec_tag = tag;
577 ist->dec = choose_decoder(o, ic, st);
579 switch (dec->codec_type) {
580 case AVMEDIA_TYPE_VIDEO:
582 ist->dec = avcodec_find_decoder(dec->codec_id);
584 dec->flags |= CODEC_FLAG_EMU_EDGE;
587 ist->resample_height = dec->height;
588 ist->resample_width = dec->width;
589 ist->resample_pix_fmt = dec->pix_fmt;
591 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
592 if (framerate && av_parse_video_rate(&ist->framerate,
594 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
599 ist->top_field_first = -1;
600 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
603 case AVMEDIA_TYPE_AUDIO:
604 guess_input_channel_layout(ist);
606 ist->resample_sample_fmt = dec->sample_fmt;
607 ist->resample_sample_rate = dec->sample_rate;
608 ist->resample_channels = dec->channels;
609 ist->resample_channel_layout = dec->channel_layout;
612 case AVMEDIA_TYPE_DATA:
613 case AVMEDIA_TYPE_SUBTITLE:
615 ist->dec = avcodec_find_decoder(dec->codec_id);
616 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
618 case AVMEDIA_TYPE_ATTACHMENT:
619 case AVMEDIA_TYPE_UNKNOWN:
627 static void assert_file_overwrite(const char *filename)
629 if ((!file_overwrite || no_file_overwrite) &&
630 (strchr(filename, ':') == NULL || filename[1] == ':' ||
631 av_strstart(filename, "file:", NULL))) {
632 if (avio_check(filename, 0) == 0) {
633 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
634 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
637 signal(SIGINT, SIG_DFL);
639 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
645 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
652 static void dump_attachment(AVStream *st, const char *filename)
655 AVIOContext *out = NULL;
656 AVDictionaryEntry *e;
658 if (!st->codec->extradata_size) {
659 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
660 nb_input_files - 1, st->index);
663 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
666 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
667 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
671 assert_file_overwrite(filename);
673 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
674 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
679 avio_write(out, st->codec->extradata, st->codec->extradata_size);
684 static int opt_input_file(void *optctx, const char *opt, const char *filename)
686 OptionsContext *o = optctx;
688 AVInputFormat *file_iformat = NULL;
693 int orig_nb_streams; // number of streams before avformat_find_stream_info
694 char * video_codec_name = NULL;
695 char * audio_codec_name = NULL;
696 char *subtitle_codec_name = NULL;
699 if (!(file_iformat = av_find_input_format(o->format))) {
700 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
705 if (!strcmp(filename, "-"))
708 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
709 strcmp(filename, "/dev/stdin");
711 /* get default parameters from command line */
712 ic = avformat_alloc_context();
714 print_error(filename, AVERROR(ENOMEM));
717 if (o->nb_audio_sample_rate) {
718 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
719 av_dict_set(&format_opts, "sample_rate", buf, 0);
721 if (o->nb_audio_channels) {
722 /* because we set audio_channels based on both the "ac" and
723 * "channel_layout" options, we need to check that the specified
724 * demuxer actually has the "channels" option before setting it */
725 if (file_iformat && file_iformat->priv_class &&
726 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
727 AV_OPT_SEARCH_FAKE_OBJ)) {
728 snprintf(buf, sizeof(buf), "%d",
729 o->audio_channels[o->nb_audio_channels - 1].u.i);
730 av_dict_set(&format_opts, "channels", buf, 0);
733 if (o->nb_frame_rates) {
734 /* set the format-level framerate option;
735 * this is important for video grabbers, e.g. x11 */
736 if (file_iformat && file_iformat->priv_class &&
737 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
738 AV_OPT_SEARCH_FAKE_OBJ)) {
739 av_dict_set(&format_opts, "framerate",
740 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
743 if (o->nb_frame_sizes) {
744 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
746 if (o->nb_frame_pix_fmts)
747 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
749 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
750 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
751 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
753 ic->video_codec_id = video_codec_name ?
754 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
755 ic->audio_codec_id = audio_codec_name ?
756 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
757 ic->subtitle_codec_id= subtitle_codec_name ?
758 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
759 ic->flags |= AVFMT_FLAG_NONBLOCK;
760 ic->interrupt_callback = int_cb;
762 /* open the input file with generic avformat function */
763 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
765 print_error(filename, err);
768 assert_avoptions(format_opts);
770 /* apply forced codec ids */
771 for (i = 0; i < ic->nb_streams; i++)
772 choose_decoder(o, ic, ic->streams[i]);
774 /* Set AVCodecContext options for avformat_find_stream_info */
775 opts = setup_find_stream_info_opts(ic, codec_opts);
776 orig_nb_streams = ic->nb_streams;
778 /* If not enough info to get the stream parameters, we decode the
779 first frames to get it. (used in mpeg case for example) */
780 ret = avformat_find_stream_info(ic, opts);
782 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
783 avformat_close_input(&ic);
787 timestamp = o->start_time;
788 /* add the stream start time */
789 if (ic->start_time != AV_NOPTS_VALUE)
790 timestamp += ic->start_time;
792 /* if seeking requested, we execute it */
793 if (o->start_time != 0) {
794 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
796 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
797 filename, (double)timestamp / AV_TIME_BASE);
801 /* update the current parameters so that they match the one of the input stream */
802 add_input_streams(o, ic);
804 /* dump the file content */
805 av_dump_format(ic, nb_input_files, filename, 0);
807 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
808 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
811 input_files[nb_input_files - 1]->ctx = ic;
812 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
813 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
814 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
815 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
817 for (i = 0; i < o->nb_dump_attachment; i++) {
820 for (j = 0; j < ic->nb_streams; j++) {
821 AVStream *st = ic->streams[j];
823 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
824 dump_attachment(st, o->dump_attachment[i].u.str);
828 for (i = 0; i < orig_nb_streams; i++)
829 av_dict_free(&opts[i]);
836 static uint8_t *get_line(AVIOContext *s)
842 if (avio_open_dyn_buf(&line) < 0) {
843 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
847 while ((c = avio_r8(s)) && c != '\n')
850 avio_close_dyn_buf(line, &buf);
855 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
859 const char *base[3] = { getenv("AVCONV_DATADIR"),
864 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
868 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
869 i != 1 ? "" : "/.avconv", codec_name, preset_name);
870 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
873 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
874 i != 1 ? "" : "/.avconv", preset_name);
875 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
881 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
883 char *codec_name = NULL;
885 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
887 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
888 NULL, ost->st->codec->codec_type);
889 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
890 } else if (!strcmp(codec_name, "copy"))
891 ost->stream_copy = 1;
893 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
894 ost->st->codec->codec_id = ost->enc->id;
898 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
901 AVStream *st = avformat_new_stream(oc, NULL);
902 int idx = oc->nb_streams - 1, ret = 0;
903 char *bsf = NULL, *next, *codec_tag = NULL;
904 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
906 char *buf = NULL, *arg = NULL, *preset = NULL;
907 AVIOContext *s = NULL;
910 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
914 if (oc->nb_streams - 1 < o->nb_streamid_map)
915 st->id = o->streamid_map[oc->nb_streams - 1];
917 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
918 nb_output_streams + 1);
919 if (!(ost = av_mallocz(sizeof(*ost))))
921 output_streams[nb_output_streams - 1] = ost;
923 ost->file_index = nb_output_files;
926 st->codec->codec_type = type;
927 choose_encoder(o, oc, ost);
929 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
932 avcodec_get_context_defaults3(st->codec, ost->enc);
933 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
935 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
936 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
939 if (!buf[0] || buf[0] == '#') {
943 if (!(arg = strchr(buf, '='))) {
944 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
948 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
950 } while (!s->eof_reached);
954 av_log(NULL, AV_LOG_FATAL,
955 "Preset %s specified for stream %d:%d, but could not be opened.\n",
956 preset, ost->file_index, ost->index);
960 ost->max_frames = INT64_MAX;
961 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
963 ost->copy_prior_start = -1;
964 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
966 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
968 if (next = strchr(bsf, ','))
970 if (!(bsfc = av_bitstream_filter_init(bsf))) {
971 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
975 bsfc_prev->next = bsfc;
977 ost->bitstream_filters = bsfc;
983 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
985 uint32_t tag = strtol(codec_tag, &next, 0);
987 tag = AV_RL32(codec_tag);
988 st->codec->codec_tag = tag;
991 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
992 if (qscale >= 0 || same_quant) {
993 st->codec->flags |= CODEC_FLAG_QSCALE;
994 st->codec->global_quality = FF_QP2LAMBDA * qscale;
997 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
998 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1000 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1001 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1002 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1004 ost->source_index = source_index;
1005 if (source_index >= 0) {
1006 ost->sync_ist = input_streams[source_index];
1007 input_streams[source_index]->discard = 0;
1008 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1014 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1017 const char *p = str;
1024 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1031 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1035 AVCodecContext *video_enc;
1036 char *frame_rate = NULL;
1038 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1040 video_enc = st->codec;
1042 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1043 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1044 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1048 if (!ost->stream_copy) {
1049 const char *p = NULL;
1050 char *frame_size = NULL;
1051 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1052 char *intra_matrix = NULL, *inter_matrix = NULL;
1053 const char *filters = "null";
1057 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1058 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1059 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1063 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1064 if (frame_aspect_ratio) {
1066 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1067 q.num <= 0 || q.den <= 0) {
1068 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1071 ost->frame_aspect_ratio = av_q2d(q);
1074 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1075 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1076 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1077 ost->keep_pix_fmt = 1;
1078 if (!*++frame_pix_fmt)
1079 frame_pix_fmt = NULL;
1081 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1082 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1085 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1088 video_enc->gop_size = 0;
1089 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1091 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1092 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1095 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1097 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1099 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1100 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1103 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1106 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1107 for (i = 0; p; i++) {
1109 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1111 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1114 /* FIXME realloc failure */
1115 video_enc->rc_override =
1116 av_realloc(video_enc->rc_override,
1117 sizeof(RcOverride) * (i + 1));
1118 video_enc->rc_override[i].start_frame = start;
1119 video_enc->rc_override[i].end_frame = end;
1121 video_enc->rc_override[i].qscale = q;
1122 video_enc->rc_override[i].quality_factor = 1.0;
1125 video_enc->rc_override[i].qscale = 0;
1126 video_enc->rc_override[i].quality_factor = -q/100.0;
1131 video_enc->rc_override_count = i;
1132 if (!video_enc->rc_initial_buffer_occupancy)
1133 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1134 video_enc->intra_dc_precision = intra_dc_precision - 8;
1137 video_enc->flags|= CODEC_FLAG_PSNR;
1140 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1143 video_enc->flags |= CODEC_FLAG_PASS1;
1146 video_enc->flags |= CODEC_FLAG_PASS2;
1150 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1151 if (ost->logfile_prefix &&
1152 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1155 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1156 if (ost->forced_keyframes)
1157 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1159 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1161 ost->top_field_first = -1;
1162 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1164 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1165 ost->avfilter = av_strdup(filters);
1167 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1173 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1178 AVCodecContext *audio_enc;
1180 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1183 audio_enc = st->codec;
1184 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1186 if (!ost->stream_copy) {
1187 char *sample_fmt = NULL;
1188 const char *filters = "anull";
1190 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1192 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1194 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1195 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1199 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1201 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1203 av_assert1(filters);
1204 ost->avfilter = av_strdup(filters);
1206 /* check for channel mapping for this audio stream */
1207 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1208 AudioChannelMap *map = &o->audio_channel_maps[n];
1209 InputStream *ist = input_streams[ost->source_index];
1210 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1211 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1212 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1213 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1214 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1216 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1217 ost->file_index, ost->st->index);
1225 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1229 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1230 if (!ost->stream_copy) {
1231 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1238 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1240 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1241 ost->stream_copy = 1;
1245 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1249 AVCodecContext *subtitle_enc;
1251 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1253 subtitle_enc = st->codec;
1255 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1257 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1259 if (!ost->stream_copy) {
1260 char *frame_size = NULL;
1262 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1263 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1264 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1272 /* arg format is "output-stream-index:streamid-value". */
1273 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1275 OptionsContext *o = optctx;
1280 av_strlcpy(idx_str, arg, sizeof(idx_str));
1281 p = strchr(idx_str, ':');
1283 av_log(NULL, AV_LOG_FATAL,
1284 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1289 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1290 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1291 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1295 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1297 AVFormatContext *is = ifile->ctx;
1298 AVFormatContext *os = ofile->ctx;
1301 for (i = 0; i < is->nb_chapters; i++) {
1302 AVChapter *in_ch = is->chapters[i], *out_ch;
1303 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1304 AV_TIME_BASE_Q, in_ch->time_base);
1305 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1306 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1309 if (in_ch->end < ts_off)
1311 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1314 out_ch = av_mallocz(sizeof(AVChapter));
1316 return AVERROR(ENOMEM);
1318 out_ch->id = in_ch->id;
1319 out_ch->time_base = in_ch->time_base;
1320 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1321 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1324 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1327 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
1329 return AVERROR(ENOMEM);
1330 os->chapters[os->nb_chapters - 1] = out_ch;
1335 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1338 AVFormatContext *ic = avformat_alloc_context();
1340 ic->interrupt_callback = int_cb;
1341 err = avformat_open_input(&ic, filename, NULL, NULL);
1344 /* copy stream format */
1345 for(i=0;i<ic->nb_streams;i++) {
1349 AVCodecContext *avctx;
1351 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1352 ost = new_output_stream(o, s, codec->type, -1);
1357 // FIXME: a more elegant solution is needed
1358 memcpy(st, ic->streams[i], sizeof(AVStream));
1360 st->info = av_malloc(sizeof(*st->info));
1361 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1363 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1365 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1366 choose_sample_fmt(st, codec);
1367 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1368 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1371 /* ffserver seeking with date=... needs a date reference */
1372 err = parse_option(o, "metadata", "creation_time=now", options);
1374 avformat_close_input(&ic);
1378 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1379 AVFormatContext *oc)
1383 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1384 ofilter->out_tmp->pad_idx)) {
1385 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1386 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1388 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1393 ost->source_index = -1;
1394 ost->filter = ofilter;
1398 if (ost->stream_copy) {
1399 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1400 "which is fed from a complex filtergraph. Filtering and streamcopy "
1401 "cannot be used together.\n", ost->file_index, ost->index);
1405 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1406 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1409 avfilter_inout_free(&ofilter->out_tmp);
1412 static int configure_complex_filters(void)
1416 for (i = 0; i < nb_filtergraphs; i++)
1417 if (!filtergraphs[i]->graph &&
1418 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1423 void opt_output_file(void *optctx, const char *filename)
1425 OptionsContext *o = optctx;
1426 AVFormatContext *oc;
1428 AVOutputFormat *file_oformat;
1432 if (configure_complex_filters() < 0) {
1433 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1437 if (!strcmp(filename, "-"))
1440 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1442 print_error(filename, err);
1445 file_oformat= oc->oformat;
1446 oc->interrupt_callback = int_cb;
1448 /* create streams for all unlabeled output pads */
1449 for (i = 0; i < nb_filtergraphs; i++) {
1450 FilterGraph *fg = filtergraphs[i];
1451 for (j = 0; j < fg->nb_outputs; j++) {
1452 OutputFilter *ofilter = fg->outputs[j];
1454 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1457 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1458 ofilter->out_tmp->pad_idx)) {
1459 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1460 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1461 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1463 init_output_filter(ofilter, o, oc);
1467 if (!strcmp(file_oformat->name, "ffm") &&
1468 av_strstart(filename, "http:", NULL)) {
1470 /* special case for files sent to ffserver: we get the stream
1471 parameters from ffserver */
1472 int err = read_ffserver_streams(o, oc, filename);
1474 print_error(filename, err);
1477 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1478 ost = output_streams[j];
1479 for (i = 0; i < nb_input_streams; i++) {
1480 ist = input_streams[i];
1481 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1483 ost->source_index= i;
1484 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1485 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1487 ist->st->discard = AVDISCARD_NONE;
1492 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));
1496 } else if (!o->nb_stream_maps) {
1497 char *subtitle_codec_name = NULL;
1498 /* pick the "best" stream of each type */
1500 /* video: highest resolution */
1501 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1502 int area = 0, idx = -1;
1503 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1504 for (i = 0; i < nb_input_streams; i++) {
1506 ist = input_streams[i];
1507 new_area = ist->st->codec->width * ist->st->codec->height;
1508 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1510 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1512 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1519 new_video_stream(o, oc, idx);
1522 /* audio: most channels */
1523 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1524 int channels = 0, idx = -1;
1525 for (i = 0; i < nb_input_streams; i++) {
1526 ist = input_streams[i];
1527 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1528 ist->st->codec->channels > channels) {
1529 channels = ist->st->codec->channels;
1534 new_audio_stream(o, oc, idx);
1537 /* subtitles: pick first */
1538 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1539 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1540 for (i = 0; i < nb_input_streams; i++)
1541 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1542 new_subtitle_stream(o, oc, i);
1546 /* do something with data? */
1548 for (i = 0; i < o->nb_stream_maps; i++) {
1549 StreamMap *map = &o->stream_maps[i];
1550 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1555 if (map->linklabel) {
1557 OutputFilter *ofilter = NULL;
1560 for (j = 0; j < nb_filtergraphs; j++) {
1561 fg = filtergraphs[j];
1562 for (k = 0; k < fg->nb_outputs; k++) {
1563 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1564 if (out && !strcmp(out->name, map->linklabel)) {
1565 ofilter = fg->outputs[k];
1572 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1573 "in any defined filter graph.\n", map->linklabel);
1576 init_output_filter(ofilter, o, oc);
1578 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1579 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1581 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1583 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1585 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1588 switch (ist->st->codec->codec_type) {
1589 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1590 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1591 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1592 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1593 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1595 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1596 map->file_index, map->stream_index);
1604 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1605 AVDictionaryEntry *e;
1606 ost = output_streams[i];
1608 if ( ost->stream_copy
1609 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1610 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1611 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1615 /* handle attached files */
1616 for (i = 0; i < o->nb_attachments; i++) {
1618 uint8_t *attachment;
1622 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1623 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1627 if ((len = avio_size(pb)) <= 0) {
1628 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1632 if (!(attachment = av_malloc(len))) {
1633 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1637 avio_read(pb, attachment, len);
1639 ost = new_attachment_stream(o, oc, -1);
1640 ost->stream_copy = 0;
1641 ost->attachment_filename = o->attachments[i];
1642 ost->st->codec->extradata = attachment;
1643 ost->st->codec->extradata_size = len;
1645 p = strrchr(o->attachments[i], '/');
1646 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1650 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1651 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1654 output_files[nb_output_files - 1]->ctx = oc;
1655 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1656 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1657 if (o->recording_time != INT64_MAX)
1658 oc->duration = o->recording_time;
1659 output_files[nb_output_files - 1]->start_time = o->start_time;
1660 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1661 output_files[nb_output_files - 1]->shortest = o->shortest;
1662 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1664 /* check filename in case of an image number is expected */
1665 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1666 if (!av_filename_number_test(oc->filename)) {
1667 print_error(oc->filename, AVERROR(EINVAL));
1672 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1673 /* test if it already exists to avoid losing precious files */
1674 assert_file_overwrite(filename);
1677 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1678 &oc->interrupt_callback,
1679 &output_files[nb_output_files - 1]->opts)) < 0) {
1680 print_error(filename, err);
1685 if (o->mux_preload) {
1687 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1688 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1690 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1693 for (i = 0; i < o->nb_metadata_map; i++) {
1695 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1697 if (in_file_index >= nb_input_files) {
1698 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1701 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
1705 if (o->chapters_input_file >= nb_input_files) {
1706 if (o->chapters_input_file == INT_MAX) {
1707 /* copy chapters from the first input file that has them*/
1708 o->chapters_input_file = -1;
1709 for (i = 0; i < nb_input_files; i++)
1710 if (input_files[i]->ctx->nb_chapters) {
1711 o->chapters_input_file = i;
1715 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1716 o->chapters_input_file);
1720 if (o->chapters_input_file >= 0)
1721 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1722 !o->metadata_chapters_manual);
1724 /* copy global metadata by default */
1725 if (!o->metadata_global_manual && nb_input_files){
1726 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1727 AV_DICT_DONT_OVERWRITE);
1728 if(o->recording_time != INT64_MAX)
1729 av_dict_set(&oc->metadata, "duration", NULL, 0);
1730 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1732 if (!o->metadata_streams_manual)
1733 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1735 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1737 ist = input_streams[output_streams[i]->source_index];
1738 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1741 /* process manually set metadata */
1742 for (i = 0; i < o->nb_metadata; i++) {
1745 const char *stream_spec;
1746 int index = 0, j, ret = 0;
1748 val = strchr(o->metadata[i].u.str, '=');
1750 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1751 o->metadata[i].u.str);
1756 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1758 for (j = 0; j < oc->nb_streams; j++) {
1759 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1760 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1771 if (index < 0 || index >= oc->nb_chapters) {
1772 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1775 m = &oc->chapters[index]->metadata;
1778 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1781 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1785 reset_options(o, 0);
1788 static int opt_target(void *optctx, const char *opt, const char *arg)
1790 OptionsContext *o = optctx;
1791 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1792 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1794 if (!strncmp(arg, "pal-", 4)) {
1797 } else if (!strncmp(arg, "ntsc-", 5)) {
1800 } else if (!strncmp(arg, "film-", 5)) {
1804 /* Try to determine PAL/NTSC by peeking in the input files */
1805 if (nb_input_files) {
1807 for (j = 0; j < nb_input_files; j++) {
1808 for (i = 0; i < input_files[j]->nb_streams; i++) {
1809 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1810 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1812 fr = c->time_base.den * 1000 / c->time_base.num;
1816 } else if ((fr == 29970) || (fr == 23976)) {
1821 if (norm != UNKNOWN)
1825 if (norm != UNKNOWN)
1826 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1829 if (norm == UNKNOWN) {
1830 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1831 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1832 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1836 if (!strcmp(arg, "vcd")) {
1837 opt_video_codec(o, "c:v", "mpeg1video");
1838 opt_audio_codec(o, "c:a", "mp2");
1839 parse_option(o, "f", "vcd", options);
1841 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1842 parse_option(o, "r", frame_rates[norm], options);
1843 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1845 opt_default(NULL, "b:v", "1150000");
1846 opt_default(NULL, "maxrate", "1150000");
1847 opt_default(NULL, "minrate", "1150000");
1848 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1850 opt_default(NULL, "b:a", "224000");
1851 parse_option(o, "ar", "44100", options);
1852 parse_option(o, "ac", "2", options);
1854 opt_default(NULL, "packetsize", "2324");
1855 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1857 /* We have to offset the PTS, so that it is consistent with the SCR.
1858 SCR starts at 36000, but the first two packs contain only padding
1859 and the first pack from the other stream, respectively, may also have
1860 been written before.
1861 So the real data starts at SCR 36000+3*1200. */
1862 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1863 } else if (!strcmp(arg, "svcd")) {
1865 opt_video_codec(o, "c:v", "mpeg2video");
1866 opt_audio_codec(o, "c:a", "mp2");
1867 parse_option(o, "f", "svcd", options);
1869 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1870 parse_option(o, "r", frame_rates[norm], options);
1871 parse_option(o, "pix_fmt", "yuv420p", options);
1872 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1874 opt_default(NULL, "b:v", "2040000");
1875 opt_default(NULL, "maxrate", "2516000");
1876 opt_default(NULL, "minrate", "0"); // 1145000;
1877 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1878 opt_default(NULL, "scan_offset", "1");
1880 opt_default(NULL, "b:a", "224000");
1881 parse_option(o, "ar", "44100", options);
1883 opt_default(NULL, "packetsize", "2324");
1885 } else if (!strcmp(arg, "dvd")) {
1887 opt_video_codec(o, "c:v", "mpeg2video");
1888 opt_audio_codec(o, "c:a", "ac3");
1889 parse_option(o, "f", "dvd", options);
1891 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1892 parse_option(o, "r", frame_rates[norm], options);
1893 parse_option(o, "pix_fmt", "yuv420p", options);
1894 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1896 opt_default(NULL, "b:v", "6000000");
1897 opt_default(NULL, "maxrate", "9000000");
1898 opt_default(NULL, "minrate", "0"); // 1500000;
1899 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1901 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1902 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1904 opt_default(NULL, "b:a", "448000");
1905 parse_option(o, "ar", "48000", options);
1907 } else if (!strncmp(arg, "dv", 2)) {
1909 parse_option(o, "f", "dv", options);
1911 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1912 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1913 norm == PAL ? "yuv420p" : "yuv411p", options);
1914 parse_option(o, "r", frame_rates[norm], options);
1916 parse_option(o, "ar", "48000", options);
1917 parse_option(o, "ac", "2", options);
1920 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1921 return AVERROR(EINVAL);
1926 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1928 av_free (vstats_filename);
1929 vstats_filename = av_strdup (arg);
1933 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1936 time_t today2 = time(NULL);
1937 struct tm *today = localtime(&today2);
1939 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1941 return opt_vstats_file(NULL, opt, filename);
1944 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1946 OptionsContext *o = optctx;
1947 return parse_option(o, "frames:v", arg, options);
1950 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1952 OptionsContext *o = optctx;
1953 return parse_option(o, "frames:a", arg, options);
1956 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1958 OptionsContext *o = optctx;
1959 return parse_option(o, "frames:d", arg, options);
1962 static int opt_preset(void *optctx, const char *opt, const char *arg)
1964 OptionsContext *o = optctx;
1966 char filename[1000], line[1000], tmp_line[1000];
1967 const char *codec_name = NULL;
1971 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1973 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1974 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1975 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1977 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1981 while (fgets(line, sizeof(line), f)) {
1982 char *key = tmp_line, *value, *endptr;
1984 if (strcspn(line, "#\n\r") == 0)
1986 strcpy(tmp_line, line);
1987 if (!av_strtok(key, "=", &value) ||
1988 !av_strtok(value, "\r\n", &endptr)) {
1989 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1992 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1994 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
1995 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
1996 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
1997 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
1998 else if (opt_default(NULL, key, value) < 0) {
1999 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2000 filename, line, key, value);
2010 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2012 OptionsContext *o = optctx;
2013 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2014 int ret = parse_option(o, s, arg, options);
2019 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2021 OptionsContext *o = optctx;
2022 if(!strcmp(opt, "b")){
2023 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2024 return parse_option(o, "b:v", arg, options);
2026 return opt_default(optctx, opt, arg);
2029 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2031 OptionsContext *o = optctx;
2034 if(!strcmp(opt, "qscale")){
2035 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2036 return parse_option(o, "q:v", arg, options);
2038 s = av_asprintf("q%s", opt + 6);
2039 ret = parse_option(o, s, arg, options);
2044 static int opt_profile(void *optctx, const char *opt, const char *arg)
2046 OptionsContext *o = optctx;
2047 if(!strcmp(opt, "profile")){
2048 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2049 return parse_option(o, "profile:v", arg, options);
2051 return opt_default(optctx, opt, arg);
2055 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2057 OptionsContext *o = optctx;
2058 return parse_option(o, "filter:v", arg, options);
2061 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2063 OptionsContext *o = optctx;
2064 return parse_option(o, "filter:a", arg, options);
2067 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2069 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2070 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2071 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2072 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2074 if (video_sync_method == VSYNC_AUTO)
2075 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2079 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2081 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2086 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2088 OptionsContext *o = optctx;
2089 char *tcr = av_asprintf("timecode=%s", arg);
2090 int ret = parse_option(o, "metadata:g", tcr, options);
2092 ret = opt_default(optctx, "gop_timecode", arg);
2097 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2099 OptionsContext *o = optctx;
2100 char layout_str[32];
2103 int ret, channels, ac_str_size;
2106 layout = av_get_channel_layout(arg);
2108 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2109 return AVERROR(EINVAL);
2111 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2112 ret = opt_default(NULL, opt, layout_str);
2116 /* set 'ac' option based on channel layout */
2117 channels = av_get_channel_layout_nb_channels(layout);
2118 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2119 stream_str = strchr(opt, ':');
2120 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2121 ac_str = av_mallocz(ac_str_size);
2123 return AVERROR(ENOMEM);
2124 av_strlcpy(ac_str, "ac", 3);
2126 av_strlcat(ac_str, stream_str, ac_str_size);
2127 ret = parse_option(o, ac_str, layout_str, options);
2133 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2135 OptionsContext *o = optctx;
2136 return parse_option(o, "q:a", arg, options);
2139 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2141 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2142 &nb_filtergraphs, nb_filtergraphs + 1);
2143 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2144 return AVERROR(ENOMEM);
2145 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2146 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2150 void show_help_default(const char *opt, const char *arg)
2152 /* per-file options have at least one of those set */
2153 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2154 int show_advanced = 0, show_avoptions = 0;
2157 if (!strcmp(opt, "long"))
2159 else if (!strcmp(opt, "full"))
2160 show_advanced = show_avoptions = 1;
2162 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2167 printf("Getting help:\n"
2168 " -h -- print basic options\n"
2169 " -h long -- print more options\n"
2170 " -h full -- print all options (including all format and codec specific options, very long)\n"
2171 " See man %s for detailed description of the options.\n"
2172 "\n", program_name);
2174 show_help_options(options, "Print help / information / capabilities:",
2177 show_help_options(options, "Global options (affect whole program "
2178 "instead of just one file:",
2179 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2181 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2182 per_file | OPT_EXIT, 0);
2184 show_help_options(options, "Per-file main options:", 0,
2185 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2186 OPT_EXIT, per_file);
2188 show_help_options(options, "Advanced per-file options:",
2189 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2191 show_help_options(options, "Video options:",
2192 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2194 show_help_options(options, "Advanced Video options:",
2195 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2197 show_help_options(options, "Audio options:",
2198 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2200 show_help_options(options, "Advanced Audio options:",
2201 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2202 show_help_options(options, "Subtitle options:",
2203 OPT_SUBTITLE, 0, 0);
2206 if (show_avoptions) {
2207 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2208 show_help_children(avcodec_get_class(), flags);
2209 show_help_children(avformat_get_class(), flags);
2210 show_help_children(sws_get_class(), flags);
2211 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2212 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2216 void show_usage(void)
2218 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2219 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2220 av_log(NULL, AV_LOG_INFO, "\n");
2224 static int opt_progress(void *optctx, const char *opt, const char *arg)
2226 AVIOContext *avio = NULL;
2229 if (!strcmp(arg, "-"))
2231 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2233 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2234 arg, av_err2str(ret));
2237 progress_avio = avio;
2241 #define OFFSET(x) offsetof(OptionsContext, x)
2242 const OptionDef options[] = {
2244 #include "cmdutils_common_opts.h"
2245 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2246 "force format", "fmt" },
2247 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2248 "input file name", "filename" },
2249 { "y", OPT_BOOL, { &file_overwrite },
2250 "overwrite output files" },
2251 { "n", OPT_BOOL, { &no_file_overwrite },
2252 "do not overwrite output files" },
2253 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2254 "codec name", "codec" },
2255 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2256 "codec name", "codec" },
2257 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2258 "preset name", "preset" },
2259 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2260 "set input stream mapping",
2261 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2262 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2263 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2264 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2265 "set metadata information of outfile from infile",
2266 "outfile[,metadata]:infile[,metadata]" },
2267 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2268 "set chapters mapping", "input_file_index" },
2269 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2270 "record or transcode \"duration\" seconds of audio/video",
2272 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2273 "set the limit file size in bytes", "limit_size" },
2274 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2275 "set the start time offset", "time_off" },
2276 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2277 "set the input ts offset", "time_off" },
2278 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2279 "set the input ts scale", "scale" },
2280 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2281 "set the recording timestamp ('now' to set the current time)", "time" },
2282 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2283 "add metadata", "string=string" },
2284 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2285 "set the number of data frames to record", "number" },
2286 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2287 "add timings for benchmarking" },
2288 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2289 "add timings for each task" },
2290 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2291 "write program-readable progress information", "url" },
2292 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2293 "enable or disable interaction on standard input" },
2294 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2295 "set max runtime in seconds", "limit" },
2296 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2297 "dump each input packet" },
2298 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2299 "when dumping packets, also dump the payload" },
2300 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2301 "read input at native frame rate", "" },
2302 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2303 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2304 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2305 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2306 "video sync method", "" },
2307 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2308 "audio sync method", "" },
2309 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2310 "audio drift threshold", "threshold" },
2311 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2312 "copy timestamps" },
2313 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2314 "copy input stream time base when stream copying", "mode" },
2315 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2316 "finish encoding within shortest input" },
2317 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2318 "timestamp discontinuity delta threshold", "threshold" },
2319 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2320 "timestamp error delta threshold", "threshold" },
2321 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2322 "exit on error", "error" },
2323 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2324 "copy initial non-keyframes" },
2325 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2326 "copy or discard frames before start time" },
2327 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2328 "set the number of frames to record", "number" },
2329 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2330 "force codec tag/fourcc", "fourcc/tag" },
2331 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2332 "use fixed quality scale (VBR)", "q" },
2333 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2334 "use fixed quality scale (VBR)", "q" },
2335 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2336 "set profile", "profile" },
2337 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2338 "set stream filterchain", "filter_list" },
2339 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2340 "create a complex filtergraph", "graph_description" },
2341 { "stats", OPT_BOOL, { &print_stats },
2342 "print progress report during encoding", },
2343 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2344 "add an attachment to the output file", "filename" },
2345 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2346 "extract an attachment into a file", "filename" },
2347 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2348 "print timestamp debugging info" },
2351 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2352 "set the number of video frames to record", "number" },
2353 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2354 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2355 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2356 "set frame size (WxH or abbreviation)", "size" },
2357 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2358 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2359 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2360 "set pixel format", "format" },
2361 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2362 "set the number of bits per raw sample", "number" },
2363 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2364 "Removed, use the crop filter instead", "size" },
2365 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2366 "Removed, use the crop filter instead", "size" },
2367 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2368 "Removed, use the crop filter instead", "size" },
2369 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2370 "Removed, use the crop filter instead", "size" },
2371 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2372 "Removed, use the pad filter instead", "size" },
2373 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2374 "Removed, use the pad filter instead", "size" },
2375 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2376 "Removed, use the pad filter instead", "size" },
2377 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2378 "Removed, use the pad filter instead", "size" },
2379 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2380 "Removed, use the pad filter instead", "color" },
2381 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2382 "deprecated use -g 1" },
2383 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2385 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2386 "discard threshold", "n" },
2387 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2388 "rate control override for specific intervals", "override" },
2389 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2390 "force video codec ('copy' to copy stream)", "codec" },
2391 { "sameq", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &same_quant },
2392 "use same quantizer as source (implies VBR)" },
2393 { "same_quant", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &same_quant },
2394 "use same quantizer as source (implies VBR)" },
2395 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2396 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2397 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2398 "select the pass number (1 to 3)", "n" },
2399 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2400 "select two pass log file name prefix", "prefix" },
2401 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2402 "this option is deprecated, use the yadif filter instead" },
2403 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2404 "calculate PSNR of compressed frames" },
2405 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2406 "dump video coding statistics to file" },
2407 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2408 "dump video coding statistics to file", "file" },
2409 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2410 "video filters", "filter list" },
2411 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2412 "specify intra matrix coeffs", "matrix" },
2413 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2414 "specify inter matrix coeffs", "matrix" },
2415 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2416 "top=1/bottom=0/auto=-1 field first", "" },
2417 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2418 "intra_dc_precision", "precision" },
2419 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2420 "force video tag/fourcc", "fourcc/tag" },
2421 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2422 "show QP histogram" },
2423 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2424 "force the selected framerate, disable the best supported framerate selection" },
2425 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2426 "set the value of an outfile streamid", "streamIndex:value" },
2427 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2428 { .off = OFFSET(forced_key_frames) },
2429 "force key frames at specified timestamps", "timestamps" },
2430 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2431 "video bitrate (please use -b:v)", "bitrate" },
2434 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2435 "set the number of audio frames to record", "number" },
2436 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2437 "set audio quality (codec-specific)", "quality", },
2438 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2439 "set audio sampling rate (in Hz)", "rate" },
2440 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2441 "set number of audio channels", "channels" },
2442 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2444 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2445 "force audio codec ('copy' to copy stream)", "codec" },
2446 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2447 "force audio tag/fourcc", "fourcc/tag" },
2448 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2449 "change audio volume (256=normal)" , "volume" },
2450 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2451 "set sample format", "format" },
2452 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2453 "set channel layout", "layout" },
2454 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2455 "audio filters", "filter list" },
2457 /* subtitle options */
2458 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2459 "disable subtitle" },
2460 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2461 "force subtitle codec ('copy' to copy stream)", "codec" },
2462 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2463 , "force subtitle tag/fourcc", "fourcc/tag" },
2464 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2465 "fix subtitles duration" },
2468 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2469 "deprecated, use -channel", "channel" },
2470 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2471 "deprecated, use -standard", "standard" },
2472 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2475 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2476 "set the maximum demux-decode delay", "seconds" },
2477 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2478 "set the initial demux-decode delay", "seconds" },
2480 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2481 "A comma-separated list of bitstream filters", "bitstream_filters" },
2482 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2483 "deprecated", "audio bitstream_filters" },
2484 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2485 "deprecated", "video bitstream_filters" },
2487 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2488 "set the audio options to the indicated preset", "preset" },
2489 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2490 "set the video options to the indicated preset", "preset" },
2491 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2492 "set the subtitle options to the indicated preset", "preset" },
2493 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2494 "set options from indicated preset file", "filename" },
2495 /* data codec support */
2496 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2497 "force data codec ('copy' to copy stream)", "codec" },
2498 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2501 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2502 "generic catch all option", "" },