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"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
73 char *vstats_filename;
75 float audio_drift_threshold = 0.1;
76 float dts_delta_threshold = 10;
77 float dts_error_threshold = 3600*30;
79 int audio_volume = 256;
80 int audio_sync_method = 0;
81 int video_sync_method = VSYNC_AUTO;
82 int do_deinterlace = 0;
84 int do_benchmark_all = 0;
90 int exit_on_error = 0;
93 int stdin_interaction = 1;
94 int frame_bits_per_raw_sample = 0;
95 float max_error_rate = 2.0/3;
98 static int intra_only = 0;
99 static int file_overwrite = 0;
100 static int no_file_overwrite = 0;
101 static int video_discard = 0;
102 static int intra_dc_precision = 8;
103 static int do_psnr = 0;
104 static int input_sync;
105 static int override_ffserver = 0;
107 static void uninit_options(OptionsContext *o)
109 const OptionDef *po = options;
112 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
114 void *dst = (uint8_t*)o + po->u.off;
116 if (po->flags & OPT_SPEC) {
117 SpecifierOpt **so = dst;
118 int i, *count = (int*)(so + 1);
119 for (i = 0; i < *count; i++) {
120 av_freep(&(*so)[i].specifier);
121 if (po->flags & OPT_STRING)
122 av_freep(&(*so)[i].u.str);
126 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
131 for (i = 0; i < o->nb_stream_maps; i++)
132 av_freep(&o->stream_maps[i].linklabel);
133 av_freep(&o->stream_maps);
134 av_freep(&o->audio_channel_maps);
135 av_freep(&o->streamid_map);
136 av_freep(&o->attachments);
139 static void init_options(OptionsContext *o)
141 memset(o, 0, sizeof(*o));
143 o->stop_time = INT64_MAX;
144 o->mux_max_delay = 0.7;
145 o->start_time = AV_NOPTS_VALUE;
146 o->recording_time = INT64_MAX;
147 o->limit_filesize = UINT64_MAX;
148 o->chapters_input_file = INT_MAX;
149 o->accurate_seek = 1;
152 /* return a copy of the input with the stream specifiers removed from the keys */
153 static AVDictionary *strip_specifiers(AVDictionary *dict)
155 AVDictionaryEntry *e = NULL;
156 AVDictionary *ret = NULL;
158 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
159 char *p = strchr(e->key, ':');
163 av_dict_set(&ret, e->key, e->value, 0);
170 static int opt_sameq(void *optctx, const char *opt, const char *arg)
172 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
173 "If you are looking for an option to preserve the quality (which is not "
174 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
176 return AVERROR(EINVAL);
179 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
181 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
182 return opt_default(optctx, "channel", arg);
185 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
187 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
188 return opt_default(optctx, "standard", arg);
191 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
193 OptionsContext *o = optctx;
194 return parse_option(o, "codec:a", arg, options);
197 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
199 OptionsContext *o = optctx;
200 return parse_option(o, "codec:v", arg, options);
203 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
205 OptionsContext *o = optctx;
206 return parse_option(o, "codec:s", arg, options);
209 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
211 OptionsContext *o = optctx;
212 return parse_option(o, "codec:d", arg, options);
215 static int opt_map(void *optctx, const char *opt, const char *arg)
217 OptionsContext *o = optctx;
219 int i, negative = 0, file_idx;
220 int sync_file_idx = -1, sync_stream_idx = 0;
228 map = av_strdup(arg);
230 /* parse sync stream first, just pick first matching stream */
231 if (sync = strchr(map, ',')) {
233 sync_file_idx = strtol(sync + 1, &sync, 0);
234 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
235 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
240 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
241 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
242 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
246 if (i == input_files[sync_file_idx]->nb_streams) {
247 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
248 "match any streams.\n", arg);
255 /* this mapping refers to lavfi output */
256 const char *c = map + 1;
257 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
258 m = &o->stream_maps[o->nb_stream_maps - 1];
259 m->linklabel = av_get_token(&c, "]");
261 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
265 file_idx = strtol(map, &p, 0);
266 if (file_idx >= nb_input_files || file_idx < 0) {
267 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
271 /* disable some already defined maps */
272 for (i = 0; i < o->nb_stream_maps; i++) {
273 m = &o->stream_maps[i];
274 if (file_idx == m->file_index &&
275 check_stream_specifier(input_files[m->file_index]->ctx,
276 input_files[m->file_index]->ctx->streams[m->stream_index],
277 *p == ':' ? p + 1 : p) > 0)
281 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
282 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
283 *p == ':' ? p + 1 : p) <= 0)
285 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
286 m = &o->stream_maps[o->nb_stream_maps - 1];
288 m->file_index = file_idx;
291 if (sync_file_idx >= 0) {
292 m->sync_file_index = sync_file_idx;
293 m->sync_stream_index = sync_stream_idx;
295 m->sync_file_index = file_idx;
296 m->sync_stream_index = i;
302 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
310 static int opt_attach(void *optctx, const char *opt, const char *arg)
312 OptionsContext *o = optctx;
313 GROW_ARRAY(o->attachments, o->nb_attachments);
314 o->attachments[o->nb_attachments - 1] = arg;
318 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
320 OptionsContext *o = optctx;
325 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
326 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
328 /* muted channel syntax */
329 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
330 if ((n == 1 || n == 3) && m->channel_idx == -1) {
331 m->file_idx = m->stream_idx = -1;
333 m->ofile_idx = m->ostream_idx = -1;
338 n = sscanf(arg, "%d.%d.%d:%d.%d",
339 &m->file_idx, &m->stream_idx, &m->channel_idx,
340 &m->ofile_idx, &m->ostream_idx);
342 if (n != 3 && n != 5) {
343 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
344 "[file.stream.channel|-1][:syncfile:syncstream]\n");
348 if (n != 5) // only file.stream.channel specified
349 m->ofile_idx = m->ostream_idx = -1;
352 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
353 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
357 if (m->stream_idx < 0 ||
358 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
359 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
360 m->file_idx, m->stream_idx);
363 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
364 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
365 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
366 m->file_idx, m->stream_idx);
369 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
370 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
371 m->file_idx, m->stream_idx, m->channel_idx);
378 * Parse a metadata specifier passed as 'arg' parameter.
379 * @param arg metadata string to parse
380 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
381 * @param index for type c/p, chapter/program index is written here
382 * @param stream_spec for type s, the stream specifier is written here
384 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
392 if (*(++arg) && *arg != ':') {
393 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
396 *stream_spec = *arg == ':' ? arg + 1 : "";
401 *index = strtol(++arg, NULL, 0);
404 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
411 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
413 AVDictionary **meta_in = NULL;
414 AVDictionary **meta_out = NULL;
416 char type_in, type_out;
417 const char *istream_spec = NULL, *ostream_spec = NULL;
418 int idx_in = 0, idx_out = 0;
420 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
421 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
424 if (type_out == 'g' || !*outspec)
425 o->metadata_global_manual = 1;
426 if (type_out == 's' || !*outspec)
427 o->metadata_streams_manual = 1;
428 if (type_out == 'c' || !*outspec)
429 o->metadata_chapters_manual = 1;
433 if (type_in == 'g' || type_out == 'g')
434 o->metadata_global_manual = 1;
435 if (type_in == 's' || type_out == 's')
436 o->metadata_streams_manual = 1;
437 if (type_in == 'c' || type_out == 'c')
438 o->metadata_chapters_manual = 1;
440 /* ic is NULL when just disabling automatic mappings */
444 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
445 if ((index) < 0 || (index) >= (nb_elems)) {\
446 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
451 #define SET_DICT(type, meta, context, index)\
454 meta = &context->metadata;\
457 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
458 meta = &context->chapters[index]->metadata;\
461 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
462 meta = &context->programs[index]->metadata;\
465 break; /* handled separately below */ \
466 default: av_assert0(0);\
469 SET_DICT(type_in, meta_in, ic, idx_in);
470 SET_DICT(type_out, meta_out, oc, idx_out);
472 /* for input streams choose first matching stream */
473 if (type_in == 's') {
474 for (i = 0; i < ic->nb_streams; i++) {
475 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
476 meta_in = &ic->streams[i]->metadata;
482 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
487 if (type_out == 's') {
488 for (i = 0; i < oc->nb_streams; i++) {
489 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
490 meta_out = &oc->streams[i]->metadata;
491 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
496 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
501 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
503 OptionsContext *o = optctx;
505 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
506 struct tm time = *gmtime((time_t*)&recording_timestamp);
507 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
508 parse_option(o, "metadata", buf, options);
510 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
511 "tag instead.\n", opt);
515 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
517 const AVCodecDescriptor *desc;
518 const char *codec_string = encoder ? "encoder" : "decoder";
522 avcodec_find_encoder_by_name(name) :
523 avcodec_find_decoder_by_name(name);
525 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
526 codec = encoder ? avcodec_find_encoder(desc->id) :
527 avcodec_find_decoder(desc->id);
529 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
530 codec_string, codec->name, desc->name);
534 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
537 if (codec->type != type) {
538 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
544 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
546 char *codec_name = NULL;
548 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
550 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
551 st->codec->codec_id = codec->id;
554 return avcodec_find_decoder(st->codec->codec_id);
557 /* Add all the streams from the given input file to the global
558 * list of input streams. */
559 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
563 for (i = 0; i < ic->nb_streams; i++) {
564 AVStream *st = ic->streams[i];
565 AVCodecContext *dec = st->codec;
566 InputStream *ist = av_mallocz(sizeof(*ist));
567 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
568 char *codec_tag = NULL;
574 GROW_ARRAY(input_streams, nb_input_streams);
575 input_streams[nb_input_streams - 1] = ist;
578 ist->file_index = nb_input_files;
580 st->discard = AVDISCARD_ALL;
583 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
585 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
587 uint32_t tag = strtol(codec_tag, &next, 0);
589 tag = AV_RL32(codec_tag);
590 st->codec->codec_tag = tag;
593 ist->dec = choose_decoder(o, ic, st);
594 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
596 ist->reinit_filters = -1;
597 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
599 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
601 switch (dec->codec_type) {
602 case AVMEDIA_TYPE_VIDEO:
604 ist->dec = avcodec_find_decoder(dec->codec_id);
605 if (av_codec_get_lowres(dec)) {
606 dec->flags |= CODEC_FLAG_EMU_EDGE;
609 ist->resample_height = dec->height;
610 ist->resample_width = dec->width;
611 ist->resample_pix_fmt = dec->pix_fmt;
613 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
614 if (framerate && av_parse_video_rate(&ist->framerate,
616 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
621 ist->top_field_first = -1;
622 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
624 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
626 if (!strcmp(hwaccel, "none"))
627 ist->hwaccel_id = HWACCEL_NONE;
628 else if (!strcmp(hwaccel, "auto"))
629 ist->hwaccel_id = HWACCEL_AUTO;
632 for (i = 0; hwaccels[i].name; i++) {
633 if (!strcmp(hwaccels[i].name, hwaccel)) {
634 ist->hwaccel_id = hwaccels[i].id;
639 if (!ist->hwaccel_id) {
640 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
642 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
643 for (i = 0; hwaccels[i].name; i++)
644 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
645 av_log(NULL, AV_LOG_FATAL, "\n");
651 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
652 if (hwaccel_device) {
653 ist->hwaccel_device = av_strdup(hwaccel_device);
654 if (!ist->hwaccel_device)
657 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
660 case AVMEDIA_TYPE_AUDIO:
661 ist->guess_layout_max = INT_MAX;
662 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
663 guess_input_channel_layout(ist);
665 ist->resample_sample_fmt = dec->sample_fmt;
666 ist->resample_sample_rate = dec->sample_rate;
667 ist->resample_channels = dec->channels;
668 ist->resample_channel_layout = dec->channel_layout;
671 case AVMEDIA_TYPE_DATA:
672 case AVMEDIA_TYPE_SUBTITLE: {
673 char *canvas_size = NULL;
675 ist->dec = avcodec_find_decoder(dec->codec_id);
676 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
677 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
679 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
680 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
685 case AVMEDIA_TYPE_ATTACHMENT:
686 case AVMEDIA_TYPE_UNKNOWN:
694 static void assert_file_overwrite(const char *filename)
696 if (file_overwrite && no_file_overwrite) {
697 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
701 if (!file_overwrite) {
702 const char *proto_name = avio_find_protocol_name(filename);
703 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
704 if (stdin_interaction && !no_file_overwrite) {
705 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
708 signal(SIGINT, SIG_DFL);
710 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
716 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
723 static void dump_attachment(AVStream *st, const char *filename)
726 AVIOContext *out = NULL;
727 AVDictionaryEntry *e;
729 if (!st->codec->extradata_size) {
730 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
731 nb_input_files - 1, st->index);
734 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
737 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
738 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
742 assert_file_overwrite(filename);
744 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
745 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
750 avio_write(out, st->codec->extradata, st->codec->extradata_size);
755 static int open_input_file(OptionsContext *o, const char *filename)
759 AVInputFormat *file_iformat = NULL;
764 AVDictionary *unused_opts = NULL;
765 AVDictionaryEntry *e = NULL;
766 int orig_nb_streams; // number of streams before avformat_find_stream_info
767 char * video_codec_name = NULL;
768 char * audio_codec_name = NULL;
769 char *subtitle_codec_name = NULL;
772 if (!(file_iformat = av_find_input_format(o->format))) {
773 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
778 if (!strcmp(filename, "-"))
781 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
782 strcmp(filename, "/dev/stdin");
784 /* get default parameters from command line */
785 ic = avformat_alloc_context();
787 print_error(filename, AVERROR(ENOMEM));
790 if (o->nb_audio_sample_rate) {
791 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
792 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
794 if (o->nb_audio_channels) {
795 /* because we set audio_channels based on both the "ac" and
796 * "channel_layout" options, we need to check that the specified
797 * demuxer actually has the "channels" option before setting it */
798 if (file_iformat && file_iformat->priv_class &&
799 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
800 AV_OPT_SEARCH_FAKE_OBJ)) {
801 snprintf(buf, sizeof(buf), "%d",
802 o->audio_channels[o->nb_audio_channels - 1].u.i);
803 av_dict_set(&o->g->format_opts, "channels", buf, 0);
806 if (o->nb_frame_rates) {
807 /* set the format-level framerate option;
808 * this is important for video grabbers, e.g. x11 */
809 if (file_iformat && file_iformat->priv_class &&
810 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
811 AV_OPT_SEARCH_FAKE_OBJ)) {
812 av_dict_set(&o->g->format_opts, "framerate",
813 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
816 if (o->nb_frame_sizes) {
817 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
819 if (o->nb_frame_pix_fmts)
820 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
822 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
823 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
824 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
826 ic->video_codec_id = video_codec_name ?
827 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
828 ic->audio_codec_id = audio_codec_name ?
829 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
830 ic->subtitle_codec_id= subtitle_codec_name ?
831 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
833 if (video_codec_name)
834 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
835 if (audio_codec_name)
836 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
837 if (subtitle_codec_name)
838 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
840 ic->flags |= AVFMT_FLAG_NONBLOCK;
841 ic->interrupt_callback = int_cb;
843 /* open the input file with generic avformat function */
844 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
846 print_error(filename, err);
849 assert_avoptions(o->g->format_opts);
851 /* apply forced codec ids */
852 for (i = 0; i < ic->nb_streams; i++)
853 choose_decoder(o, ic, ic->streams[i]);
855 /* Set AVCodecContext options for avformat_find_stream_info */
856 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
857 orig_nb_streams = ic->nb_streams;
859 /* If not enough info to get the stream parameters, we decode the
860 first frames to get it. (used in mpeg case for example) */
861 ret = avformat_find_stream_info(ic, opts);
863 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
864 avformat_close_input(&ic);
868 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
869 /* add the stream start time */
870 if (ic->start_time != AV_NOPTS_VALUE)
871 timestamp += ic->start_time;
873 /* if seeking requested, we execute it */
874 if (o->start_time != AV_NOPTS_VALUE) {
875 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
877 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
878 filename, (double)timestamp / AV_TIME_BASE);
882 /* update the current parameters so that they match the one of the input stream */
883 add_input_streams(o, ic);
885 /* dump the file content */
886 av_dump_format(ic, nb_input_files, filename, 0);
888 GROW_ARRAY(input_files, nb_input_files);
889 f = av_mallocz(sizeof(*f));
892 input_files[nb_input_files - 1] = f;
895 f->ist_index = nb_input_streams - ic->nb_streams;
896 f->start_time = o->start_time;
897 f->recording_time = o->recording_time;
898 f->input_ts_offset = o->input_ts_offset;
899 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
900 f->nb_streams = ic->nb_streams;
901 f->rate_emu = o->rate_emu;
902 f->accurate_seek = o->accurate_seek;
904 /* check if all codec options have been used */
905 unused_opts = strip_specifiers(o->g->codec_opts);
906 for (i = f->ist_index; i < nb_input_streams; i++) {
908 while ((e = av_dict_get(input_streams[i]->opts, "", e,
909 AV_DICT_IGNORE_SUFFIX)))
910 av_dict_set(&unused_opts, e->key, NULL, 0);
914 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
915 const AVClass *class = avcodec_get_class();
916 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
917 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
918 const AVClass *fclass = avformat_get_class();
919 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
920 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
921 if (!option || foption)
925 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
926 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
927 "input file #%d (%s) is not a decoding option.\n", e->key,
928 option->help ? option->help : "", nb_input_files - 1,
933 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
934 "input file #%d (%s) has not been used for any stream. The most "
935 "likely reason is either wrong type (e.g. a video option with "
936 "no video streams) or that it is a private option of some decoder "
937 "which was not actually used for any stream.\n", e->key,
938 option->help ? option->help : "", nb_input_files - 1, filename);
940 av_dict_free(&unused_opts);
942 for (i = 0; i < o->nb_dump_attachment; i++) {
945 for (j = 0; j < ic->nb_streams; j++) {
946 AVStream *st = ic->streams[j];
948 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
949 dump_attachment(st, o->dump_attachment[i].u.str);
953 for (i = 0; i < orig_nb_streams; i++)
954 av_dict_free(&opts[i]);
960 static uint8_t *get_line(AVIOContext *s)
966 if (avio_open_dyn_buf(&line) < 0) {
967 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
971 while ((c = avio_r8(s)) && c != '\n')
974 avio_close_dyn_buf(line, &buf);
979 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
983 const char *base[3] = { getenv("AVCONV_DATADIR"),
988 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
992 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
993 i != 1 ? "" : "/.avconv", codec_name, preset_name);
994 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
997 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
998 i != 1 ? "" : "/.avconv", preset_name);
999 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1005 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1007 char *codec_name = NULL;
1009 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1011 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1012 NULL, ost->st->codec->codec_type);
1013 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1014 } else if (!strcmp(codec_name, "copy"))
1015 ost->stream_copy = 1;
1017 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1018 ost->st->codec->codec_id = ost->enc->id;
1022 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1025 AVStream *st = avformat_new_stream(oc, NULL);
1026 int idx = oc->nb_streams - 1, ret = 0;
1027 char *bsf = NULL, *next, *codec_tag = NULL;
1028 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1033 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1037 if (oc->nb_streams - 1 < o->nb_streamid_map)
1038 st->id = o->streamid_map[oc->nb_streams - 1];
1040 GROW_ARRAY(output_streams, nb_output_streams);
1041 if (!(ost = av_mallocz(sizeof(*ost))))
1043 output_streams[nb_output_streams - 1] = ost;
1045 ost->file_index = nb_output_files - 1;
1048 st->codec->codec_type = type;
1049 choose_encoder(o, oc, ost);
1051 AVIOContext *s = NULL;
1052 char *buf = NULL, *arg = NULL, *preset = NULL;
1054 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1056 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1057 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1060 if (!buf[0] || buf[0] == '#') {
1064 if (!(arg = strchr(buf, '='))) {
1065 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1069 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1071 } while (!s->eof_reached);
1075 av_log(NULL, AV_LOG_FATAL,
1076 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1077 preset, ost->file_index, ost->index);
1081 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1084 avcodec_get_context_defaults3(st->codec, ost->enc);
1085 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1087 ost->max_frames = INT64_MAX;
1088 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1089 for (i = 0; i<o->nb_max_frames; i++) {
1090 char *p = o->max_frames[i].specifier;
1091 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1092 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1097 ost->copy_prior_start = -1;
1098 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1100 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1102 if (next = strchr(bsf, ','))
1104 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1105 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1109 bsfc_prev->next = bsfc;
1111 ost->bitstream_filters = bsfc;
1117 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1119 uint32_t tag = strtol(codec_tag, &next, 0);
1121 tag = AV_RL32(codec_tag);
1122 st->codec->codec_tag = tag;
1125 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1127 st->codec->flags |= CODEC_FLAG_QSCALE;
1128 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1131 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1132 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1134 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1136 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1137 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1138 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1140 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1142 ost->source_index = source_index;
1143 if (source_index >= 0) {
1144 ost->sync_ist = input_streams[source_index];
1145 input_streams[source_index]->discard = 0;
1146 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1148 ost->last_mux_dts = AV_NOPTS_VALUE;
1153 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1156 const char *p = str;
1163 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1170 /* read file contents into a string */
1171 static uint8_t *read_file(const char *filename)
1173 AVIOContext *pb = NULL;
1174 AVIOContext *dyn_buf = NULL;
1175 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1176 uint8_t buf[1024], *str;
1179 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1183 ret = avio_open_dyn_buf(&dyn_buf);
1188 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1189 avio_write(dyn_buf, buf, ret);
1190 avio_w8(dyn_buf, 0);
1193 ret = avio_close_dyn_buf(dyn_buf, &str);
1199 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1202 AVStream *st = ost->st;
1204 if (ost->filters_script && ost->filters) {
1205 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1206 "output stream #%d:%d.\n", nb_output_files, st->index);
1210 if (ost->filters_script)
1211 return read_file(ost->filters_script);
1212 else if (ost->filters)
1213 return av_strdup(ost->filters);
1215 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1219 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1220 const OutputStream *ost, enum AVMediaType type)
1222 if (ost->filters_script || ost->filters) {
1223 av_log(NULL, AV_LOG_ERROR,
1224 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1225 "Filtering and streamcopy cannot be used together.\n",
1226 ost->filters ? "Filtergraph" : "Filtergraph script",
1227 ost->filters ? ost->filters : ost->filters_script,
1228 av_get_media_type_string(type), ost->file_index, ost->index);
1233 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1237 AVCodecContext *video_enc;
1238 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1240 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1242 video_enc = st->codec;
1244 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1245 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1246 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1250 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1251 if (frame_aspect_ratio) {
1253 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1254 q.num <= 0 || q.den <= 0) {
1255 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1258 ost->frame_aspect_ratio = q;
1261 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1262 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1264 if (!ost->stream_copy) {
1265 const char *p = NULL;
1266 char *frame_size = NULL;
1267 char *frame_pix_fmt = NULL;
1268 char *intra_matrix = NULL, *inter_matrix = NULL;
1269 char *chroma_intra_matrix = NULL;
1273 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1274 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1275 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1279 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1280 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1281 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1282 ost->keep_pix_fmt = 1;
1283 if (!*++frame_pix_fmt)
1284 frame_pix_fmt = NULL;
1286 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1287 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1290 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1293 video_enc->gop_size = 0;
1294 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1296 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1297 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1300 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1302 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1303 if (chroma_intra_matrix) {
1304 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1306 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1309 av_codec_set_chroma_intra_matrix(video_enc, p);
1310 parse_matrix_coeffs(p, chroma_intra_matrix);
1312 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1314 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1315 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1318 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1321 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1322 for (i = 0; p; i++) {
1324 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1326 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1329 /* FIXME realloc failure */
1330 video_enc->rc_override =
1331 av_realloc(video_enc->rc_override,
1332 sizeof(RcOverride) * (i + 1));
1333 video_enc->rc_override[i].start_frame = start;
1334 video_enc->rc_override[i].end_frame = end;
1336 video_enc->rc_override[i].qscale = q;
1337 video_enc->rc_override[i].quality_factor = 1.0;
1340 video_enc->rc_override[i].qscale = 0;
1341 video_enc->rc_override[i].quality_factor = -q/100.0;
1346 video_enc->rc_override_count = i;
1347 video_enc->intra_dc_precision = intra_dc_precision - 8;
1350 video_enc->flags|= CODEC_FLAG_PSNR;
1353 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1356 video_enc->flags |= CODEC_FLAG_PASS1;
1357 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1360 video_enc->flags |= CODEC_FLAG_PASS2;
1361 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1365 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1366 if (ost->logfile_prefix &&
1367 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1370 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1371 if (ost->forced_keyframes)
1372 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1374 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1376 ost->top_field_first = -1;
1377 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1380 ost->avfilter = get_ost_filters(o, oc, ost);
1384 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1387 if (ost->stream_copy)
1388 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1393 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1398 AVCodecContext *audio_enc;
1400 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1403 audio_enc = st->codec;
1404 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1406 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1407 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1409 if (!ost->stream_copy) {
1410 char *sample_fmt = NULL;
1412 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1414 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1416 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1417 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1421 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1423 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1424 ost->apad = av_strdup(ost->apad);
1426 ost->avfilter = get_ost_filters(o, oc, ost);
1430 /* check for channel mapping for this audio stream */
1431 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1432 AudioChannelMap *map = &o->audio_channel_maps[n];
1433 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1434 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1437 if (map->channel_idx == -1) {
1439 } else if (ost->source_index < 0) {
1440 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1441 ost->file_index, ost->st->index);
1444 ist = input_streams[ost->source_index];
1447 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1448 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1449 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1451 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1452 ost->file_index, ost->st->index);
1458 if (ost->stream_copy)
1459 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1464 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1468 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1469 if (!ost->stream_copy) {
1470 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1477 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1479 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1480 ost->stream_copy = 1;
1485 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1489 AVCodecContext *subtitle_enc;
1491 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1493 subtitle_enc = st->codec;
1495 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1497 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1499 if (!ost->stream_copy) {
1500 char *frame_size = NULL;
1502 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1503 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1504 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1512 /* arg format is "output-stream-index:streamid-value". */
1513 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1515 OptionsContext *o = optctx;
1520 av_strlcpy(idx_str, arg, sizeof(idx_str));
1521 p = strchr(idx_str, ':');
1523 av_log(NULL, AV_LOG_FATAL,
1524 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1529 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1530 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1531 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1535 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1537 AVFormatContext *is = ifile->ctx;
1538 AVFormatContext *os = ofile->ctx;
1542 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1544 return AVERROR(ENOMEM);
1547 for (i = 0; i < is->nb_chapters; i++) {
1548 AVChapter *in_ch = is->chapters[i], *out_ch;
1549 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1550 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1551 AV_TIME_BASE_Q, in_ch->time_base);
1552 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1553 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1556 if (in_ch->end < ts_off)
1558 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1561 out_ch = av_mallocz(sizeof(AVChapter));
1563 return AVERROR(ENOMEM);
1565 out_ch->id = in_ch->id;
1566 out_ch->time_base = in_ch->time_base;
1567 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1568 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1571 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1573 os->chapters[os->nb_chapters++] = out_ch;
1578 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1581 AVFormatContext *ic = avformat_alloc_context();
1583 ic->interrupt_callback = int_cb;
1584 err = avformat_open_input(&ic, filename, NULL, NULL);
1587 /* copy stream format */
1588 for(i=0;i<ic->nb_streams;i++) {
1592 AVCodecContext *avctx;
1594 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1595 ost = new_output_stream(o, s, codec->type, -1);
1600 // FIXME: a more elegant solution is needed
1601 memcpy(st, ic->streams[i], sizeof(AVStream));
1603 st->info = av_malloc(sizeof(*st->info));
1604 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1606 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1608 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1609 choose_sample_fmt(st, codec);
1610 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1611 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1614 avformat_close_input(&ic);
1618 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1619 AVFormatContext *oc)
1623 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1624 ofilter->out_tmp->pad_idx)) {
1625 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1626 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1628 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1633 ost->source_index = -1;
1634 ost->filter = ofilter;
1638 if (ost->stream_copy) {
1639 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1640 "which is fed from a complex filtergraph. Filtering and streamcopy "
1641 "cannot be used together.\n", ost->file_index, ost->index);
1645 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1646 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1647 av_log(NULL, AV_LOG_ERROR,
1648 "%s '%s' was specified through the %s option "
1649 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1650 "%s and -filter_complex cannot be used together for the same stream.\n",
1651 ost->filters ? "Filtergraph" : "Filtergraph script",
1652 ost->filters ? ost->filters : ost->filters_script,
1653 opt, ost->file_index, ost->index, opt);
1657 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1658 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1661 avfilter_inout_free(&ofilter->out_tmp);
1664 static int configure_complex_filters(void)
1668 for (i = 0; i < nb_filtergraphs; i++)
1669 if (!filtergraphs[i]->graph &&
1670 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1675 static int open_output_file(OptionsContext *o, const char *filename)
1677 AVFormatContext *oc;
1679 AVOutputFormat *file_oformat;
1683 AVDictionary *unused_opts = NULL;
1684 AVDictionaryEntry *e = NULL;
1686 if (configure_complex_filters() < 0) {
1687 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1691 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1692 o->stop_time = INT64_MAX;
1693 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1696 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1697 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1698 if (o->stop_time <= start_time) {
1699 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1700 o->stop_time = INT64_MAX;
1702 o->recording_time = o->stop_time - start_time;
1706 GROW_ARRAY(output_files, nb_output_files);
1707 of = av_mallocz(sizeof(*of));
1710 output_files[nb_output_files - 1] = of;
1712 of->ost_index = nb_output_streams;
1713 of->recording_time = o->recording_time;
1714 of->start_time = o->start_time;
1715 of->limit_filesize = o->limit_filesize;
1716 of->shortest = o->shortest;
1717 av_dict_copy(&of->opts, o->g->format_opts, 0);
1719 if (!strcmp(filename, "-"))
1722 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1724 print_error(filename, err);
1729 if (o->recording_time != INT64_MAX)
1730 oc->duration = o->recording_time;
1732 file_oformat= oc->oformat;
1733 oc->interrupt_callback = int_cb;
1735 /* create streams for all unlabeled output pads */
1736 for (i = 0; i < nb_filtergraphs; i++) {
1737 FilterGraph *fg = filtergraphs[i];
1738 for (j = 0; j < fg->nb_outputs; j++) {
1739 OutputFilter *ofilter = fg->outputs[j];
1741 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1744 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1745 ofilter->out_tmp->pad_idx)) {
1746 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1747 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1748 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1750 init_output_filter(ofilter, o, oc);
1754 /* ffserver seeking with date=... needs a date reference */
1755 if (!strcmp(file_oformat->name, "ffm") &&
1756 av_strstart(filename, "http:", NULL)) {
1757 int err = parse_option(o, "metadata", "creation_time=now", options);
1759 print_error(filename, err);
1764 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1765 av_strstart(filename, "http:", NULL)) {
1767 /* special case for files sent to ffserver: we get the stream
1768 parameters from ffserver */
1769 int err = read_ffserver_streams(o, oc, filename);
1771 print_error(filename, err);
1774 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1775 ost = output_streams[j];
1776 for (i = 0; i < nb_input_streams; i++) {
1777 ist = input_streams[i];
1778 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1780 ost->source_index= i;
1781 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1782 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1784 ist->st->discard = AVDISCARD_NONE;
1789 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));
1793 } else if (!o->nb_stream_maps) {
1794 char *subtitle_codec_name = NULL;
1795 /* pick the "best" stream of each type */
1797 /* video: highest resolution */
1798 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1799 int area = 0, idx = -1;
1800 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1801 for (i = 0; i < nb_input_streams; i++) {
1803 ist = input_streams[i];
1804 new_area = ist->st->codec->width * ist->st->codec->height;
1805 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1807 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1809 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1816 new_video_stream(o, oc, idx);
1819 /* audio: most channels */
1820 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1821 int channels = 0, idx = -1;
1822 for (i = 0; i < nb_input_streams; i++) {
1823 ist = input_streams[i];
1824 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1825 ist->st->codec->channels > channels) {
1826 channels = ist->st->codec->channels;
1831 new_audio_stream(o, oc, idx);
1834 /* subtitles: pick first */
1835 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1836 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1837 for (i = 0; i < nb_input_streams; i++)
1838 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1839 new_subtitle_stream(o, oc, i);
1843 /* do something with data? */
1845 for (i = 0; i < o->nb_stream_maps; i++) {
1846 StreamMap *map = &o->stream_maps[i];
1851 if (map->linklabel) {
1853 OutputFilter *ofilter = NULL;
1856 for (j = 0; j < nb_filtergraphs; j++) {
1857 fg = filtergraphs[j];
1858 for (k = 0; k < fg->nb_outputs; k++) {
1859 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1860 if (out && !strcmp(out->name, map->linklabel)) {
1861 ofilter = fg->outputs[k];
1868 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1869 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1872 init_output_filter(ofilter, o, oc);
1874 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1876 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1877 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1879 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1881 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1883 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1886 switch (ist->st->codec->codec_type) {
1887 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1888 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1889 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1890 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1891 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1893 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1894 map->file_index, map->stream_index);
1901 /* handle attached files */
1902 for (i = 0; i < o->nb_attachments; i++) {
1904 uint8_t *attachment;
1908 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1909 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1913 if ((len = avio_size(pb)) <= 0) {
1914 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1918 if (!(attachment = av_malloc(len))) {
1919 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1923 avio_read(pb, attachment, len);
1925 ost = new_attachment_stream(o, oc, -1);
1926 ost->stream_copy = 0;
1927 ost->attachment_filename = o->attachments[i];
1929 ost->st->codec->extradata = attachment;
1930 ost->st->codec->extradata_size = len;
1932 p = strrchr(o->attachments[i], '/');
1933 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1937 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1938 AVDictionaryEntry *e;
1939 ost = output_streams[i];
1941 if ((ost->stream_copy || ost->attachment_filename)
1942 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1943 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1944 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1948 /* check if all codec options have been used */
1949 unused_opts = strip_specifiers(o->g->codec_opts);
1950 for (i = of->ost_index; i < nb_output_streams; i++) {
1952 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1953 AV_DICT_IGNORE_SUFFIX)))
1954 av_dict_set(&unused_opts, e->key, NULL, 0);
1958 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1959 const AVClass *class = avcodec_get_class();
1960 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1961 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1964 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1965 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1966 "output file #%d (%s) is not an encoding option.\n", e->key,
1967 option->help ? option->help : "", nb_output_files - 1,
1972 // gop_timecode is injected by generic code but not always used
1973 if (!strcmp(e->key, "gop_timecode"))
1976 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1977 "output file #%d (%s) has not been used for any stream. The most "
1978 "likely reason is either wrong type (e.g. a video option with "
1979 "no video streams) or that it is a private option of some encoder "
1980 "which was not actually used for any stream.\n", e->key,
1981 option->help ? option->help : "", nb_output_files - 1, filename);
1983 av_dict_free(&unused_opts);
1985 /* check filename in case of an image number is expected */
1986 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1987 if (!av_filename_number_test(oc->filename)) {
1988 print_error(oc->filename, AVERROR(EINVAL));
1993 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1994 /* test if it already exists to avoid losing precious files */
1995 assert_file_overwrite(filename);
1998 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1999 &oc->interrupt_callback,
2001 print_error(filename, err);
2004 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2005 assert_file_overwrite(filename);
2007 if (o->mux_preload) {
2009 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
2010 av_dict_set(&of->opts, "preload", buf, 0);
2012 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2015 for (i = 0; i < o->nb_metadata_map; i++) {
2017 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2019 if (in_file_index >= nb_input_files) {
2020 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2023 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2024 in_file_index >= 0 ?
2025 input_files[in_file_index]->ctx : NULL, o);
2029 if (o->chapters_input_file >= nb_input_files) {
2030 if (o->chapters_input_file == INT_MAX) {
2031 /* copy chapters from the first input file that has them*/
2032 o->chapters_input_file = -1;
2033 for (i = 0; i < nb_input_files; i++)
2034 if (input_files[i]->ctx->nb_chapters) {
2035 o->chapters_input_file = i;
2039 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2040 o->chapters_input_file);
2044 if (o->chapters_input_file >= 0)
2045 copy_chapters(input_files[o->chapters_input_file], of,
2046 !o->metadata_chapters_manual);
2048 /* copy global metadata by default */
2049 if (!o->metadata_global_manual && nb_input_files){
2050 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2051 AV_DICT_DONT_OVERWRITE);
2052 if(o->recording_time != INT64_MAX)
2053 av_dict_set(&oc->metadata, "duration", NULL, 0);
2054 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2056 if (!o->metadata_streams_manual)
2057 for (i = of->ost_index; i < nb_output_streams; i++) {
2059 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2061 ist = input_streams[output_streams[i]->source_index];
2062 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2065 /* process manually set metadata */
2066 for (i = 0; i < o->nb_metadata; i++) {
2069 const char *stream_spec;
2070 int index = 0, j, ret = 0;
2072 val = strchr(o->metadata[i].u.str, '=');
2074 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2075 o->metadata[i].u.str);
2080 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2082 for (j = 0; j < oc->nb_streams; j++) {
2083 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2084 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2095 if (index < 0 || index >= oc->nb_chapters) {
2096 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2099 m = &oc->chapters[index]->metadata;
2102 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2105 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2112 static int opt_target(void *optctx, const char *opt, const char *arg)
2114 OptionsContext *o = optctx;
2115 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2116 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2118 if (!strncmp(arg, "pal-", 4)) {
2121 } else if (!strncmp(arg, "ntsc-", 5)) {
2124 } else if (!strncmp(arg, "film-", 5)) {
2128 /* Try to determine PAL/NTSC by peeking in the input files */
2129 if (nb_input_files) {
2131 for (j = 0; j < nb_input_files; j++) {
2132 for (i = 0; i < input_files[j]->nb_streams; i++) {
2133 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2134 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2136 fr = c->time_base.den * 1000 / c->time_base.num;
2140 } else if ((fr == 29970) || (fr == 23976)) {
2145 if (norm != UNKNOWN)
2149 if (norm != UNKNOWN)
2150 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2153 if (norm == UNKNOWN) {
2154 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2155 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2156 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2160 if (!strcmp(arg, "vcd")) {
2161 opt_video_codec(o, "c:v", "mpeg1video");
2162 opt_audio_codec(o, "c:a", "mp2");
2163 parse_option(o, "f", "vcd", options);
2165 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2166 parse_option(o, "r", frame_rates[norm], options);
2167 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2169 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2170 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2171 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2172 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2174 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2175 parse_option(o, "ar", "44100", options);
2176 parse_option(o, "ac", "2", options);
2178 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2179 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2181 /* We have to offset the PTS, so that it is consistent with the SCR.
2182 SCR starts at 36000, but the first two packs contain only padding
2183 and the first pack from the other stream, respectively, may also have
2184 been written before.
2185 So the real data starts at SCR 36000+3*1200. */
2186 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2187 } else if (!strcmp(arg, "svcd")) {
2189 opt_video_codec(o, "c:v", "mpeg2video");
2190 opt_audio_codec(o, "c:a", "mp2");
2191 parse_option(o, "f", "svcd", options);
2193 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2194 parse_option(o, "r", frame_rates[norm], options);
2195 parse_option(o, "pix_fmt", "yuv420p", options);
2196 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2198 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2199 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2200 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2201 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2202 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2204 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2205 parse_option(o, "ar", "44100", options);
2207 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2209 } else if (!strcmp(arg, "dvd")) {
2211 opt_video_codec(o, "c:v", "mpeg2video");
2212 opt_audio_codec(o, "c:a", "ac3");
2213 parse_option(o, "f", "dvd", options);
2215 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2216 parse_option(o, "r", frame_rates[norm], options);
2217 parse_option(o, "pix_fmt", "yuv420p", options);
2218 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2220 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2221 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2222 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2223 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2225 av_dict_set(&o->g->format_opts, "packetsize", "2048", AV_DICT_DONT_OVERWRITE); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2226 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2228 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2229 parse_option(o, "ar", "48000", options);
2231 } else if (!strncmp(arg, "dv", 2)) {
2233 parse_option(o, "f", "dv", options);
2235 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2236 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2237 norm == PAL ? "yuv420p" : "yuv411p", options);
2238 parse_option(o, "r", frame_rates[norm], options);
2240 parse_option(o, "ar", "48000", options);
2241 parse_option(o, "ac", "2", options);
2244 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2245 return AVERROR(EINVAL);
2250 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2252 av_free (vstats_filename);
2253 vstats_filename = av_strdup (arg);
2257 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2260 time_t today2 = time(NULL);
2261 struct tm *today = localtime(&today2);
2263 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2265 return opt_vstats_file(NULL, opt, filename);
2268 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2270 OptionsContext *o = optctx;
2271 return parse_option(o, "frames:v", arg, options);
2274 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2276 OptionsContext *o = optctx;
2277 return parse_option(o, "frames:a", arg, options);
2280 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2282 OptionsContext *o = optctx;
2283 return parse_option(o, "frames:d", arg, options);
2286 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2289 AVDictionary *cbak = codec_opts;
2290 AVDictionary *fbak = format_opts;
2294 ret = opt_default(NULL, opt, arg);
2296 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2297 av_dict_copy(&o->g->format_opts, format_opts, 0);
2298 av_dict_free(&codec_opts);
2299 av_dict_free(&format_opts);
2306 static int opt_preset(void *optctx, const char *opt, const char *arg)
2308 OptionsContext *o = optctx;
2310 char filename[1000], line[1000], tmp_line[1000];
2311 const char *codec_name = NULL;
2315 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2317 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2318 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2319 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2321 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2325 while (fgets(line, sizeof(line), f)) {
2326 char *key = tmp_line, *value, *endptr;
2328 if (strcspn(line, "#\n\r") == 0)
2330 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2331 if (!av_strtok(key, "=", &value) ||
2332 !av_strtok(value, "\r\n", &endptr)) {
2333 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2336 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2338 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2339 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2340 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2341 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2342 else if (opt_default_new(o, key, value) < 0) {
2343 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2344 filename, line, key, value);
2354 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2356 OptionsContext *o = optctx;
2357 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2358 int ret = parse_option(o, s, arg, options);
2363 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2365 OptionsContext *o = optctx;
2366 if(!strcmp(opt, "b")){
2367 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2368 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2371 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2375 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2377 OptionsContext *o = optctx;
2380 if(!strcmp(opt, "qscale")){
2381 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2382 return parse_option(o, "q:v", arg, options);
2384 s = av_asprintf("q%s", opt + 6);
2385 ret = parse_option(o, s, arg, options);
2390 static int opt_profile(void *optctx, const char *opt, const char *arg)
2392 OptionsContext *o = optctx;
2393 if(!strcmp(opt, "profile")){
2394 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2395 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2398 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2402 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2404 OptionsContext *o = optctx;
2405 return parse_option(o, "filter:v", arg, options);
2408 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2410 OptionsContext *o = optctx;
2411 return parse_option(o, "filter:a", arg, options);
2414 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2416 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2417 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2418 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2419 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2421 if (video_sync_method == VSYNC_AUTO)
2422 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2426 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2428 OptionsContext *o = optctx;
2429 char *tcr = av_asprintf("timecode=%s", arg);
2430 int ret = parse_option(o, "metadata:g", tcr, options);
2432 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2437 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2439 OptionsContext *o = optctx;
2440 char layout_str[32];
2443 int ret, channels, ac_str_size;
2446 layout = av_get_channel_layout(arg);
2448 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2449 return AVERROR(EINVAL);
2451 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2452 ret = opt_default_new(o, opt, layout_str);
2456 /* set 'ac' option based on channel layout */
2457 channels = av_get_channel_layout_nb_channels(layout);
2458 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2459 stream_str = strchr(opt, ':');
2460 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2461 ac_str = av_mallocz(ac_str_size);
2463 return AVERROR(ENOMEM);
2464 av_strlcpy(ac_str, "ac", 3);
2466 av_strlcat(ac_str, stream_str, ac_str_size);
2467 ret = parse_option(o, ac_str, layout_str, options);
2473 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2475 OptionsContext *o = optctx;
2476 return parse_option(o, "q:a", arg, options);
2479 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2481 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2482 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2483 return AVERROR(ENOMEM);
2484 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2485 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2486 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2487 return AVERROR(ENOMEM);
2491 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2493 uint8_t *graph_desc = read_file(arg);
2495 return AVERROR(EINVAL);
2497 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2498 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2499 return AVERROR(ENOMEM);
2500 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2501 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2505 void show_help_default(const char *opt, const char *arg)
2507 /* per-file options have at least one of those set */
2508 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2509 int show_advanced = 0, show_avoptions = 0;
2512 if (!strcmp(opt, "long"))
2514 else if (!strcmp(opt, "full"))
2515 show_advanced = show_avoptions = 1;
2517 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2522 printf("Getting help:\n"
2523 " -h -- print basic options\n"
2524 " -h long -- print more options\n"
2525 " -h full -- print all options (including all format and codec specific options, very long)\n"
2526 " See man %s for detailed description of the options.\n"
2527 "\n", program_name);
2529 show_help_options(options, "Print help / information / capabilities:",
2532 show_help_options(options, "Global options (affect whole program "
2533 "instead of just one file:",
2534 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2536 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2537 per_file | OPT_EXIT, 0);
2539 show_help_options(options, "Per-file main options:", 0,
2540 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2541 OPT_EXIT, per_file);
2543 show_help_options(options, "Advanced per-file options:",
2544 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2546 show_help_options(options, "Video options:",
2547 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2549 show_help_options(options, "Advanced Video options:",
2550 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2552 show_help_options(options, "Audio options:",
2553 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2555 show_help_options(options, "Advanced Audio options:",
2556 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2557 show_help_options(options, "Subtitle options:",
2558 OPT_SUBTITLE, 0, 0);
2561 if (show_avoptions) {
2562 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2563 show_help_children(avcodec_get_class(), flags);
2564 show_help_children(avformat_get_class(), flags);
2566 show_help_children(sws_get_class(), flags);
2568 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2569 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2573 void show_usage(void)
2575 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2576 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2577 av_log(NULL, AV_LOG_INFO, "\n");
2585 static const OptionGroupDef groups[] = {
2586 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2587 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2590 static int open_files(OptionGroupList *l, const char *inout,
2591 int (*open_file)(OptionsContext*, const char*))
2595 for (i = 0; i < l->nb_groups; i++) {
2596 OptionGroup *g = &l->groups[i];
2602 ret = parse_optgroup(&o, g);
2604 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2605 "%s.\n", inout, g->arg);
2609 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2610 ret = open_file(&o, g->arg);
2613 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2617 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2623 int ffmpeg_parse_options(int argc, char **argv)
2625 OptionParseContext octx;
2629 memset(&octx, 0, sizeof(octx));
2631 /* split the commandline into an internal representation */
2632 ret = split_commandline(&octx, argc, argv, options, groups,
2633 FF_ARRAY_ELEMS(groups));
2635 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2639 /* apply global options */
2640 ret = parse_optgroup(NULL, &octx.global_opts);
2642 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2646 /* open input files */
2647 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2649 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2653 /* open output files */
2654 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2656 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2661 uninit_parse_context(&octx);
2663 av_strerror(ret, error, sizeof(error));
2664 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2669 static int opt_progress(void *optctx, const char *opt, const char *arg)
2671 AVIOContext *avio = NULL;
2674 if (!strcmp(arg, "-"))
2676 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2678 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2679 arg, av_err2str(ret));
2682 progress_avio = avio;
2686 #define OFFSET(x) offsetof(OptionsContext, x)
2687 const OptionDef options[] = {
2689 #include "cmdutils_common_opts.h"
2690 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2691 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2692 "force format", "fmt" },
2693 { "y", OPT_BOOL, { &file_overwrite },
2694 "overwrite output files" },
2695 { "n", OPT_BOOL, { &no_file_overwrite },
2696 "never overwrite output files" },
2697 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2698 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2699 "codec name", "codec" },
2700 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2701 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2702 "codec name", "codec" },
2703 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2704 OPT_OUTPUT, { .off = OFFSET(presets) },
2705 "preset name", "preset" },
2706 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2707 OPT_OUTPUT, { .func_arg = opt_map },
2708 "set input stream mapping",
2709 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2710 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2711 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2712 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2713 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2714 "set metadata information of outfile from infile",
2715 "outfile[,metadata]:infile[,metadata]" },
2716 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2717 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2718 "set chapters mapping", "input_file_index" },
2719 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2720 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2721 "record or transcode \"duration\" seconds of audio/video",
2723 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2724 "record or transcode stop time", "time_stop" },
2725 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2726 "set the limit file size in bytes", "limit_size" },
2727 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2728 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2729 "set the start time offset", "time_off" },
2730 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2731 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2732 "enable/disable accurate seeking with -ss" },
2733 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2734 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2735 "set the input ts offset", "time_off" },
2736 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2737 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2738 "set the input ts scale", "scale" },
2739 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2740 "set the recording timestamp ('now' to set the current time)", "time" },
2741 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2742 "add metadata", "string=string" },
2743 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2744 OPT_OUTPUT, { .func_arg = opt_data_frames },
2745 "set the number of data frames to record", "number" },
2746 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2747 "add timings for benchmarking" },
2748 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2749 "add timings for each task" },
2750 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2751 "write program-readable progress information", "url" },
2752 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2753 "enable or disable interaction on standard input" },
2754 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2755 "set max runtime in seconds", "limit" },
2756 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2757 "dump each input packet" },
2758 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2759 "when dumping packets, also dump the payload" },
2760 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2761 OPT_INPUT, { .off = OFFSET(rate_emu) },
2762 "read input at native frame rate", "" },
2763 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2764 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2765 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2766 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2767 "video sync method", "" },
2768 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2769 "audio sync method", "" },
2770 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2771 "audio drift threshold", "threshold" },
2772 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2773 "copy timestamps" },
2774 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2775 "copy input stream time base when stream copying", "mode" },
2776 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2777 OPT_OUTPUT, { .off = OFFSET(shortest) },
2778 "finish encoding within shortest input" },
2779 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2780 OPT_OUTPUT, { .off = OFFSET(apad) },
2782 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2783 "timestamp discontinuity delta threshold", "threshold" },
2784 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2785 "timestamp error delta threshold", "threshold" },
2786 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2787 "exit on error", "error" },
2788 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2789 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2790 "copy initial non-keyframes" },
2791 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2792 "copy or discard frames before start time" },
2793 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2794 "set the number of frames to record", "number" },
2795 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2796 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2797 "force codec tag/fourcc", "fourcc/tag" },
2798 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2799 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2800 "use fixed quality scale (VBR)", "q" },
2801 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2802 OPT_OUTPUT, { .func_arg = opt_qscale },
2803 "use fixed quality scale (VBR)", "q" },
2804 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2805 "set profile", "profile" },
2806 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2807 "set stream filtergraph", "filter_graph" },
2808 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2809 "read stream filtergraph description from a file", "filename" },
2810 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2811 "reinit filtergraph on input parameter changes", "" },
2812 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2813 "create a complex filtergraph", "graph_description" },
2814 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2815 "create a complex filtergraph", "graph_description" },
2816 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2817 "read complex filtergraph description from a file", "filename" },
2818 { "stats", OPT_BOOL, { &print_stats },
2819 "print progress report during encoding", },
2820 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2821 OPT_OUTPUT, { .func_arg = opt_attach },
2822 "add an attachment to the output file", "filename" },
2823 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2824 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2825 "extract an attachment into a file", "filename" },
2826 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2827 "print timestamp debugging info" },
2828 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2829 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2832 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2833 "set the number of video frames to record", "number" },
2834 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2835 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2836 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2837 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2838 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2839 "set frame size (WxH or abbreviation)", "size" },
2840 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2841 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2842 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2843 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2844 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2845 "set pixel format", "format" },
2846 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2847 "set the number of bits per raw sample", "number" },
2848 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2849 "deprecated use -g 1" },
2850 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2852 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2853 "discard threshold", "n" },
2854 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2855 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2856 "rate control override for specific intervals", "override" },
2857 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2858 OPT_OUTPUT, { .func_arg = opt_video_codec },
2859 "force video codec ('copy' to copy stream)", "codec" },
2860 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2862 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2864 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2865 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2866 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2867 "select the pass number (1 to 3)", "n" },
2868 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2869 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2870 "select two pass log file name prefix", "prefix" },
2871 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2872 "this option is deprecated, use the yadif filter instead" },
2873 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2874 "calculate PSNR of compressed frames" },
2875 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2876 "dump video coding statistics to file" },
2877 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2878 "dump video coding statistics to file", "file" },
2879 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2880 "set video filters", "filter_graph" },
2881 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2882 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2883 "specify intra matrix coeffs", "matrix" },
2884 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2885 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2886 "specify inter matrix coeffs", "matrix" },
2887 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2888 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2889 "specify intra matrix coeffs", "matrix" },
2890 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2891 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2892 "top=1/bottom=0/auto=-1 field first", "" },
2893 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2894 "intra_dc_precision", "precision" },
2895 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2896 OPT_OUTPUT, { .func_arg = opt_old2new },
2897 "force video tag/fourcc", "fourcc/tag" },
2898 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2899 "show QP histogram" },
2900 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2901 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2902 "force the selected framerate, disable the best supported framerate selection" },
2903 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2904 OPT_OUTPUT, { .func_arg = opt_streamid },
2905 "set the value of an outfile streamid", "streamIndex:value" },
2906 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2907 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2908 "force key frames at specified timestamps", "timestamps" },
2909 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2910 "video bitrate (please use -b:v)", "bitrate" },
2911 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2912 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2913 "use HW accelerated decoding", "hwaccel name" },
2914 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2915 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2916 "select a device for HW acceleration" "devicename" },
2919 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2920 "set the number of audio frames to record", "number" },
2921 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2922 "set audio quality (codec-specific)", "quality", },
2923 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2924 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2925 "set audio sampling rate (in Hz)", "rate" },
2926 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2927 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2928 "set number of audio channels", "channels" },
2929 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2931 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2932 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2933 "force audio codec ('copy' to copy stream)", "codec" },
2934 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2935 OPT_OUTPUT, { .func_arg = opt_old2new },
2936 "force audio tag/fourcc", "fourcc/tag" },
2937 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2938 "change audio volume (256=normal)" , "volume" },
2939 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2940 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2941 "set sample format", "format" },
2942 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2943 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2944 "set channel layout", "layout" },
2945 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2946 "set audio filters", "filter_graph" },
2947 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2948 "set the maximum number of channels to try to guess the channel layout" },
2950 /* subtitle options */
2951 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2952 "disable subtitle" },
2953 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2954 "force subtitle codec ('copy' to copy stream)", "codec" },
2955 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2956 , "force subtitle tag/fourcc", "fourcc/tag" },
2957 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2958 "fix subtitles duration" },
2959 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2960 "set canvas size (WxH or abbreviation)", "size" },
2963 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2964 "deprecated, use -channel", "channel" },
2965 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2966 "deprecated, use -standard", "standard" },
2967 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2970 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2971 "set the maximum demux-decode delay", "seconds" },
2972 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2973 "set the initial demux-decode delay", "seconds" },
2974 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2975 "override the options from ffserver", "" },
2977 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2978 "A comma-separated list of bitstream filters", "bitstream_filters" },
2979 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2980 "deprecated", "audio bitstream_filters" },
2981 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2982 "deprecated", "video bitstream_filters" },
2984 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2985 "set the audio options to the indicated preset", "preset" },
2986 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2987 "set the video options to the indicated preset", "preset" },
2988 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2989 "set the subtitle options to the indicated preset", "preset" },
2990 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2991 "set options from indicated preset file", "filename" },
2992 /* data codec support */
2993 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2994 "force data codec ('copy' to copy stream)", "codec" },
2995 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },