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/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.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_ERROR, "Option '%s' was removed. "
163 "If you are looking for an option to preserve the quality (which is not "
164 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
166 return AVERROR(EINVAL);
169 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
171 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
172 return opt_default(optctx, "channel", arg);
175 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
177 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
178 return opt_default(optctx, "standard", arg);
181 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
183 OptionsContext *o = optctx;
184 return parse_option(o, "codec:a", arg, options);
187 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
189 OptionsContext *o = optctx;
190 return parse_option(o, "codec:v", arg, options);
193 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
195 OptionsContext *o = optctx;
196 return parse_option(o, "codec:s", arg, options);
199 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
201 OptionsContext *o = optctx;
202 return parse_option(o, "codec:d", arg, options);
205 static int opt_map(void *optctx, const char *opt, const char *arg)
207 OptionsContext *o = optctx;
209 int i, negative = 0, file_idx;
210 int sync_file_idx = -1, sync_stream_idx = 0;
218 map = av_strdup(arg);
220 /* parse sync stream first, just pick first matching stream */
221 if (sync = strchr(map, ',')) {
223 sync_file_idx = strtol(sync + 1, &sync, 0);
224 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
225 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
230 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
231 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
232 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
236 if (i == input_files[sync_file_idx]->nb_streams) {
237 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
238 "match any streams.\n", arg);
245 /* this mapping refers to lavfi output */
246 const char *c = map + 1;
247 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
248 &o->nb_stream_maps, o->nb_stream_maps + 1);
249 m = &o->stream_maps[o->nb_stream_maps - 1];
250 m->linklabel = av_get_token(&c, "]");
252 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
256 file_idx = strtol(map, &p, 0);
257 if (file_idx >= nb_input_files || file_idx < 0) {
258 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
262 /* disable some already defined maps */
263 for (i = 0; i < o->nb_stream_maps; i++) {
264 m = &o->stream_maps[i];
265 if (file_idx == m->file_index &&
266 check_stream_specifier(input_files[m->file_index]->ctx,
267 input_files[m->file_index]->ctx->streams[m->stream_index],
268 *p == ':' ? p + 1 : p) > 0)
272 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
273 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
274 *p == ':' ? p + 1 : p) <= 0)
276 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
277 &o->nb_stream_maps, o->nb_stream_maps + 1);
278 m = &o->stream_maps[o->nb_stream_maps - 1];
280 m->file_index = file_idx;
283 if (sync_file_idx >= 0) {
284 m->sync_file_index = sync_file_idx;
285 m->sync_stream_index = sync_stream_idx;
287 m->sync_file_index = file_idx;
288 m->sync_stream_index = i;
294 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
302 static int opt_attach(void *optctx, const char *opt, const char *arg)
304 OptionsContext *o = optctx;
305 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
306 &o->nb_attachments, o->nb_attachments + 1);
307 o->attachments[o->nb_attachments - 1] = arg;
311 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
313 OptionsContext *o = optctx;
318 o->audio_channel_maps =
319 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
320 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
321 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
323 /* muted channel syntax */
324 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
325 if ((n == 1 || n == 3) && m->channel_idx == -1) {
326 m->file_idx = m->stream_idx = -1;
328 m->ofile_idx = m->ostream_idx = -1;
333 n = sscanf(arg, "%d.%d.%d:%d.%d",
334 &m->file_idx, &m->stream_idx, &m->channel_idx,
335 &m->ofile_idx, &m->ostream_idx);
337 if (n != 3 && n != 5) {
338 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
339 "[file.stream.channel|-1][:syncfile:syncstream]\n");
343 if (n != 5) // only file.stream.channel specified
344 m->ofile_idx = m->ostream_idx = -1;
347 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
348 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
352 if (m->stream_idx < 0 ||
353 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
354 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
355 m->file_idx, m->stream_idx);
358 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
359 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
360 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
361 m->file_idx, m->stream_idx);
364 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
365 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
366 m->file_idx, m->stream_idx, m->channel_idx);
373 * Parse a metadata specifier passed as 'arg' parameter.
374 * @param arg metadata string to parse
375 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
376 * @param index for type c/p, chapter/program index is written here
377 * @param stream_spec for type s, the stream specifier is written here
379 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
387 if (*(++arg) && *arg != ':') {
388 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
391 *stream_spec = *arg == ':' ? arg + 1 : "";
396 *index = strtol(++arg, NULL, 0);
399 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
406 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
408 AVDictionary **meta_in = NULL;
409 AVDictionary **meta_out = NULL;
411 char type_in, type_out;
412 const char *istream_spec = NULL, *ostream_spec = NULL;
413 int idx_in = 0, idx_out = 0;
415 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
416 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
419 if (type_out == 'g' || !*outspec)
420 o->metadata_global_manual = 1;
421 if (type_out == 's' || !*outspec)
422 o->metadata_streams_manual = 1;
423 if (type_out == 'c' || !*outspec)
424 o->metadata_chapters_manual = 1;
428 if (type_in == 'g' || type_out == 'g')
429 o->metadata_global_manual = 1;
430 if (type_in == 's' || type_out == 's')
431 o->metadata_streams_manual = 1;
432 if (type_in == 'c' || type_out == 'c')
433 o->metadata_chapters_manual = 1;
435 /* ic is NULL when just disabling automatic mappings */
439 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
440 if ((index) < 0 || (index) >= (nb_elems)) {\
441 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
446 #define SET_DICT(type, meta, context, index)\
449 meta = &context->metadata;\
452 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
453 meta = &context->chapters[index]->metadata;\
456 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
457 meta = &context->programs[index]->metadata;\
459 default: av_assert0(0);\
464 SET_DICT(type_in, meta_in, ic, idx_in);
465 SET_DICT(type_out, meta_out, oc, idx_out);
467 /* for input streams choose first matching stream */
468 if (type_in == 's') {
469 for (i = 0; i < ic->nb_streams; i++) {
470 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
471 meta_in = &ic->streams[i]->metadata;
477 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
482 if (type_out == 's') {
483 for (i = 0; i < oc->nb_streams; i++) {
484 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
485 meta_out = &oc->streams[i]->metadata;
486 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
491 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
496 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
498 OptionsContext *o = optctx;
500 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
501 struct tm time = *gmtime((time_t*)&recording_timestamp);
502 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
503 parse_option(o, "metadata", buf, options);
505 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
506 "tag instead.\n", opt);
510 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
512 const AVCodecDescriptor *desc;
513 const char *codec_string = encoder ? "encoder" : "decoder";
517 avcodec_find_encoder_by_name(name) :
518 avcodec_find_decoder_by_name(name);
520 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
521 codec = encoder ? avcodec_find_encoder(desc->id) :
522 avcodec_find_decoder(desc->id);
524 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
525 codec_string, codec->name, desc->name);
529 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
532 if (codec->type != type) {
533 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
539 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
541 char *codec_name = NULL;
543 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
545 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
546 st->codec->codec_id = codec->id;
549 return avcodec_find_decoder(st->codec->codec_id);
552 /* Add all the streams from the given input file to the global
553 * list of input streams. */
554 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
557 char *next, *codec_tag = NULL;
559 for (i = 0; i < ic->nb_streams; i++) {
560 AVStream *st = ic->streams[i];
561 AVCodecContext *dec = st->codec;
562 InputStream *ist = av_mallocz(sizeof(*ist));
563 char *framerate = NULL;
568 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
569 input_streams[nb_input_streams - 1] = ist;
572 ist->file_index = nb_input_files;
574 st->discard = AVDISCARD_ALL;
575 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
578 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
580 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
582 uint32_t tag = strtol(codec_tag, &next, 0);
584 tag = AV_RL32(codec_tag);
585 st->codec->codec_tag = tag;
588 ist->dec = choose_decoder(o, ic, st);
590 ist->reinit_filters = -1;
591 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
593 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
595 switch (dec->codec_type) {
596 case AVMEDIA_TYPE_VIDEO:
598 ist->dec = avcodec_find_decoder(dec->codec_id);
600 dec->flags |= CODEC_FLAG_EMU_EDGE;
603 ist->resample_height = dec->height;
604 ist->resample_width = dec->width;
605 ist->resample_pix_fmt = dec->pix_fmt;
607 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
608 if (framerate && av_parse_video_rate(&ist->framerate,
610 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
615 ist->top_field_first = -1;
616 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
619 case AVMEDIA_TYPE_AUDIO:
620 guess_input_channel_layout(ist);
622 ist->resample_sample_fmt = dec->sample_fmt;
623 ist->resample_sample_rate = dec->sample_rate;
624 ist->resample_channels = dec->channels;
625 ist->resample_channel_layout = dec->channel_layout;
628 case AVMEDIA_TYPE_DATA:
629 case AVMEDIA_TYPE_SUBTITLE:
631 ist->dec = avcodec_find_decoder(dec->codec_id);
632 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
634 case AVMEDIA_TYPE_ATTACHMENT:
635 case AVMEDIA_TYPE_UNKNOWN:
643 static void assert_file_overwrite(const char *filename)
645 if ((!file_overwrite || no_file_overwrite) &&
646 (strchr(filename, ':') == NULL || filename[1] == ':' ||
647 av_strstart(filename, "file:", NULL))) {
648 if (avio_check(filename, 0) == 0) {
649 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
650 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
653 signal(SIGINT, SIG_DFL);
655 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
661 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
668 static void dump_attachment(AVStream *st, const char *filename)
671 AVIOContext *out = NULL;
672 AVDictionaryEntry *e;
674 if (!st->codec->extradata_size) {
675 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
676 nb_input_files - 1, st->index);
679 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
682 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
683 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
687 assert_file_overwrite(filename);
689 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
690 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
695 avio_write(out, st->codec->extradata, st->codec->extradata_size);
700 static int opt_input_file(void *optctx, const char *opt, const char *filename)
702 OptionsContext *o = optctx;
704 AVInputFormat *file_iformat = NULL;
709 int orig_nb_streams; // number of streams before avformat_find_stream_info
710 char * video_codec_name = NULL;
711 char * audio_codec_name = NULL;
712 char *subtitle_codec_name = NULL;
715 if (!(file_iformat = av_find_input_format(o->format))) {
716 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
721 if (!strcmp(filename, "-"))
724 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
725 strcmp(filename, "/dev/stdin");
727 /* get default parameters from command line */
728 ic = avformat_alloc_context();
730 print_error(filename, AVERROR(ENOMEM));
733 if (o->nb_audio_sample_rate) {
734 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
735 av_dict_set(&format_opts, "sample_rate", buf, 0);
737 if (o->nb_audio_channels) {
738 /* because we set audio_channels based on both the "ac" and
739 * "channel_layout" options, we need to check that the specified
740 * demuxer actually has the "channels" option before setting it */
741 if (file_iformat && file_iformat->priv_class &&
742 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
743 AV_OPT_SEARCH_FAKE_OBJ)) {
744 snprintf(buf, sizeof(buf), "%d",
745 o->audio_channels[o->nb_audio_channels - 1].u.i);
746 av_dict_set(&format_opts, "channels", buf, 0);
749 if (o->nb_frame_rates) {
750 /* set the format-level framerate option;
751 * this is important for video grabbers, e.g. x11 */
752 if (file_iformat && file_iformat->priv_class &&
753 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
754 AV_OPT_SEARCH_FAKE_OBJ)) {
755 av_dict_set(&format_opts, "framerate",
756 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
759 if (o->nb_frame_sizes) {
760 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
762 if (o->nb_frame_pix_fmts)
763 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
765 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
766 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
767 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
769 ic->video_codec_id = video_codec_name ?
770 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
771 ic->audio_codec_id = audio_codec_name ?
772 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
773 ic->subtitle_codec_id= subtitle_codec_name ?
774 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
775 ic->flags |= AVFMT_FLAG_NONBLOCK;
776 ic->interrupt_callback = int_cb;
778 /* open the input file with generic avformat function */
779 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
781 print_error(filename, err);
784 assert_avoptions(format_opts);
786 /* apply forced codec ids */
787 for (i = 0; i < ic->nb_streams; i++)
788 choose_decoder(o, ic, ic->streams[i]);
790 /* Set AVCodecContext options for avformat_find_stream_info */
791 opts = setup_find_stream_info_opts(ic, codec_opts);
792 orig_nb_streams = ic->nb_streams;
794 /* If not enough info to get the stream parameters, we decode the
795 first frames to get it. (used in mpeg case for example) */
796 ret = avformat_find_stream_info(ic, opts);
798 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
799 avformat_close_input(&ic);
803 timestamp = o->start_time;
804 /* add the stream start time */
805 if (ic->start_time != AV_NOPTS_VALUE)
806 timestamp += ic->start_time;
808 /* if seeking requested, we execute it */
809 if (o->start_time != 0) {
810 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
812 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
813 filename, (double)timestamp / AV_TIME_BASE);
817 /* update the current parameters so that they match the one of the input stream */
818 add_input_streams(o, ic);
820 /* dump the file content */
821 av_dump_format(ic, nb_input_files, filename, 0);
823 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
824 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
827 input_files[nb_input_files - 1]->ctx = ic;
828 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
829 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
830 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
831 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
833 for (i = 0; i < o->nb_dump_attachment; i++) {
836 for (j = 0; j < ic->nb_streams; j++) {
837 AVStream *st = ic->streams[j];
839 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
840 dump_attachment(st, o->dump_attachment[i].u.str);
844 for (i = 0; i < orig_nb_streams; i++)
845 av_dict_free(&opts[i]);
852 static uint8_t *get_line(AVIOContext *s)
858 if (avio_open_dyn_buf(&line) < 0) {
859 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
863 while ((c = avio_r8(s)) && c != '\n')
866 avio_close_dyn_buf(line, &buf);
871 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
875 const char *base[3] = { getenv("AVCONV_DATADIR"),
880 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
884 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
885 i != 1 ? "" : "/.avconv", codec_name, preset_name);
886 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
889 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
890 i != 1 ? "" : "/.avconv", preset_name);
891 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
897 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
899 char *codec_name = NULL;
901 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
903 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
904 NULL, ost->st->codec->codec_type);
905 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
906 } else if (!strcmp(codec_name, "copy"))
907 ost->stream_copy = 1;
909 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
910 ost->st->codec->codec_id = ost->enc->id;
914 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
917 AVStream *st = avformat_new_stream(oc, NULL);
918 int idx = oc->nb_streams - 1, ret = 0;
919 char *bsf = NULL, *next, *codec_tag = NULL;
920 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
924 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
928 if (oc->nb_streams - 1 < o->nb_streamid_map)
929 st->id = o->streamid_map[oc->nb_streams - 1];
931 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
932 nb_output_streams + 1);
933 if (!(ost = av_mallocz(sizeof(*ost))))
935 output_streams[nb_output_streams - 1] = ost;
937 ost->file_index = nb_output_files;
940 st->codec->codec_type = type;
941 choose_encoder(o, oc, ost);
943 AVIOContext *s = NULL;
944 char *buf = NULL, *arg = NULL, *preset = NULL;
946 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
948 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
949 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
952 if (!buf[0] || buf[0] == '#') {
956 if (!(arg = strchr(buf, '='))) {
957 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
961 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
963 } while (!s->eof_reached);
967 av_log(NULL, AV_LOG_FATAL,
968 "Preset %s specified for stream %d:%d, but could not be opened.\n",
969 preset, ost->file_index, ost->index);
974 avcodec_get_context_defaults3(st->codec, ost->enc);
975 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
977 ost->max_frames = INT64_MAX;
978 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
980 ost->copy_prior_start = -1;
981 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
983 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
985 if (next = strchr(bsf, ','))
987 if (!(bsfc = av_bitstream_filter_init(bsf))) {
988 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
992 bsfc_prev->next = bsfc;
994 ost->bitstream_filters = bsfc;
1000 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1002 uint32_t tag = strtol(codec_tag, &next, 0);
1004 tag = AV_RL32(codec_tag);
1005 st->codec->codec_tag = tag;
1008 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1010 st->codec->flags |= CODEC_FLAG_QSCALE;
1011 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1014 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1015 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1017 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1018 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1019 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1021 ost->source_index = source_index;
1022 if (source_index >= 0) {
1023 ost->sync_ist = input_streams[source_index];
1024 input_streams[source_index]->discard = 0;
1025 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1031 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1034 const char *p = str;
1041 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1048 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1052 AVCodecContext *video_enc;
1053 char *frame_rate = NULL;
1055 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1057 video_enc = st->codec;
1059 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1060 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1061 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1065 if (!ost->stream_copy) {
1066 const char *p = NULL;
1067 char *frame_size = NULL;
1068 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1069 char *intra_matrix = NULL, *inter_matrix = NULL;
1070 const char *filters = "null";
1074 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1075 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1076 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1080 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1081 if (frame_aspect_ratio) {
1083 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1084 q.num <= 0 || q.den <= 0) {
1085 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1088 ost->frame_aspect_ratio = av_q2d(q);
1091 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1092 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1093 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1094 ost->keep_pix_fmt = 1;
1095 if (!*++frame_pix_fmt)
1096 frame_pix_fmt = NULL;
1098 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1099 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1102 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1105 video_enc->gop_size = 0;
1106 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1108 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1109 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1112 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1114 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1116 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1117 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1120 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1123 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1124 for (i = 0; p; i++) {
1126 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1128 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1131 /* FIXME realloc failure */
1132 video_enc->rc_override =
1133 av_realloc(video_enc->rc_override,
1134 sizeof(RcOverride) * (i + 1));
1135 video_enc->rc_override[i].start_frame = start;
1136 video_enc->rc_override[i].end_frame = end;
1138 video_enc->rc_override[i].qscale = q;
1139 video_enc->rc_override[i].quality_factor = 1.0;
1142 video_enc->rc_override[i].qscale = 0;
1143 video_enc->rc_override[i].quality_factor = -q/100.0;
1148 video_enc->rc_override_count = i;
1149 if (!video_enc->rc_initial_buffer_occupancy)
1150 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1151 video_enc->intra_dc_precision = intra_dc_precision - 8;
1154 video_enc->flags|= CODEC_FLAG_PSNR;
1157 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1160 video_enc->flags |= CODEC_FLAG_PASS1;
1163 video_enc->flags |= CODEC_FLAG_PASS2;
1167 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1168 if (ost->logfile_prefix &&
1169 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1172 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1173 if (ost->forced_keyframes)
1174 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1176 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1178 ost->top_field_first = -1;
1179 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1181 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1182 ost->avfilter = av_strdup(filters);
1184 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1190 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1195 AVCodecContext *audio_enc;
1197 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1200 audio_enc = st->codec;
1201 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1203 if (!ost->stream_copy) {
1204 char *sample_fmt = NULL;
1205 const char *filters = "anull";
1207 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1209 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1211 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1212 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1216 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1218 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1220 av_assert1(filters);
1221 ost->avfilter = av_strdup(filters);
1223 /* check for channel mapping for this audio stream */
1224 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1225 AudioChannelMap *map = &o->audio_channel_maps[n];
1226 InputStream *ist = input_streams[ost->source_index];
1227 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1228 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1229 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1230 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1231 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1233 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1234 ost->file_index, ost->st->index);
1242 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1246 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1247 if (!ost->stream_copy) {
1248 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1255 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1257 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1258 ost->stream_copy = 1;
1262 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1266 AVCodecContext *subtitle_enc;
1268 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1270 subtitle_enc = st->codec;
1272 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1274 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1276 if (!ost->stream_copy) {
1277 char *frame_size = NULL;
1279 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1280 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1281 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1289 /* arg format is "output-stream-index:streamid-value". */
1290 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1292 OptionsContext *o = optctx;
1297 av_strlcpy(idx_str, arg, sizeof(idx_str));
1298 p = strchr(idx_str, ':');
1300 av_log(NULL, AV_LOG_FATAL,
1301 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1306 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1307 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1308 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1312 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1314 AVFormatContext *is = ifile->ctx;
1315 AVFormatContext *os = ofile->ctx;
1319 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1321 return AVERROR(ENOMEM);
1324 for (i = 0; i < is->nb_chapters; i++) {
1325 AVChapter *in_ch = is->chapters[i], *out_ch;
1326 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1327 AV_TIME_BASE_Q, in_ch->time_base);
1328 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1329 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1332 if (in_ch->end < ts_off)
1334 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1337 out_ch = av_mallocz(sizeof(AVChapter));
1339 return AVERROR(ENOMEM);
1341 out_ch->id = in_ch->id;
1342 out_ch->time_base = in_ch->time_base;
1343 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1344 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1347 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1349 os->chapters[os->nb_chapters++] = out_ch;
1354 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1357 AVFormatContext *ic = avformat_alloc_context();
1359 ic->interrupt_callback = int_cb;
1360 err = avformat_open_input(&ic, filename, NULL, NULL);
1363 /* copy stream format */
1364 for(i=0;i<ic->nb_streams;i++) {
1368 AVCodecContext *avctx;
1370 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1371 ost = new_output_stream(o, s, codec->type, -1);
1376 // FIXME: a more elegant solution is needed
1377 memcpy(st, ic->streams[i], sizeof(AVStream));
1379 st->info = av_malloc(sizeof(*st->info));
1380 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1382 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1384 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1385 choose_sample_fmt(st, codec);
1386 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1387 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1390 /* ffserver seeking with date=... needs a date reference */
1391 err = parse_option(o, "metadata", "creation_time=now", options);
1393 avformat_close_input(&ic);
1397 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1398 AVFormatContext *oc)
1402 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1403 ofilter->out_tmp->pad_idx)) {
1404 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1405 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1407 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1412 ost->source_index = -1;
1413 ost->filter = ofilter;
1417 if (ost->stream_copy) {
1418 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1419 "which is fed from a complex filtergraph. Filtering and streamcopy "
1420 "cannot be used together.\n", ost->file_index, ost->index);
1424 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1425 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1428 avfilter_inout_free(&ofilter->out_tmp);
1431 static int configure_complex_filters(void)
1435 for (i = 0; i < nb_filtergraphs; i++)
1436 if (!filtergraphs[i]->graph &&
1437 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1442 void opt_output_file(void *optctx, const char *filename)
1444 OptionsContext *o = optctx;
1445 AVFormatContext *oc;
1447 AVOutputFormat *file_oformat;
1451 if (configure_complex_filters() < 0) {
1452 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1456 if (!strcmp(filename, "-"))
1459 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1461 print_error(filename, err);
1464 file_oformat= oc->oformat;
1465 oc->interrupt_callback = int_cb;
1467 /* create streams for all unlabeled output pads */
1468 for (i = 0; i < nb_filtergraphs; i++) {
1469 FilterGraph *fg = filtergraphs[i];
1470 for (j = 0; j < fg->nb_outputs; j++) {
1471 OutputFilter *ofilter = fg->outputs[j];
1473 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1476 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1477 ofilter->out_tmp->pad_idx)) {
1478 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1479 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1480 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1482 init_output_filter(ofilter, o, oc);
1486 if (!strcmp(file_oformat->name, "ffm") &&
1487 av_strstart(filename, "http:", NULL)) {
1489 /* special case for files sent to ffserver: we get the stream
1490 parameters from ffserver */
1491 int err = read_ffserver_streams(o, oc, filename);
1493 print_error(filename, err);
1496 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1497 ost = output_streams[j];
1498 for (i = 0; i < nb_input_streams; i++) {
1499 ist = input_streams[i];
1500 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1502 ost->source_index= i;
1503 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1504 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1506 ist->st->discard = AVDISCARD_NONE;
1511 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));
1515 } else if (!o->nb_stream_maps) {
1516 char *subtitle_codec_name = NULL;
1517 /* pick the "best" stream of each type */
1519 /* video: highest resolution */
1520 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1521 int area = 0, idx = -1;
1522 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1523 for (i = 0; i < nb_input_streams; i++) {
1525 ist = input_streams[i];
1526 new_area = ist->st->codec->width * ist->st->codec->height;
1527 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1529 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1531 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1538 new_video_stream(o, oc, idx);
1541 /* audio: most channels */
1542 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1543 int channels = 0, idx = -1;
1544 for (i = 0; i < nb_input_streams; i++) {
1545 ist = input_streams[i];
1546 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1547 ist->st->codec->channels > channels) {
1548 channels = ist->st->codec->channels;
1553 new_audio_stream(o, oc, idx);
1556 /* subtitles: pick first */
1557 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1558 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1559 for (i = 0; i < nb_input_streams; i++)
1560 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1561 new_subtitle_stream(o, oc, i);
1565 /* do something with data? */
1567 for (i = 0; i < o->nb_stream_maps; i++) {
1568 StreamMap *map = &o->stream_maps[i];
1569 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1574 if (map->linklabel) {
1576 OutputFilter *ofilter = NULL;
1579 for (j = 0; j < nb_filtergraphs; j++) {
1580 fg = filtergraphs[j];
1581 for (k = 0; k < fg->nb_outputs; k++) {
1582 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1583 if (out && !strcmp(out->name, map->linklabel)) {
1584 ofilter = fg->outputs[k];
1591 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1592 "in any defined filter graph.\n", map->linklabel);
1595 init_output_filter(ofilter, o, oc);
1597 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1598 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1600 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1602 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1604 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1607 switch (ist->st->codec->codec_type) {
1608 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1609 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1610 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1611 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1612 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1614 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1615 map->file_index, map->stream_index);
1623 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1624 AVDictionaryEntry *e;
1625 ost = output_streams[i];
1627 if ( ost->stream_copy
1628 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1629 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1630 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1634 /* handle attached files */
1635 for (i = 0; i < o->nb_attachments; i++) {
1637 uint8_t *attachment;
1641 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1642 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1646 if ((len = avio_size(pb)) <= 0) {
1647 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1651 if (!(attachment = av_malloc(len))) {
1652 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1656 avio_read(pb, attachment, len);
1658 ost = new_attachment_stream(o, oc, -1);
1659 ost->stream_copy = 0;
1660 ost->attachment_filename = o->attachments[i];
1661 ost->st->codec->extradata = attachment;
1662 ost->st->codec->extradata_size = len;
1664 p = strrchr(o->attachments[i], '/');
1665 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1669 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1670 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1673 output_files[nb_output_files - 1]->ctx = oc;
1674 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1675 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1676 if (o->recording_time != INT64_MAX)
1677 oc->duration = o->recording_time;
1678 output_files[nb_output_files - 1]->start_time = o->start_time;
1679 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1680 output_files[nb_output_files - 1]->shortest = o->shortest;
1681 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1683 /* check filename in case of an image number is expected */
1684 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1685 if (!av_filename_number_test(oc->filename)) {
1686 print_error(oc->filename, AVERROR(EINVAL));
1691 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1692 /* test if it already exists to avoid losing precious files */
1693 assert_file_overwrite(filename);
1696 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1697 &oc->interrupt_callback,
1698 &output_files[nb_output_files - 1]->opts)) < 0) {
1699 print_error(filename, err);
1704 if (o->mux_preload) {
1706 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1707 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1709 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1712 for (i = 0; i < o->nb_metadata_map; i++) {
1714 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1716 if (in_file_index >= nb_input_files) {
1717 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1720 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1721 in_file_index >= 0 ?
1722 input_files[in_file_index]->ctx : NULL, o);
1726 if (o->chapters_input_file >= nb_input_files) {
1727 if (o->chapters_input_file == INT_MAX) {
1728 /* copy chapters from the first input file that has them*/
1729 o->chapters_input_file = -1;
1730 for (i = 0; i < nb_input_files; i++)
1731 if (input_files[i]->ctx->nb_chapters) {
1732 o->chapters_input_file = i;
1736 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1737 o->chapters_input_file);
1741 if (o->chapters_input_file >= 0)
1742 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1743 !o->metadata_chapters_manual);
1745 /* copy global metadata by default */
1746 if (!o->metadata_global_manual && nb_input_files){
1747 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1748 AV_DICT_DONT_OVERWRITE);
1749 if(o->recording_time != INT64_MAX)
1750 av_dict_set(&oc->metadata, "duration", NULL, 0);
1751 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1753 if (!o->metadata_streams_manual)
1754 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1756 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1758 ist = input_streams[output_streams[i]->source_index];
1759 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1762 /* process manually set metadata */
1763 for (i = 0; i < o->nb_metadata; i++) {
1766 const char *stream_spec;
1767 int index = 0, j, ret = 0;
1769 val = strchr(o->metadata[i].u.str, '=');
1771 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1772 o->metadata[i].u.str);
1777 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1779 for (j = 0; j < oc->nb_streams; j++) {
1780 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1781 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1792 if (index < 0 || index >= oc->nb_chapters) {
1793 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1796 m = &oc->chapters[index]->metadata;
1799 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1802 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1806 reset_options(o, 0);
1809 static int opt_target(void *optctx, const char *opt, const char *arg)
1811 OptionsContext *o = optctx;
1812 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1813 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1815 if (!strncmp(arg, "pal-", 4)) {
1818 } else if (!strncmp(arg, "ntsc-", 5)) {
1821 } else if (!strncmp(arg, "film-", 5)) {
1825 /* Try to determine PAL/NTSC by peeking in the input files */
1826 if (nb_input_files) {
1828 for (j = 0; j < nb_input_files; j++) {
1829 for (i = 0; i < input_files[j]->nb_streams; i++) {
1830 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1831 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1833 fr = c->time_base.den * 1000 / c->time_base.num;
1837 } else if ((fr == 29970) || (fr == 23976)) {
1842 if (norm != UNKNOWN)
1846 if (norm != UNKNOWN)
1847 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1850 if (norm == UNKNOWN) {
1851 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1852 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1853 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1857 if (!strcmp(arg, "vcd")) {
1858 opt_video_codec(o, "c:v", "mpeg1video");
1859 opt_audio_codec(o, "c:a", "mp2");
1860 parse_option(o, "f", "vcd", options);
1862 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1863 parse_option(o, "r", frame_rates[norm], options);
1864 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1866 opt_default(NULL, "b:v", "1150000");
1867 opt_default(NULL, "maxrate", "1150000");
1868 opt_default(NULL, "minrate", "1150000");
1869 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1871 opt_default(NULL, "b:a", "224000");
1872 parse_option(o, "ar", "44100", options);
1873 parse_option(o, "ac", "2", options);
1875 opt_default(NULL, "packetsize", "2324");
1876 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1878 /* We have to offset the PTS, so that it is consistent with the SCR.
1879 SCR starts at 36000, but the first two packs contain only padding
1880 and the first pack from the other stream, respectively, may also have
1881 been written before.
1882 So the real data starts at SCR 36000+3*1200. */
1883 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1884 } else if (!strcmp(arg, "svcd")) {
1886 opt_video_codec(o, "c:v", "mpeg2video");
1887 opt_audio_codec(o, "c:a", "mp2");
1888 parse_option(o, "f", "svcd", options);
1890 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1891 parse_option(o, "r", frame_rates[norm], options);
1892 parse_option(o, "pix_fmt", "yuv420p", options);
1893 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1895 opt_default(NULL, "b:v", "2040000");
1896 opt_default(NULL, "maxrate", "2516000");
1897 opt_default(NULL, "minrate", "0"); // 1145000;
1898 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1899 opt_default(NULL, "scan_offset", "1");
1901 opt_default(NULL, "b:a", "224000");
1902 parse_option(o, "ar", "44100", options);
1904 opt_default(NULL, "packetsize", "2324");
1906 } else if (!strcmp(arg, "dvd")) {
1908 opt_video_codec(o, "c:v", "mpeg2video");
1909 opt_audio_codec(o, "c:a", "ac3");
1910 parse_option(o, "f", "dvd", options);
1912 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1913 parse_option(o, "r", frame_rates[norm], options);
1914 parse_option(o, "pix_fmt", "yuv420p", options);
1915 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1917 opt_default(NULL, "b:v", "6000000");
1918 opt_default(NULL, "maxrate", "9000000");
1919 opt_default(NULL, "minrate", "0"); // 1500000;
1920 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1922 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1923 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1925 opt_default(NULL, "b:a", "448000");
1926 parse_option(o, "ar", "48000", options);
1928 } else if (!strncmp(arg, "dv", 2)) {
1930 parse_option(o, "f", "dv", options);
1932 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1933 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1934 norm == PAL ? "yuv420p" : "yuv411p", options);
1935 parse_option(o, "r", frame_rates[norm], options);
1937 parse_option(o, "ar", "48000", options);
1938 parse_option(o, "ac", "2", options);
1941 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1942 return AVERROR(EINVAL);
1947 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1949 av_free (vstats_filename);
1950 vstats_filename = av_strdup (arg);
1954 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1957 time_t today2 = time(NULL);
1958 struct tm *today = localtime(&today2);
1960 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1962 return opt_vstats_file(NULL, opt, filename);
1965 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1967 OptionsContext *o = optctx;
1968 return parse_option(o, "frames:v", arg, options);
1971 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1973 OptionsContext *o = optctx;
1974 return parse_option(o, "frames:a", arg, options);
1977 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1979 OptionsContext *o = optctx;
1980 return parse_option(o, "frames:d", arg, options);
1983 static int opt_preset(void *optctx, const char *opt, const char *arg)
1985 OptionsContext *o = optctx;
1987 char filename[1000], line[1000], tmp_line[1000];
1988 const char *codec_name = NULL;
1992 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1994 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1995 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1996 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1998 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2002 while (fgets(line, sizeof(line), f)) {
2003 char *key = tmp_line, *value, *endptr;
2005 if (strcspn(line, "#\n\r") == 0)
2007 strcpy(tmp_line, line);
2008 if (!av_strtok(key, "=", &value) ||
2009 !av_strtok(value, "\r\n", &endptr)) {
2010 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2013 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2015 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2016 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2017 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2018 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2019 else if (opt_default(NULL, key, value) < 0) {
2020 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2021 filename, line, key, value);
2031 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2033 OptionsContext *o = optctx;
2034 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2035 int ret = parse_option(o, s, arg, options);
2040 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2042 OptionsContext *o = optctx;
2043 if(!strcmp(opt, "b")){
2044 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2045 return parse_option(o, "b:v", arg, options);
2047 return opt_default(optctx, opt, arg);
2050 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2052 OptionsContext *o = optctx;
2055 if(!strcmp(opt, "qscale")){
2056 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2057 return parse_option(o, "q:v", arg, options);
2059 s = av_asprintf("q%s", opt + 6);
2060 ret = parse_option(o, s, arg, options);
2065 static int opt_profile(void *optctx, const char *opt, const char *arg)
2067 OptionsContext *o = optctx;
2068 if(!strcmp(opt, "profile")){
2069 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2070 return parse_option(o, "profile:v", arg, options);
2072 return opt_default(optctx, opt, arg);
2076 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2078 OptionsContext *o = optctx;
2079 return parse_option(o, "filter:v", arg, options);
2082 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2084 OptionsContext *o = optctx;
2085 return parse_option(o, "filter:a", arg, options);
2088 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2090 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2091 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2092 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2093 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2095 if (video_sync_method == VSYNC_AUTO)
2096 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2100 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2102 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2107 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2109 OptionsContext *o = optctx;
2110 char *tcr = av_asprintf("timecode=%s", arg);
2111 int ret = parse_option(o, "metadata:g", tcr, options);
2113 ret = opt_default(optctx, "gop_timecode", arg);
2118 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2120 OptionsContext *o = optctx;
2121 char layout_str[32];
2124 int ret, channels, ac_str_size;
2127 layout = av_get_channel_layout(arg);
2129 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2130 return AVERROR(EINVAL);
2132 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2133 ret = opt_default(NULL, opt, layout_str);
2137 /* set 'ac' option based on channel layout */
2138 channels = av_get_channel_layout_nb_channels(layout);
2139 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2140 stream_str = strchr(opt, ':');
2141 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2142 ac_str = av_mallocz(ac_str_size);
2144 return AVERROR(ENOMEM);
2145 av_strlcpy(ac_str, "ac", 3);
2147 av_strlcat(ac_str, stream_str, ac_str_size);
2148 ret = parse_option(o, ac_str, layout_str, options);
2154 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2156 OptionsContext *o = optctx;
2157 return parse_option(o, "q:a", arg, options);
2160 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2162 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2163 &nb_filtergraphs, nb_filtergraphs + 1);
2164 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2165 return AVERROR(ENOMEM);
2166 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2167 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2171 void show_help_default(const char *opt, const char *arg)
2173 /* per-file options have at least one of those set */
2174 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2175 int show_advanced = 0, show_avoptions = 0;
2178 if (!strcmp(opt, "long"))
2180 else if (!strcmp(opt, "full"))
2181 show_advanced = show_avoptions = 1;
2183 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2188 printf("Getting help:\n"
2189 " -h -- print basic options\n"
2190 " -h long -- print more options\n"
2191 " -h full -- print all options (including all format and codec specific options, very long)\n"
2192 " See man %s for detailed description of the options.\n"
2193 "\n", program_name);
2195 show_help_options(options, "Print help / information / capabilities:",
2198 show_help_options(options, "Global options (affect whole program "
2199 "instead of just one file:",
2200 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2202 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2203 per_file | OPT_EXIT, 0);
2205 show_help_options(options, "Per-file main options:", 0,
2206 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2207 OPT_EXIT, per_file);
2209 show_help_options(options, "Advanced per-file options:",
2210 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2212 show_help_options(options, "Video options:",
2213 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2215 show_help_options(options, "Advanced Video options:",
2216 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2218 show_help_options(options, "Audio options:",
2219 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2221 show_help_options(options, "Advanced Audio options:",
2222 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2223 show_help_options(options, "Subtitle options:",
2224 OPT_SUBTITLE, 0, 0);
2227 if (show_avoptions) {
2228 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2229 show_help_children(avcodec_get_class(), flags);
2230 show_help_children(avformat_get_class(), flags);
2231 show_help_children(sws_get_class(), flags);
2232 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2233 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2237 void show_usage(void)
2239 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2240 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2241 av_log(NULL, AV_LOG_INFO, "\n");
2245 static int opt_progress(void *optctx, const char *opt, const char *arg)
2247 AVIOContext *avio = NULL;
2250 if (!strcmp(arg, "-"))
2252 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2254 av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2255 arg, av_err2str(ret));
2258 progress_avio = avio;
2262 #define OFFSET(x) offsetof(OptionsContext, x)
2263 const OptionDef options[] = {
2265 #include "cmdutils_common_opts.h"
2266 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2267 "force format", "fmt" },
2268 { "i", HAS_ARG | OPT_PERFILE, { .func_arg = opt_input_file },
2269 "input file name", "filename" },
2270 { "y", OPT_BOOL, { &file_overwrite },
2271 "overwrite output files" },
2272 { "n", OPT_BOOL, { &no_file_overwrite },
2273 "do not overwrite output files" },
2274 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2275 "codec name", "codec" },
2276 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2277 "codec name", "codec" },
2278 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2279 "preset name", "preset" },
2280 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2281 "set input stream mapping",
2282 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2283 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2284 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2285 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2286 "set metadata information of outfile from infile",
2287 "outfile[,metadata]:infile[,metadata]" },
2288 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2289 "set chapters mapping", "input_file_index" },
2290 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2291 "record or transcode \"duration\" seconds of audio/video",
2293 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2294 "set the limit file size in bytes", "limit_size" },
2295 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2296 "set the start time offset", "time_off" },
2297 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2298 "set the input ts offset", "time_off" },
2299 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2300 "set the input ts scale", "scale" },
2301 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2302 "set the recording timestamp ('now' to set the current time)", "time" },
2303 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2304 "add metadata", "string=string" },
2305 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2306 "set the number of data frames to record", "number" },
2307 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2308 "add timings for benchmarking" },
2309 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2310 "add timings for each task" },
2311 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2312 "write program-readable progress information", "url" },
2313 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2314 "enable or disable interaction on standard input" },
2315 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2316 "set max runtime in seconds", "limit" },
2317 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2318 "dump each input packet" },
2319 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2320 "when dumping packets, also dump the payload" },
2321 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2322 "read input at native frame rate", "" },
2323 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2324 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2325 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2326 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2327 "video sync method", "" },
2328 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2329 "audio sync method", "" },
2330 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2331 "audio drift threshold", "threshold" },
2332 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2333 "copy timestamps" },
2334 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2335 "copy input stream time base when stream copying", "mode" },
2336 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2337 "finish encoding within shortest input" },
2338 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2339 "timestamp discontinuity delta threshold", "threshold" },
2340 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2341 "timestamp error delta threshold", "threshold" },
2342 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2343 "exit on error", "error" },
2344 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2345 "copy initial non-keyframes" },
2346 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2347 "copy or discard frames before start time" },
2348 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2349 "set the number of frames to record", "number" },
2350 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2351 "force codec tag/fourcc", "fourcc/tag" },
2352 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2353 "use fixed quality scale (VBR)", "q" },
2354 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2355 "use fixed quality scale (VBR)", "q" },
2356 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2357 "set profile", "profile" },
2358 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2359 "set stream filterchain", "filter_list" },
2360 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2361 "reinit filtergraph on input parameter changes", "" },
2362 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2363 "create a complex filtergraph", "graph_description" },
2364 { "stats", OPT_BOOL, { &print_stats },
2365 "print progress report during encoding", },
2366 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2367 "add an attachment to the output file", "filename" },
2368 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2369 "extract an attachment into a file", "filename" },
2370 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2371 "print timestamp debugging info" },
2374 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2375 "set the number of video frames to record", "number" },
2376 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2377 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2378 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2379 "set frame size (WxH or abbreviation)", "size" },
2380 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2381 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2382 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2383 "set pixel format", "format" },
2384 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2385 "set the number of bits per raw sample", "number" },
2386 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2387 "Removed, use the crop filter instead", "size" },
2388 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2389 "Removed, use the crop filter instead", "size" },
2390 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2391 "Removed, use the crop filter instead", "size" },
2392 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2393 "Removed, use the crop filter instead", "size" },
2394 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2395 "Removed, use the pad filter instead", "size" },
2396 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2397 "Removed, use the pad filter instead", "size" },
2398 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2399 "Removed, use the pad filter instead", "size" },
2400 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2401 "Removed, use the pad filter instead", "size" },
2402 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2403 "Removed, use the pad filter instead", "color" },
2404 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2405 "deprecated use -g 1" },
2406 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2408 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2409 "discard threshold", "n" },
2410 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2411 "rate control override for specific intervals", "override" },
2412 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2413 "force video codec ('copy' to copy stream)", "codec" },
2414 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2416 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2418 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2419 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2420 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2421 "select the pass number (1 to 3)", "n" },
2422 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2423 "select two pass log file name prefix", "prefix" },
2424 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2425 "this option is deprecated, use the yadif filter instead" },
2426 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2427 "calculate PSNR of compressed frames" },
2428 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2429 "dump video coding statistics to file" },
2430 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2431 "dump video coding statistics to file", "file" },
2432 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2433 "video filters", "filter list" },
2434 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2435 "specify intra matrix coeffs", "matrix" },
2436 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2437 "specify inter matrix coeffs", "matrix" },
2438 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2439 "top=1/bottom=0/auto=-1 field first", "" },
2440 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2441 "intra_dc_precision", "precision" },
2442 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2443 "force video tag/fourcc", "fourcc/tag" },
2444 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2445 "show QP histogram" },
2446 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2447 "force the selected framerate, disable the best supported framerate selection" },
2448 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2449 "set the value of an outfile streamid", "streamIndex:value" },
2450 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2451 { .off = OFFSET(forced_key_frames) },
2452 "force key frames at specified timestamps", "timestamps" },
2453 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2454 "video bitrate (please use -b:v)", "bitrate" },
2457 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2458 "set the number of audio frames to record", "number" },
2459 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2460 "set audio quality (codec-specific)", "quality", },
2461 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2462 "set audio sampling rate (in Hz)", "rate" },
2463 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2464 "set number of audio channels", "channels" },
2465 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2467 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2468 "force audio codec ('copy' to copy stream)", "codec" },
2469 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2470 "force audio tag/fourcc", "fourcc/tag" },
2471 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2472 "change audio volume (256=normal)" , "volume" },
2473 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2474 "set sample format", "format" },
2475 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2476 "set channel layout", "layout" },
2477 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2478 "audio filters", "filter list" },
2480 /* subtitle options */
2481 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2482 "disable subtitle" },
2483 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2484 "force subtitle codec ('copy' to copy stream)", "codec" },
2485 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2486 , "force subtitle tag/fourcc", "fourcc/tag" },
2487 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2488 "fix subtitles duration" },
2491 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2492 "deprecated, use -channel", "channel" },
2493 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2494 "deprecated, use -standard", "standard" },
2495 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2498 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2499 "set the maximum demux-decode delay", "seconds" },
2500 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2501 "set the initial demux-decode delay", "seconds" },
2503 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2504 "A comma-separated list of bitstream filters", "bitstream_filters" },
2505 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2506 "deprecated", "audio bitstream_filters" },
2507 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2508 "deprecated", "video bitstream_filters" },
2510 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2511 "set the audio options to the indicated preset", "preset" },
2512 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2513 "set the video options to the indicated preset", "preset" },
2514 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2515 "set the subtitle options to the indicated preset", "preset" },
2516 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2517 "set options from indicated preset file", "filename" },
2518 /* data codec support */
2519 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2520 "force data codec ('copy' to copy stream)", "codec" },
2521 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2524 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2525 "generic catch all option", "" },