2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/avutil.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 for (i = 0; i < o->nb_ ## name; i++) {\
61 char *spec = o->name[i].specifier;\
62 if (!strcmp(spec, mediatype))\
63 outvar = o->name[i].u.type;\
66 char *vstats_filename;
68 float audio_drift_threshold = 0.1;
69 float dts_delta_threshold = 10;
70 float dts_error_threshold = 3600*30;
72 int audio_volume = 256;
73 int audio_sync_method = 0;
74 int video_sync_method = VSYNC_AUTO;
75 int do_deinterlace = 0;
77 int do_benchmark_all = 0;
83 int exit_on_error = 0;
86 int stdin_interaction = 1;
87 int frame_bits_per_raw_sample = 0;
90 static int intra_only = 0;
91 static int file_overwrite = 0;
92 static int no_file_overwrite = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int do_psnr = 0;
96 static int input_sync;
98 void reset_options(OptionsContext *o, int is_input)
100 const OptionDef *po = options;
101 OptionsContext bak= *o;
104 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
106 void *dst = (uint8_t*)o + po->u.off;
108 if (po->flags & OPT_SPEC) {
109 SpecifierOpt **so = dst;
110 int i, *count = (int*)(so + 1);
111 for (i = 0; i < *count; i++) {
112 av_freep(&(*so)[i].specifier);
113 if (po->flags & OPT_STRING)
114 av_freep(&(*so)[i].u.str);
118 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
123 for (i = 0; i < o->nb_stream_maps; i++)
124 av_freep(&o->stream_maps[i].linklabel);
125 av_freep(&o->stream_maps);
126 av_freep(&o->audio_channel_maps);
127 av_freep(&o->streamid_map);
129 memset(o, 0, sizeof(*o));
132 o->recording_time = bak.recording_time;
133 if (o->recording_time != INT64_MAX)
134 av_log(NULL, AV_LOG_WARNING,
135 "-t is not an input option, keeping it for the next output;"
136 " consider fixing your command line.\n");
138 o->recording_time = INT64_MAX;
139 o->mux_max_delay = 0.7;
140 o->limit_filesize = UINT64_MAX;
141 o->chapters_input_file = INT_MAX;
148 static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
150 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
151 return AVERROR(EINVAL);
154 static int opt_pad(void *optctx, const char *opt, const char *arg)
156 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
160 static int opt_sameq(void *optctx, const char *opt, const char *arg)
162 av_log(NULL, AV_LOG_WARNING, "Ignoring option '%s'\n", opt);
166 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
168 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
169 return opt_default(optctx, "channel", arg);
172 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
174 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
175 return opt_default(optctx, "standard", arg);
178 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
180 OptionsContext *o = optctx;
181 return parse_option(o, "codec:a", arg, options);
184 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
186 OptionsContext *o = optctx;
187 return parse_option(o, "codec:v", arg, options);
190 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
192 OptionsContext *o = optctx;
193 return parse_option(o, "codec:s", arg, options);
196 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
198 OptionsContext *o = optctx;
199 return parse_option(o, "codec:d", arg, options);
202 static int opt_map(void *optctx, const char *opt, const char *arg)
204 OptionsContext *o = optctx;
206 int i, negative = 0, file_idx;
207 int sync_file_idx = -1, sync_stream_idx = 0;
215 map = av_strdup(arg);
217 /* parse sync stream first, just pick first matching stream */
218 if (sync = strchr(map, ',')) {
220 sync_file_idx = strtol(sync + 1, &sync, 0);
221 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
222 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
227 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
228 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
229 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
233 if (i == input_files[sync_file_idx]->nb_streams) {
234 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
235 "match any streams.\n", arg);
242 /* this mapping refers to lavfi output */
243 const char *c = map + 1;
244 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
245 &o->nb_stream_maps, o->nb_stream_maps + 1);
246 m = &o->stream_maps[o->nb_stream_maps - 1];
247 m->linklabel = av_get_token(&c, "]");
249 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
253 file_idx = strtol(map, &p, 0);
254 if (file_idx >= nb_input_files || file_idx < 0) {
255 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
259 /* disable some already defined maps */
260 for (i = 0; i < o->nb_stream_maps; i++) {
261 m = &o->stream_maps[i];
262 if (file_idx == m->file_index &&
263 check_stream_specifier(input_files[m->file_index]->ctx,
264 input_files[m->file_index]->ctx->streams[m->stream_index],
265 *p == ':' ? p + 1 : p) > 0)
269 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
270 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
271 *p == ':' ? p + 1 : p) <= 0)
273 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
274 &o->nb_stream_maps, o->nb_stream_maps + 1);
275 m = &o->stream_maps[o->nb_stream_maps - 1];
277 m->file_index = file_idx;
280 if (sync_file_idx >= 0) {
281 m->sync_file_index = sync_file_idx;
282 m->sync_stream_index = sync_stream_idx;
284 m->sync_file_index = file_idx;
285 m->sync_stream_index = i;
291 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
299 static int opt_attach(void *optctx, const char *opt, const char *arg)
301 OptionsContext *o = optctx;
302 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
303 &o->nb_attachments, o->nb_attachments + 1);
304 o->attachments[o->nb_attachments - 1] = arg;
308 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
310 OptionsContext *o = optctx;
315 o->audio_channel_maps =
316 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
317 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
318 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
320 /* muted channel syntax */
321 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
322 if ((n == 1 || n == 3) && m->channel_idx == -1) {
323 m->file_idx = m->stream_idx = -1;
325 m->ofile_idx = m->ostream_idx = -1;
330 n = sscanf(arg, "%d.%d.%d:%d.%d",
331 &m->file_idx, &m->stream_idx, &m->channel_idx,
332 &m->ofile_idx, &m->ostream_idx);
334 if (n != 3 && n != 5) {
335 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
336 "[file.stream.channel|-1][:syncfile:syncstream]\n");
340 if (n != 5) // only file.stream.channel specified
341 m->ofile_idx = m->ostream_idx = -1;
344 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
345 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
349 if (m->stream_idx < 0 ||
350 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
351 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
352 m->file_idx, m->stream_idx);
355 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
356 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
357 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
358 m->file_idx, m->stream_idx);
361 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
362 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
363 m->file_idx, m->stream_idx, m->channel_idx);
370 * Parse a metadata specifier passed as 'arg' parameter.
371 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
372 * @param index for type c/p, chapter/program index is written here
373 * @param stream_spec for type s, the stream specifier is written here
375 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
383 if (*(++arg) && *arg != ':') {
384 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
387 *stream_spec = *arg == ':' ? arg + 1 : "";
392 *index = strtol(++arg, NULL, 0);
395 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
402 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
404 AVDictionary **meta_in = NULL;
405 AVDictionary **meta_out = NULL;
407 char type_in, type_out;
408 const char *istream_spec = NULL, *ostream_spec = NULL;
409 int idx_in = 0, idx_out = 0;
411 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
412 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
415 if (type_out == 'g' || !*outspec)
416 o->metadata_global_manual = 1;
417 if (type_out == 's' || !*outspec)
418 o->metadata_streams_manual = 1;
419 if (type_out == 'c' || !*outspec)
420 o->metadata_chapters_manual = 1;
424 if (type_in == 'g' || type_out == 'g')
425 o->metadata_global_manual = 1;
426 if (type_in == 's' || type_out == 's')
427 o->metadata_streams_manual = 1;
428 if (type_in == 'c' || type_out == 'c')
429 o->metadata_chapters_manual = 1;
431 /* ic is NULL when just disabling automatic mappings */
435 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
436 if ((index) < 0 || (index) >= (nb_elems)) {\
437 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
442 #define SET_DICT(type, meta, context, index)\
445 meta = &context->metadata;\
448 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
449 meta = &context->chapters[index]->metadata;\
452 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
453 meta = &context->programs[index]->metadata;\
455 default: av_assert0(0);\
460 SET_DICT(type_in, meta_in, ic, idx_in);
461 SET_DICT(type_out, meta_out, oc, idx_out);
463 /* for input streams choose first matching stream */
464 if (type_in == 's') {
465 for (i = 0; i < ic->nb_streams; i++) {
466 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
467 meta_in = &ic->streams[i]->metadata;
473 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
478 if (type_out == 's') {
479 for (i = 0; i < oc->nb_streams; i++) {
480 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
481 meta_out = &oc->streams[i]->metadata;
482 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
487 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
492 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
494 OptionsContext *o = optctx;
496 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
497 struct tm time = *gmtime((time_t*)&recording_timestamp);
498 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
499 parse_option(o, "metadata", buf, options);
501 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
502 "tag instead.\n", opt);
506 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
508 const AVCodecDescriptor *desc;
509 const char *codec_string = encoder ? "encoder" : "decoder";
513 avcodec_find_encoder_by_name(name) :
514 avcodec_find_decoder_by_name(name);
516 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
517 codec = encoder ? avcodec_find_encoder(desc->id) :
518 avcodec_find_decoder(desc->id);
520 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
521 codec_string, codec->name, desc->name);
525 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
528 if (codec->type != type) {
529 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
535 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
537 char *codec_name = NULL;
539 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
541 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
542 st->codec->codec_id = codec->id;
545 return avcodec_find_decoder(st->codec->codec_id);
548 /* Add all the streams from the given input file to the global
549 * list of input streams. */
550 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
553 char *next, *codec_tag = NULL;
555 for (i = 0; i < ic->nb_streams; i++) {
556 AVStream *st = ic->streams[i];
557 AVCodecContext *dec = st->codec;
558 InputStream *ist = av_mallocz(sizeof(*ist));
559 char *framerate = NULL;
564 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
565 input_streams[nb_input_streams - 1] = ist;
568 ist->file_index = nb_input_files;
570 st->discard = AVDISCARD_ALL;
571 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
574 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
576 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
578 uint32_t tag = strtol(codec_tag, &next, 0);
580 tag = AV_RL32(codec_tag);
581 st->codec->codec_tag = tag;
584 ist->dec = choose_decoder(o, ic, st);
586 ist->reinit_filters = -1;
587 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
589 switch (dec->codec_type) {
590 case AVMEDIA_TYPE_VIDEO:
592 ist->dec = avcodec_find_decoder(dec->codec_id);
594 dec->flags |= CODEC_FLAG_EMU_EDGE;
597 ist->resample_height = dec->height;
598 ist->resample_width = dec->width;
599 ist->resample_pix_fmt = dec->pix_fmt;
601 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
602 if (framerate && av_parse_video_rate(&ist->framerate,
604 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
609 ist->top_field_first = -1;
610 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
613 case AVMEDIA_TYPE_AUDIO:
614 guess_input_channel_layout(ist);
616 ist->resample_sample_fmt = dec->sample_fmt;
617 ist->resample_sample_rate = dec->sample_rate;
618 ist->resample_channels = dec->channels;
619 ist->resample_channel_layout = dec->channel_layout;
622 case AVMEDIA_TYPE_DATA:
623 case AVMEDIA_TYPE_SUBTITLE:
625 ist->dec = avcodec_find_decoder(dec->codec_id);
626 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
628 case AVMEDIA_TYPE_ATTACHMENT:
629 case AVMEDIA_TYPE_UNKNOWN:
637 static void assert_file_overwrite(const char *filename)
639 if ((!file_overwrite || no_file_overwrite) &&
640 (strchr(filename, ':') == NULL || filename[1] == ':' ||
641 av_strstart(filename, "file:", NULL))) {
642 if (avio_check(filename, 0) == 0) {
643 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
644 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
647 signal(SIGINT, SIG_DFL);
649 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
655 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
662 static void dump_attachment(AVStream *st, const char *filename)
665 AVIOContext *out = NULL;
666 AVDictionaryEntry *e;
668 if (!st->codec->extradata_size) {
669 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
670 nb_input_files - 1, st->index);
673 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
676 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
677 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
681 assert_file_overwrite(filename);
683 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
684 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
689 avio_write(out, st->codec->extradata, st->codec->extradata_size);
694 static int opt_input_file(void *optctx, const char *opt, const char *filename)
696 OptionsContext *o = optctx;
698 AVInputFormat *file_iformat = NULL;
703 int orig_nb_streams; // number of streams before avformat_find_stream_info
704 char * video_codec_name = NULL;
705 char * audio_codec_name = NULL;
706 char *subtitle_codec_name = NULL;
709 if (!(file_iformat = av_find_input_format(o->format))) {
710 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
715 if (!strcmp(filename, "-"))
718 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
719 strcmp(filename, "/dev/stdin");
721 /* get default parameters from command line */
722 ic = avformat_alloc_context();
724 print_error(filename, AVERROR(ENOMEM));
727 if (o->nb_audio_sample_rate) {
728 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
729 av_dict_set(&format_opts, "sample_rate", buf, 0);
731 if (o->nb_audio_channels) {
732 /* because we set audio_channels based on both the "ac" and
733 * "channel_layout" options, we need to check that the specified
734 * demuxer actually has the "channels" option before setting it */
735 if (file_iformat && file_iformat->priv_class &&
736 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
737 AV_OPT_SEARCH_FAKE_OBJ)) {
738 snprintf(buf, sizeof(buf), "%d",
739 o->audio_channels[o->nb_audio_channels - 1].u.i);
740 av_dict_set(&format_opts, "channels", buf, 0);
743 if (o->nb_frame_rates) {
744 /* set the format-level framerate option;
745 * this is important for video grabbers, e.g. x11 */
746 if (file_iformat && file_iformat->priv_class &&
747 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
748 AV_OPT_SEARCH_FAKE_OBJ)) {
749 av_dict_set(&format_opts, "framerate",
750 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
753 if (o->nb_frame_sizes) {
754 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
756 if (o->nb_frame_pix_fmts)
757 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
759 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
760 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
761 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
763 ic->video_codec_id = video_codec_name ?
764 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
765 ic->audio_codec_id = audio_codec_name ?
766 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
767 ic->subtitle_codec_id= subtitle_codec_name ?
768 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
769 ic->flags |= AVFMT_FLAG_NONBLOCK;
770 ic->interrupt_callback = int_cb;
772 /* open the input file with generic avformat function */
773 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
775 print_error(filename, err);
778 assert_avoptions(format_opts);
780 /* apply forced codec ids */
781 for (i = 0; i < ic->nb_streams; i++)
782 choose_decoder(o, ic, ic->streams[i]);
784 /* Set AVCodecContext options for avformat_find_stream_info */
785 opts = setup_find_stream_info_opts(ic, codec_opts);
786 orig_nb_streams = ic->nb_streams;
788 /* If not enough info to get the stream parameters, we decode the
789 first frames to get it. (used in mpeg case for example) */
790 ret = avformat_find_stream_info(ic, opts);
792 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
793 avformat_close_input(&ic);
797 timestamp = o->start_time;
798 /* add the stream start time */
799 if (ic->start_time != AV_NOPTS_VALUE)
800 timestamp += ic->start_time;
802 /* if seeking requested, we execute it */
803 if (o->start_time != 0) {
804 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
806 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
807 filename, (double)timestamp / AV_TIME_BASE);
811 /* update the current parameters so that they match the one of the input stream */
812 add_input_streams(o, ic);
814 /* dump the file content */
815 av_dump_format(ic, nb_input_files, filename, 0);
817 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
818 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
821 input_files[nb_input_files - 1]->ctx = ic;
822 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
823 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
824 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
825 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
827 for (i = 0; i < o->nb_dump_attachment; i++) {
830 for (j = 0; j < ic->nb_streams; j++) {
831 AVStream *st = ic->streams[j];
833 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
834 dump_attachment(st, o->dump_attachment[i].u.str);
838 for (i = 0; i < orig_nb_streams; i++)
839 av_dict_free(&opts[i]);
846 static uint8_t *get_line(AVIOContext *s)
852 if (avio_open_dyn_buf(&line) < 0) {
853 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
857 while ((c = avio_r8(s)) && c != '\n')
860 avio_close_dyn_buf(line, &buf);
865 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
869 const char *base[3] = { getenv("AVCONV_DATADIR"),
874 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
878 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
879 i != 1 ? "" : "/.avconv", codec_name, preset_name);
880 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
883 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
884 i != 1 ? "" : "/.avconv", preset_name);
885 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
891 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
893 char *codec_name = NULL;
895 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
897 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
898 NULL, ost->st->codec->codec_type);
899 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
900 } else if (!strcmp(codec_name, "copy"))
901 ost->stream_copy = 1;
903 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
904 ost->st->codec->codec_id = ost->enc->id;
908 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
911 AVStream *st = avformat_new_stream(oc, NULL);
912 int idx = oc->nb_streams - 1, ret = 0;
913 char *bsf = NULL, *next, *codec_tag = NULL;
914 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
916 char *buf = NULL, *arg = NULL, *preset = NULL;
917 AVIOContext *s = NULL;
920 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
924 if (oc->nb_streams - 1 < o->nb_streamid_map)
925 st->id = o->streamid_map[oc->nb_streams - 1];
927 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
928 nb_output_streams + 1);
929 if (!(ost = av_mallocz(sizeof(*ost))))
931 output_streams[nb_output_streams - 1] = ost;
933 ost->file_index = nb_output_files;
936 st->codec->codec_type = type;
937 choose_encoder(o, oc, ost);
939 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
942 avcodec_get_context_defaults3(st->codec, ost->enc);
943 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
945 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
946 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
949 if (!buf[0] || buf[0] == '#') {
953 if (!(arg = strchr(buf, '='))) {
954 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
958 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
960 } while (!s->eof_reached);
964 av_log(NULL, AV_LOG_FATAL,
965 "Preset %s specified for stream %d:%d, but could not be opened.\n",
966 preset, ost->file_index, ost->index);
970 ost->max_frames = INT64_MAX;
971 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
973 ost->copy_prior_start = -1;
974 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
976 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
978 if (next = strchr(bsf, ','))
980 if (!(bsfc = av_bitstream_filter_init(bsf))) {
981 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
985 bsfc_prev->next = bsfc;
987 ost->bitstream_filters = bsfc;
993 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
995 uint32_t tag = strtol(codec_tag, &next, 0);
997 tag = AV_RL32(codec_tag);
998 st->codec->codec_tag = tag;
1001 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1003 st->codec->flags |= CODEC_FLAG_QSCALE;
1004 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1007 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1008 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1010 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1011 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1012 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1014 ost->source_index = source_index;
1015 if (source_index >= 0) {
1016 ost->sync_ist = input_streams[source_index];
1017 input_streams[source_index]->discard = 0;
1018 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1024 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1027 const char *p = str;
1034 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1041 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1045 AVCodecContext *video_enc;
1046 char *frame_rate = NULL;
1048 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1050 video_enc = st->codec;
1052 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1053 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1054 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1058 if (!ost->stream_copy) {
1059 const char *p = NULL;
1060 char *frame_size = NULL;
1061 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1062 char *intra_matrix = NULL, *inter_matrix = NULL;
1063 const char *filters = "null";
1067 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1068 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1069 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1073 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1074 if (frame_aspect_ratio) {
1076 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1077 q.num <= 0 || q.den <= 0) {
1078 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1081 ost->frame_aspect_ratio = av_q2d(q);
1084 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1085 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1086 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1087 ost->keep_pix_fmt = 1;
1088 if (!*++frame_pix_fmt)
1089 frame_pix_fmt = NULL;
1091 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1092 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1095 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1098 video_enc->gop_size = 0;
1099 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1101 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1102 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1105 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1107 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1109 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1110 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1113 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1116 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1117 for (i = 0; p; i++) {
1119 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1121 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1124 /* FIXME realloc failure */
1125 video_enc->rc_override =
1126 av_realloc(video_enc->rc_override,
1127 sizeof(RcOverride) * (i + 1));
1128 video_enc->rc_override[i].start_frame = start;
1129 video_enc->rc_override[i].end_frame = end;
1131 video_enc->rc_override[i].qscale = q;
1132 video_enc->rc_override[i].quality_factor = 1.0;
1135 video_enc->rc_override[i].qscale = 0;
1136 video_enc->rc_override[i].quality_factor = -q/100.0;
1141 video_enc->rc_override_count = i;
1142 if (!video_enc->rc_initial_buffer_occupancy)
1143 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1144 video_enc->intra_dc_precision = intra_dc_precision - 8;
1147 video_enc->flags|= CODEC_FLAG_PSNR;
1150 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1153 video_enc->flags |= CODEC_FLAG_PASS1;
1156 video_enc->flags |= CODEC_FLAG_PASS2;
1160 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1161 if (ost->logfile_prefix &&
1162 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1165 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1166 if (ost->forced_keyframes)
1167 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1169 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1171 ost->top_field_first = -1;
1172 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1174 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1175 ost->avfilter = av_strdup(filters);
1177 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1183 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1188 AVCodecContext *audio_enc;
1190 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1193 audio_enc = st->codec;
1194 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1196 if (!ost->stream_copy) {
1197 char *sample_fmt = NULL;
1198 const char *filters = "anull";
1200 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1202 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1204 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1205 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1209 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1211 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1213 av_assert1(filters);
1214 ost->avfilter = av_strdup(filters);
1216 /* check for channel mapping for this audio stream */
1217 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1218 AudioChannelMap *map = &o->audio_channel_maps[n];
1219 InputStream *ist = input_streams[ost->source_index];
1220 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1221 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1222 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1223 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1224 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1226 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1227 ost->file_index, ost->st->index);
1235 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1239 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1240 if (!ost->stream_copy) {
1241 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1248 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1250 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1251 ost->stream_copy = 1;
1255 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1259 AVCodecContext *subtitle_enc;
1261 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1263 subtitle_enc = st->codec;
1265 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1267 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1269 if (!ost->stream_copy) {
1270 char *frame_size = NULL;
1272 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1273 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1274 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1282 /* arg format is "output-stream-index:streamid-value". */
1283 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1285 OptionsContext *o = optctx;
1290 av_strlcpy(idx_str, arg, sizeof(idx_str));
1291 p = strchr(idx_str, ':');
1293 av_log(NULL, AV_LOG_FATAL,
1294 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1299 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1300 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1301 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1305 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1307 AVFormatContext *is = ifile->ctx;
1308 AVFormatContext *os = ofile->ctx;
1312 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1314 return AVERROR(ENOMEM);
1317 for (i = 0; i < is->nb_chapters; i++) {
1318 AVChapter *in_ch = is->chapters[i], *out_ch;
1319 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1320 AV_TIME_BASE_Q, in_ch->time_base);
1321 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1322 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1325 if (in_ch->end < ts_off)
1327 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1330 out_ch = av_mallocz(sizeof(AVChapter));
1332 return AVERROR(ENOMEM);
1334 out_ch->id = in_ch->id;
1335 out_ch->time_base = in_ch->time_base;
1336 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1337 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1340 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1342 os->chapters[os->nb_chapters++] = out_ch;
1347 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1350 AVFormatContext *ic = avformat_alloc_context();
1352 ic->interrupt_callback = int_cb;
1353 err = avformat_open_input(&ic, filename, NULL, NULL);
1356 /* copy stream format */
1357 for(i=0;i<ic->nb_streams;i++) {
1361 AVCodecContext *avctx;
1363 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1364 ost = new_output_stream(o, s, codec->type, -1);
1369 // FIXME: a more elegant solution is needed
1370 memcpy(st, ic->streams[i], sizeof(AVStream));
1372 st->info = av_malloc(sizeof(*st->info));
1373 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1375 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1377 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1378 choose_sample_fmt(st, codec);
1379 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1380 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1383 /* ffserver seeking with date=... needs a date reference */
1384 err = parse_option(o, "metadata", "creation_time=now", options);
1386 avformat_close_input(&ic);
1390 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1391 AVFormatContext *oc)
1395 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1396 ofilter->out_tmp->pad_idx)) {
1397 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1398 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1400 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1405 ost->source_index = -1;
1406 ost->filter = ofilter;
1410 if (ost->stream_copy) {
1411 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1412 "which is fed from a complex filtergraph. Filtering and streamcopy "
1413 "cannot be used together.\n", ost->file_index, ost->index);
1417 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1418 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1421 avfilter_inout_free(&ofilter->out_tmp);
1424 static int configure_complex_filters(void)
1428 for (i = 0; i < nb_filtergraphs; i++)
1429 if (!filtergraphs[i]->graph &&
1430 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1435 void opt_output_file(void *optctx, const char *filename)
1437 OptionsContext *o = optctx;
1438 AVFormatContext *oc;
1440 AVOutputFormat *file_oformat;
1444 if (configure_complex_filters() < 0) {
1445 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1449 if (!strcmp(filename, "-"))
1452 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1454 print_error(filename, err);
1457 file_oformat= oc->oformat;
1458 oc->interrupt_callback = int_cb;
1460 /* create streams for all unlabeled output pads */
1461 for (i = 0; i < nb_filtergraphs; i++) {
1462 FilterGraph *fg = filtergraphs[i];
1463 for (j = 0; j < fg->nb_outputs; j++) {
1464 OutputFilter *ofilter = fg->outputs[j];
1466 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1469 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1470 ofilter->out_tmp->pad_idx)) {
1471 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1472 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1473 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1475 init_output_filter(ofilter, o, oc);
1479 if (!strcmp(file_oformat->name, "ffm") &&
1480 av_strstart(filename, "http:", NULL)) {
1482 /* special case for files sent to ffserver: we get the stream
1483 parameters from ffserver */
1484 int err = read_ffserver_streams(o, oc, filename);
1486 print_error(filename, err);
1489 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1490 ost = output_streams[j];
1491 for (i = 0; i < nb_input_streams; i++) {
1492 ist = input_streams[i];
1493 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1495 ost->source_index= i;
1496 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1497 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1499 ist->st->discard = AVDISCARD_NONE;
1504 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));
1508 } else if (!o->nb_stream_maps) {
1509 char *subtitle_codec_name = NULL;
1510 /* pick the "best" stream of each type */
1512 /* video: highest resolution */
1513 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1514 int area = 0, idx = -1;
1515 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1516 for (i = 0; i < nb_input_streams; i++) {
1518 ist = input_streams[i];
1519 new_area = ist->st->codec->width * ist->st->codec->height;
1520 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1522 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1524 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1531 new_video_stream(o, oc, idx);
1534 /* audio: most channels */
1535 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1536 int channels = 0, idx = -1;
1537 for (i = 0; i < nb_input_streams; i++) {
1538 ist = input_streams[i];
1539 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1540 ist->st->codec->channels > channels) {
1541 channels = ist->st->codec->channels;
1546 new_audio_stream(o, oc, idx);
1549 /* subtitles: pick first */
1550 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1551 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1552 for (i = 0; i < nb_input_streams; i++)
1553 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1554 new_subtitle_stream(o, oc, i);
1558 /* do something with data? */
1560 for (i = 0; i < o->nb_stream_maps; i++) {
1561 StreamMap *map = &o->stream_maps[i];
1562 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1567 if (map->linklabel) {
1569 OutputFilter *ofilter = NULL;
1572 for (j = 0; j < nb_filtergraphs; j++) {
1573 fg = filtergraphs[j];
1574 for (k = 0; k < fg->nb_outputs; k++) {
1575 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1576 if (out && !strcmp(out->name, map->linklabel)) {
1577 ofilter = fg->outputs[k];
1584 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1585 "in any defined filter graph.\n", map->linklabel);
1588 init_output_filter(ofilter, o, oc);
1590 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1591 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1593 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1595 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1597 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1600 switch (ist->st->codec->codec_type) {
1601 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1602 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1603 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1604 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1605 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1607 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1608 map->file_index, map->stream_index);
1616 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1617 AVDictionaryEntry *e;
1618 ost = output_streams[i];
1620 if ( ost->stream_copy
1621 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1622 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1623 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1627 /* handle attached files */
1628 for (i = 0; i < o->nb_attachments; i++) {
1630 uint8_t *attachment;
1634 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1635 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1639 if ((len = avio_size(pb)) <= 0) {
1640 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1644 if (!(attachment = av_malloc(len))) {
1645 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1649 avio_read(pb, attachment, len);
1651 ost = new_attachment_stream(o, oc, -1);
1652 ost->stream_copy = 0;
1653 ost->attachment_filename = o->attachments[i];
1654 ost->st->codec->extradata = attachment;
1655 ost->st->codec->extradata_size = len;
1657 p = strrchr(o->attachments[i], '/');
1658 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1662 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1663 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1666 output_files[nb_output_files - 1]->ctx = oc;
1667 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1668 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1669 if (o->recording_time != INT64_MAX)
1670 oc->duration = o->recording_time;
1671 output_files[nb_output_files - 1]->start_time = o->start_time;
1672 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1673 output_files[nb_output_files - 1]->shortest = o->shortest;
1674 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1676 /* check filename in case of an image number is expected */
1677 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1678 if (!av_filename_number_test(oc->filename)) {
1679 print_error(oc->filename, AVERROR(EINVAL));
1684 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1685 /* test if it already exists to avoid losing precious files */
1686 assert_file_overwrite(filename);
1689 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1690 &oc->interrupt_callback,
1691 &output_files[nb_output_files - 1]->opts)) < 0) {
1692 print_error(filename, err);
1697 if (o->mux_preload) {
1699 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1700 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1702 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1705 for (i = 0; i < o->nb_metadata_map; i++) {
1707 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1709 if (in_file_index >= nb_input_files) {
1710 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1713 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1714 in_file_index >= 0 ?
1715 input_files[in_file_index]->ctx : NULL, o);
1719 if (o->chapters_input_file >= nb_input_files) {
1720 if (o->chapters_input_file == INT_MAX) {
1721 /* copy chapters from the first input file that has them*/
1722 o->chapters_input_file = -1;
1723 for (i = 0; i < nb_input_files; i++)
1724 if (input_files[i]->ctx->nb_chapters) {
1725 o->chapters_input_file = i;
1729 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1730 o->chapters_input_file);
1734 if (o->chapters_input_file >= 0)
1735 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1736 !o->metadata_chapters_manual);
1738 /* copy global metadata by default */
1739 if (!o->metadata_global_manual && nb_input_files){
1740 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1741 AV_DICT_DONT_OVERWRITE);
1742 if(o->recording_time != INT64_MAX)
1743 av_dict_set(&oc->metadata, "duration", NULL, 0);
1744 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1746 if (!o->metadata_streams_manual)
1747 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1749 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1751 ist = input_streams[output_streams[i]->source_index];
1752 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1755 /* process manually set metadata */
1756 for (i = 0; i < o->nb_metadata; i++) {
1759 const char *stream_spec;
1760 int index = 0, j, ret = 0;
1762 val = strchr(o->metadata[i].u.str, '=');
1764 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1765 o->metadata[i].u.str);
1770 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1772 for (j = 0; j < oc->nb_streams; j++) {
1773 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1774 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1785 if (index < 0 || index >= oc->nb_chapters) {
1786 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1789 m = &oc->chapters[index]->metadata;
1792 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1795 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1799 reset_options(o, 0);
1802 static int opt_target(void *optctx, const char *opt, const char *arg)
1804 OptionsContext *o = optctx;
1805 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1806 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1808 if (!strncmp(arg, "pal-", 4)) {
1811 } else if (!strncmp(arg, "ntsc-", 5)) {
1814 } else if (!strncmp(arg, "film-", 5)) {
1818 /* Try to determine PAL/NTSC by peeking in the input files */
1819 if (nb_input_files) {
1821 for (j = 0; j < nb_input_files; j++) {
1822 for (i = 0; i < input_files[j]->nb_streams; i++) {
1823 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1824 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1826 fr = c->time_base.den * 1000 / c->time_base.num;
1830 } else if ((fr == 29970) || (fr == 23976)) {
1835 if (norm != UNKNOWN)
1839 if (norm != UNKNOWN)
1840 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1843 if (norm == UNKNOWN) {
1844 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1845 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1846 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1850 if (!strcmp(arg, "vcd")) {
1851 opt_video_codec(o, "c:v", "mpeg1video");
1852 opt_audio_codec(o, "c:a", "mp2");
1853 parse_option(o, "f", "vcd", options);
1855 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1856 parse_option(o, "r", frame_rates[norm], options);
1857 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1859 opt_default(NULL, "b:v", "1150000");
1860 opt_default(NULL, "maxrate", "1150000");
1861 opt_default(NULL, "minrate", "1150000");
1862 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1864 opt_default(NULL, "b:a", "224000");
1865 parse_option(o, "ar", "44100", options);
1866 parse_option(o, "ac", "2", options);
1868 opt_default(NULL, "packetsize", "2324");
1869 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1871 /* We have to offset the PTS, so that it is consistent with the SCR.
1872 SCR starts at 36000, but the first two packs contain only padding
1873 and the first pack from the other stream, respectively, may also have
1874 been written before.
1875 So the real data starts at SCR 36000+3*1200. */
1876 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1877 } else if (!strcmp(arg, "svcd")) {
1879 opt_video_codec(o, "c:v", "mpeg2video");
1880 opt_audio_codec(o, "c:a", "mp2");
1881 parse_option(o, "f", "svcd", options);
1883 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1884 parse_option(o, "r", frame_rates[norm], options);
1885 parse_option(o, "pix_fmt", "yuv420p", options);
1886 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1888 opt_default(NULL, "b:v", "2040000");
1889 opt_default(NULL, "maxrate", "2516000");
1890 opt_default(NULL, "minrate", "0"); // 1145000;
1891 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1892 opt_default(NULL, "scan_offset", "1");
1894 opt_default(NULL, "b:a", "224000");
1895 parse_option(o, "ar", "44100", options);
1897 opt_default(NULL, "packetsize", "2324");
1899 } else if (!strcmp(arg, "dvd")) {
1901 opt_video_codec(o, "c:v", "mpeg2video");
1902 opt_audio_codec(o, "c:a", "ac3");
1903 parse_option(o, "f", "dvd", options);
1905 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1906 parse_option(o, "r", frame_rates[norm], options);
1907 parse_option(o, "pix_fmt", "yuv420p", options);
1908 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1910 opt_default(NULL, "b:v", "6000000");
1911 opt_default(NULL, "maxrate", "9000000");
1912 opt_default(NULL, "minrate", "0"); // 1500000;
1913 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1915 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1916 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1918 opt_default(NULL, "b:a", "448000");
1919 parse_option(o, "ar", "48000", options);
1921 } else if (!strncmp(arg, "dv", 2)) {
1923 parse_option(o, "f", "dv", options);
1925 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1926 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1927 norm == PAL ? "yuv420p" : "yuv411p", options);
1928 parse_option(o, "r", frame_rates[norm], options);
1930 parse_option(o, "ar", "48000", options);
1931 parse_option(o, "ac", "2", options);
1934 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1935 return AVERROR(EINVAL);
1940 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1942 av_free (vstats_filename);
1943 vstats_filename = av_strdup (arg);
1947 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1950 time_t today2 = time(NULL);
1951 struct tm *today = localtime(&today2);
1953 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1955 return opt_vstats_file(NULL, opt, filename);
1958 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1960 OptionsContext *o = optctx;
1961 return parse_option(o, "frames:v", arg, options);
1964 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1966 OptionsContext *o = optctx;
1967 return parse_option(o, "frames:a", arg, options);
1970 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1972 OptionsContext *o = optctx;
1973 return parse_option(o, "frames:d", arg, options);
1976 static int opt_preset(void *optctx, const char *opt, const char *arg)
1978 OptionsContext *o = optctx;
1980 char filename[1000], line[1000], tmp_line[1000];
1981 const char *codec_name = NULL;
1985 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1987 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1988 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1989 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1991 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1995 while (fgets(line, sizeof(line), f)) {
1996 char *key = tmp_line, *value, *endptr;
1998 if (strcspn(line, "#\n\r") == 0)
2000 strcpy(tmp_line, line);
2001 if (!av_strtok(key, "=", &value) ||
2002 !av_strtok(value, "\r\n", &endptr)) {
2003 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2006 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2008 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2009 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2010 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2011 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2012 else if (opt_default(NULL, key, value) < 0) {
2013 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2014 filename, line, key, value);
2024 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2026 OptionsContext *o = optctx;
2027 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2028 int ret = parse_option(o, s, arg, options);
2033 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2035 OptionsContext *o = optctx;
2036 if(!strcmp(opt, "b")){
2037 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2038 return parse_option(o, "b:v", arg, options);
2040 return opt_default(optctx, opt, arg);
2043 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2045 OptionsContext *o = optctx;
2048 if(!strcmp(opt, "qscale")){
2049 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2050 return parse_option(o, "q:v", arg, options);
2052 s = av_asprintf("q%s", opt + 6);
2053 ret = parse_option(o, s, arg, options);
2058 static int opt_profile(void *optctx, const char *opt, const char *arg)
2060 OptionsContext *o = optctx;
2061 if(!strcmp(opt, "profile")){
2062 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2063 return parse_option(o, "profile:v", arg, options);
2065 return opt_default(optctx, opt, arg);
2069 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2071 OptionsContext *o = optctx;
2072 return parse_option(o, "filter:v", arg, options);
2075 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2077 OptionsContext *o = optctx;
2078 return parse_option(o, "filter:a", arg, options);
2081 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2083 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2084 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2085 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2086 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2088 if (video_sync_method == VSYNC_AUTO)
2089 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2093 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2095 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2100 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2102 OptionsContext *o = optctx;
2103 char *tcr = av_asprintf("timecode=%s", arg);
2104 int ret = parse_option(o, "metadata:g", tcr, options);
2106 ret = opt_default(optctx, "gop_timecode", arg);
2111 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2113 OptionsContext *o = optctx;
2114 char layout_str[32];
2117 int ret, channels, ac_str_size;
2120 layout = av_get_channel_layout(arg);
2122 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2123 return AVERROR(EINVAL);
2125 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2126 ret = opt_default(NULL, opt, layout_str);
2130 /* set 'ac' option based on channel layout */
2131 channels = av_get_channel_layout_nb_channels(layout);
2132 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2133 stream_str = strchr(opt, ':');
2134 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2135 ac_str = av_mallocz(ac_str_size);
2137 return AVERROR(ENOMEM);
2138 av_strlcpy(ac_str, "ac", 3);
2140 av_strlcat(ac_str, stream_str, ac_str_size);
2141 ret = parse_option(o, ac_str, layout_str, options);
2147 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2149 OptionsContext *o = optctx;
2150 return parse_option(o, "q:a", arg, options);
2153 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2155 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2156 &nb_filtergraphs, nb_filtergraphs + 1);
2157 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2158 return AVERROR(ENOMEM);
2159 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2160 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2164 void show_help_default(const char *opt, const char *arg)
2166 /* per-file options have at least one of those set */
2167 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2168 int show_advanced = 0, show_avoptions = 0;
2171 if (!strcmp(opt, "long"))
2173 else if (!strcmp(opt, "full"))
2174 show_advanced = show_avoptions = 1;
2176 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2181 printf("Getting help:\n"
2182 " -h -- print basic options\n"
2183 " -h long -- print more options\n"
2184 " -h full -- print all options (including all format and codec specific options, very long)\n"
2185 " See man %s for detailed description of the options.\n"
2186 "\n", program_name);
2188 show_help_options(options, "Print help / information / capabilities:",
2191 show_help_options(options, "Global options (affect whole program "
2192 "instead of just one file:",
2193 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2195 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2196 per_file | OPT_EXIT, 0);
2198 show_help_options(options, "Per-file main options:", 0,
2199 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2200 OPT_EXIT, per_file);
2202 show_help_options(options, "Advanced per-file options:",
2203 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2205 show_help_options(options, "Video options:",
2206 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2208 show_help_options(options, "Advanced Video options:",
2209 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2211 show_help_options(options, "Audio options:",
2212 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2214 show_help_options(options, "Advanced Audio options:",
2215 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2216 show_help_options(options, "Subtitle options:",
2217 OPT_SUBTITLE, 0, 0);
2220 if (show_avoptions) {
2221 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2222 show_help_children(avcodec_get_class(), flags);
2223 show_help_children(avformat_get_class(), flags);
2224 show_help_children(sws_get_class(), flags);
2225 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2226 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2230 void show_usage(void)
2232 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2233 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2234 av_log(NULL, AV_LOG_INFO, "\n");
2238 static int opt_progress(void *optctx, const char *opt, const char *arg)
2240 AVIOContext *avio = NULL;
2243 if (!strcmp(arg, "-"))
2245 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2247 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2248 arg, av_err2str(ret));
2251 progress_avio = avio;
2255 #define OFFSET(x) offsetof(OptionsContext, x)
2256 const OptionDef options[] = {
2258 #include "cmdutils_common_opts.h"
2259 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2260 "force format", "fmt" },
2261 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2262 "input file name", "filename" },
2263 { "y", OPT_BOOL, { &file_overwrite },
2264 "overwrite output files" },
2265 { "n", OPT_BOOL, { &no_file_overwrite },
2266 "do not overwrite output files" },
2267 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2268 "codec name", "codec" },
2269 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2270 "codec name", "codec" },
2271 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2272 "preset name", "preset" },
2273 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2274 "set input stream mapping",
2275 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2276 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2277 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2278 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2279 "set metadata information of outfile from infile",
2280 "outfile[,metadata]:infile[,metadata]" },
2281 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2282 "set chapters mapping", "input_file_index" },
2283 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2284 "record or transcode \"duration\" seconds of audio/video",
2286 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2287 "set the limit file size in bytes", "limit_size" },
2288 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2289 "set the start time offset", "time_off" },
2290 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2291 "set the input ts offset", "time_off" },
2292 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2293 "set the input ts scale", "scale" },
2294 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2295 "set the recording timestamp ('now' to set the current time)", "time" },
2296 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2297 "add metadata", "string=string" },
2298 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2299 "set the number of data frames to record", "number" },
2300 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2301 "add timings for benchmarking" },
2302 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2303 "add timings for each task" },
2304 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2305 "write program-readable progress information", "url" },
2306 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2307 "enable or disable interaction on standard input" },
2308 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2309 "set max runtime in seconds", "limit" },
2310 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2311 "dump each input packet" },
2312 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2313 "when dumping packets, also dump the payload" },
2314 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2315 "read input at native frame rate", "" },
2316 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2317 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2318 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2319 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2320 "video sync method", "" },
2321 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2322 "audio sync method", "" },
2323 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2324 "audio drift threshold", "threshold" },
2325 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2326 "copy timestamps" },
2327 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2328 "copy input stream time base when stream copying", "mode" },
2329 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2330 "finish encoding within shortest input" },
2331 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2332 "timestamp discontinuity delta threshold", "threshold" },
2333 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2334 "timestamp error delta threshold", "threshold" },
2335 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2336 "exit on error", "error" },
2337 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2338 "copy initial non-keyframes" },
2339 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2340 "copy or discard frames before start time" },
2341 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2342 "set the number of frames to record", "number" },
2343 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2344 "force codec tag/fourcc", "fourcc/tag" },
2345 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2346 "use fixed quality scale (VBR)", "q" },
2347 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2348 "use fixed quality scale (VBR)", "q" },
2349 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2350 "set profile", "profile" },
2351 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2352 "set stream filterchain", "filter_list" },
2353 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2354 "reinit filtergraph on input parameter changes", "" },
2355 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2356 "create a complex filtergraph", "graph_description" },
2357 { "stats", OPT_BOOL, { &print_stats },
2358 "print progress report during encoding", },
2359 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2360 "add an attachment to the output file", "filename" },
2361 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2362 "extract an attachment into a file", "filename" },
2363 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2364 "print timestamp debugging info" },
2367 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2368 "set the number of video frames to record", "number" },
2369 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2370 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2371 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2372 "set frame size (WxH or abbreviation)", "size" },
2373 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2374 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2375 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2376 "set pixel format", "format" },
2377 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2378 "set the number of bits per raw sample", "number" },
2379 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2380 "Removed, use the crop filter instead", "size" },
2381 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2382 "Removed, use the crop filter instead", "size" },
2383 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2384 "Removed, use the crop filter instead", "size" },
2385 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2386 "Removed, use the crop filter instead", "size" },
2387 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2388 "Removed, use the pad filter instead", "size" },
2389 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2390 "Removed, use the pad filter instead", "size" },
2391 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2392 "Removed, use the pad filter instead", "size" },
2393 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2394 "Removed, use the pad filter instead", "size" },
2395 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2396 "Removed, use the pad filter instead", "color" },
2397 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2398 "deprecated use -g 1" },
2399 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2401 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2402 "discard threshold", "n" },
2403 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2404 "rate control override for specific intervals", "override" },
2405 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2406 "force video codec ('copy' to copy stream)", "codec" },
2407 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2409 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2411 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2412 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2413 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2414 "select the pass number (1 to 3)", "n" },
2415 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2416 "select two pass log file name prefix", "prefix" },
2417 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2418 "this option is deprecated, use the yadif filter instead" },
2419 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2420 "calculate PSNR of compressed frames" },
2421 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2422 "dump video coding statistics to file" },
2423 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2424 "dump video coding statistics to file", "file" },
2425 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2426 "video filters", "filter list" },
2427 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2428 "specify intra matrix coeffs", "matrix" },
2429 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2430 "specify inter matrix coeffs", "matrix" },
2431 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2432 "top=1/bottom=0/auto=-1 field first", "" },
2433 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2434 "intra_dc_precision", "precision" },
2435 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2436 "force video tag/fourcc", "fourcc/tag" },
2437 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2438 "show QP histogram" },
2439 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2440 "force the selected framerate, disable the best supported framerate selection" },
2441 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2442 "set the value of an outfile streamid", "streamIndex:value" },
2443 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2444 { .off = OFFSET(forced_key_frames) },
2445 "force key frames at specified timestamps", "timestamps" },
2446 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2447 "video bitrate (please use -b:v)", "bitrate" },
2450 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2451 "set the number of audio frames to record", "number" },
2452 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2453 "set audio quality (codec-specific)", "quality", },
2454 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2455 "set audio sampling rate (in Hz)", "rate" },
2456 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2457 "set number of audio channels", "channels" },
2458 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2460 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2461 "force audio codec ('copy' to copy stream)", "codec" },
2462 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2463 "force audio tag/fourcc", "fourcc/tag" },
2464 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2465 "change audio volume (256=normal)" , "volume" },
2466 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2467 "set sample format", "format" },
2468 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2469 "set channel layout", "layout" },
2470 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2471 "audio filters", "filter list" },
2473 /* subtitle options */
2474 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2475 "disable subtitle" },
2476 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2477 "force subtitle codec ('copy' to copy stream)", "codec" },
2478 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2479 , "force subtitle tag/fourcc", "fourcc/tag" },
2480 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2481 "fix subtitles duration" },
2484 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2485 "deprecated, use -channel", "channel" },
2486 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2487 "deprecated, use -standard", "standard" },
2488 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2491 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2492 "set the maximum demux-decode delay", "seconds" },
2493 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2494 "set the initial demux-decode delay", "seconds" },
2496 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2497 "A comma-separated list of bitstream filters", "bitstream_filters" },
2498 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2499 "deprecated", "audio bitstream_filters" },
2500 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2501 "deprecated", "video bitstream_filters" },
2503 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2504 "set the audio options to the indicated preset", "preset" },
2505 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2506 "set the video options to the indicated preset", "preset" },
2507 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2508 "set the subtitle options to the indicated preset", "preset" },
2509 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2510 "set options from indicated preset file", "filename" },
2511 /* data codec support */
2512 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2513 "force data codec ('copy' to copy stream)", "codec" },
2514 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2517 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2518 "generic catch all option", "" },