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);
131 recording_time = o->recording_time;
133 recording_time = INT64_MAX;
136 static void init_options(OptionsContext *o, int is_input)
138 memset(o, 0, sizeof(*o));
140 if (!is_input && recording_time != INT64_MAX) {
141 o->recording_time = recording_time;
142 av_log(NULL, AV_LOG_WARNING,
143 "-t is not an input option, keeping it for the next output;"
144 " consider fixing your command line.\n");
146 o->recording_time = INT64_MAX;
147 o->mux_max_delay = 0.7;
148 o->limit_filesize = UINT64_MAX;
149 o->chapters_input_file = INT_MAX;
152 static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
154 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
155 return AVERROR(EINVAL);
158 static int opt_pad(void *optctx, const char *opt, const char *arg)
160 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
164 static int opt_sameq(void *optctx, const char *opt, const char *arg)
166 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
167 "If you are looking for an option to preserve the quality (which is not "
168 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
170 return AVERROR(EINVAL);
173 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
175 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
176 return opt_default(optctx, "channel", arg);
179 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
181 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
182 return opt_default(optctx, "standard", arg);
185 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
187 OptionsContext *o = optctx;
188 return parse_option(o, "codec:a", arg, options);
191 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
193 OptionsContext *o = optctx;
194 return parse_option(o, "codec:v", arg, options);
197 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
199 OptionsContext *o = optctx;
200 return parse_option(o, "codec:s", arg, options);
203 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
205 OptionsContext *o = optctx;
206 return parse_option(o, "codec:d", arg, options);
209 static int opt_map(void *optctx, const char *opt, const char *arg)
211 OptionsContext *o = optctx;
213 int i, negative = 0, file_idx;
214 int sync_file_idx = -1, sync_stream_idx = 0;
222 map = av_strdup(arg);
224 /* parse sync stream first, just pick first matching stream */
225 if (sync = strchr(map, ',')) {
227 sync_file_idx = strtol(sync + 1, &sync, 0);
228 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
229 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
234 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
235 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
236 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
240 if (i == input_files[sync_file_idx]->nb_streams) {
241 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
242 "match any streams.\n", arg);
249 /* this mapping refers to lavfi output */
250 const char *c = map + 1;
251 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
252 m = &o->stream_maps[o->nb_stream_maps - 1];
253 m->linklabel = av_get_token(&c, "]");
255 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
259 file_idx = strtol(map, &p, 0);
260 if (file_idx >= nb_input_files || file_idx < 0) {
261 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
265 /* disable some already defined maps */
266 for (i = 0; i < o->nb_stream_maps; i++) {
267 m = &o->stream_maps[i];
268 if (file_idx == m->file_index &&
269 check_stream_specifier(input_files[m->file_index]->ctx,
270 input_files[m->file_index]->ctx->streams[m->stream_index],
271 *p == ':' ? p + 1 : p) > 0)
275 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
276 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
277 *p == ':' ? p + 1 : p) <= 0)
279 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
280 m = &o->stream_maps[o->nb_stream_maps - 1];
282 m->file_index = file_idx;
285 if (sync_file_idx >= 0) {
286 m->sync_file_index = sync_file_idx;
287 m->sync_stream_index = sync_stream_idx;
289 m->sync_file_index = file_idx;
290 m->sync_stream_index = i;
296 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
304 static int opt_attach(void *optctx, const char *opt, const char *arg)
306 OptionsContext *o = optctx;
307 GROW_ARRAY(o->attachments, o->nb_attachments);
308 o->attachments[o->nb_attachments - 1] = arg;
312 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
314 OptionsContext *o = optctx;
319 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
320 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
322 /* muted channel syntax */
323 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
324 if ((n == 1 || n == 3) && m->channel_idx == -1) {
325 m->file_idx = m->stream_idx = -1;
327 m->ofile_idx = m->ostream_idx = -1;
332 n = sscanf(arg, "%d.%d.%d:%d.%d",
333 &m->file_idx, &m->stream_idx, &m->channel_idx,
334 &m->ofile_idx, &m->ostream_idx);
336 if (n != 3 && n != 5) {
337 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
338 "[file.stream.channel|-1][:syncfile:syncstream]\n");
342 if (n != 5) // only file.stream.channel specified
343 m->ofile_idx = m->ostream_idx = -1;
346 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
347 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
351 if (m->stream_idx < 0 ||
352 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
353 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
354 m->file_idx, m->stream_idx);
357 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
358 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
359 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
360 m->file_idx, m->stream_idx);
363 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
364 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
365 m->file_idx, m->stream_idx, m->channel_idx);
372 * Parse a metadata specifier passed as 'arg' parameter.
373 * @param arg metadata string to parse
374 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
375 * @param index for type c/p, chapter/program index is written here
376 * @param stream_spec for type s, the stream specifier is written here
378 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
386 if (*(++arg) && *arg != ':') {
387 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
390 *stream_spec = *arg == ':' ? arg + 1 : "";
395 *index = strtol(++arg, NULL, 0);
398 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
405 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
407 AVDictionary **meta_in = NULL;
408 AVDictionary **meta_out = NULL;
410 char type_in, type_out;
411 const char *istream_spec = NULL, *ostream_spec = NULL;
412 int idx_in = 0, idx_out = 0;
414 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
415 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
418 if (type_out == 'g' || !*outspec)
419 o->metadata_global_manual = 1;
420 if (type_out == 's' || !*outspec)
421 o->metadata_streams_manual = 1;
422 if (type_out == 'c' || !*outspec)
423 o->metadata_chapters_manual = 1;
427 if (type_in == 'g' || type_out == 'g')
428 o->metadata_global_manual = 1;
429 if (type_in == 's' || type_out == 's')
430 o->metadata_streams_manual = 1;
431 if (type_in == 'c' || type_out == 'c')
432 o->metadata_chapters_manual = 1;
434 /* ic is NULL when just disabling automatic mappings */
438 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
439 if ((index) < 0 || (index) >= (nb_elems)) {\
440 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
445 #define SET_DICT(type, meta, context, index)\
448 meta = &context->metadata;\
451 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
452 meta = &context->chapters[index]->metadata;\
455 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
456 meta = &context->programs[index]->metadata;\
459 break; /* handled separately below */ \
460 default: av_assert0(0);\
463 SET_DICT(type_in, meta_in, ic, idx_in);
464 SET_DICT(type_out, meta_out, oc, idx_out);
466 /* for input streams choose first matching stream */
467 if (type_in == 's') {
468 for (i = 0; i < ic->nb_streams; i++) {
469 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
470 meta_in = &ic->streams[i]->metadata;
476 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
481 if (type_out == 's') {
482 for (i = 0; i < oc->nb_streams; i++) {
483 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
484 meta_out = &oc->streams[i]->metadata;
485 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
490 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
495 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
497 OptionsContext *o = optctx;
499 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
500 struct tm time = *gmtime((time_t*)&recording_timestamp);
501 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
502 parse_option(o, "metadata", buf, options);
504 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
505 "tag instead.\n", opt);
509 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
511 const AVCodecDescriptor *desc;
512 const char *codec_string = encoder ? "encoder" : "decoder";
516 avcodec_find_encoder_by_name(name) :
517 avcodec_find_decoder_by_name(name);
519 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
520 codec = encoder ? avcodec_find_encoder(desc->id) :
521 avcodec_find_decoder(desc->id);
523 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
524 codec_string, codec->name, desc->name);
528 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
531 if (codec->type != type) {
532 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
538 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
540 char *codec_name = NULL;
542 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
544 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
545 st->codec->codec_id = codec->id;
548 return avcodec_find_decoder(st->codec->codec_id);
551 /* Add all the streams from the given input file to the global
552 * list of input streams. */
553 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
556 char *next, *codec_tag = NULL;
558 for (i = 0; i < ic->nb_streams; i++) {
559 AVStream *st = ic->streams[i];
560 AVCodecContext *dec = st->codec;
561 InputStream *ist = av_mallocz(sizeof(*ist));
562 char *framerate = NULL;
567 GROW_ARRAY(input_streams, nb_input_streams);
568 input_streams[nb_input_streams - 1] = ist;
571 ist->file_index = nb_input_files;
573 st->discard = AVDISCARD_ALL;
576 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
578 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
580 uint32_t tag = strtol(codec_tag, &next, 0);
582 tag = AV_RL32(codec_tag);
583 st->codec->codec_tag = tag;
586 ist->dec = choose_decoder(o, ic, st);
587 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
589 ist->reinit_filters = -1;
590 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
592 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
594 switch (dec->codec_type) {
595 case AVMEDIA_TYPE_VIDEO:
597 ist->dec = avcodec_find_decoder(dec->codec_id);
599 dec->flags |= CODEC_FLAG_EMU_EDGE;
602 ist->resample_height = dec->height;
603 ist->resample_width = dec->width;
604 ist->resample_pix_fmt = dec->pix_fmt;
606 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
607 if (framerate && av_parse_video_rate(&ist->framerate,
609 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
614 ist->top_field_first = -1;
615 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
618 case AVMEDIA_TYPE_AUDIO:
619 guess_input_channel_layout(ist);
621 ist->resample_sample_fmt = dec->sample_fmt;
622 ist->resample_sample_rate = dec->sample_rate;
623 ist->resample_channels = dec->channels;
624 ist->resample_channel_layout = dec->channel_layout;
627 case AVMEDIA_TYPE_DATA:
628 case AVMEDIA_TYPE_SUBTITLE:
630 ist->dec = avcodec_find_decoder(dec->codec_id);
631 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
633 case AVMEDIA_TYPE_ATTACHMENT:
634 case AVMEDIA_TYPE_UNKNOWN:
642 static void assert_file_overwrite(const char *filename)
644 if ((!file_overwrite || no_file_overwrite) &&
645 (strchr(filename, ':') == NULL || filename[1] == ':' ||
646 av_strstart(filename, "file:", NULL))) {
647 if (avio_check(filename, 0) == 0) {
648 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
649 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
652 signal(SIGINT, SIG_DFL);
654 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
660 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
667 static void dump_attachment(AVStream *st, const char *filename)
670 AVIOContext *out = NULL;
671 AVDictionaryEntry *e;
673 if (!st->codec->extradata_size) {
674 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
675 nb_input_files - 1, st->index);
678 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
681 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
682 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
686 assert_file_overwrite(filename);
688 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
689 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
694 avio_write(out, st->codec->extradata, st->codec->extradata_size);
699 static int open_input_file(OptionsContext *o, const char *filename)
702 AVInputFormat *file_iformat = NULL;
707 int orig_nb_streams; // number of streams before avformat_find_stream_info
708 char * video_codec_name = NULL;
709 char * audio_codec_name = NULL;
710 char *subtitle_codec_name = NULL;
713 if (!(file_iformat = av_find_input_format(o->format))) {
714 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
719 if (!strcmp(filename, "-"))
722 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
723 strcmp(filename, "/dev/stdin");
725 /* get default parameters from command line */
726 ic = avformat_alloc_context();
728 print_error(filename, AVERROR(ENOMEM));
731 if (o->nb_audio_sample_rate) {
732 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
733 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
735 if (o->nb_audio_channels) {
736 /* because we set audio_channels based on both the "ac" and
737 * "channel_layout" options, we need to check that the specified
738 * demuxer actually has the "channels" option before setting it */
739 if (file_iformat && file_iformat->priv_class &&
740 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
741 AV_OPT_SEARCH_FAKE_OBJ)) {
742 snprintf(buf, sizeof(buf), "%d",
743 o->audio_channels[o->nb_audio_channels - 1].u.i);
744 av_dict_set(&o->g->format_opts, "channels", buf, 0);
747 if (o->nb_frame_rates) {
748 /* set the format-level framerate option;
749 * this is important for video grabbers, e.g. x11 */
750 if (file_iformat && file_iformat->priv_class &&
751 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
752 AV_OPT_SEARCH_FAKE_OBJ)) {
753 av_dict_set(&o->g->format_opts, "framerate",
754 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
757 if (o->nb_frame_sizes) {
758 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
760 if (o->nb_frame_pix_fmts)
761 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
763 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
764 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
765 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
767 ic->video_codec_id = video_codec_name ?
768 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
769 ic->audio_codec_id = audio_codec_name ?
770 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
771 ic->subtitle_codec_id= subtitle_codec_name ?
772 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
773 ic->flags |= AVFMT_FLAG_NONBLOCK;
774 ic->interrupt_callback = int_cb;
776 /* open the input file with generic avformat function */
777 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
779 print_error(filename, err);
782 assert_avoptions(o->g->format_opts);
784 /* apply forced codec ids */
785 for (i = 0; i < ic->nb_streams; i++)
786 choose_decoder(o, ic, ic->streams[i]);
788 /* Set AVCodecContext options for avformat_find_stream_info */
789 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
790 orig_nb_streams = ic->nb_streams;
792 /* If not enough info to get the stream parameters, we decode the
793 first frames to get it. (used in mpeg case for example) */
794 ret = avformat_find_stream_info(ic, opts);
796 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
797 avformat_close_input(&ic);
801 timestamp = o->start_time;
802 /* add the stream start time */
803 if (ic->start_time != AV_NOPTS_VALUE)
804 timestamp += ic->start_time;
806 /* if seeking requested, we execute it */
807 if (o->start_time != 0) {
808 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
810 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
811 filename, (double)timestamp / AV_TIME_BASE);
815 /* update the current parameters so that they match the one of the input stream */
816 add_input_streams(o, ic);
818 /* dump the file content */
819 av_dump_format(ic, nb_input_files, filename, 0);
821 GROW_ARRAY(input_files, nb_input_files);
822 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
825 input_files[nb_input_files - 1]->ctx = ic;
826 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
827 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
828 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
829 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
831 for (i = 0; i < o->nb_dump_attachment; i++) {
834 for (j = 0; j < ic->nb_streams; j++) {
835 AVStream *st = ic->streams[j];
837 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
838 dump_attachment(st, o->dump_attachment[i].u.str);
842 for (i = 0; i < orig_nb_streams; i++)
843 av_dict_free(&opts[i]);
849 static uint8_t *get_line(AVIOContext *s)
855 if (avio_open_dyn_buf(&line) < 0) {
856 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
860 while ((c = avio_r8(s)) && c != '\n')
863 avio_close_dyn_buf(line, &buf);
868 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
872 const char *base[3] = { getenv("AVCONV_DATADIR"),
877 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
881 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
882 i != 1 ? "" : "/.avconv", codec_name, preset_name);
883 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
886 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
887 i != 1 ? "" : "/.avconv", preset_name);
888 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
894 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
896 char *codec_name = NULL;
898 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
900 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
901 NULL, ost->st->codec->codec_type);
902 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
903 } else if (!strcmp(codec_name, "copy"))
904 ost->stream_copy = 1;
906 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
907 ost->st->codec->codec_id = ost->enc->id;
911 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
914 AVStream *st = avformat_new_stream(oc, NULL);
915 int idx = oc->nb_streams - 1, ret = 0;
916 char *bsf = NULL, *next, *codec_tag = NULL;
917 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
921 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
925 if (oc->nb_streams - 1 < o->nb_streamid_map)
926 st->id = o->streamid_map[oc->nb_streams - 1];
928 GROW_ARRAY(output_streams, nb_output_streams);
929 if (!(ost = av_mallocz(sizeof(*ost))))
931 output_streams[nb_output_streams - 1] = ost;
933 ost->file_index = nb_output_files;
936 st->codec->codec_type = type;
937 choose_encoder(o, oc, ost);
939 AVIOContext *s = NULL;
940 char *buf = NULL, *arg = NULL, *preset = NULL;
942 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
944 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
945 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
948 if (!buf[0] || buf[0] == '#') {
952 if (!(arg = strchr(buf, '='))) {
953 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
957 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
959 } while (!s->eof_reached);
963 av_log(NULL, AV_LOG_FATAL,
964 "Preset %s specified for stream %d:%d, but could not be opened.\n",
965 preset, ost->file_index, ost->index);
970 avcodec_get_context_defaults3(st->codec, ost->enc);
971 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
973 ost->max_frames = INT64_MAX;
974 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
976 ost->copy_prior_start = -1;
977 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
979 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
981 if (next = strchr(bsf, ','))
983 if (!(bsfc = av_bitstream_filter_init(bsf))) {
984 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
988 bsfc_prev->next = bsfc;
990 ost->bitstream_filters = bsfc;
996 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
998 uint32_t tag = strtol(codec_tag, &next, 0);
1000 tag = AV_RL32(codec_tag);
1001 st->codec->codec_tag = tag;
1004 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1006 st->codec->flags |= CODEC_FLAG_QSCALE;
1007 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1010 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1011 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1013 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1014 av_opt_get_int (o->g->swr_opts, "filter_type" , 0, &ost->swr_filter_type);
1015 av_opt_get_int (o->g->swr_opts, "dither_method", 0, &ost->swr_dither_method);
1016 av_opt_get_double(o->g->swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1017 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1018 ost->swr_dither_scale = ost->swr_dither_scale*256;
1020 ost->source_index = source_index;
1021 if (source_index >= 0) {
1022 ost->sync_ist = input_streams[source_index];
1023 input_streams[source_index]->discard = 0;
1024 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1030 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1033 const char *p = str;
1040 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1047 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1051 AVCodecContext *video_enc;
1052 char *frame_rate = NULL;
1054 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1056 video_enc = st->codec;
1058 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1059 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1060 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1064 if (!ost->stream_copy) {
1065 const char *p = NULL;
1066 char *frame_size = NULL;
1067 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1068 char *intra_matrix = NULL, *inter_matrix = NULL;
1069 const char *filters = "null";
1073 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1074 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1075 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1079 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1080 if (frame_aspect_ratio) {
1082 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1083 q.num <= 0 || q.den <= 0) {
1084 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1087 ost->frame_aspect_ratio = av_q2d(q);
1090 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1091 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1092 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1093 ost->keep_pix_fmt = 1;
1094 if (!*++frame_pix_fmt)
1095 frame_pix_fmt = NULL;
1097 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1098 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1101 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1104 video_enc->gop_size = 0;
1105 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1107 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1108 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1111 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1113 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1115 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1116 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1119 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1122 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1123 for (i = 0; p; i++) {
1125 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1127 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1130 /* FIXME realloc failure */
1131 video_enc->rc_override =
1132 av_realloc(video_enc->rc_override,
1133 sizeof(RcOverride) * (i + 1));
1134 video_enc->rc_override[i].start_frame = start;
1135 video_enc->rc_override[i].end_frame = end;
1137 video_enc->rc_override[i].qscale = q;
1138 video_enc->rc_override[i].quality_factor = 1.0;
1141 video_enc->rc_override[i].qscale = 0;
1142 video_enc->rc_override[i].quality_factor = -q/100.0;
1147 video_enc->rc_override_count = i;
1148 if (!video_enc->rc_initial_buffer_occupancy)
1149 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1150 video_enc->intra_dc_precision = intra_dc_precision - 8;
1153 video_enc->flags|= CODEC_FLAG_PSNR;
1156 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1159 video_enc->flags |= CODEC_FLAG_PASS1;
1162 video_enc->flags |= CODEC_FLAG_PASS2;
1166 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1167 if (ost->logfile_prefix &&
1168 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1171 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1172 if (ost->forced_keyframes)
1173 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1175 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1177 ost->top_field_first = -1;
1178 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1180 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1181 ost->avfilter = av_strdup(filters);
1183 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1189 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1194 AVCodecContext *audio_enc;
1196 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1199 audio_enc = st->codec;
1200 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1202 if (!ost->stream_copy) {
1203 char *sample_fmt = NULL;
1204 const char *filters = "anull";
1206 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1208 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1210 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1211 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1215 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1217 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1219 av_assert1(filters);
1220 ost->avfilter = av_strdup(filters);
1222 /* check for channel mapping for this audio stream */
1223 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1224 AudioChannelMap *map = &o->audio_channel_maps[n];
1225 InputStream *ist = input_streams[ost->source_index];
1226 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1227 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1228 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1229 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1230 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1232 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1233 ost->file_index, ost->st->index);
1241 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1245 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1246 if (!ost->stream_copy) {
1247 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1254 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1256 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1257 ost->stream_copy = 1;
1261 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1265 AVCodecContext *subtitle_enc;
1267 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1269 subtitle_enc = st->codec;
1271 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1273 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1275 if (!ost->stream_copy) {
1276 char *frame_size = NULL;
1278 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1279 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1280 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1288 /* arg format is "output-stream-index:streamid-value". */
1289 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1291 OptionsContext *o = optctx;
1296 av_strlcpy(idx_str, arg, sizeof(idx_str));
1297 p = strchr(idx_str, ':');
1299 av_log(NULL, AV_LOG_FATAL,
1300 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1305 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1306 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1307 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1311 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1313 AVFormatContext *is = ifile->ctx;
1314 AVFormatContext *os = ofile->ctx;
1318 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1320 return AVERROR(ENOMEM);
1323 for (i = 0; i < is->nb_chapters; i++) {
1324 AVChapter *in_ch = is->chapters[i], *out_ch;
1325 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1326 AV_TIME_BASE_Q, in_ch->time_base);
1327 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1328 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1331 if (in_ch->end < ts_off)
1333 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1336 out_ch = av_mallocz(sizeof(AVChapter));
1338 return AVERROR(ENOMEM);
1340 out_ch->id = in_ch->id;
1341 out_ch->time_base = in_ch->time_base;
1342 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1343 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1346 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1348 os->chapters[os->nb_chapters++] = out_ch;
1353 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1356 AVFormatContext *ic = avformat_alloc_context();
1358 ic->interrupt_callback = int_cb;
1359 err = avformat_open_input(&ic, filename, NULL, NULL);
1362 /* copy stream format */
1363 for(i=0;i<ic->nb_streams;i++) {
1367 AVCodecContext *avctx;
1369 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1370 ost = new_output_stream(o, s, codec->type, -1);
1375 // FIXME: a more elegant solution is needed
1376 memcpy(st, ic->streams[i], sizeof(AVStream));
1378 st->info = av_malloc(sizeof(*st->info));
1379 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1381 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1383 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1384 choose_sample_fmt(st, codec);
1385 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1386 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1389 /* ffserver seeking with date=... needs a date reference */
1390 err = parse_option(o, "metadata", "creation_time=now", options);
1392 avformat_close_input(&ic);
1396 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1397 AVFormatContext *oc)
1401 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1402 ofilter->out_tmp->pad_idx)) {
1403 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1404 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1406 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1411 ost->source_index = -1;
1412 ost->filter = ofilter;
1416 if (ost->stream_copy) {
1417 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1418 "which is fed from a complex filtergraph. Filtering and streamcopy "
1419 "cannot be used together.\n", ost->file_index, ost->index);
1423 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1424 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1427 avfilter_inout_free(&ofilter->out_tmp);
1430 static int configure_complex_filters(void)
1434 for (i = 0; i < nb_filtergraphs; i++)
1435 if (!filtergraphs[i]->graph &&
1436 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1441 static int open_output_file(OptionsContext *o, const char *filename)
1443 AVFormatContext *oc;
1445 AVOutputFormat *file_oformat;
1449 if (configure_complex_filters() < 0) {
1450 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1454 if (!strcmp(filename, "-"))
1457 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1459 print_error(filename, err);
1462 file_oformat= oc->oformat;
1463 oc->interrupt_callback = int_cb;
1465 /* create streams for all unlabeled output pads */
1466 for (i = 0; i < nb_filtergraphs; i++) {
1467 FilterGraph *fg = filtergraphs[i];
1468 for (j = 0; j < fg->nb_outputs; j++) {
1469 OutputFilter *ofilter = fg->outputs[j];
1471 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1474 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1475 ofilter->out_tmp->pad_idx)) {
1476 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1477 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1478 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1480 init_output_filter(ofilter, o, oc);
1484 if (!strcmp(file_oformat->name, "ffm") &&
1485 av_strstart(filename, "http:", NULL)) {
1487 /* special case for files sent to ffserver: we get the stream
1488 parameters from ffserver */
1489 int err = read_ffserver_streams(o, oc, filename);
1491 print_error(filename, err);
1494 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1495 ost = output_streams[j];
1496 for (i = 0; i < nb_input_streams; i++) {
1497 ist = input_streams[i];
1498 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1500 ost->source_index= i;
1501 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1502 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1504 ist->st->discard = AVDISCARD_NONE;
1509 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));
1513 } else if (!o->nb_stream_maps) {
1514 char *subtitle_codec_name = NULL;
1515 /* pick the "best" stream of each type */
1517 /* video: highest resolution */
1518 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1519 int area = 0, idx = -1;
1520 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1521 for (i = 0; i < nb_input_streams; i++) {
1523 ist = input_streams[i];
1524 new_area = ist->st->codec->width * ist->st->codec->height;
1525 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1527 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1529 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1536 new_video_stream(o, oc, idx);
1539 /* audio: most channels */
1540 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1541 int channels = 0, idx = -1;
1542 for (i = 0; i < nb_input_streams; i++) {
1543 ist = input_streams[i];
1544 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1545 ist->st->codec->channels > channels) {
1546 channels = ist->st->codec->channels;
1551 new_audio_stream(o, oc, idx);
1554 /* subtitles: pick first */
1555 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1556 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1557 for (i = 0; i < nb_input_streams; i++)
1558 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1559 new_subtitle_stream(o, oc, i);
1563 /* do something with data? */
1565 for (i = 0; i < o->nb_stream_maps; i++) {
1566 StreamMap *map = &o->stream_maps[i];
1567 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1572 if (map->linklabel) {
1574 OutputFilter *ofilter = NULL;
1577 for (j = 0; j < nb_filtergraphs; j++) {
1578 fg = filtergraphs[j];
1579 for (k = 0; k < fg->nb_outputs; k++) {
1580 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1581 if (out && !strcmp(out->name, map->linklabel)) {
1582 ofilter = fg->outputs[k];
1589 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1590 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1593 init_output_filter(ofilter, o, oc);
1595 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1596 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1598 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1600 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1602 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1605 switch (ist->st->codec->codec_type) {
1606 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1607 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1608 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1609 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1610 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1612 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1613 map->file_index, map->stream_index);
1620 /* handle attached files */
1621 for (i = 0; i < o->nb_attachments; i++) {
1623 uint8_t *attachment;
1627 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1628 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1632 if ((len = avio_size(pb)) <= 0) {
1633 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1637 if (!(attachment = av_malloc(len))) {
1638 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1642 avio_read(pb, attachment, len);
1644 ost = new_attachment_stream(o, oc, -1);
1645 ost->stream_copy = 0;
1646 ost->attachment_filename = o->attachments[i];
1648 ost->st->codec->extradata = attachment;
1649 ost->st->codec->extradata_size = len;
1651 p = strrchr(o->attachments[i], '/');
1652 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1656 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1657 AVDictionaryEntry *e;
1658 ost = output_streams[i];
1660 if ((ost->stream_copy || ost->attachment_filename)
1661 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1662 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1663 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1667 GROW_ARRAY(output_files, nb_output_files);
1668 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1671 output_files[nb_output_files - 1]->ctx = oc;
1672 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1673 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1674 if (o->recording_time != INT64_MAX)
1675 oc->duration = o->recording_time;
1676 output_files[nb_output_files - 1]->start_time = o->start_time;
1677 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1678 output_files[nb_output_files - 1]->shortest = o->shortest;
1679 av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1681 /* check filename in case of an image number is expected */
1682 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1683 if (!av_filename_number_test(oc->filename)) {
1684 print_error(oc->filename, AVERROR(EINVAL));
1689 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1690 /* test if it already exists to avoid losing precious files */
1691 assert_file_overwrite(filename);
1694 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1695 &oc->interrupt_callback,
1696 &output_files[nb_output_files - 1]->opts)) < 0) {
1697 print_error(filename, err);
1702 if (o->mux_preload) {
1704 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1705 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1707 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1710 for (i = 0; i < o->nb_metadata_map; i++) {
1712 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1714 if (in_file_index >= nb_input_files) {
1715 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1718 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1719 in_file_index >= 0 ?
1720 input_files[in_file_index]->ctx : NULL, o);
1724 if (o->chapters_input_file >= nb_input_files) {
1725 if (o->chapters_input_file == INT_MAX) {
1726 /* copy chapters from the first input file that has them*/
1727 o->chapters_input_file = -1;
1728 for (i = 0; i < nb_input_files; i++)
1729 if (input_files[i]->ctx->nb_chapters) {
1730 o->chapters_input_file = i;
1734 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1735 o->chapters_input_file);
1739 if (o->chapters_input_file >= 0)
1740 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1741 !o->metadata_chapters_manual);
1743 /* copy global metadata by default */
1744 if (!o->metadata_global_manual && nb_input_files){
1745 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1746 AV_DICT_DONT_OVERWRITE);
1747 if(o->recording_time != INT64_MAX)
1748 av_dict_set(&oc->metadata, "duration", NULL, 0);
1749 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1751 if (!o->metadata_streams_manual)
1752 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1754 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1756 ist = input_streams[output_streams[i]->source_index];
1757 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1760 /* process manually set metadata */
1761 for (i = 0; i < o->nb_metadata; i++) {
1764 const char *stream_spec;
1765 int index = 0, j, ret = 0;
1767 val = strchr(o->metadata[i].u.str, '=');
1769 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1770 o->metadata[i].u.str);
1775 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1777 for (j = 0; j < oc->nb_streams; j++) {
1778 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1779 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1790 if (index < 0 || index >= oc->nb_chapters) {
1791 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1794 m = &oc->chapters[index]->metadata;
1797 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1800 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1807 static int opt_target(void *optctx, const char *opt, const char *arg)
1809 OptionsContext *o = optctx;
1810 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1811 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1813 if (!strncmp(arg, "pal-", 4)) {
1816 } else if (!strncmp(arg, "ntsc-", 5)) {
1819 } else if (!strncmp(arg, "film-", 5)) {
1823 /* Try to determine PAL/NTSC by peeking in the input files */
1824 if (nb_input_files) {
1826 for (j = 0; j < nb_input_files; j++) {
1827 for (i = 0; i < input_files[j]->nb_streams; i++) {
1828 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1829 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1831 fr = c->time_base.den * 1000 / c->time_base.num;
1835 } else if ((fr == 29970) || (fr == 23976)) {
1840 if (norm != UNKNOWN)
1844 if (norm != UNKNOWN)
1845 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1848 if (norm == UNKNOWN) {
1849 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1850 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1851 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1855 if (!strcmp(arg, "vcd")) {
1856 opt_video_codec(o, "c:v", "mpeg1video");
1857 opt_audio_codec(o, "c:a", "mp2");
1858 parse_option(o, "f", "vcd", options);
1859 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1861 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1862 parse_option(o, "r", frame_rates[norm], options);
1863 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1865 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1866 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1867 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1868 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1870 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1871 parse_option(o, "ar", "44100", options);
1872 parse_option(o, "ac", "2", options);
1874 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1875 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1877 /* We have to offset the PTS, so that it is consistent with the SCR.
1878 SCR starts at 36000, but the first two packs contain only padding
1879 and the first pack from the other stream, respectively, may also have
1880 been written before.
1881 So the real data starts at SCR 36000+3*1200. */
1882 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1883 } else if (!strcmp(arg, "svcd")) {
1885 opt_video_codec(o, "c:v", "mpeg2video");
1886 opt_audio_codec(o, "c:a", "mp2");
1887 parse_option(o, "f", "svcd", options);
1889 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1890 parse_option(o, "r", frame_rates[norm], options);
1891 parse_option(o, "pix_fmt", "yuv420p", options);
1892 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1894 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1895 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1896 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1897 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1898 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1900 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1901 parse_option(o, "ar", "44100", options);
1903 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1905 } else if (!strcmp(arg, "dvd")) {
1907 opt_video_codec(o, "c:v", "mpeg2video");
1908 opt_audio_codec(o, "c:a", "ac3");
1909 parse_option(o, "f", "dvd", options);
1911 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1912 parse_option(o, "r", frame_rates[norm], options);
1913 parse_option(o, "pix_fmt", "yuv420p", options);
1914 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1916 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1917 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1918 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1919 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1921 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.
1922 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1924 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1925 parse_option(o, "ar", "48000", options);
1927 } else if (!strncmp(arg, "dv", 2)) {
1929 parse_option(o, "f", "dv", options);
1931 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1932 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1933 norm == PAL ? "yuv420p" : "yuv411p", options);
1934 parse_option(o, "r", frame_rates[norm], options);
1936 parse_option(o, "ar", "48000", options);
1937 parse_option(o, "ac", "2", options);
1940 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1941 return AVERROR(EINVAL);
1946 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1948 av_free (vstats_filename);
1949 vstats_filename = av_strdup (arg);
1953 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1956 time_t today2 = time(NULL);
1957 struct tm *today = localtime(&today2);
1959 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1961 return opt_vstats_file(NULL, opt, filename);
1964 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1966 OptionsContext *o = optctx;
1967 return parse_option(o, "frames:v", arg, options);
1970 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1972 OptionsContext *o = optctx;
1973 return parse_option(o, "frames:a", arg, options);
1976 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1978 OptionsContext *o = optctx;
1979 return parse_option(o, "frames:d", arg, options);
1982 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1985 AVDictionary *cbak = codec_opts;
1986 AVDictionary *fbak = format_opts;
1990 ret = opt_default(NULL, opt, arg);
1992 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
1993 av_dict_copy(&o->g->format_opts, format_opts, 0);
1994 av_dict_free(&codec_opts);
1995 av_dict_free(&format_opts);
2002 static int opt_preset(void *optctx, const char *opt, const char *arg)
2004 OptionsContext *o = optctx;
2006 char filename[1000], line[1000], tmp_line[1000];
2007 const char *codec_name = NULL;
2011 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2013 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2014 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2015 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2017 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2021 while (fgets(line, sizeof(line), f)) {
2022 char *key = tmp_line, *value, *endptr;
2024 if (strcspn(line, "#\n\r") == 0)
2026 strcpy(tmp_line, line);
2027 if (!av_strtok(key, "=", &value) ||
2028 !av_strtok(value, "\r\n", &endptr)) {
2029 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2032 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2034 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2035 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2036 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2037 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2038 else if (opt_default_new(o, key, value) < 0) {
2039 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2040 filename, line, key, value);
2050 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2052 OptionsContext *o = optctx;
2053 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2054 int ret = parse_option(o, s, arg, options);
2059 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2061 OptionsContext *o = optctx;
2062 if(!strcmp(opt, "b")){
2063 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2064 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2067 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2071 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2073 OptionsContext *o = optctx;
2076 if(!strcmp(opt, "qscale")){
2077 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2078 return parse_option(o, "q:v", arg, options);
2080 s = av_asprintf("q%s", opt + 6);
2081 ret = parse_option(o, s, arg, options);
2086 static int opt_profile(void *optctx, const char *opt, const char *arg)
2088 OptionsContext *o = optctx;
2089 if(!strcmp(opt, "profile")){
2090 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2091 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2094 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2098 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2100 OptionsContext *o = optctx;
2101 return parse_option(o, "filter:v", arg, options);
2104 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2106 OptionsContext *o = optctx;
2107 return parse_option(o, "filter:a", arg, options);
2110 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2112 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2113 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2114 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2115 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2117 if (video_sync_method == VSYNC_AUTO)
2118 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2122 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2124 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2129 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2131 OptionsContext *o = optctx;
2132 char *tcr = av_asprintf("timecode=%s", arg);
2133 int ret = parse_option(o, "metadata:g", tcr, options);
2135 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2140 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2142 OptionsContext *o = optctx;
2143 char layout_str[32];
2146 int ret, channels, ac_str_size;
2149 layout = av_get_channel_layout(arg);
2151 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2152 return AVERROR(EINVAL);
2154 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2155 ret = opt_default(NULL, opt, layout_str);
2159 /* set 'ac' option based on channel layout */
2160 channels = av_get_channel_layout_nb_channels(layout);
2161 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2162 stream_str = strchr(opt, ':');
2163 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2164 ac_str = av_mallocz(ac_str_size);
2166 return AVERROR(ENOMEM);
2167 av_strlcpy(ac_str, "ac", 3);
2169 av_strlcat(ac_str, stream_str, ac_str_size);
2170 ret = parse_option(o, ac_str, layout_str, options);
2176 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2178 OptionsContext *o = optctx;
2179 return parse_option(o, "q:a", arg, options);
2182 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2184 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2185 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2186 return AVERROR(ENOMEM);
2187 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2188 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2192 void show_help_default(const char *opt, const char *arg)
2194 /* per-file options have at least one of those set */
2195 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2196 int show_advanced = 0, show_avoptions = 0;
2199 if (!strcmp(opt, "long"))
2201 else if (!strcmp(opt, "full"))
2202 show_advanced = show_avoptions = 1;
2204 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2209 printf("Getting help:\n"
2210 " -h -- print basic options\n"
2211 " -h long -- print more options\n"
2212 " -h full -- print all options (including all format and codec specific options, very long)\n"
2213 " See man %s for detailed description of the options.\n"
2214 "\n", program_name);
2216 show_help_options(options, "Print help / information / capabilities:",
2219 show_help_options(options, "Global options (affect whole program "
2220 "instead of just one file:",
2221 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2223 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2224 per_file | OPT_EXIT, 0);
2226 show_help_options(options, "Per-file main options:", 0,
2227 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2228 OPT_EXIT, per_file);
2230 show_help_options(options, "Advanced per-file options:",
2231 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2233 show_help_options(options, "Video options:",
2234 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2236 show_help_options(options, "Advanced Video options:",
2237 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2239 show_help_options(options, "Audio options:",
2240 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2242 show_help_options(options, "Advanced Audio options:",
2243 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2244 show_help_options(options, "Subtitle options:",
2245 OPT_SUBTITLE, 0, 0);
2248 if (show_avoptions) {
2249 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2250 show_help_children(avcodec_get_class(), flags);
2251 show_help_children(avformat_get_class(), flags);
2252 show_help_children(sws_get_class(), flags);
2253 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2254 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2258 void show_usage(void)
2260 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2261 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2262 av_log(NULL, AV_LOG_INFO, "\n");
2270 static const OptionGroupDef groups[] = {
2271 [GROUP_OUTFILE] = { "output file", NULL },
2272 [GROUP_INFILE] = { "input file", "i" },
2275 static int open_files(OptionGroupList *l, const char *inout,
2276 int (*open_file)(OptionsContext*, const char*))
2280 for (i = 0; i < l->nb_groups; i++) {
2281 OptionGroup *g = &l->groups[i];
2284 init_options(&o, !strcmp(inout, "input"));
2287 ret = parse_optgroup(&o, g);
2289 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2290 "%s.\n", inout, g->arg);
2294 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2295 ret = open_file(&o, g->arg);
2296 uninit_options(&o, !strcmp(inout, "input"));
2298 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2302 av_log(NULL, AV_LOG_DEBUG, "Successfully openened the file.\n");
2308 int ffmpeg_parse_options(int argc, char **argv)
2310 OptionParseContext octx;
2314 memset(&octx, 0, sizeof(octx));
2316 /* split the commandline into an internal representation */
2317 ret = split_commandline(&octx, argc, argv, options, groups,
2318 FF_ARRAY_ELEMS(groups));
2320 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2324 /* apply global options */
2325 ret = parse_optgroup(NULL, &octx.global_opts);
2327 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2331 /* open input files */
2332 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2334 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2338 /* open output files */
2339 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2341 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2346 uninit_parse_context(&octx);
2348 av_strerror(ret, error, sizeof(error));
2349 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2354 static int opt_progress(void *optctx, const char *opt, const char *arg)
2356 AVIOContext *avio = NULL;
2359 if (!strcmp(arg, "-"))
2361 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2363 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2364 arg, av_err2str(ret));
2367 progress_avio = avio;
2371 #define OFFSET(x) offsetof(OptionsContext, x)
2372 const OptionDef options[] = {
2374 #include "cmdutils_common_opts.h"
2375 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2376 "force format", "fmt" },
2377 { "y", OPT_BOOL, { &file_overwrite },
2378 "overwrite output files" },
2379 { "n", OPT_BOOL, { &no_file_overwrite },
2380 "do not overwrite output files" },
2381 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2382 "codec name", "codec" },
2383 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2384 "codec name", "codec" },
2385 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2386 "preset name", "preset" },
2387 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2388 "set input stream mapping",
2389 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2390 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2391 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2392 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2393 "set metadata information of outfile from infile",
2394 "outfile[,metadata]:infile[,metadata]" },
2395 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2396 "set chapters mapping", "input_file_index" },
2397 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2398 "record or transcode \"duration\" seconds of audio/video",
2400 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2401 "set the limit file size in bytes", "limit_size" },
2402 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2403 "set the start time offset", "time_off" },
2404 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2405 "set the input ts offset", "time_off" },
2406 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2407 "set the input ts scale", "scale" },
2408 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2409 "set the recording timestamp ('now' to set the current time)", "time" },
2410 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2411 "add metadata", "string=string" },
2412 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2413 "set the number of data frames to record", "number" },
2414 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2415 "add timings for benchmarking" },
2416 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2417 "add timings for each task" },
2418 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2419 "write program-readable progress information", "url" },
2420 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2421 "enable or disable interaction on standard input" },
2422 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2423 "set max runtime in seconds", "limit" },
2424 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2425 "dump each input packet" },
2426 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2427 "when dumping packets, also dump the payload" },
2428 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2429 "read input at native frame rate", "" },
2430 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2431 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2432 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2433 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2434 "video sync method", "" },
2435 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2436 "audio sync method", "" },
2437 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2438 "audio drift threshold", "threshold" },
2439 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2440 "copy timestamps" },
2441 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2442 "copy input stream time base when stream copying", "mode" },
2443 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2444 "finish encoding within shortest input" },
2445 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2446 "timestamp discontinuity delta threshold", "threshold" },
2447 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2448 "timestamp error delta threshold", "threshold" },
2449 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2450 "exit on error", "error" },
2451 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2452 "copy initial non-keyframes" },
2453 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2454 "copy or discard frames before start time" },
2455 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2456 "set the number of frames to record", "number" },
2457 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2458 "force codec tag/fourcc", "fourcc/tag" },
2459 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2460 "use fixed quality scale (VBR)", "q" },
2461 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2462 "use fixed quality scale (VBR)", "q" },
2463 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2464 "set profile", "profile" },
2465 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2466 "set stream filtergraph", "filter_graph" },
2467 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2468 "reinit filtergraph on input parameter changes", "" },
2469 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2470 "create a complex filtergraph", "graph_description" },
2471 { "stats", OPT_BOOL, { &print_stats },
2472 "print progress report during encoding", },
2473 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2474 "add an attachment to the output file", "filename" },
2475 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2476 "extract an attachment into a file", "filename" },
2477 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2478 "print timestamp debugging info" },
2481 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2482 "set the number of video frames to record", "number" },
2483 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2484 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2485 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2486 "set frame size (WxH or abbreviation)", "size" },
2487 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2488 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2489 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2490 "set pixel format", "format" },
2491 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2492 "set the number of bits per raw sample", "number" },
2493 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2494 "Removed, use the crop filter instead", "size" },
2495 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2496 "Removed, use the crop filter instead", "size" },
2497 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2498 "Removed, use the crop filter instead", "size" },
2499 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2500 "Removed, use the crop filter instead", "size" },
2501 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2502 "Removed, use the pad filter instead", "size" },
2503 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2504 "Removed, use the pad filter instead", "size" },
2505 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2506 "Removed, use the pad filter instead", "size" },
2507 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2508 "Removed, use the pad filter instead", "size" },
2509 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2510 "Removed, use the pad filter instead", "color" },
2511 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2512 "deprecated use -g 1" },
2513 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2515 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2516 "discard threshold", "n" },
2517 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2518 "rate control override for specific intervals", "override" },
2519 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2520 "force video codec ('copy' to copy stream)", "codec" },
2521 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2523 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2525 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2526 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2527 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2528 "select the pass number (1 to 3)", "n" },
2529 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2530 "select two pass log file name prefix", "prefix" },
2531 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2532 "this option is deprecated, use the yadif filter instead" },
2533 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2534 "calculate PSNR of compressed frames" },
2535 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2536 "dump video coding statistics to file" },
2537 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2538 "dump video coding statistics to file", "file" },
2539 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2540 "set video filters", "filter_graph" },
2541 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2542 "specify intra matrix coeffs", "matrix" },
2543 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2544 "specify inter matrix coeffs", "matrix" },
2545 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2546 "top=1/bottom=0/auto=-1 field first", "" },
2547 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2548 "intra_dc_precision", "precision" },
2549 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2550 "force video tag/fourcc", "fourcc/tag" },
2551 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2552 "show QP histogram" },
2553 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2554 "force the selected framerate, disable the best supported framerate selection" },
2555 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2556 "set the value of an outfile streamid", "streamIndex:value" },
2557 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2558 { .off = OFFSET(forced_key_frames) },
2559 "force key frames at specified timestamps", "timestamps" },
2560 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2561 "video bitrate (please use -b:v)", "bitrate" },
2564 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2565 "set the number of audio frames to record", "number" },
2566 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2567 "set audio quality (codec-specific)", "quality", },
2568 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2569 "set audio sampling rate (in Hz)", "rate" },
2570 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2571 "set number of audio channels", "channels" },
2572 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2574 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2575 "force audio codec ('copy' to copy stream)", "codec" },
2576 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2577 "force audio tag/fourcc", "fourcc/tag" },
2578 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2579 "change audio volume (256=normal)" , "volume" },
2580 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2581 "set sample format", "format" },
2582 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2583 "set channel layout", "layout" },
2584 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2585 "set audio filters", "filter_graph" },
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) },