2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 for (i = 0; i < o->nb_ ## name; i++) {\
61 char *spec = o->name[i].specifier;\
62 if (!strcmp(spec, mediatype))\
63 outvar = o->name[i].u.type;\
66 char *vstats_filename;
68 float audio_drift_threshold = 0.1;
69 float dts_delta_threshold = 10;
70 float dts_error_threshold = 3600*30;
72 int audio_volume = 256;
73 int audio_sync_method = 0;
74 int video_sync_method = VSYNC_AUTO;
75 int do_deinterlace = 0;
77 int do_benchmark_all = 0;
83 int exit_on_error = 0;
86 int stdin_interaction = 1;
87 int frame_bits_per_raw_sample = 0;
90 static int intra_only = 0;
91 static int file_overwrite = 0;
92 static int no_file_overwrite = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int do_psnr = 0;
96 static int input_sync;
98 static int64_t recording_time = INT64_MAX;
100 static void uninit_options(OptionsContext *o, int is_input)
102 const OptionDef *po = options;
105 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
107 void *dst = (uint8_t*)o + po->u.off;
109 if (po->flags & OPT_SPEC) {
110 SpecifierOpt **so = dst;
111 int i, *count = (int*)(so + 1);
112 for (i = 0; i < *count; i++) {
113 av_freep(&(*so)[i].specifier);
114 if (po->flags & OPT_STRING)
115 av_freep(&(*so)[i].u.str);
119 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
124 for (i = 0; i < o->nb_stream_maps; i++)
125 av_freep(&o->stream_maps[i].linklabel);
126 av_freep(&o->stream_maps);
127 av_freep(&o->audio_channel_maps);
128 av_freep(&o->streamid_map);
129 av_freep(&o->attachments);
132 recording_time = o->recording_time;
134 recording_time = INT64_MAX;
137 static void init_options(OptionsContext *o, int is_input)
139 memset(o, 0, sizeof(*o));
141 if (!is_input && recording_time != INT64_MAX) {
142 o->recording_time = recording_time;
143 av_log(NULL, AV_LOG_WARNING,
144 "-t is not an input option, keeping it for the next output;"
145 " consider fixing your command line.\n");
147 o->recording_time = INT64_MAX;
148 o->stop_time = INT64_MAX;
149 o->mux_max_delay = 0.7;
150 o->limit_filesize = UINT64_MAX;
151 o->chapters_input_file = INT_MAX;
154 static int opt_sameq(void *optctx, const char *opt, const char *arg)
156 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
157 "If you are looking for an option to preserve the quality (which is not "
158 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
160 return AVERROR(EINVAL);
163 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
165 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
166 return opt_default(optctx, "channel", arg);
169 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
171 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
172 return opt_default(optctx, "standard", arg);
175 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
177 OptionsContext *o = optctx;
178 return parse_option(o, "codec:a", arg, options);
181 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
183 OptionsContext *o = optctx;
184 return parse_option(o, "codec:v", arg, options);
187 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
189 OptionsContext *o = optctx;
190 return parse_option(o, "codec:s", arg, options);
193 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
195 OptionsContext *o = optctx;
196 return parse_option(o, "codec:d", arg, options);
199 static int opt_map(void *optctx, const char *opt, const char *arg)
201 OptionsContext *o = optctx;
203 int i, negative = 0, file_idx;
204 int sync_file_idx = -1, sync_stream_idx = 0;
212 map = av_strdup(arg);
214 /* parse sync stream first, just pick first matching stream */
215 if (sync = strchr(map, ',')) {
217 sync_file_idx = strtol(sync + 1, &sync, 0);
218 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
219 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
224 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
225 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
226 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
230 if (i == input_files[sync_file_idx]->nb_streams) {
231 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
232 "match any streams.\n", arg);
239 /* this mapping refers to lavfi output */
240 const char *c = map + 1;
241 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
242 m = &o->stream_maps[o->nb_stream_maps - 1];
243 m->linklabel = av_get_token(&c, "]");
245 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
249 file_idx = strtol(map, &p, 0);
250 if (file_idx >= nb_input_files || file_idx < 0) {
251 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
255 /* disable some already defined maps */
256 for (i = 0; i < o->nb_stream_maps; i++) {
257 m = &o->stream_maps[i];
258 if (file_idx == m->file_index &&
259 check_stream_specifier(input_files[m->file_index]->ctx,
260 input_files[m->file_index]->ctx->streams[m->stream_index],
261 *p == ':' ? p + 1 : p) > 0)
265 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
266 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
267 *p == ':' ? p + 1 : p) <= 0)
269 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
270 m = &o->stream_maps[o->nb_stream_maps - 1];
272 m->file_index = file_idx;
275 if (sync_file_idx >= 0) {
276 m->sync_file_index = sync_file_idx;
277 m->sync_stream_index = sync_stream_idx;
279 m->sync_file_index = file_idx;
280 m->sync_stream_index = i;
286 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
294 static int opt_attach(void *optctx, const char *opt, const char *arg)
296 OptionsContext *o = optctx;
297 GROW_ARRAY(o->attachments, o->nb_attachments);
298 o->attachments[o->nb_attachments - 1] = arg;
302 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
304 OptionsContext *o = optctx;
309 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
310 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
312 /* muted channel syntax */
313 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
314 if ((n == 1 || n == 3) && m->channel_idx == -1) {
315 m->file_idx = m->stream_idx = -1;
317 m->ofile_idx = m->ostream_idx = -1;
322 n = sscanf(arg, "%d.%d.%d:%d.%d",
323 &m->file_idx, &m->stream_idx, &m->channel_idx,
324 &m->ofile_idx, &m->ostream_idx);
326 if (n != 3 && n != 5) {
327 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
328 "[file.stream.channel|-1][:syncfile:syncstream]\n");
332 if (n != 5) // only file.stream.channel specified
333 m->ofile_idx = m->ostream_idx = -1;
336 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
337 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
341 if (m->stream_idx < 0 ||
342 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
343 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
344 m->file_idx, m->stream_idx);
347 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
348 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
349 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
350 m->file_idx, m->stream_idx);
353 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
354 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
355 m->file_idx, m->stream_idx, m->channel_idx);
362 * Parse a metadata specifier passed as 'arg' parameter.
363 * @param arg metadata string to parse
364 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
365 * @param index for type c/p, chapter/program index is written here
366 * @param stream_spec for type s, the stream specifier is written here
368 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
376 if (*(++arg) && *arg != ':') {
377 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
380 *stream_spec = *arg == ':' ? arg + 1 : "";
385 *index = strtol(++arg, NULL, 0);
388 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
395 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
397 AVDictionary **meta_in = NULL;
398 AVDictionary **meta_out = NULL;
400 char type_in, type_out;
401 const char *istream_spec = NULL, *ostream_spec = NULL;
402 int idx_in = 0, idx_out = 0;
404 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
405 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
408 if (type_out == 'g' || !*outspec)
409 o->metadata_global_manual = 1;
410 if (type_out == 's' || !*outspec)
411 o->metadata_streams_manual = 1;
412 if (type_out == 'c' || !*outspec)
413 o->metadata_chapters_manual = 1;
417 if (type_in == 'g' || type_out == 'g')
418 o->metadata_global_manual = 1;
419 if (type_in == 's' || type_out == 's')
420 o->metadata_streams_manual = 1;
421 if (type_in == 'c' || type_out == 'c')
422 o->metadata_chapters_manual = 1;
424 /* ic is NULL when just disabling automatic mappings */
428 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
429 if ((index) < 0 || (index) >= (nb_elems)) {\
430 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
435 #define SET_DICT(type, meta, context, index)\
438 meta = &context->metadata;\
441 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
442 meta = &context->chapters[index]->metadata;\
445 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
446 meta = &context->programs[index]->metadata;\
449 break; /* handled separately below */ \
450 default: av_assert0(0);\
453 SET_DICT(type_in, meta_in, ic, idx_in);
454 SET_DICT(type_out, meta_out, oc, idx_out);
456 /* for input streams choose first matching stream */
457 if (type_in == 's') {
458 for (i = 0; i < ic->nb_streams; i++) {
459 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
460 meta_in = &ic->streams[i]->metadata;
466 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
471 if (type_out == 's') {
472 for (i = 0; i < oc->nb_streams; i++) {
473 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
474 meta_out = &oc->streams[i]->metadata;
475 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
480 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
485 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
487 OptionsContext *o = optctx;
489 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
490 struct tm time = *gmtime((time_t*)&recording_timestamp);
491 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
492 parse_option(o, "metadata", buf, options);
494 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
495 "tag instead.\n", opt);
499 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
501 const AVCodecDescriptor *desc;
502 const char *codec_string = encoder ? "encoder" : "decoder";
506 avcodec_find_encoder_by_name(name) :
507 avcodec_find_decoder_by_name(name);
509 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
510 codec = encoder ? avcodec_find_encoder(desc->id) :
511 avcodec_find_decoder(desc->id);
513 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
514 codec_string, codec->name, desc->name);
518 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
521 if (codec->type != type) {
522 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
528 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
530 char *codec_name = NULL;
532 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
534 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
535 st->codec->codec_id = codec->id;
538 return avcodec_find_decoder(st->codec->codec_id);
541 /* Add all the streams from the given input file to the global
542 * list of input streams. */
543 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
546 char *next, *codec_tag = NULL;
548 for (i = 0; i < ic->nb_streams; i++) {
549 AVStream *st = ic->streams[i];
550 AVCodecContext *dec = st->codec;
551 InputStream *ist = av_mallocz(sizeof(*ist));
552 char *framerate = NULL;
557 GROW_ARRAY(input_streams, nb_input_streams);
558 input_streams[nb_input_streams - 1] = ist;
561 ist->file_index = nb_input_files;
563 st->discard = AVDISCARD_ALL;
566 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
568 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
570 uint32_t tag = strtol(codec_tag, &next, 0);
572 tag = AV_RL32(codec_tag);
573 st->codec->codec_tag = tag;
576 ist->dec = choose_decoder(o, ic, st);
577 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
579 ist->reinit_filters = -1;
580 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
582 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
584 switch (dec->codec_type) {
585 case AVMEDIA_TYPE_VIDEO:
587 ist->dec = avcodec_find_decoder(dec->codec_id);
589 dec->flags |= CODEC_FLAG_EMU_EDGE;
592 ist->resample_height = dec->height;
593 ist->resample_width = dec->width;
594 ist->resample_pix_fmt = dec->pix_fmt;
596 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
597 if (framerate && av_parse_video_rate(&ist->framerate,
599 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
604 ist->top_field_first = -1;
605 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
608 case AVMEDIA_TYPE_AUDIO:
609 ist->guess_layout_max = INT_MAX;
610 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
611 guess_input_channel_layout(ist);
613 ist->resample_sample_fmt = dec->sample_fmt;
614 ist->resample_sample_rate = dec->sample_rate;
615 ist->resample_channels = dec->channels;
616 ist->resample_channel_layout = dec->channel_layout;
619 case AVMEDIA_TYPE_DATA:
620 case AVMEDIA_TYPE_SUBTITLE: {
621 char *canvas_size = NULL;
623 ist->dec = avcodec_find_decoder(dec->codec_id);
624 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
625 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
627 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
628 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
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);
969 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
972 avcodec_get_context_defaults3(st->codec, ost->enc);
973 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
975 ost->max_frames = INT64_MAX;
976 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
978 ost->copy_prior_start = -1;
979 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
981 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
983 if (next = strchr(bsf, ','))
985 if (!(bsfc = av_bitstream_filter_init(bsf))) {
986 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
990 bsfc_prev->next = bsfc;
992 ost->bitstream_filters = bsfc;
998 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1000 uint32_t tag = strtol(codec_tag, &next, 0);
1002 tag = AV_RL32(codec_tag);
1003 st->codec->codec_tag = tag;
1006 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1008 st->codec->flags |= CODEC_FLAG_QSCALE;
1009 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1012 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1013 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1015 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1017 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1018 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1019 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1021 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1023 ost->source_index = source_index;
1024 if (source_index >= 0) {
1025 ost->sync_ist = input_streams[source_index];
1026 input_streams[source_index]->discard = 0;
1027 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1033 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1036 const char *p = str;
1043 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1050 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1054 AVCodecContext *video_enc;
1055 char *frame_rate = NULL;
1057 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1059 video_enc = st->codec;
1061 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1062 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1063 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1067 if (!ost->stream_copy) {
1068 const char *p = NULL;
1069 char *frame_size = NULL;
1070 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1071 char *intra_matrix = NULL, *inter_matrix = NULL;
1072 const char *filters = "null";
1076 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1077 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1078 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1082 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1083 if (frame_aspect_ratio) {
1085 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1086 q.num <= 0 || q.den <= 0) {
1087 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1090 ost->frame_aspect_ratio = av_q2d(q);
1093 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1094 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1095 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1096 ost->keep_pix_fmt = 1;
1097 if (!*++frame_pix_fmt)
1098 frame_pix_fmt = NULL;
1100 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1101 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1104 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1107 video_enc->gop_size = 0;
1108 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1110 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1111 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1114 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1116 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1118 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1119 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1122 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1125 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1126 for (i = 0; p; i++) {
1128 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1130 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1133 /* FIXME realloc failure */
1134 video_enc->rc_override =
1135 av_realloc(video_enc->rc_override,
1136 sizeof(RcOverride) * (i + 1));
1137 video_enc->rc_override[i].start_frame = start;
1138 video_enc->rc_override[i].end_frame = end;
1140 video_enc->rc_override[i].qscale = q;
1141 video_enc->rc_override[i].quality_factor = 1.0;
1144 video_enc->rc_override[i].qscale = 0;
1145 video_enc->rc_override[i].quality_factor = -q/100.0;
1150 video_enc->rc_override_count = i;
1151 video_enc->intra_dc_precision = intra_dc_precision - 8;
1154 video_enc->flags|= CODEC_FLAG_PSNR;
1157 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1160 video_enc->flags |= CODEC_FLAG_PASS1;
1161 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1164 video_enc->flags |= CODEC_FLAG_PASS2;
1165 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1169 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1170 if (ost->logfile_prefix &&
1171 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1174 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1175 if (ost->forced_keyframes)
1176 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1178 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1180 ost->top_field_first = -1;
1181 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1183 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1184 ost->avfilter = av_strdup(filters);
1186 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1192 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1197 AVCodecContext *audio_enc;
1199 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1202 audio_enc = st->codec;
1203 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1205 if (!ost->stream_copy) {
1206 char *sample_fmt = NULL;
1207 const char *filters = "anull";
1209 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1211 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1213 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1214 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1218 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1220 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1222 av_assert1(filters);
1223 ost->avfilter = av_strdup(filters);
1225 /* check for channel mapping for this audio stream */
1226 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1227 AudioChannelMap *map = &o->audio_channel_maps[n];
1228 InputStream *ist = input_streams[ost->source_index];
1229 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1230 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1231 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1232 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1233 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1235 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1236 ost->file_index, ost->st->index);
1244 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1248 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1249 if (!ost->stream_copy) {
1250 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1257 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1259 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1260 ost->stream_copy = 1;
1264 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1268 AVCodecContext *subtitle_enc;
1270 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1272 subtitle_enc = st->codec;
1274 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1276 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1278 if (!ost->stream_copy) {
1279 char *frame_size = NULL;
1281 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1282 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1283 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1291 /* arg format is "output-stream-index:streamid-value". */
1292 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1294 OptionsContext *o = optctx;
1299 av_strlcpy(idx_str, arg, sizeof(idx_str));
1300 p = strchr(idx_str, ':');
1302 av_log(NULL, AV_LOG_FATAL,
1303 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1308 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1309 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1310 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1314 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1316 AVFormatContext *is = ifile->ctx;
1317 AVFormatContext *os = ofile->ctx;
1321 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1323 return AVERROR(ENOMEM);
1326 for (i = 0; i < is->nb_chapters; i++) {
1327 AVChapter *in_ch = is->chapters[i], *out_ch;
1328 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1329 AV_TIME_BASE_Q, in_ch->time_base);
1330 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1331 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1334 if (in_ch->end < ts_off)
1336 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1339 out_ch = av_mallocz(sizeof(AVChapter));
1341 return AVERROR(ENOMEM);
1343 out_ch->id = in_ch->id;
1344 out_ch->time_base = in_ch->time_base;
1345 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1346 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1349 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1351 os->chapters[os->nb_chapters++] = out_ch;
1356 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1359 AVFormatContext *ic = avformat_alloc_context();
1361 ic->interrupt_callback = int_cb;
1362 err = avformat_open_input(&ic, filename, NULL, NULL);
1365 /* copy stream format */
1366 for(i=0;i<ic->nb_streams;i++) {
1370 AVCodecContext *avctx;
1372 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1373 ost = new_output_stream(o, s, codec->type, -1);
1378 // FIXME: a more elegant solution is needed
1379 memcpy(st, ic->streams[i], sizeof(AVStream));
1381 st->info = av_malloc(sizeof(*st->info));
1382 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1384 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1386 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1387 choose_sample_fmt(st, codec);
1388 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1389 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1392 /* ffserver seeking with date=... needs a date reference */
1393 err = parse_option(o, "metadata", "creation_time=now", options);
1395 avformat_close_input(&ic);
1399 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1400 AVFormatContext *oc)
1404 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1405 ofilter->out_tmp->pad_idx)) {
1406 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1407 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1409 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1414 ost->source_index = -1;
1415 ost->filter = ofilter;
1419 if (ost->stream_copy) {
1420 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1421 "which is fed from a complex filtergraph. Filtering and streamcopy "
1422 "cannot be used together.\n", ost->file_index, ost->index);
1426 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1427 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1430 avfilter_inout_free(&ofilter->out_tmp);
1433 static int configure_complex_filters(void)
1437 for (i = 0; i < nb_filtergraphs; i++)
1438 if (!filtergraphs[i]->graph &&
1439 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1444 static int open_output_file(OptionsContext *o, const char *filename)
1446 AVFormatContext *oc;
1448 AVOutputFormat *file_oformat;
1452 if (configure_complex_filters() < 0) {
1453 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1457 if (!strcmp(filename, "-"))
1460 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1462 print_error(filename, err);
1465 file_oformat= oc->oformat;
1466 oc->interrupt_callback = int_cb;
1468 /* create streams for all unlabeled output pads */
1469 for (i = 0; i < nb_filtergraphs; i++) {
1470 FilterGraph *fg = filtergraphs[i];
1471 for (j = 0; j < fg->nb_outputs; j++) {
1472 OutputFilter *ofilter = fg->outputs[j];
1474 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1477 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1478 ofilter->out_tmp->pad_idx)) {
1479 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1480 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1481 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1483 init_output_filter(ofilter, o, oc);
1487 if (!strcmp(file_oformat->name, "ffm") &&
1488 av_strstart(filename, "http:", NULL)) {
1490 /* special case for files sent to ffserver: we get the stream
1491 parameters from ffserver */
1492 int err = read_ffserver_streams(o, oc, filename);
1494 print_error(filename, err);
1497 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1498 ost = output_streams[j];
1499 for (i = 0; i < nb_input_streams; i++) {
1500 ist = input_streams[i];
1501 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1503 ost->source_index= i;
1504 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1505 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1507 ist->st->discard = AVDISCARD_NONE;
1512 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));
1516 } else if (!o->nb_stream_maps) {
1517 char *subtitle_codec_name = NULL;
1518 /* pick the "best" stream of each type */
1520 /* video: highest resolution */
1521 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1522 int area = 0, idx = -1;
1523 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1524 for (i = 0; i < nb_input_streams; i++) {
1526 ist = input_streams[i];
1527 new_area = ist->st->codec->width * ist->st->codec->height;
1528 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1530 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1532 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1539 new_video_stream(o, oc, idx);
1542 /* audio: most channels */
1543 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1544 int channels = 0, idx = -1;
1545 for (i = 0; i < nb_input_streams; i++) {
1546 ist = input_streams[i];
1547 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1548 ist->st->codec->channels > channels) {
1549 channels = ist->st->codec->channels;
1554 new_audio_stream(o, oc, idx);
1557 /* subtitles: pick first */
1558 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1559 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1560 for (i = 0; i < nb_input_streams; i++)
1561 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1562 new_subtitle_stream(o, oc, i);
1566 /* do something with data? */
1568 for (i = 0; i < o->nb_stream_maps; i++) {
1569 StreamMap *map = &o->stream_maps[i];
1570 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1575 if (map->linklabel) {
1577 OutputFilter *ofilter = NULL;
1580 for (j = 0; j < nb_filtergraphs; j++) {
1581 fg = filtergraphs[j];
1582 for (k = 0; k < fg->nb_outputs; k++) {
1583 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1584 if (out && !strcmp(out->name, map->linklabel)) {
1585 ofilter = fg->outputs[k];
1592 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1593 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1596 init_output_filter(ofilter, o, oc);
1598 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1599 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1601 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1603 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1605 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1608 switch (ist->st->codec->codec_type) {
1609 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1610 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1611 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1612 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1613 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1615 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1616 map->file_index, map->stream_index);
1623 /* handle attached files */
1624 for (i = 0; i < o->nb_attachments; i++) {
1626 uint8_t *attachment;
1630 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1631 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1635 if ((len = avio_size(pb)) <= 0) {
1636 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1640 if (!(attachment = av_malloc(len))) {
1641 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1645 avio_read(pb, attachment, len);
1647 ost = new_attachment_stream(o, oc, -1);
1648 ost->stream_copy = 0;
1649 ost->attachment_filename = o->attachments[i];
1651 ost->st->codec->extradata = attachment;
1652 ost->st->codec->extradata_size = len;
1654 p = strrchr(o->attachments[i], '/');
1655 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1659 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1660 AVDictionaryEntry *e;
1661 ost = output_streams[i];
1663 if ((ost->stream_copy || ost->attachment_filename)
1664 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1665 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1666 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1670 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1671 o->stop_time = INT64_MAX;
1672 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1675 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1676 if (o->stop_time <= o->start_time) {
1677 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1678 o->stop_time = INT64_MAX;
1680 o->recording_time = o->stop_time - o->start_time;
1684 GROW_ARRAY(output_files, nb_output_files);
1685 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1688 output_files[nb_output_files - 1]->ctx = oc;
1689 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1690 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1691 if (o->recording_time != INT64_MAX)
1692 oc->duration = o->recording_time;
1693 output_files[nb_output_files - 1]->start_time = o->start_time;
1694 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1695 output_files[nb_output_files - 1]->shortest = o->shortest;
1696 av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1698 /* check filename in case of an image number is expected */
1699 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1700 if (!av_filename_number_test(oc->filename)) {
1701 print_error(oc->filename, AVERROR(EINVAL));
1706 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1707 /* test if it already exists to avoid losing precious files */
1708 assert_file_overwrite(filename);
1711 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1712 &oc->interrupt_callback,
1713 &output_files[nb_output_files - 1]->opts)) < 0) {
1714 print_error(filename, err);
1717 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1718 assert_file_overwrite(filename);
1720 if (o->mux_preload) {
1722 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1723 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1725 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1728 for (i = 0; i < o->nb_metadata_map; i++) {
1730 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1732 if (in_file_index >= nb_input_files) {
1733 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1736 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1737 in_file_index >= 0 ?
1738 input_files[in_file_index]->ctx : NULL, o);
1742 if (o->chapters_input_file >= nb_input_files) {
1743 if (o->chapters_input_file == INT_MAX) {
1744 /* copy chapters from the first input file that has them*/
1745 o->chapters_input_file = -1;
1746 for (i = 0; i < nb_input_files; i++)
1747 if (input_files[i]->ctx->nb_chapters) {
1748 o->chapters_input_file = i;
1752 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1753 o->chapters_input_file);
1757 if (o->chapters_input_file >= 0)
1758 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1759 !o->metadata_chapters_manual);
1761 /* copy global metadata by default */
1762 if (!o->metadata_global_manual && nb_input_files){
1763 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1764 AV_DICT_DONT_OVERWRITE);
1765 if(o->recording_time != INT64_MAX)
1766 av_dict_set(&oc->metadata, "duration", NULL, 0);
1767 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1769 if (!o->metadata_streams_manual)
1770 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1772 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1774 ist = input_streams[output_streams[i]->source_index];
1775 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1778 /* process manually set metadata */
1779 for (i = 0; i < o->nb_metadata; i++) {
1782 const char *stream_spec;
1783 int index = 0, j, ret = 0;
1785 val = strchr(o->metadata[i].u.str, '=');
1787 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1788 o->metadata[i].u.str);
1793 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1795 for (j = 0; j < oc->nb_streams; j++) {
1796 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1797 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1808 if (index < 0 || index >= oc->nb_chapters) {
1809 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1812 m = &oc->chapters[index]->metadata;
1815 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1818 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1825 static int opt_target(void *optctx, const char *opt, const char *arg)
1827 OptionsContext *o = optctx;
1828 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1829 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1831 if (!strncmp(arg, "pal-", 4)) {
1834 } else if (!strncmp(arg, "ntsc-", 5)) {
1837 } else if (!strncmp(arg, "film-", 5)) {
1841 /* Try to determine PAL/NTSC by peeking in the input files */
1842 if (nb_input_files) {
1844 for (j = 0; j < nb_input_files; j++) {
1845 for (i = 0; i < input_files[j]->nb_streams; i++) {
1846 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1847 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1849 fr = c->time_base.den * 1000 / c->time_base.num;
1853 } else if ((fr == 29970) || (fr == 23976)) {
1858 if (norm != UNKNOWN)
1862 if (norm != UNKNOWN)
1863 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1866 if (norm == UNKNOWN) {
1867 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1868 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1869 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1873 if (!strcmp(arg, "vcd")) {
1874 opt_video_codec(o, "c:v", "mpeg1video");
1875 opt_audio_codec(o, "c:a", "mp2");
1876 parse_option(o, "f", "vcd", options);
1877 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1879 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1880 parse_option(o, "r", frame_rates[norm], options);
1881 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1883 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1884 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1885 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1886 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1888 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1889 parse_option(o, "ar", "44100", options);
1890 parse_option(o, "ac", "2", options);
1892 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1893 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1895 /* We have to offset the PTS, so that it is consistent with the SCR.
1896 SCR starts at 36000, but the first two packs contain only padding
1897 and the first pack from the other stream, respectively, may also have
1898 been written before.
1899 So the real data starts at SCR 36000+3*1200. */
1900 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1901 } else if (!strcmp(arg, "svcd")) {
1903 opt_video_codec(o, "c:v", "mpeg2video");
1904 opt_audio_codec(o, "c:a", "mp2");
1905 parse_option(o, "f", "svcd", options);
1907 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1908 parse_option(o, "r", frame_rates[norm], options);
1909 parse_option(o, "pix_fmt", "yuv420p", options);
1910 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1912 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
1913 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
1914 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
1915 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1916 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
1918 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1919 parse_option(o, "ar", "44100", options);
1921 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1923 } else if (!strcmp(arg, "dvd")) {
1925 opt_video_codec(o, "c:v", "mpeg2video");
1926 opt_audio_codec(o, "c:a", "ac3");
1927 parse_option(o, "f", "dvd", options);
1929 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1930 parse_option(o, "r", frame_rates[norm], options);
1931 parse_option(o, "pix_fmt", "yuv420p", options);
1932 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1934 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
1935 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
1936 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
1937 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
1939 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.
1940 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1942 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
1943 parse_option(o, "ar", "48000", options);
1945 } else if (!strncmp(arg, "dv", 2)) {
1947 parse_option(o, "f", "dv", options);
1949 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1950 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1951 norm == PAL ? "yuv420p" : "yuv411p", options);
1952 parse_option(o, "r", frame_rates[norm], options);
1954 parse_option(o, "ar", "48000", options);
1955 parse_option(o, "ac", "2", options);
1958 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1959 return AVERROR(EINVAL);
1964 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1966 av_free (vstats_filename);
1967 vstats_filename = av_strdup (arg);
1971 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1974 time_t today2 = time(NULL);
1975 struct tm *today = localtime(&today2);
1977 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1979 return opt_vstats_file(NULL, opt, filename);
1982 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1984 OptionsContext *o = optctx;
1985 return parse_option(o, "frames:v", arg, options);
1988 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1990 OptionsContext *o = optctx;
1991 return parse_option(o, "frames:a", arg, options);
1994 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1996 OptionsContext *o = optctx;
1997 return parse_option(o, "frames:d", arg, options);
2000 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2003 AVDictionary *cbak = codec_opts;
2004 AVDictionary *fbak = format_opts;
2008 ret = opt_default(NULL, opt, arg);
2010 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2011 av_dict_copy(&o->g->format_opts, format_opts, 0);
2012 av_dict_free(&codec_opts);
2013 av_dict_free(&format_opts);
2020 static int opt_preset(void *optctx, const char *opt, const char *arg)
2022 OptionsContext *o = optctx;
2024 char filename[1000], line[1000], tmp_line[1000];
2025 const char *codec_name = NULL;
2029 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2031 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2032 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2033 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2035 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2039 while (fgets(line, sizeof(line), f)) {
2040 char *key = tmp_line, *value, *endptr;
2042 if (strcspn(line, "#\n\r") == 0)
2044 strcpy(tmp_line, line);
2045 if (!av_strtok(key, "=", &value) ||
2046 !av_strtok(value, "\r\n", &endptr)) {
2047 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2050 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2052 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2053 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2054 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2055 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2056 else if (opt_default_new(o, key, value) < 0) {
2057 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2058 filename, line, key, value);
2068 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2070 OptionsContext *o = optctx;
2071 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2072 int ret = parse_option(o, s, arg, options);
2077 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2079 OptionsContext *o = optctx;
2080 if(!strcmp(opt, "b")){
2081 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2082 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2085 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2089 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2091 OptionsContext *o = optctx;
2094 if(!strcmp(opt, "qscale")){
2095 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2096 return parse_option(o, "q:v", arg, options);
2098 s = av_asprintf("q%s", opt + 6);
2099 ret = parse_option(o, s, arg, options);
2104 static int opt_profile(void *optctx, const char *opt, const char *arg)
2106 OptionsContext *o = optctx;
2107 if(!strcmp(opt, "profile")){
2108 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2109 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2112 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2116 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2118 OptionsContext *o = optctx;
2119 return parse_option(o, "filter:v", arg, options);
2122 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2124 OptionsContext *o = optctx;
2125 return parse_option(o, "filter:a", arg, options);
2128 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2130 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2131 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2132 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2133 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2135 if (video_sync_method == VSYNC_AUTO)
2136 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2140 #if FF_API_DEINTERLACE
2141 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2143 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2149 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2151 OptionsContext *o = optctx;
2152 char *tcr = av_asprintf("timecode=%s", arg);
2153 int ret = parse_option(o, "metadata:g", tcr, options);
2155 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2160 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2162 OptionsContext *o = optctx;
2163 char layout_str[32];
2166 int ret, channels, ac_str_size;
2169 layout = av_get_channel_layout(arg);
2171 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2172 return AVERROR(EINVAL);
2174 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2175 ret = opt_default_new(o, opt, layout_str);
2179 /* set 'ac' option based on channel layout */
2180 channels = av_get_channel_layout_nb_channels(layout);
2181 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2182 stream_str = strchr(opt, ':');
2183 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2184 ac_str = av_mallocz(ac_str_size);
2186 return AVERROR(ENOMEM);
2187 av_strlcpy(ac_str, "ac", 3);
2189 av_strlcat(ac_str, stream_str, ac_str_size);
2190 ret = parse_option(o, ac_str, layout_str, options);
2196 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2198 OptionsContext *o = optctx;
2199 return parse_option(o, "q:a", arg, options);
2202 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2204 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2205 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2206 return AVERROR(ENOMEM);
2207 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2208 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2212 void show_help_default(const char *opt, const char *arg)
2214 /* per-file options have at least one of those set */
2215 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2216 int show_advanced = 0, show_avoptions = 0;
2219 if (!strcmp(opt, "long"))
2221 else if (!strcmp(opt, "full"))
2222 show_advanced = show_avoptions = 1;
2224 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2229 printf("Getting help:\n"
2230 " -h -- print basic options\n"
2231 " -h long -- print more options\n"
2232 " -h full -- print all options (including all format and codec specific options, very long)\n"
2233 " See man %s for detailed description of the options.\n"
2234 "\n", program_name);
2236 show_help_options(options, "Print help / information / capabilities:",
2239 show_help_options(options, "Global options (affect whole program "
2240 "instead of just one file:",
2241 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2243 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2244 per_file | OPT_EXIT, 0);
2246 show_help_options(options, "Per-file main options:", 0,
2247 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2248 OPT_EXIT, per_file);
2250 show_help_options(options, "Advanced per-file options:",
2251 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2253 show_help_options(options, "Video options:",
2254 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2256 show_help_options(options, "Advanced Video options:",
2257 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2259 show_help_options(options, "Audio options:",
2260 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2262 show_help_options(options, "Advanced Audio options:",
2263 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2264 show_help_options(options, "Subtitle options:",
2265 OPT_SUBTITLE, 0, 0);
2268 if (show_avoptions) {
2269 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2270 show_help_children(avcodec_get_class(), flags);
2271 show_help_children(avformat_get_class(), flags);
2272 show_help_children(sws_get_class(), flags);
2273 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2274 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2278 void show_usage(void)
2280 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2281 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2282 av_log(NULL, AV_LOG_INFO, "\n");
2290 static const OptionGroupDef groups[] = {
2291 [GROUP_OUTFILE] = { "output file", NULL },
2292 [GROUP_INFILE] = { "input file", "i" },
2295 static int open_files(OptionGroupList *l, const char *inout,
2296 int (*open_file)(OptionsContext*, const char*))
2300 for (i = 0; i < l->nb_groups; i++) {
2301 OptionGroup *g = &l->groups[i];
2304 init_options(&o, !strcmp(inout, "input"));
2307 ret = parse_optgroup(&o, g);
2309 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2310 "%s.\n", inout, g->arg);
2314 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2315 ret = open_file(&o, g->arg);
2316 uninit_options(&o, !strcmp(inout, "input"));
2318 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2322 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2328 int ffmpeg_parse_options(int argc, char **argv)
2330 OptionParseContext octx;
2334 memset(&octx, 0, sizeof(octx));
2336 /* split the commandline into an internal representation */
2337 ret = split_commandline(&octx, argc, argv, options, groups,
2338 FF_ARRAY_ELEMS(groups));
2340 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2344 /* apply global options */
2345 ret = parse_optgroup(NULL, &octx.global_opts);
2347 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2351 /* open input files */
2352 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2354 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2358 /* open output files */
2359 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2361 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2366 uninit_parse_context(&octx);
2368 av_strerror(ret, error, sizeof(error));
2369 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2374 static int opt_progress(void *optctx, const char *opt, const char *arg)
2376 AVIOContext *avio = NULL;
2379 if (!strcmp(arg, "-"))
2381 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2383 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2384 arg, av_err2str(ret));
2387 progress_avio = avio;
2391 #define OFFSET(x) offsetof(OptionsContext, x)
2392 const OptionDef options[] = {
2394 #include "cmdutils_common_opts.h"
2395 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
2396 "force format", "fmt" },
2397 { "y", OPT_BOOL, { &file_overwrite },
2398 "overwrite output files" },
2399 { "n", OPT_BOOL, { &no_file_overwrite },
2400 "do not overwrite output files" },
2401 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2402 "codec name", "codec" },
2403 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
2404 "codec name", "codec" },
2405 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
2406 "preset name", "preset" },
2407 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
2408 "set input stream mapping",
2409 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2410 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map_channel },
2411 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2412 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
2413 "set metadata information of outfile from infile",
2414 "outfile[,metadata]:infile[,metadata]" },
2415 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2416 "set chapters mapping", "input_file_index" },
2417 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
2418 "record or transcode \"duration\" seconds of audio/video",
2420 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(stop_time) },
2421 "record or transcode stop time", "time_stop" },
2422 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
2423 "set the limit file size in bytes", "limit_size" },
2424 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
2425 "set the start time offset", "time_off" },
2426 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2427 "set the input ts offset", "time_off" },
2428 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2429 "set the input ts scale", "scale" },
2430 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2431 "set the recording timestamp ('now' to set the current time)", "time" },
2432 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
2433 "add metadata", "string=string" },
2434 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
2435 "set the number of data frames to record", "number" },
2436 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2437 "add timings for benchmarking" },
2438 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2439 "add timings for each task" },
2440 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2441 "write program-readable progress information", "url" },
2442 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2443 "enable or disable interaction on standard input" },
2444 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2445 "set max runtime in seconds", "limit" },
2446 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2447 "dump each input packet" },
2448 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2449 "when dumping packets, also dump the payload" },
2450 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
2451 "read input at native frame rate", "" },
2452 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
2453 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2454 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2455 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2456 "video sync method", "" },
2457 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2458 "audio sync method", "" },
2459 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2460 "audio drift threshold", "threshold" },
2461 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2462 "copy timestamps" },
2463 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2464 "copy input stream time base when stream copying", "mode" },
2465 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2466 "finish encoding within shortest input" },
2467 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2468 "timestamp discontinuity delta threshold", "threshold" },
2469 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2470 "timestamp error delta threshold", "threshold" },
2471 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2472 "exit on error", "error" },
2473 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2474 "copy initial non-keyframes" },
2475 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_prior_start) },
2476 "copy or discard frames before start time" },
2477 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2478 "set the number of frames to record", "number" },
2479 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2480 "force codec tag/fourcc", "fourcc/tag" },
2481 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2482 "use fixed quality scale (VBR)", "q" },
2483 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_qscale },
2484 "use fixed quality scale (VBR)", "q" },
2485 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_profile },
2486 "set profile", "profile" },
2487 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2488 "set stream filtergraph", "filter_graph" },
2489 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(reinit_filters) },
2490 "reinit filtergraph on input parameter changes", "" },
2491 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2492 "create a complex filtergraph", "graph_description" },
2493 { "stats", OPT_BOOL, { &print_stats },
2494 "print progress report during encoding", },
2495 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2496 "add an attachment to the output file", "filename" },
2497 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2498 "extract an attachment into a file", "filename" },
2499 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2500 "print timestamp debugging info" },
2503 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2504 "set the number of video frames to record", "number" },
2505 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2506 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2507 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2508 "set frame size (WxH or abbreviation)", "size" },
2509 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2510 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2511 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2512 "set pixel format", "format" },
2513 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2514 "set the number of bits per raw sample", "number" },
2515 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2516 "deprecated use -g 1" },
2517 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2519 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2520 "discard threshold", "n" },
2521 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2522 "rate control override for specific intervals", "override" },
2523 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2524 "force video codec ('copy' to copy stream)", "codec" },
2525 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2527 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2529 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_timecode },
2530 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2531 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2532 "select the pass number (1 to 3)", "n" },
2533 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2534 "select two pass log file name prefix", "prefix" },
2535 #if FF_API_DEINTERLACE
2536 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2537 "this option is deprecated, use the yadif filter instead" },
2539 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2540 "calculate PSNR of compressed frames" },
2541 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2542 "dump video coding statistics to file" },
2543 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2544 "dump video coding statistics to file", "file" },
2545 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2546 "set video filters", "filter_graph" },
2547 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2548 "specify intra matrix coeffs", "matrix" },
2549 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2550 "specify inter matrix coeffs", "matrix" },
2551 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2552 "top=1/bottom=0/auto=-1 field first", "" },
2553 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2554 "intra_dc_precision", "precision" },
2555 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2556 "force video tag/fourcc", "fourcc/tag" },
2557 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2558 "show QP histogram" },
2559 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2560 "force the selected framerate, disable the best supported framerate selection" },
2561 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2562 "set the value of an outfile streamid", "streamIndex:value" },
2563 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2564 { .off = OFFSET(forced_key_frames) },
2565 "force key frames at specified timestamps", "timestamps" },
2566 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_bitrate },
2567 "video bitrate (please use -b:v)", "bitrate" },
2570 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2571 "set the number of audio frames to record", "number" },
2572 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2573 "set audio quality (codec-specific)", "quality", },
2574 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2575 "set audio sampling rate (in Hz)", "rate" },
2576 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2577 "set number of audio channels", "channels" },
2578 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2580 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2581 "force audio codec ('copy' to copy stream)", "codec" },
2582 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new },
2583 "force audio tag/fourcc", "fourcc/tag" },
2584 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2585 "change audio volume (256=normal)" , "volume" },
2586 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2587 "set sample format", "format" },
2588 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2589 "set channel layout", "layout" },
2590 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2591 "set audio filters", "filter_graph" },
2592 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(guess_layout_max) },
2593 "set the maximum number of channels to try to guess the channel layout" },
2595 /* subtitle options */
2596 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2597 "disable subtitle" },
2598 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2599 "force subtitle codec ('copy' to copy stream)", "codec" },
2600 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_old2new }
2601 , "force subtitle tag/fourcc", "fourcc/tag" },
2602 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2603 "fix subtitles duration" },
2604 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(canvas_sizes) },
2605 "set canvas size (WxH or abbreviation)", "size" },
2608 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2609 "deprecated, use -channel", "channel" },
2610 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2611 "deprecated, use -standard", "standard" },
2612 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2615 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2616 "set the maximum demux-decode delay", "seconds" },
2617 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2618 "set the initial demux-decode delay", "seconds" },
2620 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2621 "A comma-separated list of bitstream filters", "bitstream_filters" },
2622 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2623 "deprecated", "audio bitstream_filters" },
2624 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2625 "deprecated", "video bitstream_filters" },
2627 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2628 "set the audio options to the indicated preset", "preset" },
2629 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2630 "set the video options to the indicated preset", "preset" },
2631 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2632 "set the subtitle options to the indicated preset", "preset" },
2633 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2634 "set options from indicated preset file", "filename" },
2635 /* data codec support */
2636 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2637 "force data codec ('copy' to copy stream)", "codec" },
2638 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },