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);
1018 ost->source_index = source_index;
1019 if (source_index >= 0) {
1020 ost->sync_ist = input_streams[source_index];
1021 input_streams[source_index]->discard = 0;
1022 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1028 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1031 const char *p = str;
1038 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1045 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1049 AVCodecContext *video_enc;
1050 char *frame_rate = NULL;
1052 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1054 video_enc = st->codec;
1056 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1057 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1058 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1062 if (!ost->stream_copy) {
1063 const char *p = NULL;
1064 char *frame_size = NULL;
1065 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1066 char *intra_matrix = NULL, *inter_matrix = NULL;
1067 const char *filters = "null";
1071 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1072 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1073 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1077 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1078 if (frame_aspect_ratio) {
1080 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1081 q.num <= 0 || q.den <= 0) {
1082 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1085 ost->frame_aspect_ratio = av_q2d(q);
1088 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1089 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1090 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1091 ost->keep_pix_fmt = 1;
1092 if (!*++frame_pix_fmt)
1093 frame_pix_fmt = NULL;
1095 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1096 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1099 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1102 video_enc->gop_size = 0;
1103 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1105 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1106 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1109 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1111 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1113 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1114 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1117 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1120 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1121 for (i = 0; p; i++) {
1123 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1125 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1128 /* FIXME realloc failure */
1129 video_enc->rc_override =
1130 av_realloc(video_enc->rc_override,
1131 sizeof(RcOverride) * (i + 1));
1132 video_enc->rc_override[i].start_frame = start;
1133 video_enc->rc_override[i].end_frame = end;
1135 video_enc->rc_override[i].qscale = q;
1136 video_enc->rc_override[i].quality_factor = 1.0;
1139 video_enc->rc_override[i].qscale = 0;
1140 video_enc->rc_override[i].quality_factor = -q/100.0;
1145 video_enc->rc_override_count = i;
1146 if (!video_enc->rc_initial_buffer_occupancy)
1147 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1148 video_enc->intra_dc_precision = intra_dc_precision - 8;
1151 video_enc->flags|= CODEC_FLAG_PSNR;
1154 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1157 video_enc->flags |= CODEC_FLAG_PASS1;
1160 video_enc->flags |= CODEC_FLAG_PASS2;
1164 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1165 if (ost->logfile_prefix &&
1166 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1169 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1170 if (ost->forced_keyframes)
1171 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1173 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1175 ost->top_field_first = -1;
1176 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1178 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1179 ost->avfilter = av_strdup(filters);
1181 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1187 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1192 AVCodecContext *audio_enc;
1194 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1197 audio_enc = st->codec;
1198 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1200 if (!ost->stream_copy) {
1201 char *sample_fmt = NULL;
1202 const char *filters = "anull";
1204 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1206 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1208 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1209 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1213 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1215 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1217 av_assert1(filters);
1218 ost->avfilter = av_strdup(filters);
1220 /* check for channel mapping for this audio stream */
1221 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1222 AudioChannelMap *map = &o->audio_channel_maps[n];
1223 InputStream *ist = input_streams[ost->source_index];
1224 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1225 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1226 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1227 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1228 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1230 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1231 ost->file_index, ost->st->index);
1239 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1243 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1244 if (!ost->stream_copy) {
1245 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1252 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1254 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1255 ost->stream_copy = 1;
1259 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1263 AVCodecContext *subtitle_enc;
1265 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1267 subtitle_enc = st->codec;
1269 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1271 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1273 if (!ost->stream_copy) {
1274 char *frame_size = NULL;
1276 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1277 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1278 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1286 /* arg format is "output-stream-index:streamid-value". */
1287 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1289 OptionsContext *o = optctx;
1294 av_strlcpy(idx_str, arg, sizeof(idx_str));
1295 p = strchr(idx_str, ':');
1297 av_log(NULL, AV_LOG_FATAL,
1298 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1303 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1304 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1305 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1309 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1311 AVFormatContext *is = ifile->ctx;
1312 AVFormatContext *os = ofile->ctx;
1316 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1318 return AVERROR(ENOMEM);
1321 for (i = 0; i < is->nb_chapters; i++) {
1322 AVChapter *in_ch = is->chapters[i], *out_ch;
1323 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1324 AV_TIME_BASE_Q, in_ch->time_base);
1325 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1326 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1329 if (in_ch->end < ts_off)
1331 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1334 out_ch = av_mallocz(sizeof(AVChapter));
1336 return AVERROR(ENOMEM);
1338 out_ch->id = in_ch->id;
1339 out_ch->time_base = in_ch->time_base;
1340 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1341 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1344 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1346 os->chapters[os->nb_chapters++] = out_ch;
1351 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1354 AVFormatContext *ic = avformat_alloc_context();
1356 ic->interrupt_callback = int_cb;
1357 err = avformat_open_input(&ic, filename, NULL, NULL);
1360 /* copy stream format */
1361 for(i=0;i<ic->nb_streams;i++) {
1365 AVCodecContext *avctx;
1367 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1368 ost = new_output_stream(o, s, codec->type, -1);
1373 // FIXME: a more elegant solution is needed
1374 memcpy(st, ic->streams[i], sizeof(AVStream));
1376 st->info = av_malloc(sizeof(*st->info));
1377 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1379 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1381 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1382 choose_sample_fmt(st, codec);
1383 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1384 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1387 /* ffserver seeking with date=... needs a date reference */
1388 err = parse_option(o, "metadata", "creation_time=now", options);
1390 avformat_close_input(&ic);
1394 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1395 AVFormatContext *oc)
1399 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1400 ofilter->out_tmp->pad_idx)) {
1401 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1402 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1404 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1409 ost->source_index = -1;
1410 ost->filter = ofilter;
1414 if (ost->stream_copy) {
1415 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1416 "which is fed from a complex filtergraph. Filtering and streamcopy "
1417 "cannot be used together.\n", ost->file_index, ost->index);
1421 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1422 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1425 avfilter_inout_free(&ofilter->out_tmp);
1428 static int configure_complex_filters(void)
1432 for (i = 0; i < nb_filtergraphs; i++)
1433 if (!filtergraphs[i]->graph &&
1434 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1439 static int open_output_file(OptionsContext *o, const char *filename)
1441 AVFormatContext *oc;
1443 AVOutputFormat *file_oformat;
1447 if (configure_complex_filters() < 0) {
1448 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1452 if (!strcmp(filename, "-"))
1455 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1457 print_error(filename, err);
1460 file_oformat= oc->oformat;
1461 oc->interrupt_callback = int_cb;
1463 /* create streams for all unlabeled output pads */
1464 for (i = 0; i < nb_filtergraphs; i++) {
1465 FilterGraph *fg = filtergraphs[i];
1466 for (j = 0; j < fg->nb_outputs; j++) {
1467 OutputFilter *ofilter = fg->outputs[j];
1469 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1472 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1473 ofilter->out_tmp->pad_idx)) {
1474 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1475 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1476 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1478 init_output_filter(ofilter, o, oc);
1482 if (!strcmp(file_oformat->name, "ffm") &&
1483 av_strstart(filename, "http:", NULL)) {
1485 /* special case for files sent to ffserver: we get the stream
1486 parameters from ffserver */
1487 int err = read_ffserver_streams(o, oc, filename);
1489 print_error(filename, err);
1492 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1493 ost = output_streams[j];
1494 for (i = 0; i < nb_input_streams; i++) {
1495 ist = input_streams[i];
1496 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1498 ost->source_index= i;
1499 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1500 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1502 ist->st->discard = AVDISCARD_NONE;
1507 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));
1511 } else if (!o->nb_stream_maps) {
1512 char *subtitle_codec_name = NULL;
1513 /* pick the "best" stream of each type */
1515 /* video: highest resolution */
1516 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1517 int area = 0, idx = -1;
1518 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1519 for (i = 0; i < nb_input_streams; i++) {
1521 ist = input_streams[i];
1522 new_area = ist->st->codec->width * ist->st->codec->height;
1523 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1525 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1527 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1534 new_video_stream(o, oc, idx);
1537 /* audio: most channels */
1538 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1539 int channels = 0, idx = -1;
1540 for (i = 0; i < nb_input_streams; i++) {
1541 ist = input_streams[i];
1542 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1543 ist->st->codec->channels > channels) {
1544 channels = ist->st->codec->channels;
1549 new_audio_stream(o, oc, idx);
1552 /* subtitles: pick first */
1553 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1554 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1555 for (i = 0; i < nb_input_streams; i++)
1556 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1557 new_subtitle_stream(o, oc, i);
1561 /* do something with data? */
1563 for (i = 0; i < o->nb_stream_maps; i++) {
1564 StreamMap *map = &o->stream_maps[i];
1565 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1570 if (map->linklabel) {
1572 OutputFilter *ofilter = NULL;
1575 for (j = 0; j < nb_filtergraphs; j++) {
1576 fg = filtergraphs[j];
1577 for (k = 0; k < fg->nb_outputs; k++) {
1578 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1579 if (out && !strcmp(out->name, map->linklabel)) {
1580 ofilter = fg->outputs[k];
1587 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1588 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1591 init_output_filter(ofilter, o, oc);
1593 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1594 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1596 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1598 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1600 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1603 switch (ist->st->codec->codec_type) {
1604 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1605 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1606 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1607 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1608 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1610 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1611 map->file_index, map->stream_index);
1618 /* handle attached files */
1619 for (i = 0; i < o->nb_attachments; i++) {
1621 uint8_t *attachment;
1625 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1626 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1630 if ((len = avio_size(pb)) <= 0) {
1631 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1635 if (!(attachment = av_malloc(len))) {
1636 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1640 avio_read(pb, attachment, len);
1642 ost = new_attachment_stream(o, oc, -1);
1643 ost->stream_copy = 0;
1644 ost->attachment_filename = o->attachments[i];
1646 ost->st->codec->extradata = attachment;
1647 ost->st->codec->extradata_size = len;
1649 p = strrchr(o->attachments[i], '/');
1650 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1654 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1655 AVDictionaryEntry *e;
1656 ost = output_streams[i];
1658 if ((ost->stream_copy || ost->attachment_filename)
1659 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1660 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1661 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1665 GROW_ARRAY(output_files, nb_output_files);
1666 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1669 output_files[nb_output_files - 1]->ctx = oc;
1670 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1671 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1672 if (o->recording_time != INT64_MAX)
1673 oc->duration = o->recording_time;
1674 output_files[nb_output_files - 1]->start_time = o->start_time;
1675 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1676 output_files[nb_output_files - 1]->shortest = o->shortest;
1677 av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1679 /* check filename in case of an image number is expected */
1680 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1681 if (!av_filename_number_test(oc->filename)) {
1682 print_error(oc->filename, AVERROR(EINVAL));
1687 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1688 /* test if it already exists to avoid losing precious files */
1689 assert_file_overwrite(filename);
1692 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1693 &oc->interrupt_callback,
1694 &output_files[nb_output_files - 1]->opts)) < 0) {
1695 print_error(filename, err);
1700 if (o->mux_preload) {
1702 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1703 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1705 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1708 for (i = 0; i < o->nb_metadata_map; i++) {
1710 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1712 if (in_file_index >= nb_input_files) {
1713 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1716 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1717 in_file_index >= 0 ?
1718 input_files[in_file_index]->ctx : NULL, o);
1722 if (o->chapters_input_file >= nb_input_files) {
1723 if (o->chapters_input_file == INT_MAX) {
1724 /* copy chapters from the first input file that has them*/
1725 o->chapters_input_file = -1;
1726 for (i = 0; i < nb_input_files; i++)
1727 if (input_files[i]->ctx->nb_chapters) {
1728 o->chapters_input_file = i;
1732 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1733 o->chapters_input_file);
1737 if (o->chapters_input_file >= 0)
1738 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1739 !o->metadata_chapters_manual);
1741 /* copy global metadata by default */
1742 if (!o->metadata_global_manual && nb_input_files){
1743 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1744 AV_DICT_DONT_OVERWRITE);
1745 if(o->recording_time != INT64_MAX)
1746 av_dict_set(&oc->metadata, "duration", NULL, 0);
1747 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1749 if (!o->metadata_streams_manual)
1750 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1752 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1754 ist = input_streams[output_streams[i]->source_index];
1755 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1758 /* process manually set metadata */
1759 for (i = 0; i < o->nb_metadata; i++) {
1762 const char *stream_spec;
1763 int index = 0, j, ret = 0;
1765 val = strchr(o->metadata[i].u.str, '=');
1767 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1768 o->metadata[i].u.str);
1773 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1775 for (j = 0; j < oc->nb_streams; j++) {
1776 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1777 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1788 if (index < 0 || index >= oc->nb_chapters) {
1789 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1792 m = &oc->chapters[index]->metadata;
1795 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1798 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1805 static int opt_target(void *optctx, const char *opt, const char *arg)
1807 OptionsContext *o = optctx;
1808 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1809 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1811 if (!strncmp(arg, "pal-", 4)) {
1814 } else if (!strncmp(arg, "ntsc-", 5)) {
1817 } else if (!strncmp(arg, "film-", 5)) {
1821 /* Try to determine PAL/NTSC by peeking in the input files */
1822 if (nb_input_files) {
1824 for (j = 0; j < nb_input_files; j++) {
1825 for (i = 0; i < input_files[j]->nb_streams; i++) {
1826 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1827 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1829 fr = c->time_base.den * 1000 / c->time_base.num;
1833 } else if ((fr == 29970) || (fr == 23976)) {
1838 if (norm != UNKNOWN)
1842 if (norm != UNKNOWN)
1843 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1846 if (norm == UNKNOWN) {
1847 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1848 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1849 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1853 if (!strcmp(arg, "vcd")) {
1854 opt_video_codec(o, "c:v", "mpeg1video");
1855 opt_audio_codec(o, "c:a", "mp2");
1856 parse_option(o, "f", "vcd", options);
1857 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1859 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1860 parse_option(o, "r", frame_rates[norm], options);
1861 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1863 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1864 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1865 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1866 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1868 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1869 parse_option(o, "ar", "44100", options);
1870 parse_option(o, "ac", "2", options);
1872 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1873 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1875 /* We have to offset the PTS, so that it is consistent with the SCR.
1876 SCR starts at 36000, but the first two packs contain only padding
1877 and the first pack from the other stream, respectively, may also have
1878 been written before.
1879 So the real data starts at SCR 36000+3*1200. */
1880 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1881 } else if (!strcmp(arg, "svcd")) {
1883 opt_video_codec(o, "c:v", "mpeg2video");
1884 opt_audio_codec(o, "c:a", "mp2");
1885 parse_option(o, "f", "svcd", options);
1887 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1888 parse_option(o, "r", frame_rates[norm], options);
1889 parse_option(o, "pix_fmt", "yuv420p", options);
1890 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1892 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1893 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1894 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1895 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1896 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1898 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1899 parse_option(o, "ar", "44100", options);
1901 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1903 } else if (!strcmp(arg, "dvd")) {
1905 opt_video_codec(o, "c:v", "mpeg2video");
1906 opt_audio_codec(o, "c:a", "ac3");
1907 parse_option(o, "f", "dvd", options);
1909 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1910 parse_option(o, "r", frame_rates[norm], options);
1911 parse_option(o, "pix_fmt", "yuv420p", options);
1912 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1914 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1915 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1916 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1917 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1919 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.
1920 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1922 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1923 parse_option(o, "ar", "48000", options);
1925 } else if (!strncmp(arg, "dv", 2)) {
1927 parse_option(o, "f", "dv", options);
1929 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1930 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1931 norm == PAL ? "yuv420p" : "yuv411p", options);
1932 parse_option(o, "r", frame_rates[norm], options);
1934 parse_option(o, "ar", "48000", options);
1935 parse_option(o, "ac", "2", options);
1938 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1939 return AVERROR(EINVAL);
1944 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1946 av_free (vstats_filename);
1947 vstats_filename = av_strdup (arg);
1951 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1954 time_t today2 = time(NULL);
1955 struct tm *today = localtime(&today2);
1957 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1959 return opt_vstats_file(NULL, opt, filename);
1962 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1964 OptionsContext *o = optctx;
1965 return parse_option(o, "frames:v", arg, options);
1968 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1970 OptionsContext *o = optctx;
1971 return parse_option(o, "frames:a", arg, options);
1974 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1976 OptionsContext *o = optctx;
1977 return parse_option(o, "frames:d", arg, options);
1980 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
1983 AVDictionary *cbak = codec_opts;
1984 AVDictionary *fbak = format_opts;
1988 ret = opt_default(NULL, opt, arg);
1990 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
1991 av_dict_copy(&o->g->format_opts, format_opts, 0);
1992 av_dict_free(&codec_opts);
1993 av_dict_free(&format_opts);
2000 static int opt_preset(void *optctx, const char *opt, const char *arg)
2002 OptionsContext *o = optctx;
2004 char filename[1000], line[1000], tmp_line[1000];
2005 const char *codec_name = NULL;
2009 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2011 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2012 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2013 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2015 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2019 while (fgets(line, sizeof(line), f)) {
2020 char *key = tmp_line, *value, *endptr;
2022 if (strcspn(line, "#\n\r") == 0)
2024 strcpy(tmp_line, line);
2025 if (!av_strtok(key, "=", &value) ||
2026 !av_strtok(value, "\r\n", &endptr)) {
2027 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2030 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2032 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2033 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2034 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2035 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2036 else if (opt_default_new(o, key, value) < 0) {
2037 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2038 filename, line, key, value);
2048 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2050 OptionsContext *o = optctx;
2051 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2052 int ret = parse_option(o, s, arg, options);
2057 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2059 OptionsContext *o = optctx;
2060 if(!strcmp(opt, "b")){
2061 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2062 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2065 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2069 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2071 OptionsContext *o = optctx;
2074 if(!strcmp(opt, "qscale")){
2075 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2076 return parse_option(o, "q:v", arg, options);
2078 s = av_asprintf("q%s", opt + 6);
2079 ret = parse_option(o, s, arg, options);
2084 static int opt_profile(void *optctx, const char *opt, const char *arg)
2086 OptionsContext *o = optctx;
2087 if(!strcmp(opt, "profile")){
2088 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2089 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2092 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2096 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2098 OptionsContext *o = optctx;
2099 return parse_option(o, "filter:v", arg, options);
2102 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2104 OptionsContext *o = optctx;
2105 return parse_option(o, "filter:a", arg, options);
2108 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2110 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2111 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2112 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2113 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2115 if (video_sync_method == VSYNC_AUTO)
2116 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2120 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2122 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2127 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2129 OptionsContext *o = optctx;
2130 char *tcr = av_asprintf("timecode=%s", arg);
2131 int ret = parse_option(o, "metadata:g", tcr, options);
2133 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2138 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2140 OptionsContext *o = optctx;
2141 char layout_str[32];
2144 int ret, channels, ac_str_size;
2147 layout = av_get_channel_layout(arg);
2149 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2150 return AVERROR(EINVAL);
2152 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2153 ret = opt_default(NULL, opt, layout_str);
2157 /* set 'ac' option based on channel layout */
2158 channels = av_get_channel_layout_nb_channels(layout);
2159 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2160 stream_str = strchr(opt, ':');
2161 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2162 ac_str = av_mallocz(ac_str_size);
2164 return AVERROR(ENOMEM);
2165 av_strlcpy(ac_str, "ac", 3);
2167 av_strlcat(ac_str, stream_str, ac_str_size);
2168 ret = parse_option(o, ac_str, layout_str, options);
2174 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2176 OptionsContext *o = optctx;
2177 return parse_option(o, "q:a", arg, options);
2180 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2182 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2183 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2184 return AVERROR(ENOMEM);
2185 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2186 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2190 void show_help_default(const char *opt, const char *arg)
2192 /* per-file options have at least one of those set */
2193 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2194 int show_advanced = 0, show_avoptions = 0;
2197 if (!strcmp(opt, "long"))
2199 else if (!strcmp(opt, "full"))
2200 show_advanced = show_avoptions = 1;
2202 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2207 printf("Getting help:\n"
2208 " -h -- print basic options\n"
2209 " -h long -- print more options\n"
2210 " -h full -- print all options (including all format and codec specific options, very long)\n"
2211 " See man %s for detailed description of the options.\n"
2212 "\n", program_name);
2214 show_help_options(options, "Print help / information / capabilities:",
2217 show_help_options(options, "Global options (affect whole program "
2218 "instead of just one file:",
2219 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2221 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2222 per_file | OPT_EXIT, 0);
2224 show_help_options(options, "Per-file main options:", 0,
2225 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2226 OPT_EXIT, per_file);
2228 show_help_options(options, "Advanced per-file options:",
2229 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2231 show_help_options(options, "Video options:",
2232 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2234 show_help_options(options, "Advanced Video options:",
2235 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2237 show_help_options(options, "Audio options:",
2238 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2240 show_help_options(options, "Advanced Audio options:",
2241 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2242 show_help_options(options, "Subtitle options:",
2243 OPT_SUBTITLE, 0, 0);
2246 if (show_avoptions) {
2247 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2248 show_help_children(avcodec_get_class(), flags);
2249 show_help_children(avformat_get_class(), flags);
2250 show_help_children(sws_get_class(), flags);
2251 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2252 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2256 void show_usage(void)
2258 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2259 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2260 av_log(NULL, AV_LOG_INFO, "\n");
2268 static const OptionGroupDef groups[] = {
2269 [GROUP_OUTFILE] = { "output file", NULL },
2270 [GROUP_INFILE] = { "input file", "i" },
2273 static int open_files(OptionGroupList *l, const char *inout,
2274 int (*open_file)(OptionsContext*, const char*))
2278 for (i = 0; i < l->nb_groups; i++) {
2279 OptionGroup *g = &l->groups[i];
2282 init_options(&o, !strcmp(inout, "input"));
2285 ret = parse_optgroup(&o, g);
2287 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2288 "%s.\n", inout, g->arg);
2292 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2293 ret = open_file(&o, g->arg);
2294 uninit_options(&o, !strcmp(inout, "input"));
2296 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2300 av_log(NULL, AV_LOG_DEBUG, "Successfully openened the file.\n");
2306 int ffmpeg_parse_options(int argc, char **argv)
2308 OptionParseContext octx;
2312 memset(&octx, 0, sizeof(octx));
2314 /* split the commandline into an internal representation */
2315 ret = split_commandline(&octx, argc, argv, options, groups,
2316 FF_ARRAY_ELEMS(groups));
2318 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2322 /* apply global options */
2323 ret = parse_optgroup(NULL, &octx.global_opts);
2325 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2329 /* open input files */
2330 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2332 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2336 /* open output files */
2337 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2339 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2344 uninit_parse_context(&octx);
2346 av_strerror(ret, error, sizeof(error));
2347 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2352 static int opt_progress(void *optctx, const char *opt, const char *arg)
2354 AVIOContext *avio = NULL;
2357 if (!strcmp(arg, "-"))
2359 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2361 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2362 arg, av_err2str(ret));
2365 progress_avio = avio;
2369 #define OFFSET(x) offsetof(OptionsContext, x)
2370 const OptionDef options[] = {
2372 #include "cmdutils_common_opts.h"
2373 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2374 "force format", "fmt" },
2375 { "y", OPT_BOOL, { &file_overwrite },
2376 "overwrite output files" },
2377 { "n", OPT_BOOL, { &no_file_overwrite },
2378 "do not overwrite output files" },
2379 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2380 "codec name", "codec" },
2381 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2382 "codec name", "codec" },
2383 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2384 "preset name", "preset" },
2385 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2386 "set input stream mapping",
2387 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2388 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2389 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2390 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2391 "set metadata information of outfile from infile",
2392 "outfile[,metadata]:infile[,metadata]" },
2393 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2394 "set chapters mapping", "input_file_index" },
2395 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2396 "record or transcode \"duration\" seconds of audio/video",
2398 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2399 "set the limit file size in bytes", "limit_size" },
2400 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2401 "set the start time offset", "time_off" },
2402 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2403 "set the input ts offset", "time_off" },
2404 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2405 "set the input ts scale", "scale" },
2406 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2407 "set the recording timestamp ('now' to set the current time)", "time" },
2408 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2409 "add metadata", "string=string" },
2410 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2411 "set the number of data frames to record", "number" },
2412 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2413 "add timings for benchmarking" },
2414 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2415 "add timings for each task" },
2416 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2417 "write program-readable progress information", "url" },
2418 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2419 "enable or disable interaction on standard input" },
2420 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2421 "set max runtime in seconds", "limit" },
2422 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2423 "dump each input packet" },
2424 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2425 "when dumping packets, also dump the payload" },
2426 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2427 "read input at native frame rate", "" },
2428 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2429 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2430 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2431 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2432 "video sync method", "" },
2433 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2434 "audio sync method", "" },
2435 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2436 "audio drift threshold", "threshold" },
2437 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2438 "copy timestamps" },
2439 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2440 "copy input stream time base when stream copying", "mode" },
2441 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2442 "finish encoding within shortest input" },
2443 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2444 "timestamp discontinuity delta threshold", "threshold" },
2445 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2446 "timestamp error delta threshold", "threshold" },
2447 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2448 "exit on error", "error" },
2449 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2450 "copy initial non-keyframes" },
2451 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2452 "copy or discard frames before start time" },
2453 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2454 "set the number of frames to record", "number" },
2455 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2456 "force codec tag/fourcc", "fourcc/tag" },
2457 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2458 "use fixed quality scale (VBR)", "q" },
2459 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2460 "use fixed quality scale (VBR)", "q" },
2461 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2462 "set profile", "profile" },
2463 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2464 "set stream filterchain", "filter_list" },
2465 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2466 "reinit filtergraph on input parameter changes", "" },
2467 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2468 "create a complex filtergraph", "graph_description" },
2469 { "stats", OPT_BOOL, { &print_stats },
2470 "print progress report during encoding", },
2471 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2472 "add an attachment to the output file", "filename" },
2473 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2474 "extract an attachment into a file", "filename" },
2475 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2476 "print timestamp debugging info" },
2479 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2480 "set the number of video frames to record", "number" },
2481 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2482 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2483 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2484 "set frame size (WxH or abbreviation)", "size" },
2485 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2486 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2487 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2488 "set pixel format", "format" },
2489 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2490 "set the number of bits per raw sample", "number" },
2491 { "croptop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2492 "Removed, use the crop filter instead", "size" },
2493 { "cropbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2494 "Removed, use the crop filter instead", "size" },
2495 { "cropleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2496 "Removed, use the crop filter instead", "size" },
2497 { "cropright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_frame_crop },
2498 "Removed, use the crop filter instead", "size" },
2499 { "padtop", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2500 "Removed, use the pad filter instead", "size" },
2501 { "padbottom", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2502 "Removed, use the pad filter instead", "size" },
2503 { "padleft", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2504 "Removed, use the pad filter instead", "size" },
2505 { "padright", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2506 "Removed, use the pad filter instead", "size" },
2507 { "padcolor", OPT_VIDEO | HAS_ARG, { .func_arg = opt_pad },
2508 "Removed, use the pad filter instead", "color" },
2509 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2510 "deprecated use -g 1" },
2511 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2513 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2514 "discard threshold", "n" },
2515 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2516 "rate control override for specific intervals", "override" },
2517 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2518 "force video codec ('copy' to copy stream)", "codec" },
2519 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2521 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2523 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2524 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2525 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2526 "select the pass number (1 to 3)", "n" },
2527 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2528 "select two pass log file name prefix", "prefix" },
2529 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2530 "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 "video filters", "filter list" },
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 "audio filters", "filter list" },
2585 /* subtitle options */
2586 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2587 "disable subtitle" },
2588 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2589 "force subtitle codec ('copy' to copy stream)", "codec" },
2590 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2591 , "force subtitle tag/fourcc", "fourcc/tag" },
2592 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2593 "fix subtitles duration" },
2596 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2597 "deprecated, use -channel", "channel" },
2598 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2599 "deprecated, use -standard", "standard" },
2600 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2603 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2604 "set the maximum demux-decode delay", "seconds" },
2605 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2606 "set the initial demux-decode delay", "seconds" },
2608 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2609 "A comma-separated list of bitstream filters", "bitstream_filters" },
2610 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2611 "deprecated", "audio bitstream_filters" },
2612 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2613 "deprecated", "video bitstream_filters" },
2615 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2616 "set the audio options to the indicated preset", "preset" },
2617 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2618 "set the video options to the indicated preset", "preset" },
2619 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2620 "set the subtitle options to the indicated preset", "preset" },
2621 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2622 "set options from indicated preset file", "filename" },
2623 /* data codec support */
2624 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2625 "force data codec ('copy' to copy stream)", "codec" },
2626 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },