2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 for (i = 0; i < o->nb_ ## name; i++) {\
61 char *spec = o->name[i].specifier;\
62 if (!strcmp(spec, mediatype))\
63 outvar = o->name[i].u.type;\
66 char *vstats_filename;
68 float audio_drift_threshold = 0.1;
69 float dts_delta_threshold = 10;
70 float dts_error_threshold = 3600*30;
72 int audio_volume = 256;
73 int audio_sync_method = 0;
74 int video_sync_method = VSYNC_AUTO;
75 int do_deinterlace = 0;
77 int do_benchmark_all = 0;
83 int exit_on_error = 0;
86 int stdin_interaction = 1;
87 int frame_bits_per_raw_sample = 0;
90 static int intra_only = 0;
91 static int file_overwrite = 0;
92 static int no_file_overwrite = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int do_psnr = 0;
96 static int input_sync;
98 void reset_options(OptionsContext *o, int is_input)
100 const OptionDef *po = options;
101 OptionsContext bak= *o;
104 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
106 void *dst = (uint8_t*)o + po->u.off;
108 if (po->flags & OPT_SPEC) {
109 SpecifierOpt **so = dst;
110 int i, *count = (int*)(so + 1);
111 for (i = 0; i < *count; i++) {
112 av_freep(&(*so)[i].specifier);
113 if (po->flags & OPT_STRING)
114 av_freep(&(*so)[i].u.str);
118 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
123 for (i = 0; i < o->nb_stream_maps; i++)
124 av_freep(&o->stream_maps[i].linklabel);
125 av_freep(&o->stream_maps);
126 av_freep(&o->audio_channel_maps);
127 av_freep(&o->streamid_map);
129 memset(o, 0, sizeof(*o));
132 o->recording_time = bak.recording_time;
133 if (o->recording_time != INT64_MAX)
134 av_log(NULL, AV_LOG_WARNING,
135 "-t is not an input option, keeping it for the next output;"
136 " consider fixing your command line.\n");
138 o->recording_time = INT64_MAX;
139 o->mux_max_delay = 0.7;
140 o->limit_filesize = UINT64_MAX;
141 o->chapters_input_file = INT_MAX;
148 static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
150 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
151 return AVERROR(EINVAL);
154 static int opt_pad(void *optctx, const char *opt, const char *arg)
156 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
160 static int opt_sameq(void *optctx, const char *opt, const char *arg)
162 av_log(NULL, AV_LOG_WARNING, "Ignoring option '%s'\n", opt);
166 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
168 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
169 return opt_default(optctx, "channel", arg);
172 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
174 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
175 return opt_default(optctx, "standard", arg);
178 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
180 OptionsContext *o = optctx;
181 return parse_option(o, "codec:a", arg, options);
184 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
186 OptionsContext *o = optctx;
187 return parse_option(o, "codec:v", arg, options);
190 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
192 OptionsContext *o = optctx;
193 return parse_option(o, "codec:s", arg, options);
196 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
198 OptionsContext *o = optctx;
199 return parse_option(o, "codec:d", arg, options);
202 static int opt_map(void *optctx, const char *opt, const char *arg)
204 OptionsContext *o = optctx;
206 int i, negative = 0, file_idx;
207 int sync_file_idx = -1, sync_stream_idx = 0;
215 map = av_strdup(arg);
217 /* parse sync stream first, just pick first matching stream */
218 if (sync = strchr(map, ',')) {
220 sync_file_idx = strtol(sync + 1, &sync, 0);
221 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
222 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
227 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
228 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
229 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
233 if (i == input_files[sync_file_idx]->nb_streams) {
234 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
235 "match any streams.\n", arg);
242 /* this mapping refers to lavfi output */
243 const char *c = map + 1;
244 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
245 &o->nb_stream_maps, o->nb_stream_maps + 1);
246 m = &o->stream_maps[o->nb_stream_maps - 1];
247 m->linklabel = av_get_token(&c, "]");
249 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
253 file_idx = strtol(map, &p, 0);
254 if (file_idx >= nb_input_files || file_idx < 0) {
255 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
259 /* disable some already defined maps */
260 for (i = 0; i < o->nb_stream_maps; i++) {
261 m = &o->stream_maps[i];
262 if (file_idx == m->file_index &&
263 check_stream_specifier(input_files[m->file_index]->ctx,
264 input_files[m->file_index]->ctx->streams[m->stream_index],
265 *p == ':' ? p + 1 : p) > 0)
269 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
270 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
271 *p == ':' ? p + 1 : p) <= 0)
273 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
274 &o->nb_stream_maps, o->nb_stream_maps + 1);
275 m = &o->stream_maps[o->nb_stream_maps - 1];
277 m->file_index = file_idx;
280 if (sync_file_idx >= 0) {
281 m->sync_file_index = sync_file_idx;
282 m->sync_stream_index = sync_stream_idx;
284 m->sync_file_index = file_idx;
285 m->sync_stream_index = i;
291 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
299 static int opt_attach(void *optctx, const char *opt, const char *arg)
301 OptionsContext *o = optctx;
302 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
303 &o->nb_attachments, o->nb_attachments + 1);
304 o->attachments[o->nb_attachments - 1] = arg;
308 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
310 OptionsContext *o = optctx;
315 o->audio_channel_maps =
316 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
317 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
318 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
320 /* muted channel syntax */
321 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
322 if ((n == 1 || n == 3) && m->channel_idx == -1) {
323 m->file_idx = m->stream_idx = -1;
325 m->ofile_idx = m->ostream_idx = -1;
330 n = sscanf(arg, "%d.%d.%d:%d.%d",
331 &m->file_idx, &m->stream_idx, &m->channel_idx,
332 &m->ofile_idx, &m->ostream_idx);
334 if (n != 3 && n != 5) {
335 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
336 "[file.stream.channel|-1][:syncfile:syncstream]\n");
340 if (n != 5) // only file.stream.channel specified
341 m->ofile_idx = m->ostream_idx = -1;
344 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
345 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
349 if (m->stream_idx < 0 ||
350 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
351 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
352 m->file_idx, m->stream_idx);
355 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
356 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
357 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
358 m->file_idx, m->stream_idx);
361 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
362 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
363 m->file_idx, m->stream_idx, m->channel_idx);
370 * Parse a metadata specifier passed as 'arg' parameter.
371 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
372 * @param index for type c/p, chapter/program index is written here
373 * @param stream_spec for type s, the stream specifier is written here
375 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
383 if (*(++arg) && *arg != ':') {
384 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
387 *stream_spec = *arg == ':' ? arg + 1 : "";
392 *index = strtol(++arg, NULL, 0);
395 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
402 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
404 AVDictionary **meta_in = NULL;
405 AVDictionary **meta_out = NULL;
407 char type_in, type_out;
408 const char *istream_spec = NULL, *ostream_spec = NULL;
409 int idx_in = 0, idx_out = 0;
411 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
412 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
415 if (type_out == 'g' || !*outspec)
416 o->metadata_global_manual = 1;
417 if (type_out == 's' || !*outspec)
418 o->metadata_streams_manual = 1;
419 if (type_out == 'c' || !*outspec)
420 o->metadata_chapters_manual = 1;
424 if (type_in == 'g' || type_out == 'g')
425 o->metadata_global_manual = 1;
426 if (type_in == 's' || type_out == 's')
427 o->metadata_streams_manual = 1;
428 if (type_in == 'c' || type_out == 'c')
429 o->metadata_chapters_manual = 1;
431 #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);
544 /* Add all the streams from the given input file to the global
545 * list of input streams. */
546 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
549 char *next, *codec_tag = NULL;
551 for (i = 0; i < ic->nb_streams; i++) {
552 AVStream *st = ic->streams[i];
553 AVCodecContext *dec = st->codec;
554 InputStream *ist = av_mallocz(sizeof(*ist));
555 char *framerate = NULL;
560 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
561 input_streams[nb_input_streams - 1] = ist;
564 ist->file_index = nb_input_files;
566 st->discard = AVDISCARD_ALL;
567 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
570 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
572 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
574 uint32_t tag = strtol(codec_tag, &next, 0);
576 tag = AV_RL32(codec_tag);
577 st->codec->codec_tag = tag;
580 ist->dec = choose_decoder(o, ic, st);
582 switch (dec->codec_type) {
583 case AVMEDIA_TYPE_VIDEO:
585 ist->dec = avcodec_find_decoder(dec->codec_id);
587 dec->flags |= CODEC_FLAG_EMU_EDGE;
590 ist->resample_height = dec->height;
591 ist->resample_width = dec->width;
592 ist->resample_pix_fmt = dec->pix_fmt;
594 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
595 if (framerate && av_parse_video_rate(&ist->framerate,
597 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
602 ist->top_field_first = -1;
603 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
606 case AVMEDIA_TYPE_AUDIO:
607 guess_input_channel_layout(ist);
609 ist->resample_sample_fmt = dec->sample_fmt;
610 ist->resample_sample_rate = dec->sample_rate;
611 ist->resample_channels = dec->channels;
612 ist->resample_channel_layout = dec->channel_layout;
615 case AVMEDIA_TYPE_DATA:
616 case AVMEDIA_TYPE_SUBTITLE:
618 ist->dec = avcodec_find_decoder(dec->codec_id);
619 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
621 case AVMEDIA_TYPE_ATTACHMENT:
622 case AVMEDIA_TYPE_UNKNOWN:
630 static void assert_file_overwrite(const char *filename)
632 if ((!file_overwrite || no_file_overwrite) &&
633 (strchr(filename, ':') == NULL || filename[1] == ':' ||
634 av_strstart(filename, "file:", NULL))) {
635 if (avio_check(filename, 0) == 0) {
636 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
637 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
640 signal(SIGINT, SIG_DFL);
642 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
648 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
655 static void dump_attachment(AVStream *st, const char *filename)
658 AVIOContext *out = NULL;
659 AVDictionaryEntry *e;
661 if (!st->codec->extradata_size) {
662 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
663 nb_input_files - 1, st->index);
666 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
669 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
670 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
674 assert_file_overwrite(filename);
676 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
677 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
682 avio_write(out, st->codec->extradata, st->codec->extradata_size);
687 static int opt_input_file(void *optctx, const char *opt, const char *filename)
689 OptionsContext *o = optctx;
691 AVInputFormat *file_iformat = NULL;
696 int orig_nb_streams; // number of streams before avformat_find_stream_info
697 char * video_codec_name = NULL;
698 char * audio_codec_name = NULL;
699 char *subtitle_codec_name = NULL;
702 if (!(file_iformat = av_find_input_format(o->format))) {
703 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
708 if (!strcmp(filename, "-"))
711 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
712 strcmp(filename, "/dev/stdin");
714 /* get default parameters from command line */
715 ic = avformat_alloc_context();
717 print_error(filename, AVERROR(ENOMEM));
720 if (o->nb_audio_sample_rate) {
721 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
722 av_dict_set(&format_opts, "sample_rate", buf, 0);
724 if (o->nb_audio_channels) {
725 /* because we set audio_channels based on both the "ac" and
726 * "channel_layout" options, we need to check that the specified
727 * demuxer actually has the "channels" option before setting it */
728 if (file_iformat && file_iformat->priv_class &&
729 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
730 AV_OPT_SEARCH_FAKE_OBJ)) {
731 snprintf(buf, sizeof(buf), "%d",
732 o->audio_channels[o->nb_audio_channels - 1].u.i);
733 av_dict_set(&format_opts, "channels", buf, 0);
736 if (o->nb_frame_rates) {
737 /* set the format-level framerate option;
738 * this is important for video grabbers, e.g. x11 */
739 if (file_iformat && file_iformat->priv_class &&
740 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
741 AV_OPT_SEARCH_FAKE_OBJ)) {
742 av_dict_set(&format_opts, "framerate",
743 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
746 if (o->nb_frame_sizes) {
747 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
749 if (o->nb_frame_pix_fmts)
750 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
752 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
753 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
754 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
756 ic->video_codec_id = video_codec_name ?
757 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
758 ic->audio_codec_id = audio_codec_name ?
759 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
760 ic->subtitle_codec_id= subtitle_codec_name ?
761 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
762 ic->flags |= AVFMT_FLAG_NONBLOCK;
763 ic->interrupt_callback = int_cb;
765 /* open the input file with generic avformat function */
766 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
768 print_error(filename, err);
771 assert_avoptions(format_opts);
773 /* apply forced codec ids */
774 for (i = 0; i < ic->nb_streams; i++)
775 choose_decoder(o, ic, ic->streams[i]);
777 /* Set AVCodecContext options for avformat_find_stream_info */
778 opts = setup_find_stream_info_opts(ic, codec_opts);
779 orig_nb_streams = ic->nb_streams;
781 /* If not enough info to get the stream parameters, we decode the
782 first frames to get it. (used in mpeg case for example) */
783 ret = avformat_find_stream_info(ic, opts);
785 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
786 avformat_close_input(&ic);
790 timestamp = o->start_time;
791 /* add the stream start time */
792 if (ic->start_time != AV_NOPTS_VALUE)
793 timestamp += ic->start_time;
795 /* if seeking requested, we execute it */
796 if (o->start_time != 0) {
797 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
799 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
800 filename, (double)timestamp / AV_TIME_BASE);
804 /* update the current parameters so that they match the one of the input stream */
805 add_input_streams(o, ic);
807 /* dump the file content */
808 av_dump_format(ic, nb_input_files, filename, 0);
810 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
811 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
814 input_files[nb_input_files - 1]->ctx = ic;
815 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
816 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
817 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
818 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
820 for (i = 0; i < o->nb_dump_attachment; i++) {
823 for (j = 0; j < ic->nb_streams; j++) {
824 AVStream *st = ic->streams[j];
826 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
827 dump_attachment(st, o->dump_attachment[i].u.str);
831 for (i = 0; i < orig_nb_streams; i++)
832 av_dict_free(&opts[i]);
839 static uint8_t *get_line(AVIOContext *s)
845 if (avio_open_dyn_buf(&line) < 0) {
846 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
850 while ((c = avio_r8(s)) && c != '\n')
853 avio_close_dyn_buf(line, &buf);
858 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
862 const char *base[3] = { getenv("AVCONV_DATADIR"),
867 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
871 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
872 i != 1 ? "" : "/.avconv", codec_name, preset_name);
873 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
876 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
877 i != 1 ? "" : "/.avconv", preset_name);
878 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
884 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
886 char *codec_name = NULL;
888 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
890 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
891 NULL, ost->st->codec->codec_type);
892 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
893 } else if (!strcmp(codec_name, "copy"))
894 ost->stream_copy = 1;
896 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
897 ost->st->codec->codec_id = ost->enc->id;
901 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
904 AVStream *st = avformat_new_stream(oc, NULL);
905 int idx = oc->nb_streams - 1, ret = 0;
906 char *bsf = NULL, *next, *codec_tag = NULL;
907 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
909 char *buf = NULL, *arg = NULL, *preset = NULL;
910 AVIOContext *s = NULL;
913 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
917 if (oc->nb_streams - 1 < o->nb_streamid_map)
918 st->id = o->streamid_map[oc->nb_streams - 1];
920 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
921 nb_output_streams + 1);
922 if (!(ost = av_mallocz(sizeof(*ost))))
924 output_streams[nb_output_streams - 1] = ost;
926 ost->file_index = nb_output_files;
929 st->codec->codec_type = type;
930 choose_encoder(o, oc, ost);
932 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
935 avcodec_get_context_defaults3(st->codec, ost->enc);
936 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
938 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
939 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
942 if (!buf[0] || buf[0] == '#') {
946 if (!(arg = strchr(buf, '='))) {
947 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
951 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
953 } while (!s->eof_reached);
957 av_log(NULL, AV_LOG_FATAL,
958 "Preset %s specified for stream %d:%d, but could not be opened.\n",
959 preset, ost->file_index, ost->index);
963 ost->max_frames = INT64_MAX;
964 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
966 ost->copy_prior_start = -1;
967 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
969 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
971 if (next = strchr(bsf, ','))
973 if (!(bsfc = av_bitstream_filter_init(bsf))) {
974 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
978 bsfc_prev->next = bsfc;
980 ost->bitstream_filters = bsfc;
986 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
988 uint32_t tag = strtol(codec_tag, &next, 0);
990 tag = AV_RL32(codec_tag);
991 st->codec->codec_tag = tag;
994 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
996 st->codec->flags |= CODEC_FLAG_QSCALE;
997 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1000 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1001 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1003 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1004 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1005 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1007 ost->source_index = source_index;
1008 if (source_index >= 0) {
1009 ost->sync_ist = input_streams[source_index];
1010 input_streams[source_index]->discard = 0;
1011 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1017 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1020 const char *p = str;
1027 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1034 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1038 AVCodecContext *video_enc;
1039 char *frame_rate = NULL;
1041 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1043 video_enc = st->codec;
1045 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1046 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1047 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1051 if (!ost->stream_copy) {
1052 const char *p = NULL;
1053 char *frame_size = NULL;
1054 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1055 char *intra_matrix = NULL, *inter_matrix = NULL;
1056 const char *filters = "null";
1060 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1061 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1062 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1066 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1067 if (frame_aspect_ratio) {
1069 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1070 q.num <= 0 || q.den <= 0) {
1071 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1074 ost->frame_aspect_ratio = av_q2d(q);
1077 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1078 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1079 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1080 ost->keep_pix_fmt = 1;
1081 if (!*++frame_pix_fmt)
1082 frame_pix_fmt = NULL;
1084 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1085 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1088 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1091 video_enc->gop_size = 0;
1092 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1094 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1095 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1098 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1100 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1102 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1103 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1106 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1109 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1110 for (i = 0; p; i++) {
1112 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1114 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1117 /* FIXME realloc failure */
1118 video_enc->rc_override =
1119 av_realloc(video_enc->rc_override,
1120 sizeof(RcOverride) * (i + 1));
1121 video_enc->rc_override[i].start_frame = start;
1122 video_enc->rc_override[i].end_frame = end;
1124 video_enc->rc_override[i].qscale = q;
1125 video_enc->rc_override[i].quality_factor = 1.0;
1128 video_enc->rc_override[i].qscale = 0;
1129 video_enc->rc_override[i].quality_factor = -q/100.0;
1134 video_enc->rc_override_count = i;
1135 if (!video_enc->rc_initial_buffer_occupancy)
1136 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1137 video_enc->intra_dc_precision = intra_dc_precision - 8;
1140 video_enc->flags|= CODEC_FLAG_PSNR;
1143 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1146 video_enc->flags |= CODEC_FLAG_PASS1;
1149 video_enc->flags |= CODEC_FLAG_PASS2;
1153 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1154 if (ost->logfile_prefix &&
1155 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1158 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1159 if (ost->forced_keyframes)
1160 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1162 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1164 ost->top_field_first = -1;
1165 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1167 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1168 ost->avfilter = av_strdup(filters);
1170 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1176 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1181 AVCodecContext *audio_enc;
1183 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1186 audio_enc = st->codec;
1187 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1189 if (!ost->stream_copy) {
1190 char *sample_fmt = NULL;
1191 const char *filters = "anull";
1193 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1195 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1197 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1198 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1202 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1204 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1206 av_assert1(filters);
1207 ost->avfilter = av_strdup(filters);
1209 /* check for channel mapping for this audio stream */
1210 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1211 AudioChannelMap *map = &o->audio_channel_maps[n];
1212 InputStream *ist = input_streams[ost->source_index];
1213 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1214 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1215 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1216 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1217 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1219 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1220 ost->file_index, ost->st->index);
1228 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1232 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1233 if (!ost->stream_copy) {
1234 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1241 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1243 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1244 ost->stream_copy = 1;
1248 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1252 AVCodecContext *subtitle_enc;
1254 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1256 subtitle_enc = st->codec;
1258 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1260 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1262 if (!ost->stream_copy) {
1263 char *frame_size = NULL;
1265 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1266 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1267 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1275 /* arg format is "output-stream-index:streamid-value". */
1276 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1278 OptionsContext *o = optctx;
1283 av_strlcpy(idx_str, arg, sizeof(idx_str));
1284 p = strchr(idx_str, ':');
1286 av_log(NULL, AV_LOG_FATAL,
1287 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1292 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1293 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1294 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1298 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1300 AVFormatContext *is = ifile->ctx;
1301 AVFormatContext *os = ofile->ctx;
1305 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1307 return AVERROR(ENOMEM);
1310 for (i = 0; i < is->nb_chapters; i++) {
1311 AVChapter *in_ch = is->chapters[i], *out_ch;
1312 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1313 AV_TIME_BASE_Q, in_ch->time_base);
1314 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1315 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1318 if (in_ch->end < ts_off)
1320 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1323 out_ch = av_mallocz(sizeof(AVChapter));
1325 return AVERROR(ENOMEM);
1327 out_ch->id = in_ch->id;
1328 out_ch->time_base = in_ch->time_base;
1329 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1330 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1333 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1335 os->chapters[os->nb_chapters++] = out_ch;
1340 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1343 AVFormatContext *ic = avformat_alloc_context();
1345 ic->interrupt_callback = int_cb;
1346 err = avformat_open_input(&ic, filename, NULL, NULL);
1349 /* copy stream format */
1350 for(i=0;i<ic->nb_streams;i++) {
1354 AVCodecContext *avctx;
1356 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1357 ost = new_output_stream(o, s, codec->type, -1);
1362 // FIXME: a more elegant solution is needed
1363 memcpy(st, ic->streams[i], sizeof(AVStream));
1365 st->info = av_malloc(sizeof(*st->info));
1366 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1368 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1370 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1371 choose_sample_fmt(st, codec);
1372 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1373 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1376 /* ffserver seeking with date=... needs a date reference */
1377 err = parse_option(o, "metadata", "creation_time=now", options);
1379 avformat_close_input(&ic);
1383 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1384 AVFormatContext *oc)
1388 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1389 ofilter->out_tmp->pad_idx)) {
1390 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1391 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1393 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1398 ost->source_index = -1;
1399 ost->filter = ofilter;
1403 if (ost->stream_copy) {
1404 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1405 "which is fed from a complex filtergraph. Filtering and streamcopy "
1406 "cannot be used together.\n", ost->file_index, ost->index);
1410 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1411 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1414 avfilter_inout_free(&ofilter->out_tmp);
1417 static int configure_complex_filters(void)
1421 for (i = 0; i < nb_filtergraphs; i++)
1422 if (!filtergraphs[i]->graph &&
1423 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1428 void opt_output_file(void *optctx, const char *filename)
1430 OptionsContext *o = optctx;
1431 AVFormatContext *oc;
1433 AVOutputFormat *file_oformat;
1437 if (configure_complex_filters() < 0) {
1438 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1442 if (!strcmp(filename, "-"))
1445 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1447 print_error(filename, err);
1450 file_oformat= oc->oformat;
1451 oc->interrupt_callback = int_cb;
1453 /* create streams for all unlabeled output pads */
1454 for (i = 0; i < nb_filtergraphs; i++) {
1455 FilterGraph *fg = filtergraphs[i];
1456 for (j = 0; j < fg->nb_outputs; j++) {
1457 OutputFilter *ofilter = fg->outputs[j];
1459 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1462 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1463 ofilter->out_tmp->pad_idx)) {
1464 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1465 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1466 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1468 init_output_filter(ofilter, o, oc);
1472 if (!strcmp(file_oformat->name, "ffm") &&
1473 av_strstart(filename, "http:", NULL)) {
1475 /* special case for files sent to ffserver: we get the stream
1476 parameters from ffserver */
1477 int err = read_ffserver_streams(o, oc, filename);
1479 print_error(filename, err);
1482 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1483 ost = output_streams[j];
1484 for (i = 0; i < nb_input_streams; i++) {
1485 ist = input_streams[i];
1486 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1488 ost->source_index= i;
1489 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1490 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1492 ist->st->discard = AVDISCARD_NONE;
1497 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));
1501 } else if (!o->nb_stream_maps) {
1502 char *subtitle_codec_name = NULL;
1503 /* pick the "best" stream of each type */
1505 /* video: highest resolution */
1506 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1507 int area = 0, idx = -1;
1508 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1509 for (i = 0; i < nb_input_streams; i++) {
1511 ist = input_streams[i];
1512 new_area = ist->st->codec->width * ist->st->codec->height;
1513 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1515 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1517 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1524 new_video_stream(o, oc, idx);
1527 /* audio: most channels */
1528 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1529 int channels = 0, idx = -1;
1530 for (i = 0; i < nb_input_streams; i++) {
1531 ist = input_streams[i];
1532 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1533 ist->st->codec->channels > channels) {
1534 channels = ist->st->codec->channels;
1539 new_audio_stream(o, oc, idx);
1542 /* subtitles: pick first */
1543 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1544 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1545 for (i = 0; i < nb_input_streams; i++)
1546 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1547 new_subtitle_stream(o, oc, i);
1551 /* do something with data? */
1553 for (i = 0; i < o->nb_stream_maps; i++) {
1554 StreamMap *map = &o->stream_maps[i];
1555 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1560 if (map->linklabel) {
1562 OutputFilter *ofilter = NULL;
1565 for (j = 0; j < nb_filtergraphs; j++) {
1566 fg = filtergraphs[j];
1567 for (k = 0; k < fg->nb_outputs; k++) {
1568 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1569 if (out && !strcmp(out->name, map->linklabel)) {
1570 ofilter = fg->outputs[k];
1577 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1578 "in any defined filter graph.\n", map->linklabel);
1581 init_output_filter(ofilter, o, oc);
1583 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1584 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1586 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1588 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1590 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1593 switch (ist->st->codec->codec_type) {
1594 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1595 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1596 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1597 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1598 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1600 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1601 map->file_index, map->stream_index);
1609 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1610 AVDictionaryEntry *e;
1611 ost = output_streams[i];
1613 if ( ost->stream_copy
1614 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1615 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1616 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1620 /* handle attached files */
1621 for (i = 0; i < o->nb_attachments; i++) {
1623 uint8_t *attachment;
1627 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1628 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1632 if ((len = avio_size(pb)) <= 0) {
1633 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1637 if (!(attachment = av_malloc(len))) {
1638 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1642 avio_read(pb, attachment, len);
1644 ost = new_attachment_stream(o, oc, -1);
1645 ost->stream_copy = 0;
1646 ost->attachment_filename = o->attachments[i];
1647 ost->st->codec->extradata = attachment;
1648 ost->st->codec->extradata_size = len;
1650 p = strrchr(o->attachments[i], '/');
1651 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1655 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1656 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1659 output_files[nb_output_files - 1]->ctx = oc;
1660 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1661 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1662 if (o->recording_time != INT64_MAX)
1663 oc->duration = o->recording_time;
1664 output_files[nb_output_files - 1]->start_time = o->start_time;
1665 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1666 output_files[nb_output_files - 1]->shortest = o->shortest;
1667 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1669 /* check filename in case of an image number is expected */
1670 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1671 if (!av_filename_number_test(oc->filename)) {
1672 print_error(oc->filename, AVERROR(EINVAL));
1677 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1678 /* test if it already exists to avoid losing precious files */
1679 assert_file_overwrite(filename);
1682 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1683 &oc->interrupt_callback,
1684 &output_files[nb_output_files - 1]->opts)) < 0) {
1685 print_error(filename, err);
1690 if (o->mux_preload) {
1692 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1693 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1695 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1698 for (i = 0; i < o->nb_metadata_map; i++) {
1700 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1702 if (in_file_index >= nb_input_files) {
1703 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1706 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
1710 if (o->chapters_input_file >= nb_input_files) {
1711 if (o->chapters_input_file == INT_MAX) {
1712 /* copy chapters from the first input file that has them*/
1713 o->chapters_input_file = -1;
1714 for (i = 0; i < nb_input_files; i++)
1715 if (input_files[i]->ctx->nb_chapters) {
1716 o->chapters_input_file = i;
1720 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1721 o->chapters_input_file);
1725 if (o->chapters_input_file >= 0)
1726 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1727 !o->metadata_chapters_manual);
1729 /* copy global metadata by default */
1730 if (!o->metadata_global_manual && nb_input_files){
1731 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1732 AV_DICT_DONT_OVERWRITE);
1733 if(o->recording_time != INT64_MAX)
1734 av_dict_set(&oc->metadata, "duration", NULL, 0);
1735 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1737 if (!o->metadata_streams_manual)
1738 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1740 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1742 ist = input_streams[output_streams[i]->source_index];
1743 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1746 /* process manually set metadata */
1747 for (i = 0; i < o->nb_metadata; i++) {
1750 const char *stream_spec;
1751 int index = 0, j, ret = 0;
1753 val = strchr(o->metadata[i].u.str, '=');
1755 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1756 o->metadata[i].u.str);
1761 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1763 for (j = 0; j < oc->nb_streams; j++) {
1764 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1765 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1776 if (index < 0 || index >= oc->nb_chapters) {
1777 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1780 m = &oc->chapters[index]->metadata;
1783 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1786 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1790 reset_options(o, 0);
1793 static int opt_target(void *optctx, const char *opt, const char *arg)
1795 OptionsContext *o = optctx;
1796 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1797 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1799 if (!strncmp(arg, "pal-", 4)) {
1802 } else if (!strncmp(arg, "ntsc-", 5)) {
1805 } else if (!strncmp(arg, "film-", 5)) {
1809 /* Try to determine PAL/NTSC by peeking in the input files */
1810 if (nb_input_files) {
1812 for (j = 0; j < nb_input_files; j++) {
1813 for (i = 0; i < input_files[j]->nb_streams; i++) {
1814 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1815 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1817 fr = c->time_base.den * 1000 / c->time_base.num;
1821 } else if ((fr == 29970) || (fr == 23976)) {
1826 if (norm != UNKNOWN)
1830 if (norm != UNKNOWN)
1831 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1834 if (norm == UNKNOWN) {
1835 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1836 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1837 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1841 if (!strcmp(arg, "vcd")) {
1842 opt_video_codec(o, "c:v", "mpeg1video");
1843 opt_audio_codec(o, "c:a", "mp2");
1844 parse_option(o, "f", "vcd", options);
1846 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1847 parse_option(o, "r", frame_rates[norm], options);
1848 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1850 opt_default(NULL, "b:v", "1150000");
1851 opt_default(NULL, "maxrate", "1150000");
1852 opt_default(NULL, "minrate", "1150000");
1853 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1855 opt_default(NULL, "b:a", "224000");
1856 parse_option(o, "ar", "44100", options);
1857 parse_option(o, "ac", "2", options);
1859 opt_default(NULL, "packetsize", "2324");
1860 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1862 /* We have to offset the PTS, so that it is consistent with the SCR.
1863 SCR starts at 36000, but the first two packs contain only padding
1864 and the first pack from the other stream, respectively, may also have
1865 been written before.
1866 So the real data starts at SCR 36000+3*1200. */
1867 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1868 } else if (!strcmp(arg, "svcd")) {
1870 opt_video_codec(o, "c:v", "mpeg2video");
1871 opt_audio_codec(o, "c:a", "mp2");
1872 parse_option(o, "f", "svcd", options);
1874 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1875 parse_option(o, "r", frame_rates[norm], options);
1876 parse_option(o, "pix_fmt", "yuv420p", options);
1877 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1879 opt_default(NULL, "b:v", "2040000");
1880 opt_default(NULL, "maxrate", "2516000");
1881 opt_default(NULL, "minrate", "0"); // 1145000;
1882 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1883 opt_default(NULL, "scan_offset", "1");
1885 opt_default(NULL, "b:a", "224000");
1886 parse_option(o, "ar", "44100", options);
1888 opt_default(NULL, "packetsize", "2324");
1890 } else if (!strcmp(arg, "dvd")) {
1892 opt_video_codec(o, "c:v", "mpeg2video");
1893 opt_audio_codec(o, "c:a", "ac3");
1894 parse_option(o, "f", "dvd", options);
1896 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1897 parse_option(o, "r", frame_rates[norm], options);
1898 parse_option(o, "pix_fmt", "yuv420p", options);
1899 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1901 opt_default(NULL, "b:v", "6000000");
1902 opt_default(NULL, "maxrate", "9000000");
1903 opt_default(NULL, "minrate", "0"); // 1500000;
1904 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1906 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1907 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1909 opt_default(NULL, "b:a", "448000");
1910 parse_option(o, "ar", "48000", options);
1912 } else if (!strncmp(arg, "dv", 2)) {
1914 parse_option(o, "f", "dv", options);
1916 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1917 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1918 norm == PAL ? "yuv420p" : "yuv411p", options);
1919 parse_option(o, "r", frame_rates[norm], options);
1921 parse_option(o, "ar", "48000", options);
1922 parse_option(o, "ac", "2", options);
1925 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1926 return AVERROR(EINVAL);
1931 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1933 av_free (vstats_filename);
1934 vstats_filename = av_strdup (arg);
1938 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1941 time_t today2 = time(NULL);
1942 struct tm *today = localtime(&today2);
1944 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1946 return opt_vstats_file(NULL, opt, filename);
1949 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1951 OptionsContext *o = optctx;
1952 return parse_option(o, "frames:v", arg, options);
1955 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1957 OptionsContext *o = optctx;
1958 return parse_option(o, "frames:a", arg, options);
1961 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1963 OptionsContext *o = optctx;
1964 return parse_option(o, "frames:d", arg, options);
1967 static int opt_preset(void *optctx, const char *opt, const char *arg)
1969 OptionsContext *o = optctx;
1971 char filename[1000], line[1000], tmp_line[1000];
1972 const char *codec_name = NULL;
1976 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1978 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1979 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1980 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1982 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1986 while (fgets(line, sizeof(line), f)) {
1987 char *key = tmp_line, *value, *endptr;
1989 if (strcspn(line, "#\n\r") == 0)
1991 strcpy(tmp_line, line);
1992 if (!av_strtok(key, "=", &value) ||
1993 !av_strtok(value, "\r\n", &endptr)) {
1994 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1997 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
1999 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2000 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2001 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2002 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2003 else if (opt_default(NULL, key, value) < 0) {
2004 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2005 filename, line, key, value);
2015 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2017 OptionsContext *o = optctx;
2018 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2019 int ret = parse_option(o, s, arg, options);
2024 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2026 OptionsContext *o = optctx;
2027 if(!strcmp(opt, "b")){
2028 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2029 return parse_option(o, "b:v", arg, options);
2031 return opt_default(optctx, opt, arg);
2034 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2036 OptionsContext *o = optctx;
2039 if(!strcmp(opt, "qscale")){
2040 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2041 return parse_option(o, "q:v", arg, options);
2043 s = av_asprintf("q%s", opt + 6);
2044 ret = parse_option(o, s, arg, options);
2049 static int opt_profile(void *optctx, const char *opt, const char *arg)
2051 OptionsContext *o = optctx;
2052 if(!strcmp(opt, "profile")){
2053 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2054 return parse_option(o, "profile:v", arg, options);
2056 return opt_default(optctx, opt, arg);
2060 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2062 OptionsContext *o = optctx;
2063 return parse_option(o, "filter:v", arg, options);
2066 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2068 OptionsContext *o = optctx;
2069 return parse_option(o, "filter:a", arg, options);
2072 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2074 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2075 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2076 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2077 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2079 if (video_sync_method == VSYNC_AUTO)
2080 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2084 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2086 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2091 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2093 OptionsContext *o = optctx;
2094 char *tcr = av_asprintf("timecode=%s", arg);
2095 int ret = parse_option(o, "metadata:g", tcr, options);
2097 ret = opt_default(optctx, "gop_timecode", arg);
2102 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2104 OptionsContext *o = optctx;
2105 char layout_str[32];
2108 int ret, channels, ac_str_size;
2111 layout = av_get_channel_layout(arg);
2113 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2114 return AVERROR(EINVAL);
2116 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2117 ret = opt_default(NULL, opt, layout_str);
2121 /* set 'ac' option based on channel layout */
2122 channels = av_get_channel_layout_nb_channels(layout);
2123 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2124 stream_str = strchr(opt, ':');
2125 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2126 ac_str = av_mallocz(ac_str_size);
2128 return AVERROR(ENOMEM);
2129 av_strlcpy(ac_str, "ac", 3);
2131 av_strlcat(ac_str, stream_str, ac_str_size);
2132 ret = parse_option(o, ac_str, layout_str, options);
2138 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2140 OptionsContext *o = optctx;
2141 return parse_option(o, "q:a", arg, options);
2144 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2146 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2147 &nb_filtergraphs, nb_filtergraphs + 1);
2148 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2149 return AVERROR(ENOMEM);
2150 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2151 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2155 void show_help_default(const char *opt, const char *arg)
2157 /* per-file options have at least one of those set */
2158 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2159 int show_advanced = 0, show_avoptions = 0;
2162 if (!strcmp(opt, "long"))
2164 else if (!strcmp(opt, "full"))
2165 show_advanced = show_avoptions = 1;
2167 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2172 printf("Getting help:\n"
2173 " -h -- print basic options\n"
2174 " -h long -- print more options\n"
2175 " -h full -- print all options (including all format and codec specific options, very long)\n"
2176 " See man %s for detailed description of the options.\n"
2177 "\n", program_name);
2179 show_help_options(options, "Print help / information / capabilities:",
2182 show_help_options(options, "Global options (affect whole program "
2183 "instead of just one file:",
2184 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2186 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2187 per_file | OPT_EXIT, 0);
2189 show_help_options(options, "Per-file main options:", 0,
2190 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2191 OPT_EXIT, per_file);
2193 show_help_options(options, "Advanced per-file options:",
2194 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2196 show_help_options(options, "Video options:",
2197 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2199 show_help_options(options, "Advanced Video options:",
2200 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2202 show_help_options(options, "Audio options:",
2203 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2205 show_help_options(options, "Advanced Audio options:",
2206 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2207 show_help_options(options, "Subtitle options:",
2208 OPT_SUBTITLE, 0, 0);
2211 if (show_avoptions) {
2212 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2213 show_help_children(avcodec_get_class(), flags);
2214 show_help_children(avformat_get_class(), flags);
2215 show_help_children(sws_get_class(), flags);
2216 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2217 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2221 void show_usage(void)
2223 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2224 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2225 av_log(NULL, AV_LOG_INFO, "\n");
2229 static int opt_progress(void *optctx, const char *opt, const char *arg)
2231 AVIOContext *avio = NULL;
2234 if (!strcmp(arg, "-"))
2236 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2238 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2239 arg, av_err2str(ret));
2242 progress_avio = avio;
2246 #define OFFSET(x) offsetof(OptionsContext, x)
2247 const OptionDef options[] = {
2249 #include "cmdutils_common_opts.h"
2250 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2251 "force format", "fmt" },
2252 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2253 "input file name", "filename" },
2254 { "y", OPT_BOOL, { &file_overwrite },
2255 "overwrite output files" },
2256 { "n", OPT_BOOL, { &no_file_overwrite },
2257 "do not overwrite output files" },
2258 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2259 "codec name", "codec" },
2260 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2261 "codec name", "codec" },
2262 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2263 "preset name", "preset" },
2264 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2265 "set input stream mapping",
2266 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2267 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2268 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2269 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2270 "set metadata information of outfile from infile",
2271 "outfile[,metadata]:infile[,metadata]" },
2272 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2273 "set chapters mapping", "input_file_index" },
2274 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2275 "record or transcode \"duration\" seconds of audio/video",
2277 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2278 "set the limit file size in bytes", "limit_size" },
2279 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2280 "set the start time offset", "time_off" },
2281 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2282 "set the input ts offset", "time_off" },
2283 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2284 "set the input ts scale", "scale" },
2285 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2286 "set the recording timestamp ('now' to set the current time)", "time" },
2287 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2288 "add metadata", "string=string" },
2289 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2290 "set the number of data frames to record", "number" },
2291 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2292 "add timings for benchmarking" },
2293 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2294 "add timings for each task" },
2295 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2296 "write program-readable progress information", "url" },
2297 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2298 "enable or disable interaction on standard input" },
2299 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2300 "set max runtime in seconds", "limit" },
2301 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2302 "dump each input packet" },
2303 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2304 "when dumping packets, also dump the payload" },
2305 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2306 "read input at native frame rate", "" },
2307 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2308 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2309 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2310 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2311 "video sync method", "" },
2312 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2313 "audio sync method", "" },
2314 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2315 "audio drift threshold", "threshold" },
2316 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2317 "copy timestamps" },
2318 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2319 "copy input stream time base when stream copying", "mode" },
2320 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2321 "finish encoding within shortest input" },
2322 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2323 "timestamp discontinuity delta threshold", "threshold" },
2324 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2325 "timestamp error delta threshold", "threshold" },
2326 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2327 "exit on error", "error" },
2328 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2329 "copy initial non-keyframes" },
2330 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2331 "copy or discard frames before start time" },
2332 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2333 "set the number of frames to record", "number" },
2334 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2335 "force codec tag/fourcc", "fourcc/tag" },
2336 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2337 "use fixed quality scale (VBR)", "q" },
2338 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2339 "use fixed quality scale (VBR)", "q" },
2340 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2341 "set profile", "profile" },
2342 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2343 "set stream filterchain", "filter_list" },
2344 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2345 "create a complex filtergraph", "graph_description" },
2346 { "stats", OPT_BOOL, { &print_stats },
2347 "print progress report during encoding", },
2348 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2349 "add an attachment to the output file", "filename" },
2350 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2351 "extract an attachment into a file", "filename" },
2352 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2353 "print timestamp debugging info" },
2356 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2357 "set the number of video frames to record", "number" },
2358 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2359 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2360 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2361 "set frame size (WxH or abbreviation)", "size" },
2362 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2363 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2364 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2365 "set pixel format", "format" },
2366 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2367 "set the number of bits per raw sample", "number" },
2368 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2369 "Removed, use the crop filter instead", "size" },
2370 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2371 "Removed, use the crop filter instead", "size" },
2372 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2373 "Removed, use the crop filter instead", "size" },
2374 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2375 "Removed, use the crop filter instead", "size" },
2376 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2377 "Removed, use the pad filter instead", "size" },
2378 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2379 "Removed, use the pad filter instead", "size" },
2380 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2381 "Removed, use the pad filter instead", "size" },
2382 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2383 "Removed, use the pad filter instead", "size" },
2384 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2385 "Removed, use the pad filter instead", "color" },
2386 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2387 "deprecated use -g 1" },
2388 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2390 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2391 "discard threshold", "n" },
2392 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2393 "rate control override for specific intervals", "override" },
2394 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2395 "force video codec ('copy' to copy stream)", "codec" },
2396 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2398 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2400 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2401 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2402 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2403 "select the pass number (1 to 3)", "n" },
2404 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2405 "select two pass log file name prefix", "prefix" },
2406 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2407 "this option is deprecated, use the yadif filter instead" },
2408 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2409 "calculate PSNR of compressed frames" },
2410 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2411 "dump video coding statistics to file" },
2412 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2413 "dump video coding statistics to file", "file" },
2414 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2415 "video filters", "filter list" },
2416 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2417 "specify intra matrix coeffs", "matrix" },
2418 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2419 "specify inter matrix coeffs", "matrix" },
2420 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2421 "top=1/bottom=0/auto=-1 field first", "" },
2422 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2423 "intra_dc_precision", "precision" },
2424 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2425 "force video tag/fourcc", "fourcc/tag" },
2426 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2427 "show QP histogram" },
2428 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2429 "force the selected framerate, disable the best supported framerate selection" },
2430 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2431 "set the value of an outfile streamid", "streamIndex:value" },
2432 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2433 { .off = OFFSET(forced_key_frames) },
2434 "force key frames at specified timestamps", "timestamps" },
2435 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2436 "video bitrate (please use -b:v)", "bitrate" },
2439 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2440 "set the number of audio frames to record", "number" },
2441 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2442 "set audio quality (codec-specific)", "quality", },
2443 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2444 "set audio sampling rate (in Hz)", "rate" },
2445 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2446 "set number of audio channels", "channels" },
2447 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2449 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2450 "force audio codec ('copy' to copy stream)", "codec" },
2451 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2452 "force audio tag/fourcc", "fourcc/tag" },
2453 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2454 "change audio volume (256=normal)" , "volume" },
2455 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2456 "set sample format", "format" },
2457 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2458 "set channel layout", "layout" },
2459 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2460 "audio filters", "filter list" },
2462 /* subtitle options */
2463 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2464 "disable subtitle" },
2465 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2466 "force subtitle codec ('copy' to copy stream)", "codec" },
2467 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2468 , "force subtitle tag/fourcc", "fourcc/tag" },
2469 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2470 "fix subtitles duration" },
2473 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2474 "deprecated, use -channel", "channel" },
2475 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2476 "deprecated, use -standard", "standard" },
2477 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2480 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2481 "set the maximum demux-decode delay", "seconds" },
2482 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2483 "set the initial demux-decode delay", "seconds" },
2485 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2486 "A comma-separated list of bitstream filters", "bitstream_filters" },
2487 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2488 "deprecated", "audio bitstream_filters" },
2489 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2490 "deprecated", "video bitstream_filters" },
2492 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2493 "set the audio options to the indicated preset", "preset" },
2494 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2495 "set the video options to the indicated preset", "preset" },
2496 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2497 "set the subtitle options to the indicated preset", "preset" },
2498 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2499 "set options from indicated preset file", "filename" },
2500 /* data codec support */
2501 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2502 "force data codec ('copy' to copy stream)", "codec" },
2503 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2506 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2507 "generic catch all option", "" },