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)
562 char *next, *codec_tag = NULL;
564 for (i = 0; i < ic->nb_streams; i++) {
565 AVStream *st = ic->streams[i];
566 AVCodecContext *dec = st->codec;
567 InputStream *ist = av_mallocz(sizeof(*ist));
568 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
573 GROW_ARRAY(input_streams, nb_input_streams);
574 input_streams[nb_input_streams - 1] = ist;
577 ist->file_index = nb_input_files;
579 st->discard = AVDISCARD_ALL;
582 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
584 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
586 uint32_t tag = strtol(codec_tag, &next, 0);
588 tag = AV_RL32(codec_tag);
589 st->codec->codec_tag = tag;
592 ist->dec = choose_decoder(o, ic, st);
593 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
595 ist->reinit_filters = -1;
596 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
598 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
600 switch (dec->codec_type) {
601 case AVMEDIA_TYPE_VIDEO:
603 ist->dec = avcodec_find_decoder(dec->codec_id);
604 if (av_codec_get_lowres(dec)) {
605 dec->flags |= CODEC_FLAG_EMU_EDGE;
608 ist->resample_height = dec->height;
609 ist->resample_width = dec->width;
610 ist->resample_pix_fmt = dec->pix_fmt;
612 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
613 if (framerate && av_parse_video_rate(&ist->framerate,
615 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
620 ist->top_field_first = -1;
621 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
623 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
625 if (!strcmp(hwaccel, "none"))
626 ist->hwaccel_id = HWACCEL_NONE;
627 else if (!strcmp(hwaccel, "auto"))
628 ist->hwaccel_id = HWACCEL_AUTO;
631 for (i = 0; hwaccels[i].name; i++) {
632 if (!strcmp(hwaccels[i].name, hwaccel)) {
633 ist->hwaccel_id = hwaccels[i].id;
638 if (!ist->hwaccel_id) {
639 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
641 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
642 for (i = 0; hwaccels[i].name; i++)
643 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
644 av_log(NULL, AV_LOG_FATAL, "\n");
650 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
651 if (hwaccel_device) {
652 ist->hwaccel_device = av_strdup(hwaccel_device);
653 if (!ist->hwaccel_device)
656 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
659 case AVMEDIA_TYPE_AUDIO:
660 ist->guess_layout_max = INT_MAX;
661 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
662 guess_input_channel_layout(ist);
664 ist->resample_sample_fmt = dec->sample_fmt;
665 ist->resample_sample_rate = dec->sample_rate;
666 ist->resample_channels = dec->channels;
667 ist->resample_channel_layout = dec->channel_layout;
670 case AVMEDIA_TYPE_DATA:
671 case AVMEDIA_TYPE_SUBTITLE: {
672 char *canvas_size = NULL;
674 ist->dec = avcodec_find_decoder(dec->codec_id);
675 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
676 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
678 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
679 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
684 case AVMEDIA_TYPE_ATTACHMENT:
685 case AVMEDIA_TYPE_UNKNOWN:
693 static void assert_file_overwrite(const char *filename)
695 if (file_overwrite && no_file_overwrite) {
696 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
700 if (!file_overwrite) {
701 const char *proto_name = avio_find_protocol_name(filename);
702 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
703 if (stdin_interaction && !no_file_overwrite) {
704 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
707 signal(SIGINT, SIG_DFL);
709 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
715 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
722 static void dump_attachment(AVStream *st, const char *filename)
725 AVIOContext *out = NULL;
726 AVDictionaryEntry *e;
728 if (!st->codec->extradata_size) {
729 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
730 nb_input_files - 1, st->index);
733 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
736 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
737 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
741 assert_file_overwrite(filename);
743 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
744 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
749 avio_write(out, st->codec->extradata, st->codec->extradata_size);
754 static int open_input_file(OptionsContext *o, const char *filename)
758 AVInputFormat *file_iformat = NULL;
763 AVDictionary *unused_opts = NULL;
764 AVDictionaryEntry *e = NULL;
765 int orig_nb_streams; // number of streams before avformat_find_stream_info
766 char * video_codec_name = NULL;
767 char * audio_codec_name = NULL;
768 char *subtitle_codec_name = NULL;
771 if (!(file_iformat = av_find_input_format(o->format))) {
772 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
777 if (!strcmp(filename, "-"))
780 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
781 strcmp(filename, "/dev/stdin");
783 /* get default parameters from command line */
784 ic = avformat_alloc_context();
786 print_error(filename, AVERROR(ENOMEM));
789 if (o->nb_audio_sample_rate) {
790 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
791 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
793 if (o->nb_audio_channels) {
794 /* because we set audio_channels based on both the "ac" and
795 * "channel_layout" options, we need to check that the specified
796 * demuxer actually has the "channels" option before setting it */
797 if (file_iformat && file_iformat->priv_class &&
798 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
799 AV_OPT_SEARCH_FAKE_OBJ)) {
800 snprintf(buf, sizeof(buf), "%d",
801 o->audio_channels[o->nb_audio_channels - 1].u.i);
802 av_dict_set(&o->g->format_opts, "channels", buf, 0);
805 if (o->nb_frame_rates) {
806 /* set the format-level framerate option;
807 * this is important for video grabbers, e.g. x11 */
808 if (file_iformat && file_iformat->priv_class &&
809 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
810 AV_OPT_SEARCH_FAKE_OBJ)) {
811 av_dict_set(&o->g->format_opts, "framerate",
812 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
815 if (o->nb_frame_sizes) {
816 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
818 if (o->nb_frame_pix_fmts)
819 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
821 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
822 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
823 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
825 ic->video_codec_id = video_codec_name ?
826 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
827 ic->audio_codec_id = audio_codec_name ?
828 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
829 ic->subtitle_codec_id= subtitle_codec_name ?
830 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
832 if (video_codec_name)
833 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
834 if (audio_codec_name)
835 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
836 if (subtitle_codec_name)
837 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
839 ic->flags |= AVFMT_FLAG_NONBLOCK;
840 ic->interrupt_callback = int_cb;
842 /* open the input file with generic avformat function */
843 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
845 print_error(filename, err);
848 assert_avoptions(o->g->format_opts);
850 /* apply forced codec ids */
851 for (i = 0; i < ic->nb_streams; i++)
852 choose_decoder(o, ic, ic->streams[i]);
854 /* Set AVCodecContext options for avformat_find_stream_info */
855 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
856 orig_nb_streams = ic->nb_streams;
858 /* If not enough info to get the stream parameters, we decode the
859 first frames to get it. (used in mpeg case for example) */
860 ret = avformat_find_stream_info(ic, opts);
862 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
863 avformat_close_input(&ic);
867 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
868 /* add the stream start time */
869 if (ic->start_time != AV_NOPTS_VALUE)
870 timestamp += ic->start_time;
872 /* if seeking requested, we execute it */
873 if (o->start_time != AV_NOPTS_VALUE) {
874 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
876 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
877 filename, (double)timestamp / AV_TIME_BASE);
881 /* update the current parameters so that they match the one of the input stream */
882 add_input_streams(o, ic);
884 /* dump the file content */
885 av_dump_format(ic, nb_input_files, filename, 0);
887 GROW_ARRAY(input_files, nb_input_files);
888 f = av_mallocz(sizeof(*f));
891 input_files[nb_input_files - 1] = f;
894 f->ist_index = nb_input_streams - ic->nb_streams;
895 f->start_time = o->start_time;
896 f->recording_time = o->recording_time;
897 f->input_ts_offset = o->input_ts_offset;
898 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
899 f->nb_streams = ic->nb_streams;
900 f->rate_emu = o->rate_emu;
901 f->accurate_seek = o->accurate_seek;
903 /* check if all codec options have been used */
904 unused_opts = strip_specifiers(o->g->codec_opts);
905 for (i = f->ist_index; i < nb_input_streams; i++) {
907 while ((e = av_dict_get(input_streams[i]->opts, "", e,
908 AV_DICT_IGNORE_SUFFIX)))
909 av_dict_set(&unused_opts, e->key, NULL, 0);
913 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
914 const AVClass *class = avcodec_get_class();
915 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
916 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
917 const AVClass *fclass = avformat_get_class();
918 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
919 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
920 if (!option || foption)
924 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
925 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
926 "input file #%d (%s) is not a decoding option.\n", e->key,
927 option->help ? option->help : "", nb_input_files - 1,
932 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
933 "input file #%d (%s) has not been used for any stream. The most "
934 "likely reason is either wrong type (e.g. a video option with "
935 "no video streams) or that it is a private option of some decoder "
936 "which was not actually used for any stream.\n", e->key,
937 option->help ? option->help : "", nb_input_files - 1, filename);
939 av_dict_free(&unused_opts);
941 for (i = 0; i < o->nb_dump_attachment; i++) {
944 for (j = 0; j < ic->nb_streams; j++) {
945 AVStream *st = ic->streams[j];
947 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
948 dump_attachment(st, o->dump_attachment[i].u.str);
952 for (i = 0; i < orig_nb_streams; i++)
953 av_dict_free(&opts[i]);
959 static uint8_t *get_line(AVIOContext *s)
965 if (avio_open_dyn_buf(&line) < 0) {
966 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
970 while ((c = avio_r8(s)) && c != '\n')
973 avio_close_dyn_buf(line, &buf);
978 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
982 const char *base[3] = { getenv("AVCONV_DATADIR"),
987 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
991 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
992 i != 1 ? "" : "/.avconv", codec_name, preset_name);
993 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
996 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
997 i != 1 ? "" : "/.avconv", preset_name);
998 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1004 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1006 char *codec_name = NULL;
1008 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1010 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1011 NULL, ost->st->codec->codec_type);
1012 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1013 } else if (!strcmp(codec_name, "copy"))
1014 ost->stream_copy = 1;
1016 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1017 ost->st->codec->codec_id = ost->enc->id;
1021 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1024 AVStream *st = avformat_new_stream(oc, NULL);
1025 int idx = oc->nb_streams - 1, ret = 0;
1026 char *bsf = NULL, *next, *codec_tag = NULL;
1027 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1032 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1036 if (oc->nb_streams - 1 < o->nb_streamid_map)
1037 st->id = o->streamid_map[oc->nb_streams - 1];
1039 GROW_ARRAY(output_streams, nb_output_streams);
1040 if (!(ost = av_mallocz(sizeof(*ost))))
1042 output_streams[nb_output_streams - 1] = ost;
1044 ost->file_index = nb_output_files - 1;
1047 st->codec->codec_type = type;
1048 choose_encoder(o, oc, ost);
1050 AVIOContext *s = NULL;
1051 char *buf = NULL, *arg = NULL, *preset = NULL;
1053 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1055 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1056 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1059 if (!buf[0] || buf[0] == '#') {
1063 if (!(arg = strchr(buf, '='))) {
1064 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1068 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1070 } while (!s->eof_reached);
1074 av_log(NULL, AV_LOG_FATAL,
1075 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1076 preset, ost->file_index, ost->index);
1080 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1083 avcodec_get_context_defaults3(st->codec, ost->enc);
1084 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1086 ost->max_frames = INT64_MAX;
1087 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1088 for (i = 0; i<o->nb_max_frames; i++) {
1089 char *p = o->max_frames[i].specifier;
1090 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1091 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1096 ost->copy_prior_start = -1;
1097 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1099 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1101 if (next = strchr(bsf, ','))
1103 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1104 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1108 bsfc_prev->next = bsfc;
1110 ost->bitstream_filters = bsfc;
1116 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1118 uint32_t tag = strtol(codec_tag, &next, 0);
1120 tag = AV_RL32(codec_tag);
1121 st->codec->codec_tag = tag;
1124 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1126 st->codec->flags |= CODEC_FLAG_QSCALE;
1127 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1130 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1131 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1133 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1135 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1136 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1137 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1139 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1141 ost->source_index = source_index;
1142 if (source_index >= 0) {
1143 ost->sync_ist = input_streams[source_index];
1144 input_streams[source_index]->discard = 0;
1145 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1147 ost->last_mux_dts = AV_NOPTS_VALUE;
1152 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1155 const char *p = str;
1162 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1169 /* read file contents into a string */
1170 static uint8_t *read_file(const char *filename)
1172 AVIOContext *pb = NULL;
1173 AVIOContext *dyn_buf = NULL;
1174 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1175 uint8_t buf[1024], *str;
1178 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1182 ret = avio_open_dyn_buf(&dyn_buf);
1187 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1188 avio_write(dyn_buf, buf, ret);
1189 avio_w8(dyn_buf, 0);
1192 ret = avio_close_dyn_buf(dyn_buf, &str);
1198 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1201 AVStream *st = ost->st;
1203 if (ost->filters_script && ost->filters) {
1204 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1205 "output stream #%d:%d.\n", nb_output_files, st->index);
1209 if (ost->filters_script)
1210 return read_file(ost->filters_script);
1211 else if (ost->filters)
1212 return av_strdup(ost->filters);
1214 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1218 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1219 const OutputStream *ost, enum AVMediaType type)
1221 if (ost->filters_script || ost->filters) {
1222 av_log(NULL, AV_LOG_ERROR,
1223 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1224 "Filtering and streamcopy cannot be used together.\n",
1225 ost->filters ? "Filtergraph" : "Filtergraph script",
1226 ost->filters ? ost->filters : ost->filters_script,
1227 av_get_media_type_string(type), ost->file_index, ost->index);
1232 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1236 AVCodecContext *video_enc;
1237 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1239 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1241 video_enc = st->codec;
1243 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1244 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1245 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1249 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1250 if (frame_aspect_ratio) {
1252 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1253 q.num <= 0 || q.den <= 0) {
1254 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1257 ost->frame_aspect_ratio = q;
1260 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1261 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1263 if (!ost->stream_copy) {
1264 const char *p = NULL;
1265 char *frame_size = NULL;
1266 char *frame_pix_fmt = NULL;
1267 char *intra_matrix = NULL, *inter_matrix = NULL;
1268 char *chroma_intra_matrix = NULL;
1272 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1273 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1274 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1278 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1279 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1280 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1281 ost->keep_pix_fmt = 1;
1282 if (!*++frame_pix_fmt)
1283 frame_pix_fmt = NULL;
1285 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1286 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1289 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1292 video_enc->gop_size = 0;
1293 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1295 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1296 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1299 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1301 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1302 if (chroma_intra_matrix) {
1303 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1305 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1308 av_codec_set_chroma_intra_matrix(video_enc, p);
1309 parse_matrix_coeffs(p, chroma_intra_matrix);
1311 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1313 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1314 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1317 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1320 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1321 for (i = 0; p; i++) {
1323 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1325 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1328 /* FIXME realloc failure */
1329 video_enc->rc_override =
1330 av_realloc(video_enc->rc_override,
1331 sizeof(RcOverride) * (i + 1));
1332 video_enc->rc_override[i].start_frame = start;
1333 video_enc->rc_override[i].end_frame = end;
1335 video_enc->rc_override[i].qscale = q;
1336 video_enc->rc_override[i].quality_factor = 1.0;
1339 video_enc->rc_override[i].qscale = 0;
1340 video_enc->rc_override[i].quality_factor = -q/100.0;
1345 video_enc->rc_override_count = i;
1346 video_enc->intra_dc_precision = intra_dc_precision - 8;
1349 video_enc->flags|= CODEC_FLAG_PSNR;
1352 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1355 video_enc->flags |= CODEC_FLAG_PASS1;
1356 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1359 video_enc->flags |= CODEC_FLAG_PASS2;
1360 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1364 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1365 if (ost->logfile_prefix &&
1366 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1369 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1370 if (ost->forced_keyframes)
1371 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1373 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1375 ost->top_field_first = -1;
1376 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1379 ost->avfilter = get_ost_filters(o, oc, ost);
1383 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1386 if (ost->stream_copy)
1387 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1392 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1397 AVCodecContext *audio_enc;
1399 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1402 audio_enc = st->codec;
1403 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1405 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1406 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1408 if (!ost->stream_copy) {
1409 char *sample_fmt = NULL;
1411 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1413 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1415 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1416 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1420 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1422 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1423 ost->apad = av_strdup(ost->apad);
1425 ost->avfilter = get_ost_filters(o, oc, ost);
1429 /* check for channel mapping for this audio stream */
1430 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1431 AudioChannelMap *map = &o->audio_channel_maps[n];
1432 InputStream *ist = input_streams[ost->source_index];
1433 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1434 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1435 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1436 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1437 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1439 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1440 ost->file_index, ost->st->index);
1445 if (ost->stream_copy)
1446 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1451 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1455 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1456 if (!ost->stream_copy) {
1457 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1464 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1466 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1467 ost->stream_copy = 1;
1472 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1476 AVCodecContext *subtitle_enc;
1478 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1480 subtitle_enc = st->codec;
1482 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1484 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1486 if (!ost->stream_copy) {
1487 char *frame_size = NULL;
1489 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1490 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1491 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1499 /* arg format is "output-stream-index:streamid-value". */
1500 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1502 OptionsContext *o = optctx;
1507 av_strlcpy(idx_str, arg, sizeof(idx_str));
1508 p = strchr(idx_str, ':');
1510 av_log(NULL, AV_LOG_FATAL,
1511 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1516 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1517 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1518 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1522 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1524 AVFormatContext *is = ifile->ctx;
1525 AVFormatContext *os = ofile->ctx;
1529 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1531 return AVERROR(ENOMEM);
1534 for (i = 0; i < is->nb_chapters; i++) {
1535 AVChapter *in_ch = is->chapters[i], *out_ch;
1536 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1537 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1538 AV_TIME_BASE_Q, in_ch->time_base);
1539 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1540 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1543 if (in_ch->end < ts_off)
1545 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1548 out_ch = av_mallocz(sizeof(AVChapter));
1550 return AVERROR(ENOMEM);
1552 out_ch->id = in_ch->id;
1553 out_ch->time_base = in_ch->time_base;
1554 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1555 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1558 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1560 os->chapters[os->nb_chapters++] = out_ch;
1565 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1568 AVFormatContext *ic = avformat_alloc_context();
1570 ic->interrupt_callback = int_cb;
1571 err = avformat_open_input(&ic, filename, NULL, NULL);
1574 /* copy stream format */
1575 for(i=0;i<ic->nb_streams;i++) {
1579 AVCodecContext *avctx;
1581 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1582 ost = new_output_stream(o, s, codec->type, -1);
1587 // FIXME: a more elegant solution is needed
1588 memcpy(st, ic->streams[i], sizeof(AVStream));
1590 st->info = av_malloc(sizeof(*st->info));
1591 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1593 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1595 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1596 choose_sample_fmt(st, codec);
1597 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1598 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1601 avformat_close_input(&ic);
1605 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1606 AVFormatContext *oc)
1610 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1611 ofilter->out_tmp->pad_idx)) {
1612 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1613 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1615 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1620 ost->source_index = -1;
1621 ost->filter = ofilter;
1625 if (ost->stream_copy) {
1626 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1627 "which is fed from a complex filtergraph. Filtering and streamcopy "
1628 "cannot be used together.\n", ost->file_index, ost->index);
1632 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1633 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1634 av_log(NULL, AV_LOG_ERROR,
1635 "%s '%s' was specified through the %s option "
1636 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1637 "%s and -filter_complex cannot be used together for the same stream.\n",
1638 ost->filters ? "Filtergraph" : "Filtergraph script",
1639 ost->filters ? ost->filters : ost->filters_script,
1640 opt, ost->file_index, ost->index, opt);
1644 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1645 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1648 avfilter_inout_free(&ofilter->out_tmp);
1651 static int configure_complex_filters(void)
1655 for (i = 0; i < nb_filtergraphs; i++)
1656 if (!filtergraphs[i]->graph &&
1657 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1662 static int open_output_file(OptionsContext *o, const char *filename)
1664 AVFormatContext *oc;
1666 AVOutputFormat *file_oformat;
1670 AVDictionary *unused_opts = NULL;
1671 AVDictionaryEntry *e = NULL;
1673 if (configure_complex_filters() < 0) {
1674 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1678 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1679 o->stop_time = INT64_MAX;
1680 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1683 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1684 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1685 if (o->stop_time <= start_time) {
1686 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1687 o->stop_time = INT64_MAX;
1689 o->recording_time = o->stop_time - start_time;
1693 GROW_ARRAY(output_files, nb_output_files);
1694 of = av_mallocz(sizeof(*of));
1697 output_files[nb_output_files - 1] = of;
1699 of->ost_index = nb_output_streams;
1700 of->recording_time = o->recording_time;
1701 of->start_time = o->start_time;
1702 of->limit_filesize = o->limit_filesize;
1703 of->shortest = o->shortest;
1704 av_dict_copy(&of->opts, o->g->format_opts, 0);
1706 if (!strcmp(filename, "-"))
1709 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1711 print_error(filename, err);
1716 if (o->recording_time != INT64_MAX)
1717 oc->duration = o->recording_time;
1719 file_oformat= oc->oformat;
1720 oc->interrupt_callback = int_cb;
1722 /* create streams for all unlabeled output pads */
1723 for (i = 0; i < nb_filtergraphs; i++) {
1724 FilterGraph *fg = filtergraphs[i];
1725 for (j = 0; j < fg->nb_outputs; j++) {
1726 OutputFilter *ofilter = fg->outputs[j];
1728 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1731 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1732 ofilter->out_tmp->pad_idx)) {
1733 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1734 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1735 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1737 init_output_filter(ofilter, o, oc);
1741 /* ffserver seeking with date=... needs a date reference */
1742 if (!strcmp(file_oformat->name, "ffm") &&
1743 av_strstart(filename, "http:", NULL)) {
1744 int err = parse_option(o, "metadata", "creation_time=now", options);
1746 print_error(filename, err);
1751 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1752 av_strstart(filename, "http:", NULL)) {
1754 /* special case for files sent to ffserver: we get the stream
1755 parameters from ffserver */
1756 int err = read_ffserver_streams(o, oc, filename);
1758 print_error(filename, err);
1761 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1762 ost = output_streams[j];
1763 for (i = 0; i < nb_input_streams; i++) {
1764 ist = input_streams[i];
1765 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1767 ost->source_index= i;
1768 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1769 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1771 ist->st->discard = AVDISCARD_NONE;
1776 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));
1780 } else if (!o->nb_stream_maps) {
1781 char *subtitle_codec_name = NULL;
1782 /* pick the "best" stream of each type */
1784 /* video: highest resolution */
1785 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1786 int area = 0, idx = -1;
1787 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1788 for (i = 0; i < nb_input_streams; i++) {
1790 ist = input_streams[i];
1791 new_area = ist->st->codec->width * ist->st->codec->height;
1792 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1794 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1796 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1803 new_video_stream(o, oc, idx);
1806 /* audio: most channels */
1807 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1808 int channels = 0, idx = -1;
1809 for (i = 0; i < nb_input_streams; i++) {
1810 ist = input_streams[i];
1811 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1812 ist->st->codec->channels > channels) {
1813 channels = ist->st->codec->channels;
1818 new_audio_stream(o, oc, idx);
1821 /* subtitles: pick first */
1822 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1823 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1824 for (i = 0; i < nb_input_streams; i++)
1825 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1826 new_subtitle_stream(o, oc, i);
1830 /* do something with data? */
1832 for (i = 0; i < o->nb_stream_maps; i++) {
1833 StreamMap *map = &o->stream_maps[i];
1838 if (map->linklabel) {
1840 OutputFilter *ofilter = NULL;
1843 for (j = 0; j < nb_filtergraphs; j++) {
1844 fg = filtergraphs[j];
1845 for (k = 0; k < fg->nb_outputs; k++) {
1846 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1847 if (out && !strcmp(out->name, map->linklabel)) {
1848 ofilter = fg->outputs[k];
1855 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1856 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1859 init_output_filter(ofilter, o, oc);
1861 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1863 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1864 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1866 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1868 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1870 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1873 switch (ist->st->codec->codec_type) {
1874 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1875 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1876 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1877 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1878 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1880 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1881 map->file_index, map->stream_index);
1888 /* handle attached files */
1889 for (i = 0; i < o->nb_attachments; i++) {
1891 uint8_t *attachment;
1895 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1896 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1900 if ((len = avio_size(pb)) <= 0) {
1901 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1905 if (!(attachment = av_malloc(len))) {
1906 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1910 avio_read(pb, attachment, len);
1912 ost = new_attachment_stream(o, oc, -1);
1913 ost->stream_copy = 0;
1914 ost->attachment_filename = o->attachments[i];
1916 ost->st->codec->extradata = attachment;
1917 ost->st->codec->extradata_size = len;
1919 p = strrchr(o->attachments[i], '/');
1920 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1924 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1925 AVDictionaryEntry *e;
1926 ost = output_streams[i];
1928 if ((ost->stream_copy || ost->attachment_filename)
1929 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1930 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1931 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1935 /* check if all codec options have been used */
1936 unused_opts = strip_specifiers(o->g->codec_opts);
1937 for (i = of->ost_index; i < nb_output_streams; i++) {
1939 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1940 AV_DICT_IGNORE_SUFFIX)))
1941 av_dict_set(&unused_opts, e->key, NULL, 0);
1945 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1946 const AVClass *class = avcodec_get_class();
1947 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1948 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1951 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1952 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1953 "output file #%d (%s) is not an encoding option.\n", e->key,
1954 option->help ? option->help : "", nb_output_files - 1,
1959 // gop_timecode is injected by generic code but not always used
1960 if (!strcmp(e->key, "gop_timecode"))
1963 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1964 "output file #%d (%s) has not been used for any stream. The most "
1965 "likely reason is either wrong type (e.g. a video option with "
1966 "no video streams) or that it is a private option of some encoder "
1967 "which was not actually used for any stream.\n", e->key,
1968 option->help ? option->help : "", nb_output_files - 1, filename);
1970 av_dict_free(&unused_opts);
1972 /* check filename in case of an image number is expected */
1973 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1974 if (!av_filename_number_test(oc->filename)) {
1975 print_error(oc->filename, AVERROR(EINVAL));
1980 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1981 /* test if it already exists to avoid losing precious files */
1982 assert_file_overwrite(filename);
1985 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1986 &oc->interrupt_callback,
1988 print_error(filename, err);
1991 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1992 assert_file_overwrite(filename);
1994 if (o->mux_preload) {
1996 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1997 av_dict_set(&of->opts, "preload", buf, 0);
1999 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2002 for (i = 0; i < o->nb_metadata_map; i++) {
2004 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2006 if (in_file_index >= nb_input_files) {
2007 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2010 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2011 in_file_index >= 0 ?
2012 input_files[in_file_index]->ctx : NULL, o);
2016 if (o->chapters_input_file >= nb_input_files) {
2017 if (o->chapters_input_file == INT_MAX) {
2018 /* copy chapters from the first input file that has them*/
2019 o->chapters_input_file = -1;
2020 for (i = 0; i < nb_input_files; i++)
2021 if (input_files[i]->ctx->nb_chapters) {
2022 o->chapters_input_file = i;
2026 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2027 o->chapters_input_file);
2031 if (o->chapters_input_file >= 0)
2032 copy_chapters(input_files[o->chapters_input_file], of,
2033 !o->metadata_chapters_manual);
2035 /* copy global metadata by default */
2036 if (!o->metadata_global_manual && nb_input_files){
2037 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2038 AV_DICT_DONT_OVERWRITE);
2039 if(o->recording_time != INT64_MAX)
2040 av_dict_set(&oc->metadata, "duration", NULL, 0);
2041 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2043 if (!o->metadata_streams_manual)
2044 for (i = of->ost_index; i < nb_output_streams; i++) {
2046 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2048 ist = input_streams[output_streams[i]->source_index];
2049 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2052 /* process manually set metadata */
2053 for (i = 0; i < o->nb_metadata; i++) {
2056 const char *stream_spec;
2057 int index = 0, j, ret = 0;
2059 val = strchr(o->metadata[i].u.str, '=');
2061 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2062 o->metadata[i].u.str);
2067 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2069 for (j = 0; j < oc->nb_streams; j++) {
2070 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2071 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2082 if (index < 0 || index >= oc->nb_chapters) {
2083 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2086 m = &oc->chapters[index]->metadata;
2089 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2092 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2099 static int opt_target(void *optctx, const char *opt, const char *arg)
2101 OptionsContext *o = optctx;
2102 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2103 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2105 if (!strncmp(arg, "pal-", 4)) {
2108 } else if (!strncmp(arg, "ntsc-", 5)) {
2111 } else if (!strncmp(arg, "film-", 5)) {
2115 /* Try to determine PAL/NTSC by peeking in the input files */
2116 if (nb_input_files) {
2118 for (j = 0; j < nb_input_files; j++) {
2119 for (i = 0; i < input_files[j]->nb_streams; i++) {
2120 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2121 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2123 fr = c->time_base.den * 1000 / c->time_base.num;
2127 } else if ((fr == 29970) || (fr == 23976)) {
2132 if (norm != UNKNOWN)
2136 if (norm != UNKNOWN)
2137 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2140 if (norm == UNKNOWN) {
2141 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2142 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2143 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2147 if (!strcmp(arg, "vcd")) {
2148 opt_video_codec(o, "c:v", "mpeg1video");
2149 opt_audio_codec(o, "c:a", "mp2");
2150 parse_option(o, "f", "vcd", options);
2152 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2153 parse_option(o, "r", frame_rates[norm], options);
2154 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2156 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2157 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2158 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2159 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2161 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2162 parse_option(o, "ar", "44100", options);
2163 parse_option(o, "ac", "2", options);
2165 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2166 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2168 /* We have to offset the PTS, so that it is consistent with the SCR.
2169 SCR starts at 36000, but the first two packs contain only padding
2170 and the first pack from the other stream, respectively, may also have
2171 been written before.
2172 So the real data starts at SCR 36000+3*1200. */
2173 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2174 } else if (!strcmp(arg, "svcd")) {
2176 opt_video_codec(o, "c:v", "mpeg2video");
2177 opt_audio_codec(o, "c:a", "mp2");
2178 parse_option(o, "f", "svcd", options);
2180 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2181 parse_option(o, "r", frame_rates[norm], options);
2182 parse_option(o, "pix_fmt", "yuv420p", options);
2183 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2185 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2186 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2187 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2188 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2189 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2191 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2192 parse_option(o, "ar", "44100", options);
2194 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2196 } else if (!strcmp(arg, "dvd")) {
2198 opt_video_codec(o, "c:v", "mpeg2video");
2199 opt_audio_codec(o, "c:a", "ac3");
2200 parse_option(o, "f", "dvd", options);
2202 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2203 parse_option(o, "r", frame_rates[norm], options);
2204 parse_option(o, "pix_fmt", "yuv420p", options);
2205 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2207 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2208 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2209 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2210 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2212 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.
2213 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2215 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2216 parse_option(o, "ar", "48000", options);
2218 } else if (!strncmp(arg, "dv", 2)) {
2220 parse_option(o, "f", "dv", options);
2222 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2223 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2224 norm == PAL ? "yuv420p" : "yuv411p", options);
2225 parse_option(o, "r", frame_rates[norm], options);
2227 parse_option(o, "ar", "48000", options);
2228 parse_option(o, "ac", "2", options);
2231 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2232 return AVERROR(EINVAL);
2237 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2239 av_free (vstats_filename);
2240 vstats_filename = av_strdup (arg);
2244 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2247 time_t today2 = time(NULL);
2248 struct tm *today = localtime(&today2);
2250 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2252 return opt_vstats_file(NULL, opt, filename);
2255 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2257 OptionsContext *o = optctx;
2258 return parse_option(o, "frames:v", arg, options);
2261 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2263 OptionsContext *o = optctx;
2264 return parse_option(o, "frames:a", arg, options);
2267 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2269 OptionsContext *o = optctx;
2270 return parse_option(o, "frames:d", arg, options);
2273 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2276 AVDictionary *cbak = codec_opts;
2277 AVDictionary *fbak = format_opts;
2281 ret = opt_default(NULL, opt, arg);
2283 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2284 av_dict_copy(&o->g->format_opts, format_opts, 0);
2285 av_dict_free(&codec_opts);
2286 av_dict_free(&format_opts);
2293 static int opt_preset(void *optctx, const char *opt, const char *arg)
2295 OptionsContext *o = optctx;
2297 char filename[1000], line[1000], tmp_line[1000];
2298 const char *codec_name = NULL;
2302 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2304 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2305 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2306 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2308 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2312 while (fgets(line, sizeof(line), f)) {
2313 char *key = tmp_line, *value, *endptr;
2315 if (strcspn(line, "#\n\r") == 0)
2317 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2318 if (!av_strtok(key, "=", &value) ||
2319 !av_strtok(value, "\r\n", &endptr)) {
2320 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2323 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2325 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2326 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2327 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2328 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2329 else if (opt_default_new(o, key, value) < 0) {
2330 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2331 filename, line, key, value);
2341 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2343 OptionsContext *o = optctx;
2344 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2345 int ret = parse_option(o, s, arg, options);
2350 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2352 OptionsContext *o = optctx;
2353 if(!strcmp(opt, "b")){
2354 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2355 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2358 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2362 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2364 OptionsContext *o = optctx;
2367 if(!strcmp(opt, "qscale")){
2368 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2369 return parse_option(o, "q:v", arg, options);
2371 s = av_asprintf("q%s", opt + 6);
2372 ret = parse_option(o, s, arg, options);
2377 static int opt_profile(void *optctx, const char *opt, const char *arg)
2379 OptionsContext *o = optctx;
2380 if(!strcmp(opt, "profile")){
2381 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2382 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2385 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2389 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2391 OptionsContext *o = optctx;
2392 return parse_option(o, "filter:v", arg, options);
2395 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2397 OptionsContext *o = optctx;
2398 return parse_option(o, "filter:a", arg, options);
2401 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2403 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2404 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2405 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2406 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2408 if (video_sync_method == VSYNC_AUTO)
2409 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2413 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2415 OptionsContext *o = optctx;
2416 char *tcr = av_asprintf("timecode=%s", arg);
2417 int ret = parse_option(o, "metadata:g", tcr, options);
2419 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2424 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2426 OptionsContext *o = optctx;
2427 char layout_str[32];
2430 int ret, channels, ac_str_size;
2433 layout = av_get_channel_layout(arg);
2435 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2436 return AVERROR(EINVAL);
2438 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2439 ret = opt_default_new(o, opt, layout_str);
2443 /* set 'ac' option based on channel layout */
2444 channels = av_get_channel_layout_nb_channels(layout);
2445 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2446 stream_str = strchr(opt, ':');
2447 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2448 ac_str = av_mallocz(ac_str_size);
2450 return AVERROR(ENOMEM);
2451 av_strlcpy(ac_str, "ac", 3);
2453 av_strlcat(ac_str, stream_str, ac_str_size);
2454 ret = parse_option(o, ac_str, layout_str, options);
2460 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2462 OptionsContext *o = optctx;
2463 return parse_option(o, "q:a", arg, options);
2466 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2468 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2469 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2470 return AVERROR(ENOMEM);
2471 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2472 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2473 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2474 return AVERROR(ENOMEM);
2478 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2480 uint8_t *graph_desc = read_file(arg);
2482 return AVERROR(EINVAL);
2484 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2485 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2486 return AVERROR(ENOMEM);
2487 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2488 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2492 void show_help_default(const char *opt, const char *arg)
2494 /* per-file options have at least one of those set */
2495 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2496 int show_advanced = 0, show_avoptions = 0;
2499 if (!strcmp(opt, "long"))
2501 else if (!strcmp(opt, "full"))
2502 show_advanced = show_avoptions = 1;
2504 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2509 printf("Getting help:\n"
2510 " -h -- print basic options\n"
2511 " -h long -- print more options\n"
2512 " -h full -- print all options (including all format and codec specific options, very long)\n"
2513 " See man %s for detailed description of the options.\n"
2514 "\n", program_name);
2516 show_help_options(options, "Print help / information / capabilities:",
2519 show_help_options(options, "Global options (affect whole program "
2520 "instead of just one file:",
2521 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2523 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2524 per_file | OPT_EXIT, 0);
2526 show_help_options(options, "Per-file main options:", 0,
2527 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2528 OPT_EXIT, per_file);
2530 show_help_options(options, "Advanced per-file options:",
2531 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2533 show_help_options(options, "Video options:",
2534 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2536 show_help_options(options, "Advanced Video options:",
2537 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2539 show_help_options(options, "Audio options:",
2540 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2542 show_help_options(options, "Advanced Audio options:",
2543 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2544 show_help_options(options, "Subtitle options:",
2545 OPT_SUBTITLE, 0, 0);
2548 if (show_avoptions) {
2549 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2550 show_help_children(avcodec_get_class(), flags);
2551 show_help_children(avformat_get_class(), flags);
2553 show_help_children(sws_get_class(), flags);
2555 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2556 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2560 void show_usage(void)
2562 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2563 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2564 av_log(NULL, AV_LOG_INFO, "\n");
2572 static const OptionGroupDef groups[] = {
2573 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2574 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2577 static int open_files(OptionGroupList *l, const char *inout,
2578 int (*open_file)(OptionsContext*, const char*))
2582 for (i = 0; i < l->nb_groups; i++) {
2583 OptionGroup *g = &l->groups[i];
2589 ret = parse_optgroup(&o, g);
2591 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2592 "%s.\n", inout, g->arg);
2596 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2597 ret = open_file(&o, g->arg);
2600 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2604 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2610 int ffmpeg_parse_options(int argc, char **argv)
2612 OptionParseContext octx;
2616 memset(&octx, 0, sizeof(octx));
2618 /* split the commandline into an internal representation */
2619 ret = split_commandline(&octx, argc, argv, options, groups,
2620 FF_ARRAY_ELEMS(groups));
2622 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2626 /* apply global options */
2627 ret = parse_optgroup(NULL, &octx.global_opts);
2629 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2633 /* open input files */
2634 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2636 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2640 /* open output files */
2641 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2643 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2648 uninit_parse_context(&octx);
2650 av_strerror(ret, error, sizeof(error));
2651 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2656 static int opt_progress(void *optctx, const char *opt, const char *arg)
2658 AVIOContext *avio = NULL;
2661 if (!strcmp(arg, "-"))
2663 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2665 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2666 arg, av_err2str(ret));
2669 progress_avio = avio;
2673 #define OFFSET(x) offsetof(OptionsContext, x)
2674 const OptionDef options[] = {
2676 #include "cmdutils_common_opts.h"
2677 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2678 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2679 "force format", "fmt" },
2680 { "y", OPT_BOOL, { &file_overwrite },
2681 "overwrite output files" },
2682 { "n", OPT_BOOL, { &no_file_overwrite },
2683 "never overwrite output files" },
2684 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2685 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2686 "codec name", "codec" },
2687 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2688 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2689 "codec name", "codec" },
2690 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2691 OPT_OUTPUT, { .off = OFFSET(presets) },
2692 "preset name", "preset" },
2693 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2694 OPT_OUTPUT, { .func_arg = opt_map },
2695 "set input stream mapping",
2696 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2697 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2698 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2699 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2700 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2701 "set metadata information of outfile from infile",
2702 "outfile[,metadata]:infile[,metadata]" },
2703 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2704 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2705 "set chapters mapping", "input_file_index" },
2706 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2707 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2708 "record or transcode \"duration\" seconds of audio/video",
2710 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2711 "record or transcode stop time", "time_stop" },
2712 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2713 "set the limit file size in bytes", "limit_size" },
2714 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2715 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2716 "set the start time offset", "time_off" },
2717 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2718 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2719 "enable/disable accurate seeking with -ss" },
2720 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2721 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2722 "set the input ts offset", "time_off" },
2723 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2724 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2725 "set the input ts scale", "scale" },
2726 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2727 "set the recording timestamp ('now' to set the current time)", "time" },
2728 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2729 "add metadata", "string=string" },
2730 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2731 OPT_OUTPUT, { .func_arg = opt_data_frames },
2732 "set the number of data frames to record", "number" },
2733 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2734 "add timings for benchmarking" },
2735 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2736 "add timings for each task" },
2737 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2738 "write program-readable progress information", "url" },
2739 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2740 "enable or disable interaction on standard input" },
2741 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2742 "set max runtime in seconds", "limit" },
2743 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2744 "dump each input packet" },
2745 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2746 "when dumping packets, also dump the payload" },
2747 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2748 OPT_INPUT, { .off = OFFSET(rate_emu) },
2749 "read input at native frame rate", "" },
2750 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2751 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2752 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2753 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2754 "video sync method", "" },
2755 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2756 "audio sync method", "" },
2757 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2758 "audio drift threshold", "threshold" },
2759 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2760 "copy timestamps" },
2761 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2762 "copy input stream time base when stream copying", "mode" },
2763 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2764 OPT_OUTPUT, { .off = OFFSET(shortest) },
2765 "finish encoding within shortest input" },
2766 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2767 OPT_OUTPUT, { .off = OFFSET(apad) },
2769 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2770 "timestamp discontinuity delta threshold", "threshold" },
2771 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2772 "timestamp error delta threshold", "threshold" },
2773 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2774 "exit on error", "error" },
2775 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2776 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2777 "copy initial non-keyframes" },
2778 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2779 "copy or discard frames before start time" },
2780 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2781 "set the number of frames to record", "number" },
2782 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2783 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2784 "force codec tag/fourcc", "fourcc/tag" },
2785 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2786 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2787 "use fixed quality scale (VBR)", "q" },
2788 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2789 OPT_OUTPUT, { .func_arg = opt_qscale },
2790 "use fixed quality scale (VBR)", "q" },
2791 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2792 "set profile", "profile" },
2793 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2794 "set stream filtergraph", "filter_graph" },
2795 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2796 "read stream filtergraph description from a file", "filename" },
2797 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2798 "reinit filtergraph on input parameter changes", "" },
2799 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2800 "create a complex filtergraph", "graph_description" },
2801 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2802 "create a complex filtergraph", "graph_description" },
2803 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2804 "read complex filtergraph description from a file", "filename" },
2805 { "stats", OPT_BOOL, { &print_stats },
2806 "print progress report during encoding", },
2807 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2808 OPT_OUTPUT, { .func_arg = opt_attach },
2809 "add an attachment to the output file", "filename" },
2810 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2811 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2812 "extract an attachment into a file", "filename" },
2813 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2814 "print timestamp debugging info" },
2815 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2816 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2819 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2820 "set the number of video frames to record", "number" },
2821 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2822 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2823 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2824 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2825 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2826 "set frame size (WxH or abbreviation)", "size" },
2827 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2828 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2829 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2830 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2831 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2832 "set pixel format", "format" },
2833 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2834 "set the number of bits per raw sample", "number" },
2835 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2836 "deprecated use -g 1" },
2837 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2839 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2840 "discard threshold", "n" },
2841 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2842 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2843 "rate control override for specific intervals", "override" },
2844 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2845 OPT_OUTPUT, { .func_arg = opt_video_codec },
2846 "force video codec ('copy' to copy stream)", "codec" },
2847 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2849 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2851 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2852 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2853 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2854 "select the pass number (1 to 3)", "n" },
2855 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2856 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2857 "select two pass log file name prefix", "prefix" },
2858 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2859 "this option is deprecated, use the yadif filter instead" },
2860 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2861 "calculate PSNR of compressed frames" },
2862 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2863 "dump video coding statistics to file" },
2864 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2865 "dump video coding statistics to file", "file" },
2866 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2867 "set video filters", "filter_graph" },
2868 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2869 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2870 "specify intra matrix coeffs", "matrix" },
2871 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2872 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2873 "specify inter matrix coeffs", "matrix" },
2874 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2875 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2876 "specify intra matrix coeffs", "matrix" },
2877 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2878 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2879 "top=1/bottom=0/auto=-1 field first", "" },
2880 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2881 "intra_dc_precision", "precision" },
2882 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2883 OPT_OUTPUT, { .func_arg = opt_old2new },
2884 "force video tag/fourcc", "fourcc/tag" },
2885 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2886 "show QP histogram" },
2887 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2888 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2889 "force the selected framerate, disable the best supported framerate selection" },
2890 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2891 OPT_OUTPUT, { .func_arg = opt_streamid },
2892 "set the value of an outfile streamid", "streamIndex:value" },
2893 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2894 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2895 "force key frames at specified timestamps", "timestamps" },
2896 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2897 "video bitrate (please use -b:v)", "bitrate" },
2898 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2899 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2900 "use HW accelerated decoding", "hwaccel name" },
2901 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2902 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2903 "select a device for HW acceleration" "devicename" },
2906 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2907 "set the number of audio frames to record", "number" },
2908 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2909 "set audio quality (codec-specific)", "quality", },
2910 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2911 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2912 "set audio sampling rate (in Hz)", "rate" },
2913 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2914 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2915 "set number of audio channels", "channels" },
2916 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2918 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2919 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2920 "force audio codec ('copy' to copy stream)", "codec" },
2921 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2922 OPT_OUTPUT, { .func_arg = opt_old2new },
2923 "force audio tag/fourcc", "fourcc/tag" },
2924 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2925 "change audio volume (256=normal)" , "volume" },
2926 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2927 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2928 "set sample format", "format" },
2929 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2930 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2931 "set channel layout", "layout" },
2932 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2933 "set audio filters", "filter_graph" },
2934 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2935 "set the maximum number of channels to try to guess the channel layout" },
2937 /* subtitle options */
2938 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2939 "disable subtitle" },
2940 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2941 "force subtitle codec ('copy' to copy stream)", "codec" },
2942 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2943 , "force subtitle tag/fourcc", "fourcc/tag" },
2944 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2945 "fix subtitles duration" },
2946 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2947 "set canvas size (WxH or abbreviation)", "size" },
2950 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2951 "deprecated, use -channel", "channel" },
2952 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2953 "deprecated, use -standard", "standard" },
2954 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2957 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2958 "set the maximum demux-decode delay", "seconds" },
2959 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2960 "set the initial demux-decode delay", "seconds" },
2961 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2962 "override the options from ffserver", "" },
2964 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2965 "A comma-separated list of bitstream filters", "bitstream_filters" },
2966 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2967 "deprecated", "audio bitstream_filters" },
2968 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2969 "deprecated", "video bitstream_filters" },
2971 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2972 "set the audio options to the indicated preset", "preset" },
2973 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2974 "set the video options to the indicated preset", "preset" },
2975 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2976 "set the subtitle options to the indicated preset", "preset" },
2977 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2978 "set options from indicated preset file", "filename" },
2979 /* data codec support */
2980 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2981 "force data codec ('copy' to copy stream)", "codec" },
2982 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },