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 static int64_t recording_time = INT64_MAX;
100 static void uninit_options(OptionsContext *o, int is_input)
102 const OptionDef *po = options;
105 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
107 void *dst = (uint8_t*)o + po->u.off;
109 if (po->flags & OPT_SPEC) {
110 SpecifierOpt **so = dst;
111 int i, *count = (int*)(so + 1);
112 for (i = 0; i < *count; i++) {
113 av_freep(&(*so)[i].specifier);
114 if (po->flags & OPT_STRING)
115 av_freep(&(*so)[i].u.str);
119 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
124 for (i = 0; i < o->nb_stream_maps; i++)
125 av_freep(&o->stream_maps[i].linklabel);
126 av_freep(&o->stream_maps);
127 av_freep(&o->audio_channel_maps);
128 av_freep(&o->streamid_map);
129 av_freep(&o->attachments);
132 recording_time = o->recording_time;
134 recording_time = INT64_MAX;
137 static void init_options(OptionsContext *o, int is_input)
139 memset(o, 0, sizeof(*o));
141 if (!is_input && recording_time != INT64_MAX) {
142 o->recording_time = recording_time;
143 av_log(NULL, AV_LOG_WARNING,
144 "-t is not an input option, keeping it for the next output;"
145 " consider fixing your command line.\n");
147 o->recording_time = INT64_MAX;
148 o->stop_time = INT64_MAX;
149 o->mux_max_delay = 0.7;
150 o->limit_filesize = UINT64_MAX;
151 o->chapters_input_file = INT_MAX;
154 static int opt_sameq(void *optctx, const char *opt, const char *arg)
156 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
157 "If you are looking for an option to preserve the quality (which is not "
158 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
160 return AVERROR(EINVAL);
163 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
165 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
166 return opt_default(optctx, "channel", arg);
169 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
171 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
172 return opt_default(optctx, "standard", arg);
175 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
177 OptionsContext *o = optctx;
178 return parse_option(o, "codec:a", arg, options);
181 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
183 OptionsContext *o = optctx;
184 return parse_option(o, "codec:v", arg, options);
187 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
189 OptionsContext *o = optctx;
190 return parse_option(o, "codec:s", arg, options);
193 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
195 OptionsContext *o = optctx;
196 return parse_option(o, "codec:d", arg, options);
199 static int opt_map(void *optctx, const char *opt, const char *arg)
201 OptionsContext *o = optctx;
203 int i, negative = 0, file_idx;
204 int sync_file_idx = -1, sync_stream_idx = 0;
212 map = av_strdup(arg);
214 /* parse sync stream first, just pick first matching stream */
215 if (sync = strchr(map, ',')) {
217 sync_file_idx = strtol(sync + 1, &sync, 0);
218 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
219 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
224 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
225 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
226 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
230 if (i == input_files[sync_file_idx]->nb_streams) {
231 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
232 "match any streams.\n", arg);
239 /* this mapping refers to lavfi output */
240 const char *c = map + 1;
241 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
242 m = &o->stream_maps[o->nb_stream_maps - 1];
243 m->linklabel = av_get_token(&c, "]");
245 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
249 file_idx = strtol(map, &p, 0);
250 if (file_idx >= nb_input_files || file_idx < 0) {
251 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
255 /* disable some already defined maps */
256 for (i = 0; i < o->nb_stream_maps; i++) {
257 m = &o->stream_maps[i];
258 if (file_idx == m->file_index &&
259 check_stream_specifier(input_files[m->file_index]->ctx,
260 input_files[m->file_index]->ctx->streams[m->stream_index],
261 *p == ':' ? p + 1 : p) > 0)
265 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
266 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
267 *p == ':' ? p + 1 : p) <= 0)
269 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
270 m = &o->stream_maps[o->nb_stream_maps - 1];
272 m->file_index = file_idx;
275 if (sync_file_idx >= 0) {
276 m->sync_file_index = sync_file_idx;
277 m->sync_stream_index = sync_stream_idx;
279 m->sync_file_index = file_idx;
280 m->sync_stream_index = i;
286 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
294 static int opt_attach(void *optctx, const char *opt, const char *arg)
296 OptionsContext *o = optctx;
297 GROW_ARRAY(o->attachments, o->nb_attachments);
298 o->attachments[o->nb_attachments - 1] = arg;
302 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
304 OptionsContext *o = optctx;
309 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
310 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
312 /* muted channel syntax */
313 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
314 if ((n == 1 || n == 3) && m->channel_idx == -1) {
315 m->file_idx = m->stream_idx = -1;
317 m->ofile_idx = m->ostream_idx = -1;
322 n = sscanf(arg, "%d.%d.%d:%d.%d",
323 &m->file_idx, &m->stream_idx, &m->channel_idx,
324 &m->ofile_idx, &m->ostream_idx);
326 if (n != 3 && n != 5) {
327 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
328 "[file.stream.channel|-1][:syncfile:syncstream]\n");
332 if (n != 5) // only file.stream.channel specified
333 m->ofile_idx = m->ostream_idx = -1;
336 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
337 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
341 if (m->stream_idx < 0 ||
342 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
343 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
344 m->file_idx, m->stream_idx);
347 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
348 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
349 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
350 m->file_idx, m->stream_idx);
353 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
354 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
355 m->file_idx, m->stream_idx, m->channel_idx);
362 * Parse a metadata specifier passed as 'arg' parameter.
363 * @param arg metadata string to parse
364 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
365 * @param index for type c/p, chapter/program index is written here
366 * @param stream_spec for type s, the stream specifier is written here
368 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
376 if (*(++arg) && *arg != ':') {
377 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
380 *stream_spec = *arg == ':' ? arg + 1 : "";
385 *index = strtol(++arg, NULL, 0);
388 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
395 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
397 AVDictionary **meta_in = NULL;
398 AVDictionary **meta_out = NULL;
400 char type_in, type_out;
401 const char *istream_spec = NULL, *ostream_spec = NULL;
402 int idx_in = 0, idx_out = 0;
404 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
405 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
408 if (type_out == 'g' || !*outspec)
409 o->metadata_global_manual = 1;
410 if (type_out == 's' || !*outspec)
411 o->metadata_streams_manual = 1;
412 if (type_out == 'c' || !*outspec)
413 o->metadata_chapters_manual = 1;
417 if (type_in == 'g' || type_out == 'g')
418 o->metadata_global_manual = 1;
419 if (type_in == 's' || type_out == 's')
420 o->metadata_streams_manual = 1;
421 if (type_in == 'c' || type_out == 'c')
422 o->metadata_chapters_manual = 1;
424 /* ic is NULL when just disabling automatic mappings */
428 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
429 if ((index) < 0 || (index) >= (nb_elems)) {\
430 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
435 #define SET_DICT(type, meta, context, index)\
438 meta = &context->metadata;\
441 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
442 meta = &context->chapters[index]->metadata;\
445 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
446 meta = &context->programs[index]->metadata;\
449 break; /* handled separately below */ \
450 default: av_assert0(0);\
453 SET_DICT(type_in, meta_in, ic, idx_in);
454 SET_DICT(type_out, meta_out, oc, idx_out);
456 /* for input streams choose first matching stream */
457 if (type_in == 's') {
458 for (i = 0; i < ic->nb_streams; i++) {
459 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
460 meta_in = &ic->streams[i]->metadata;
466 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
471 if (type_out == 's') {
472 for (i = 0; i < oc->nb_streams; i++) {
473 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
474 meta_out = &oc->streams[i]->metadata;
475 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
480 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
485 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
487 OptionsContext *o = optctx;
489 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
490 struct tm time = *gmtime((time_t*)&recording_timestamp);
491 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
492 parse_option(o, "metadata", buf, options);
494 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
495 "tag instead.\n", opt);
499 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
501 const AVCodecDescriptor *desc;
502 const char *codec_string = encoder ? "encoder" : "decoder";
506 avcodec_find_encoder_by_name(name) :
507 avcodec_find_decoder_by_name(name);
509 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
510 codec = encoder ? avcodec_find_encoder(desc->id) :
511 avcodec_find_decoder(desc->id);
513 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
514 codec_string, codec->name, desc->name);
518 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
521 if (codec->type != type) {
522 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
528 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
530 char *codec_name = NULL;
532 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
534 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
535 st->codec->codec_id = codec->id;
538 return avcodec_find_decoder(st->codec->codec_id);
541 /* Add all the streams from the given input file to the global
542 * list of input streams. */
543 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
546 char *next, *codec_tag = NULL;
548 for (i = 0; i < ic->nb_streams; i++) {
549 AVStream *st = ic->streams[i];
550 AVCodecContext *dec = st->codec;
551 InputStream *ist = av_mallocz(sizeof(*ist));
552 char *framerate = NULL;
557 GROW_ARRAY(input_streams, nb_input_streams);
558 input_streams[nb_input_streams - 1] = ist;
561 ist->file_index = nb_input_files;
563 st->discard = AVDISCARD_ALL;
566 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
568 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
570 uint32_t tag = strtol(codec_tag, &next, 0);
572 tag = AV_RL32(codec_tag);
573 st->codec->codec_tag = tag;
576 ist->dec = choose_decoder(o, ic, st);
577 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
579 ist->reinit_filters = -1;
580 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
582 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
584 switch (dec->codec_type) {
585 case AVMEDIA_TYPE_VIDEO:
587 ist->dec = avcodec_find_decoder(dec->codec_id);
589 dec->flags |= CODEC_FLAG_EMU_EDGE;
592 ist->resample_height = dec->height;
593 ist->resample_width = dec->width;
594 ist->resample_pix_fmt = dec->pix_fmt;
596 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
597 if (framerate && av_parse_video_rate(&ist->framerate,
599 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
604 ist->top_field_first = -1;
605 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
608 case AVMEDIA_TYPE_AUDIO:
609 ist->guess_layout_max = INT_MAX;
610 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
611 guess_input_channel_layout(ist);
613 ist->resample_sample_fmt = dec->sample_fmt;
614 ist->resample_sample_rate = dec->sample_rate;
615 ist->resample_channels = dec->channels;
616 ist->resample_channel_layout = dec->channel_layout;
619 case AVMEDIA_TYPE_DATA:
620 case AVMEDIA_TYPE_SUBTITLE:
622 ist->dec = avcodec_find_decoder(dec->codec_id);
623 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
625 case AVMEDIA_TYPE_ATTACHMENT:
626 case AVMEDIA_TYPE_UNKNOWN:
634 static void assert_file_overwrite(const char *filename)
636 if ((!file_overwrite || no_file_overwrite) &&
637 (strchr(filename, ':') == NULL || filename[1] == ':' ||
638 av_strstart(filename, "file:", NULL))) {
639 if (avio_check(filename, 0) == 0) {
640 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
641 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
644 signal(SIGINT, SIG_DFL);
646 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
652 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
659 static void dump_attachment(AVStream *st, const char *filename)
662 AVIOContext *out = NULL;
663 AVDictionaryEntry *e;
665 if (!st->codec->extradata_size) {
666 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
667 nb_input_files - 1, st->index);
670 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
673 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
674 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
678 assert_file_overwrite(filename);
680 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
681 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
686 avio_write(out, st->codec->extradata, st->codec->extradata_size);
691 static int open_input_file(OptionsContext *o, const char *filename)
694 AVInputFormat *file_iformat = NULL;
699 int orig_nb_streams; // number of streams before avformat_find_stream_info
700 char * video_codec_name = NULL;
701 char * audio_codec_name = NULL;
702 char *subtitle_codec_name = NULL;
705 if (!(file_iformat = av_find_input_format(o->format))) {
706 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
711 if (!strcmp(filename, "-"))
714 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
715 strcmp(filename, "/dev/stdin");
717 /* get default parameters from command line */
718 ic = avformat_alloc_context();
720 print_error(filename, AVERROR(ENOMEM));
723 if (o->nb_audio_sample_rate) {
724 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
725 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
727 if (o->nb_audio_channels) {
728 /* because we set audio_channels based on both the "ac" and
729 * "channel_layout" options, we need to check that the specified
730 * demuxer actually has the "channels" option before setting it */
731 if (file_iformat && file_iformat->priv_class &&
732 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
733 AV_OPT_SEARCH_FAKE_OBJ)) {
734 snprintf(buf, sizeof(buf), "%d",
735 o->audio_channels[o->nb_audio_channels - 1].u.i);
736 av_dict_set(&o->g->format_opts, "channels", buf, 0);
739 if (o->nb_frame_rates) {
740 /* set the format-level framerate option;
741 * this is important for video grabbers, e.g. x11 */
742 if (file_iformat && file_iformat->priv_class &&
743 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
744 AV_OPT_SEARCH_FAKE_OBJ)) {
745 av_dict_set(&o->g->format_opts, "framerate",
746 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
749 if (o->nb_frame_sizes) {
750 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
752 if (o->nb_frame_pix_fmts)
753 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
755 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
756 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
757 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
759 ic->video_codec_id = video_codec_name ?
760 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
761 ic->audio_codec_id = audio_codec_name ?
762 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
763 ic->subtitle_codec_id= subtitle_codec_name ?
764 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
765 ic->flags |= AVFMT_FLAG_NONBLOCK;
766 ic->interrupt_callback = int_cb;
768 /* open the input file with generic avformat function */
769 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
771 print_error(filename, err);
774 assert_avoptions(o->g->format_opts);
776 /* apply forced codec ids */
777 for (i = 0; i < ic->nb_streams; i++)
778 choose_decoder(o, ic, ic->streams[i]);
780 /* Set AVCodecContext options for avformat_find_stream_info */
781 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
782 orig_nb_streams = ic->nb_streams;
784 /* If not enough info to get the stream parameters, we decode the
785 first frames to get it. (used in mpeg case for example) */
786 ret = avformat_find_stream_info(ic, opts);
788 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
789 avformat_close_input(&ic);
793 timestamp = o->start_time;
794 /* add the stream start time */
795 if (ic->start_time != AV_NOPTS_VALUE)
796 timestamp += ic->start_time;
798 /* if seeking requested, we execute it */
799 if (o->start_time != 0) {
800 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
802 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
803 filename, (double)timestamp / AV_TIME_BASE);
807 /* update the current parameters so that they match the one of the input stream */
808 add_input_streams(o, ic);
810 /* dump the file content */
811 av_dump_format(ic, nb_input_files, filename, 0);
813 GROW_ARRAY(input_files, nb_input_files);
814 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
817 input_files[nb_input_files - 1]->ctx = ic;
818 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
819 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
820 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
821 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
823 for (i = 0; i < o->nb_dump_attachment; i++) {
826 for (j = 0; j < ic->nb_streams; j++) {
827 AVStream *st = ic->streams[j];
829 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
830 dump_attachment(st, o->dump_attachment[i].u.str);
834 for (i = 0; i < orig_nb_streams; i++)
835 av_dict_free(&opts[i]);
841 static uint8_t *get_line(AVIOContext *s)
847 if (avio_open_dyn_buf(&line) < 0) {
848 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
852 while ((c = avio_r8(s)) && c != '\n')
855 avio_close_dyn_buf(line, &buf);
860 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
864 const char *base[3] = { getenv("AVCONV_DATADIR"),
869 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
873 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
874 i != 1 ? "" : "/.avconv", codec_name, preset_name);
875 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
878 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
879 i != 1 ? "" : "/.avconv", preset_name);
880 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
886 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
888 char *codec_name = NULL;
890 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
892 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
893 NULL, ost->st->codec->codec_type);
894 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
895 } else if (!strcmp(codec_name, "copy"))
896 ost->stream_copy = 1;
898 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
899 ost->st->codec->codec_id = ost->enc->id;
903 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
906 AVStream *st = avformat_new_stream(oc, NULL);
907 int idx = oc->nb_streams - 1, ret = 0;
908 char *bsf = NULL, *next, *codec_tag = NULL;
909 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
913 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
917 if (oc->nb_streams - 1 < o->nb_streamid_map)
918 st->id = o->streamid_map[oc->nb_streams - 1];
920 GROW_ARRAY(output_streams, nb_output_streams);
921 if (!(ost = av_mallocz(sizeof(*ost))))
923 output_streams[nb_output_streams - 1] = ost;
925 ost->file_index = nb_output_files;
928 st->codec->codec_type = type;
929 choose_encoder(o, oc, ost);
931 AVIOContext *s = NULL;
932 char *buf = NULL, *arg = NULL, *preset = NULL;
934 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
936 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
937 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
940 if (!buf[0] || buf[0] == '#') {
944 if (!(arg = strchr(buf, '='))) {
945 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
949 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
951 } while (!s->eof_reached);
955 av_log(NULL, AV_LOG_FATAL,
956 "Preset %s specified for stream %d:%d, but could not be opened.\n",
957 preset, ost->file_index, ost->index);
961 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
964 avcodec_get_context_defaults3(st->codec, ost->enc);
965 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
967 ost->max_frames = INT64_MAX;
968 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
970 ost->copy_prior_start = -1;
971 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
973 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
975 if (next = strchr(bsf, ','))
977 if (!(bsfc = av_bitstream_filter_init(bsf))) {
978 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
982 bsfc_prev->next = bsfc;
984 ost->bitstream_filters = bsfc;
990 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
992 uint32_t tag = strtol(codec_tag, &next, 0);
994 tag = AV_RL32(codec_tag);
995 st->codec->codec_tag = tag;
998 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1000 st->codec->flags |= CODEC_FLAG_QSCALE;
1001 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1004 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1005 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1007 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1009 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1010 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1011 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1013 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1015 ost->source_index = source_index;
1016 if (source_index >= 0) {
1017 ost->sync_ist = input_streams[source_index];
1018 input_streams[source_index]->discard = 0;
1019 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1025 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1028 const char *p = str;
1035 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1042 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1046 AVCodecContext *video_enc;
1047 char *frame_rate = NULL;
1049 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1051 video_enc = st->codec;
1053 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1054 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1055 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1059 if (!ost->stream_copy) {
1060 const char *p = NULL;
1061 char *frame_size = NULL;
1062 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1063 char *intra_matrix = NULL, *inter_matrix = NULL;
1064 const char *filters = "null";
1068 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1069 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1070 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1074 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1075 if (frame_aspect_ratio) {
1077 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1078 q.num <= 0 || q.den <= 0) {
1079 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1082 ost->frame_aspect_ratio = av_q2d(q);
1085 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1086 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1087 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1088 ost->keep_pix_fmt = 1;
1089 if (!*++frame_pix_fmt)
1090 frame_pix_fmt = NULL;
1092 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1093 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1096 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1099 video_enc->gop_size = 0;
1100 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1102 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1103 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1106 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1108 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1110 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1111 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1114 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1117 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1118 for (i = 0; p; i++) {
1120 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1122 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1125 /* FIXME realloc failure */
1126 video_enc->rc_override =
1127 av_realloc(video_enc->rc_override,
1128 sizeof(RcOverride) * (i + 1));
1129 video_enc->rc_override[i].start_frame = start;
1130 video_enc->rc_override[i].end_frame = end;
1132 video_enc->rc_override[i].qscale = q;
1133 video_enc->rc_override[i].quality_factor = 1.0;
1136 video_enc->rc_override[i].qscale = 0;
1137 video_enc->rc_override[i].quality_factor = -q/100.0;
1142 video_enc->rc_override_count = i;
1143 video_enc->intra_dc_precision = intra_dc_precision - 8;
1146 video_enc->flags|= CODEC_FLAG_PSNR;
1149 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1152 video_enc->flags |= CODEC_FLAG_PASS1;
1153 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1156 video_enc->flags |= CODEC_FLAG_PASS2;
1157 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1161 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1162 if (ost->logfile_prefix &&
1163 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1166 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1167 if (ost->forced_keyframes)
1168 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1170 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1172 ost->top_field_first = -1;
1173 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1175 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1176 ost->avfilter = av_strdup(filters);
1178 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1184 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1189 AVCodecContext *audio_enc;
1191 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1194 audio_enc = st->codec;
1195 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1197 if (!ost->stream_copy) {
1198 char *sample_fmt = NULL;
1199 const char *filters = "anull";
1201 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1203 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1205 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1206 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1210 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1212 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1214 av_assert1(filters);
1215 ost->avfilter = av_strdup(filters);
1217 /* check for channel mapping for this audio stream */
1218 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1219 AudioChannelMap *map = &o->audio_channel_maps[n];
1220 InputStream *ist = input_streams[ost->source_index];
1221 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1222 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1223 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1224 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1225 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1227 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1228 ost->file_index, ost->st->index);
1236 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1240 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1241 if (!ost->stream_copy) {
1242 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1249 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1251 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1252 ost->stream_copy = 1;
1256 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1260 AVCodecContext *subtitle_enc;
1262 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1264 subtitle_enc = st->codec;
1266 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1268 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1270 if (!ost->stream_copy) {
1271 char *frame_size = NULL;
1273 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1274 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1275 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1283 /* arg format is "output-stream-index:streamid-value". */
1284 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1286 OptionsContext *o = optctx;
1291 av_strlcpy(idx_str, arg, sizeof(idx_str));
1292 p = strchr(idx_str, ':');
1294 av_log(NULL, AV_LOG_FATAL,
1295 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1300 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1301 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1302 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1306 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1308 AVFormatContext *is = ifile->ctx;
1309 AVFormatContext *os = ofile->ctx;
1313 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1315 return AVERROR(ENOMEM);
1318 for (i = 0; i < is->nb_chapters; i++) {
1319 AVChapter *in_ch = is->chapters[i], *out_ch;
1320 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1321 AV_TIME_BASE_Q, in_ch->time_base);
1322 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1323 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1326 if (in_ch->end < ts_off)
1328 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1331 out_ch = av_mallocz(sizeof(AVChapter));
1333 return AVERROR(ENOMEM);
1335 out_ch->id = in_ch->id;
1336 out_ch->time_base = in_ch->time_base;
1337 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1338 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1341 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1343 os->chapters[os->nb_chapters++] = out_ch;
1348 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1351 AVFormatContext *ic = avformat_alloc_context();
1353 ic->interrupt_callback = int_cb;
1354 err = avformat_open_input(&ic, filename, NULL, NULL);
1357 /* copy stream format */
1358 for(i=0;i<ic->nb_streams;i++) {
1362 AVCodecContext *avctx;
1364 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1365 ost = new_output_stream(o, s, codec->type, -1);
1370 // FIXME: a more elegant solution is needed
1371 memcpy(st, ic->streams[i], sizeof(AVStream));
1373 st->info = av_malloc(sizeof(*st->info));
1374 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1376 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1378 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1379 choose_sample_fmt(st, codec);
1380 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1381 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1384 /* ffserver seeking with date=... needs a date reference */
1385 err = parse_option(o, "metadata", "creation_time=now", options);
1387 avformat_close_input(&ic);
1391 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1392 AVFormatContext *oc)
1396 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1397 ofilter->out_tmp->pad_idx)) {
1398 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1399 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1401 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1406 ost->source_index = -1;
1407 ost->filter = ofilter;
1411 if (ost->stream_copy) {
1412 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1413 "which is fed from a complex filtergraph. Filtering and streamcopy "
1414 "cannot be used together.\n", ost->file_index, ost->index);
1418 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1419 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1422 avfilter_inout_free(&ofilter->out_tmp);
1425 static int configure_complex_filters(void)
1429 for (i = 0; i < nb_filtergraphs; i++)
1430 if (!filtergraphs[i]->graph &&
1431 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1436 static int open_output_file(OptionsContext *o, const char *filename)
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, or was already used elsewhere.\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);
1615 /* handle attached files */
1616 for (i = 0; i < o->nb_attachments; i++) {
1618 uint8_t *attachment;
1622 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1623 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1627 if ((len = avio_size(pb)) <= 0) {
1628 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1632 if (!(attachment = av_malloc(len))) {
1633 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1637 avio_read(pb, attachment, len);
1639 ost = new_attachment_stream(o, oc, -1);
1640 ost->stream_copy = 0;
1641 ost->attachment_filename = o->attachments[i];
1643 ost->st->codec->extradata = attachment;
1644 ost->st->codec->extradata_size = len;
1646 p = strrchr(o->attachments[i], '/');
1647 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1651 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1652 AVDictionaryEntry *e;
1653 ost = output_streams[i];
1655 if ((ost->stream_copy || ost->attachment_filename)
1656 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1657 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1658 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1662 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1663 o->stop_time = INT64_MAX;
1664 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1667 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1668 if (o->stop_time <= o->start_time) {
1669 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1670 o->stop_time = INT64_MAX;
1672 o->recording_time = o->stop_time - o->start_time;
1676 GROW_ARRAY(output_files, nb_output_files);
1677 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1680 output_files[nb_output_files - 1]->ctx = oc;
1681 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1682 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1683 if (o->recording_time != INT64_MAX)
1684 oc->duration = o->recording_time;
1685 output_files[nb_output_files - 1]->start_time = o->start_time;
1686 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1687 output_files[nb_output_files - 1]->shortest = o->shortest;
1688 av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1690 /* check filename in case of an image number is expected */
1691 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1692 if (!av_filename_number_test(oc->filename)) {
1693 print_error(oc->filename, AVERROR(EINVAL));
1698 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1699 /* test if it already exists to avoid losing precious files */
1700 assert_file_overwrite(filename);
1703 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1704 &oc->interrupt_callback,
1705 &output_files[nb_output_files - 1]->opts)) < 0) {
1706 print_error(filename, err);
1709 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1710 assert_file_overwrite(filename);
1712 if (o->mux_preload) {
1714 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1715 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1717 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1720 for (i = 0; i < o->nb_metadata_map; i++) {
1722 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1724 if (in_file_index >= nb_input_files) {
1725 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1728 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1729 in_file_index >= 0 ?
1730 input_files[in_file_index]->ctx : NULL, o);
1734 if (o->chapters_input_file >= nb_input_files) {
1735 if (o->chapters_input_file == INT_MAX) {
1736 /* copy chapters from the first input file that has them*/
1737 o->chapters_input_file = -1;
1738 for (i = 0; i < nb_input_files; i++)
1739 if (input_files[i]->ctx->nb_chapters) {
1740 o->chapters_input_file = i;
1744 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1745 o->chapters_input_file);
1749 if (o->chapters_input_file >= 0)
1750 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1751 !o->metadata_chapters_manual);
1753 /* copy global metadata by default */
1754 if (!o->metadata_global_manual && nb_input_files){
1755 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1756 AV_DICT_DONT_OVERWRITE);
1757 if(o->recording_time != INT64_MAX)
1758 av_dict_set(&oc->metadata, "duration", NULL, 0);
1759 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1761 if (!o->metadata_streams_manual)
1762 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1764 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1766 ist = input_streams[output_streams[i]->source_index];
1767 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1770 /* process manually set metadata */
1771 for (i = 0; i < o->nb_metadata; i++) {
1774 const char *stream_spec;
1775 int index = 0, j, ret = 0;
1777 val = strchr(o->metadata[i].u.str, '=');
1779 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1780 o->metadata[i].u.str);
1785 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1787 for (j = 0; j < oc->nb_streams; j++) {
1788 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1789 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1800 if (index < 0 || index >= oc->nb_chapters) {
1801 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1804 m = &oc->chapters[index]->metadata;
1807 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1810 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1817 static int opt_target(void *optctx, const char *opt, const char *arg)
1819 OptionsContext *o = optctx;
1820 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1821 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1823 if (!strncmp(arg, "pal-", 4)) {
1826 } else if (!strncmp(arg, "ntsc-", 5)) {
1829 } else if (!strncmp(arg, "film-", 5)) {
1833 /* Try to determine PAL/NTSC by peeking in the input files */
1834 if (nb_input_files) {
1836 for (j = 0; j < nb_input_files; j++) {
1837 for (i = 0; i < input_files[j]->nb_streams; i++) {
1838 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1839 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1841 fr = c->time_base.den * 1000 / c->time_base.num;
1845 } else if ((fr == 29970) || (fr == 23976)) {
1850 if (norm != UNKNOWN)
1854 if (norm != UNKNOWN)
1855 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1858 if (norm == UNKNOWN) {
1859 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1860 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1861 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1865 if (!strcmp(arg, "vcd")) {
1866 opt_video_codec(o, "c:v", "mpeg1video");
1867 opt_audio_codec(o, "c:a", "mp2");
1868 parse_option(o, "f", "vcd", options);
1869 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1871 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1872 parse_option(o, "r", frame_rates[norm], options);
1873 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1875 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1876 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1877 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1878 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1880 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1881 parse_option(o, "ar", "44100", options);
1882 parse_option(o, "ac", "2", options);
1884 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1885 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1887 /* We have to offset the PTS, so that it is consistent with the SCR.
1888 SCR starts at 36000, but the first two packs contain only padding
1889 and the first pack from the other stream, respectively, may also have
1890 been written before.
1891 So the real data starts at SCR 36000+3*1200. */
1892 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1893 } else if (!strcmp(arg, "svcd")) {
1895 opt_video_codec(o, "c:v", "mpeg2video");
1896 opt_audio_codec(o, "c:a", "mp2");
1897 parse_option(o, "f", "svcd", options);
1899 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1900 parse_option(o, "r", frame_rates[norm], options);
1901 parse_option(o, "pix_fmt", "yuv420p", options);
1902 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1904 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1905 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1906 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1907 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1908 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1910 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1911 parse_option(o, "ar", "44100", options);
1913 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1915 } else if (!strcmp(arg, "dvd")) {
1917 opt_video_codec(o, "c:v", "mpeg2video");
1918 opt_audio_codec(o, "c:a", "ac3");
1919 parse_option(o, "f", "dvd", options);
1921 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1922 parse_option(o, "r", frame_rates[norm], options);
1923 parse_option(o, "pix_fmt", "yuv420p", options);
1924 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1926 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1927 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1928 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1929 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1931 av_dict_set(&o->g->format_opts, "packetsize", "2048", 0); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1932 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1934 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1935 parse_option(o, "ar", "48000", options);
1937 } else if (!strncmp(arg, "dv", 2)) {
1939 parse_option(o, "f", "dv", options);
1941 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1942 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1943 norm == PAL ? "yuv420p" : "yuv411p", options);
1944 parse_option(o, "r", frame_rates[norm], options);
1946 parse_option(o, "ar", "48000", options);
1947 parse_option(o, "ac", "2", options);
1950 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1951 return AVERROR(EINVAL);
1956 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1958 av_free (vstats_filename);
1959 vstats_filename = av_strdup (arg);
1963 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1966 time_t today2 = time(NULL);
1967 struct tm *today = localtime(&today2);
1969 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1971 return opt_vstats_file(NULL, opt, filename);
1974 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1976 OptionsContext *o = optctx;
1977 return parse_option(o, "frames:v", arg, options);
1980 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1982 OptionsContext *o = optctx;
1983 return parse_option(o, "frames:a", arg, options);
1986 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1988 OptionsContext *o = optctx;
1989 return parse_option(o, "frames:d", arg, options);
1992 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1995 AVDictionary *cbak = codec_opts;
1996 AVDictionary *fbak = format_opts;
2000 ret = opt_default(NULL, opt, arg);
2002 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2003 av_dict_copy(&o->g->format_opts, format_opts, 0);
2004 av_dict_free(&codec_opts);
2005 av_dict_free(&format_opts);
2012 static int opt_preset(void *optctx, const char *opt, const char *arg)
2014 OptionsContext *o = optctx;
2016 char filename[1000], line[1000], tmp_line[1000];
2017 const char *codec_name = NULL;
2021 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2023 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2024 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2025 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2027 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2031 while (fgets(line, sizeof(line), f)) {
2032 char *key = tmp_line, *value, *endptr;
2034 if (strcspn(line, "#\n\r") == 0)
2036 strcpy(tmp_line, line);
2037 if (!av_strtok(key, "=", &value) ||
2038 !av_strtok(value, "\r\n", &endptr)) {
2039 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2042 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2044 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2045 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2046 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2047 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2048 else if (opt_default_new(o, key, value) < 0) {
2049 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2050 filename, line, key, value);
2060 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2062 OptionsContext *o = optctx;
2063 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2064 int ret = parse_option(o, s, arg, options);
2069 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2071 OptionsContext *o = optctx;
2072 if(!strcmp(opt, "b")){
2073 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2074 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2077 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2081 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2083 OptionsContext *o = optctx;
2086 if(!strcmp(opt, "qscale")){
2087 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2088 return parse_option(o, "q:v", arg, options);
2090 s = av_asprintf("q%s", opt + 6);
2091 ret = parse_option(o, s, arg, options);
2096 static int opt_profile(void *optctx, const char *opt, const char *arg)
2098 OptionsContext *o = optctx;
2099 if(!strcmp(opt, "profile")){
2100 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2101 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2104 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2108 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2110 OptionsContext *o = optctx;
2111 return parse_option(o, "filter:v", arg, options);
2114 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2116 OptionsContext *o = optctx;
2117 return parse_option(o, "filter:a", arg, options);
2120 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2122 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2123 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2124 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2125 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2127 if (video_sync_method == VSYNC_AUTO)
2128 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2132 #if FF_API_DEINTERLACE
2133 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2135 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2141 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2143 OptionsContext *o = optctx;
2144 char *tcr = av_asprintf("timecode=%s", arg);
2145 int ret = parse_option(o, "metadata:g", tcr, options);
2147 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2152 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2154 OptionsContext *o = optctx;
2155 char layout_str[32];
2158 int ret, channels, ac_str_size;
2161 layout = av_get_channel_layout(arg);
2163 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2164 return AVERROR(EINVAL);
2166 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2167 ret = opt_default_new(o, opt, layout_str);
2171 /* set 'ac' option based on channel layout */
2172 channels = av_get_channel_layout_nb_channels(layout);
2173 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2174 stream_str = strchr(opt, ':');
2175 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2176 ac_str = av_mallocz(ac_str_size);
2178 return AVERROR(ENOMEM);
2179 av_strlcpy(ac_str, "ac", 3);
2181 av_strlcat(ac_str, stream_str, ac_str_size);
2182 ret = parse_option(o, ac_str, layout_str, options);
2188 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2190 OptionsContext *o = optctx;
2191 return parse_option(o, "q:a", arg, options);
2194 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2196 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2197 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2198 return AVERROR(ENOMEM);
2199 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2200 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2204 void show_help_default(const char *opt, const char *arg)
2206 /* per-file options have at least one of those set */
2207 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2208 int show_advanced = 0, show_avoptions = 0;
2211 if (!strcmp(opt, "long"))
2213 else if (!strcmp(opt, "full"))
2214 show_advanced = show_avoptions = 1;
2216 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2221 printf("Getting help:\n"
2222 " -h -- print basic options\n"
2223 " -h long -- print more options\n"
2224 " -h full -- print all options (including all format and codec specific options, very long)\n"
2225 " See man %s for detailed description of the options.\n"
2226 "\n", program_name);
2228 show_help_options(options, "Print help / information / capabilities:",
2231 show_help_options(options, "Global options (affect whole program "
2232 "instead of just one file:",
2233 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2235 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2236 per_file | OPT_EXIT, 0);
2238 show_help_options(options, "Per-file main options:", 0,
2239 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2240 OPT_EXIT, per_file);
2242 show_help_options(options, "Advanced per-file options:",
2243 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2245 show_help_options(options, "Video options:",
2246 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2248 show_help_options(options, "Advanced Video options:",
2249 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2251 show_help_options(options, "Audio options:",
2252 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2254 show_help_options(options, "Advanced Audio options:",
2255 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2256 show_help_options(options, "Subtitle options:",
2257 OPT_SUBTITLE, 0, 0);
2260 if (show_avoptions) {
2261 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2262 show_help_children(avcodec_get_class(), flags);
2263 show_help_children(avformat_get_class(), flags);
2264 show_help_children(sws_get_class(), flags);
2265 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2266 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2270 void show_usage(void)
2272 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2273 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2274 av_log(NULL, AV_LOG_INFO, "\n");
2282 static const OptionGroupDef groups[] = {
2283 [GROUP_OUTFILE] = { "output file", NULL },
2284 [GROUP_INFILE] = { "input file", "i" },
2287 static int open_files(OptionGroupList *l, const char *inout,
2288 int (*open_file)(OptionsContext*, const char*))
2292 for (i = 0; i < l->nb_groups; i++) {
2293 OptionGroup *g = &l->groups[i];
2296 init_options(&o, !strcmp(inout, "input"));
2299 ret = parse_optgroup(&o, g);
2301 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2302 "%s.\n", inout, g->arg);
2306 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2307 ret = open_file(&o, g->arg);
2308 uninit_options(&o, !strcmp(inout, "input"));
2310 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2314 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2320 int ffmpeg_parse_options(int argc, char **argv)
2322 OptionParseContext octx;
2326 memset(&octx, 0, sizeof(octx));
2328 /* split the commandline into an internal representation */
2329 ret = split_commandline(&octx, argc, argv, options, groups,
2330 FF_ARRAY_ELEMS(groups));
2332 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2336 /* apply global options */
2337 ret = parse_optgroup(NULL, &octx.global_opts);
2339 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2343 /* open input files */
2344 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2346 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2350 /* open output files */
2351 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2353 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2358 uninit_parse_context(&octx);
2360 av_strerror(ret, error, sizeof(error));
2361 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2366 static int opt_progress(void *optctx, const char *opt, const char *arg)
2368 AVIOContext *avio = NULL;
2371 if (!strcmp(arg, "-"))
2373 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2375 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2376 arg, av_err2str(ret));
2379 progress_avio = avio;
2383 #define OFFSET(x) offsetof(OptionsContext, x)
2384 const OptionDef options[] = {
2386 #include "cmdutils_common_opts.h"
2387 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2388 "force format", "fmt" },
2389 { "y", OPT_BOOL, { &file_overwrite },
2390 "overwrite output files" },
2391 { "n", OPT_BOOL, { &no_file_overwrite },
2392 "do not overwrite output files" },
2393 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2394 "codec name", "codec" },
2395 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2396 "codec name", "codec" },
2397 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2398 "preset name", "preset" },
2399 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2400 "set input stream mapping",
2401 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2402 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2403 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2404 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2405 "set metadata information of outfile from infile",
2406 "outfile[,metadata]:infile[,metadata]" },
2407 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2408 "set chapters mapping", "input_file_index" },
2409 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2410 "record or transcode \"duration\" seconds of audio/video",
2412 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(stop_time) },
2413 "record or transcode stop time", "time_stop" },
2414 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2415 "set the limit file size in bytes", "limit_size" },
2416 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2417 "set the start time offset", "time_off" },
2418 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2419 "set the input ts offset", "time_off" },
2420 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2421 "set the input ts scale", "scale" },
2422 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2423 "set the recording timestamp ('now' to set the current time)", "time" },
2424 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2425 "add metadata", "string=string" },
2426 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2427 "set the number of data frames to record", "number" },
2428 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2429 "add timings for benchmarking" },
2430 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2431 "add timings for each task" },
2432 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2433 "write program-readable progress information", "url" },
2434 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2435 "enable or disable interaction on standard input" },
2436 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2437 "set max runtime in seconds", "limit" },
2438 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2439 "dump each input packet" },
2440 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2441 "when dumping packets, also dump the payload" },
2442 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2443 "read input at native frame rate", "" },
2444 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2445 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2446 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2447 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2448 "video sync method", "" },
2449 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2450 "audio sync method", "" },
2451 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2452 "audio drift threshold", "threshold" },
2453 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2454 "copy timestamps" },
2455 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2456 "copy input stream time base when stream copying", "mode" },
2457 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2458 "finish encoding within shortest input" },
2459 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2460 "timestamp discontinuity delta threshold", "threshold" },
2461 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2462 "timestamp error delta threshold", "threshold" },
2463 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2464 "exit on error", "error" },
2465 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2466 "copy initial non-keyframes" },
2467 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2468 "copy or discard frames before start time" },
2469 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2470 "set the number of frames to record", "number" },
2471 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2472 "force codec tag/fourcc", "fourcc/tag" },
2473 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2474 "use fixed quality scale (VBR)", "q" },
2475 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2476 "use fixed quality scale (VBR)", "q" },
2477 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2478 "set profile", "profile" },
2479 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2480 "set stream filtergraph", "filter_graph" },
2481 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2482 "reinit filtergraph on input parameter changes", "" },
2483 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2484 "create a complex filtergraph", "graph_description" },
2485 { "stats", OPT_BOOL, { &print_stats },
2486 "print progress report during encoding", },
2487 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2488 "add an attachment to the output file", "filename" },
2489 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2490 "extract an attachment into a file", "filename" },
2491 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2492 "print timestamp debugging info" },
2495 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2496 "set the number of video frames to record", "number" },
2497 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2498 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2499 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2500 "set frame size (WxH or abbreviation)", "size" },
2501 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2502 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2503 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2504 "set pixel format", "format" },
2505 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2506 "set the number of bits per raw sample", "number" },
2507 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2508 "deprecated use -g 1" },
2509 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2511 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2512 "discard threshold", "n" },
2513 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2514 "rate control override for specific intervals", "override" },
2515 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2516 "force video codec ('copy' to copy stream)", "codec" },
2517 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2519 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2521 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2522 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2523 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2524 "select the pass number (1 to 3)", "n" },
2525 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2526 "select two pass log file name prefix", "prefix" },
2527 #if FF_API_DEINTERLACE
2528 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2529 "this option is deprecated, use the yadif filter instead" },
2531 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2532 "calculate PSNR of compressed frames" },
2533 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2534 "dump video coding statistics to file" },
2535 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2536 "dump video coding statistics to file", "file" },
2537 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2538 "set video filters", "filter_graph" },
2539 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2540 "specify intra matrix coeffs", "matrix" },
2541 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2542 "specify inter matrix coeffs", "matrix" },
2543 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2544 "top=1/bottom=0/auto=-1 field first", "" },
2545 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2546 "intra_dc_precision", "precision" },
2547 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2548 "force video tag/fourcc", "fourcc/tag" },
2549 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2550 "show QP histogram" },
2551 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2552 "force the selected framerate, disable the best supported framerate selection" },
2553 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2554 "set the value of an outfile streamid", "streamIndex:value" },
2555 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2556 { .off = OFFSET(forced_key_frames) },
2557 "force key frames at specified timestamps", "timestamps" },
2558 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2559 "video bitrate (please use -b:v)", "bitrate" },
2562 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2563 "set the number of audio frames to record", "number" },
2564 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2565 "set audio quality (codec-specific)", "quality", },
2566 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2567 "set audio sampling rate (in Hz)", "rate" },
2568 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2569 "set number of audio channels", "channels" },
2570 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2572 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2573 "force audio codec ('copy' to copy stream)", "codec" },
2574 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2575 "force audio tag/fourcc", "fourcc/tag" },
2576 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2577 "change audio volume (256=normal)" , "volume" },
2578 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2579 "set sample format", "format" },
2580 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2581 "set channel layout", "layout" },
2582 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2583 "set audio filters", "filter_graph" },
2584 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(guess_layout_max) },
2585 "set the maximum number of channels to try to guess the channel layout" },
2587 /* subtitle options */
2588 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2589 "disable subtitle" },
2590 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2591 "force subtitle codec ('copy' to copy stream)", "codec" },
2592 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2593 , "force subtitle tag/fourcc", "fourcc/tag" },
2594 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2595 "fix subtitles duration" },
2598 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2599 "deprecated, use -channel", "channel" },
2600 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2601 "deprecated, use -standard", "standard" },
2602 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2605 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2606 "set the maximum demux-decode delay", "seconds" },
2607 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2608 "set the initial demux-decode delay", "seconds" },
2610 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2611 "A comma-separated list of bitstream filters", "bitstream_filters" },
2612 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2613 "deprecated", "audio bitstream_filters" },
2614 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2615 "deprecated", "video bitstream_filters" },
2617 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2618 "set the audio options to the indicated preset", "preset" },
2619 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2620 "set the video options to the indicated preset", "preset" },
2621 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2622 "set the subtitle options to the indicated preset", "preset" },
2623 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2624 "set options from indicated preset file", "filename" },
2625 /* data codec support */
2626 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2627 "force data codec ('copy' to copy stream)", "codec" },
2628 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },