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)
658 case AVMEDIA_TYPE_AUDIO:
659 ist->guess_layout_max = INT_MAX;
660 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
661 guess_input_channel_layout(ist);
663 ist->resample_sample_fmt = dec->sample_fmt;
664 ist->resample_sample_rate = dec->sample_rate;
665 ist->resample_channels = dec->channels;
666 ist->resample_channel_layout = dec->channel_layout;
669 case AVMEDIA_TYPE_DATA:
670 case AVMEDIA_TYPE_SUBTITLE: {
671 char *canvas_size = NULL;
673 ist->dec = avcodec_find_decoder(dec->codec_id);
674 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
675 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
677 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
678 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
683 case AVMEDIA_TYPE_ATTACHMENT:
684 case AVMEDIA_TYPE_UNKNOWN:
692 static void assert_file_overwrite(const char *filename)
694 if (file_overwrite && no_file_overwrite) {
695 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
699 if (!file_overwrite &&
700 (strchr(filename, ':') == NULL || filename[1] == ':' ||
701 av_strstart(filename, "file:", NULL))) {
702 if (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);
919 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
920 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
921 "input file #%d (%s) is not a decoding option.\n", e->key,
922 option->help ? option->help : "", nb_input_files - 1,
927 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
928 "input file #%d (%s) has not been used for any stream. The most "
929 "likely reason is either wrong type (e.g. a video option with "
930 "no video streams) or that it is a private option of some decoder "
931 "which was not actually used for any stream.\n", e->key,
932 option->help ? option->help : "", nb_input_files - 1, filename);
934 av_dict_free(&unused_opts);
936 for (i = 0; i < o->nb_dump_attachment; i++) {
939 for (j = 0; j < ic->nb_streams; j++) {
940 AVStream *st = ic->streams[j];
942 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
943 dump_attachment(st, o->dump_attachment[i].u.str);
947 for (i = 0; i < orig_nb_streams; i++)
948 av_dict_free(&opts[i]);
954 static uint8_t *get_line(AVIOContext *s)
960 if (avio_open_dyn_buf(&line) < 0) {
961 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
965 while ((c = avio_r8(s)) && c != '\n')
968 avio_close_dyn_buf(line, &buf);
973 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
977 const char *base[3] = { getenv("AVCONV_DATADIR"),
982 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
986 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
987 i != 1 ? "" : "/.avconv", codec_name, preset_name);
988 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
991 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
992 i != 1 ? "" : "/.avconv", preset_name);
993 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
999 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1001 char *codec_name = NULL;
1003 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1005 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1006 NULL, ost->st->codec->codec_type);
1007 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1008 } else if (!strcmp(codec_name, "copy"))
1009 ost->stream_copy = 1;
1011 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1012 ost->st->codec->codec_id = ost->enc->id;
1016 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1019 AVStream *st = avformat_new_stream(oc, NULL);
1020 int idx = oc->nb_streams - 1, ret = 0;
1021 char *bsf = NULL, *next, *codec_tag = NULL;
1022 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1027 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1031 if (oc->nb_streams - 1 < o->nb_streamid_map)
1032 st->id = o->streamid_map[oc->nb_streams - 1];
1034 GROW_ARRAY(output_streams, nb_output_streams);
1035 if (!(ost = av_mallocz(sizeof(*ost))))
1037 output_streams[nb_output_streams - 1] = ost;
1039 ost->file_index = nb_output_files - 1;
1042 st->codec->codec_type = type;
1043 choose_encoder(o, oc, ost);
1045 AVIOContext *s = NULL;
1046 char *buf = NULL, *arg = NULL, *preset = NULL;
1048 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1050 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1051 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1054 if (!buf[0] || buf[0] == '#') {
1058 if (!(arg = strchr(buf, '='))) {
1059 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1063 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1065 } while (!s->eof_reached);
1069 av_log(NULL, AV_LOG_FATAL,
1070 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1071 preset, ost->file_index, ost->index);
1075 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1078 avcodec_get_context_defaults3(st->codec, ost->enc);
1079 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1081 ost->max_frames = INT64_MAX;
1082 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1083 for (i = 0; i<o->nb_max_frames; i++) {
1084 char *p = o->max_frames[i].specifier;
1085 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1086 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1091 ost->copy_prior_start = -1;
1092 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1094 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1096 if (next = strchr(bsf, ','))
1098 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1099 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1103 bsfc_prev->next = bsfc;
1105 ost->bitstream_filters = bsfc;
1111 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1113 uint32_t tag = strtol(codec_tag, &next, 0);
1115 tag = AV_RL32(codec_tag);
1116 st->codec->codec_tag = tag;
1119 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1121 st->codec->flags |= CODEC_FLAG_QSCALE;
1122 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1125 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1126 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1128 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1130 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1131 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1132 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1134 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1136 ost->source_index = source_index;
1137 if (source_index >= 0) {
1138 ost->sync_ist = input_streams[source_index];
1139 input_streams[source_index]->discard = 0;
1140 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1142 ost->last_mux_dts = AV_NOPTS_VALUE;
1147 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1150 const char *p = str;
1157 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1164 /* read file contents into a string */
1165 static uint8_t *read_file(const char *filename)
1167 AVIOContext *pb = NULL;
1168 AVIOContext *dyn_buf = NULL;
1169 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1170 uint8_t buf[1024], *str;
1173 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1177 ret = avio_open_dyn_buf(&dyn_buf);
1182 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1183 avio_write(dyn_buf, buf, ret);
1184 avio_w8(dyn_buf, 0);
1187 ret = avio_close_dyn_buf(dyn_buf, &str);
1193 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1196 AVStream *st = ost->st;
1198 if (ost->filters_script && ost->filters) {
1199 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1200 "output stream #%d:%d.\n", nb_output_files, st->index);
1204 if (ost->filters_script)
1205 return read_file(ost->filters_script);
1206 else if (ost->filters)
1207 return av_strdup(ost->filters);
1209 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1213 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1214 const OutputStream *ost, enum AVMediaType type)
1216 if (ost->filters_script || ost->filters) {
1217 av_log(NULL, AV_LOG_ERROR,
1218 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1219 "Filtering and streamcopy cannot be used together.\n",
1220 ost->filters ? "Filtergraph" : "Filtergraph script",
1221 ost->filters ? ost->filters : ost->filters_script,
1222 av_get_media_type_string(type), ost->file_index, ost->index);
1227 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1231 AVCodecContext *video_enc;
1232 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1234 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1236 video_enc = st->codec;
1238 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1239 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1240 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1244 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1245 if (frame_aspect_ratio) {
1247 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1248 q.num <= 0 || q.den <= 0) {
1249 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1252 ost->frame_aspect_ratio = q;
1255 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1256 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1258 if (!ost->stream_copy) {
1259 const char *p = NULL;
1260 char *frame_size = NULL;
1261 char *frame_pix_fmt = NULL;
1262 char *intra_matrix = NULL, *inter_matrix = NULL;
1266 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1267 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1268 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1272 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1273 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1274 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1275 ost->keep_pix_fmt = 1;
1276 if (!*++frame_pix_fmt)
1277 frame_pix_fmt = NULL;
1279 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1280 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1283 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1286 video_enc->gop_size = 0;
1287 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1289 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1290 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1293 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1295 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1297 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1298 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1301 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1304 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1305 for (i = 0; p; i++) {
1307 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1309 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1312 /* FIXME realloc failure */
1313 video_enc->rc_override =
1314 av_realloc(video_enc->rc_override,
1315 sizeof(RcOverride) * (i + 1));
1316 video_enc->rc_override[i].start_frame = start;
1317 video_enc->rc_override[i].end_frame = end;
1319 video_enc->rc_override[i].qscale = q;
1320 video_enc->rc_override[i].quality_factor = 1.0;
1323 video_enc->rc_override[i].qscale = 0;
1324 video_enc->rc_override[i].quality_factor = -q/100.0;
1329 video_enc->rc_override_count = i;
1330 video_enc->intra_dc_precision = intra_dc_precision - 8;
1333 video_enc->flags|= CODEC_FLAG_PSNR;
1336 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1339 video_enc->flags |= CODEC_FLAG_PASS1;
1340 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1343 video_enc->flags |= CODEC_FLAG_PASS2;
1344 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1348 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1349 if (ost->logfile_prefix &&
1350 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1353 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1354 if (ost->forced_keyframes)
1355 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1357 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1359 ost->top_field_first = -1;
1360 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1363 ost->avfilter = get_ost_filters(o, oc, ost);
1367 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1370 if (ost->stream_copy)
1371 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1376 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1381 AVCodecContext *audio_enc;
1383 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1386 audio_enc = st->codec;
1387 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1389 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1390 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1392 if (!ost->stream_copy) {
1393 char *sample_fmt = NULL;
1395 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1397 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1399 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1400 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1404 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1406 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1407 ost->apad = av_strdup(ost->apad);
1409 ost->avfilter = get_ost_filters(o, oc, ost);
1413 /* check for channel mapping for this audio stream */
1414 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1415 AudioChannelMap *map = &o->audio_channel_maps[n];
1416 InputStream *ist = input_streams[ost->source_index];
1417 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1418 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1419 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1420 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1421 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1423 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1424 ost->file_index, ost->st->index);
1429 if (ost->stream_copy)
1430 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1435 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1439 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1440 if (!ost->stream_copy) {
1441 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1448 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1450 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1451 ost->stream_copy = 1;
1456 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1460 AVCodecContext *subtitle_enc;
1462 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1464 subtitle_enc = st->codec;
1466 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1468 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1470 if (!ost->stream_copy) {
1471 char *frame_size = NULL;
1473 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1474 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1475 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1483 /* arg format is "output-stream-index:streamid-value". */
1484 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1486 OptionsContext *o = optctx;
1491 av_strlcpy(idx_str, arg, sizeof(idx_str));
1492 p = strchr(idx_str, ':');
1494 av_log(NULL, AV_LOG_FATAL,
1495 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1500 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1501 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1502 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1506 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1508 AVFormatContext *is = ifile->ctx;
1509 AVFormatContext *os = ofile->ctx;
1513 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1515 return AVERROR(ENOMEM);
1518 for (i = 0; i < is->nb_chapters; i++) {
1519 AVChapter *in_ch = is->chapters[i], *out_ch;
1520 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1521 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1522 AV_TIME_BASE_Q, in_ch->time_base);
1523 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1524 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1527 if (in_ch->end < ts_off)
1529 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1532 out_ch = av_mallocz(sizeof(AVChapter));
1534 return AVERROR(ENOMEM);
1536 out_ch->id = in_ch->id;
1537 out_ch->time_base = in_ch->time_base;
1538 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1539 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1542 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1544 os->chapters[os->nb_chapters++] = out_ch;
1549 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1552 AVFormatContext *ic = avformat_alloc_context();
1554 ic->interrupt_callback = int_cb;
1555 err = avformat_open_input(&ic, filename, NULL, NULL);
1558 /* copy stream format */
1559 for(i=0;i<ic->nb_streams;i++) {
1563 AVCodecContext *avctx;
1565 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1566 ost = new_output_stream(o, s, codec->type, -1);
1571 // FIXME: a more elegant solution is needed
1572 memcpy(st, ic->streams[i], sizeof(AVStream));
1574 st->info = av_malloc(sizeof(*st->info));
1575 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1577 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1579 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1580 choose_sample_fmt(st, codec);
1581 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1582 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1585 avformat_close_input(&ic);
1589 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1590 AVFormatContext *oc)
1594 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1595 ofilter->out_tmp->pad_idx)) {
1596 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1597 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1599 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1604 ost->source_index = -1;
1605 ost->filter = ofilter;
1609 if (ost->stream_copy) {
1610 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1611 "which is fed from a complex filtergraph. Filtering and streamcopy "
1612 "cannot be used together.\n", ost->file_index, ost->index);
1616 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1617 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1618 av_log(NULL, AV_LOG_ERROR,
1619 "%s '%s' was specified through the %s option "
1620 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1621 "%s and -filter_complex cannot be used together for the same stream.\n",
1622 ost->filters ? "Filtergraph" : "Filtergraph script",
1623 ost->filters ? ost->filters : ost->filters_script,
1624 opt, ost->file_index, ost->index, opt);
1628 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1629 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1632 avfilter_inout_free(&ofilter->out_tmp);
1635 static int configure_complex_filters(void)
1639 for (i = 0; i < nb_filtergraphs; i++)
1640 if (!filtergraphs[i]->graph &&
1641 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1646 static int open_output_file(OptionsContext *o, const char *filename)
1648 AVFormatContext *oc;
1650 AVOutputFormat *file_oformat;
1654 AVDictionary *unused_opts = NULL;
1655 AVDictionaryEntry *e = NULL;
1657 if (configure_complex_filters() < 0) {
1658 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1662 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1663 o->stop_time = INT64_MAX;
1664 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1667 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1668 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1669 if (o->stop_time <= start_time) {
1670 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1671 o->stop_time = INT64_MAX;
1673 o->recording_time = o->stop_time - start_time;
1677 GROW_ARRAY(output_files, nb_output_files);
1678 of = av_mallocz(sizeof(*of));
1681 output_files[nb_output_files - 1] = of;
1683 of->ost_index = nb_output_streams;
1684 of->recording_time = o->recording_time;
1685 of->start_time = o->start_time;
1686 of->limit_filesize = o->limit_filesize;
1687 of->shortest = o->shortest;
1688 av_dict_copy(&of->opts, o->g->format_opts, 0);
1690 if (!strcmp(filename, "-"))
1693 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1695 print_error(filename, err);
1700 if (o->recording_time != INT64_MAX)
1701 oc->duration = o->recording_time;
1703 file_oformat= oc->oformat;
1704 oc->interrupt_callback = int_cb;
1706 /* create streams for all unlabeled output pads */
1707 for (i = 0; i < nb_filtergraphs; i++) {
1708 FilterGraph *fg = filtergraphs[i];
1709 for (j = 0; j < fg->nb_outputs; j++) {
1710 OutputFilter *ofilter = fg->outputs[j];
1712 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1715 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1716 ofilter->out_tmp->pad_idx)) {
1717 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1718 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1719 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1721 init_output_filter(ofilter, o, oc);
1725 /* ffserver seeking with date=... needs a date reference */
1726 if (!strcmp(file_oformat->name, "ffm") &&
1727 av_strstart(filename, "http:", NULL)) {
1728 int err = parse_option(o, "metadata", "creation_time=now", options);
1730 print_error(filename, err);
1735 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1736 av_strstart(filename, "http:", NULL)) {
1738 /* special case for files sent to ffserver: we get the stream
1739 parameters from ffserver */
1740 int err = read_ffserver_streams(o, oc, filename);
1742 print_error(filename, err);
1745 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1746 ost = output_streams[j];
1747 for (i = 0; i < nb_input_streams; i++) {
1748 ist = input_streams[i];
1749 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1751 ost->source_index= i;
1752 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1753 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1755 ist->st->discard = AVDISCARD_NONE;
1760 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));
1764 } else if (!o->nb_stream_maps) {
1765 char *subtitle_codec_name = NULL;
1766 /* pick the "best" stream of each type */
1768 /* video: highest resolution */
1769 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1770 int area = 0, idx = -1;
1771 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1772 for (i = 0; i < nb_input_streams; i++) {
1774 ist = input_streams[i];
1775 new_area = ist->st->codec->width * ist->st->codec->height;
1776 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1778 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1780 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1787 new_video_stream(o, oc, idx);
1790 /* audio: most channels */
1791 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1792 int channels = 0, idx = -1;
1793 for (i = 0; i < nb_input_streams; i++) {
1794 ist = input_streams[i];
1795 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1796 ist->st->codec->channels > channels) {
1797 channels = ist->st->codec->channels;
1802 new_audio_stream(o, oc, idx);
1805 /* subtitles: pick first */
1806 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1807 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1808 for (i = 0; i < nb_input_streams; i++)
1809 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1810 new_subtitle_stream(o, oc, i);
1814 /* do something with data? */
1816 for (i = 0; i < o->nb_stream_maps; i++) {
1817 StreamMap *map = &o->stream_maps[i];
1822 if (map->linklabel) {
1824 OutputFilter *ofilter = NULL;
1827 for (j = 0; j < nb_filtergraphs; j++) {
1828 fg = filtergraphs[j];
1829 for (k = 0; k < fg->nb_outputs; k++) {
1830 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1831 if (out && !strcmp(out->name, map->linklabel)) {
1832 ofilter = fg->outputs[k];
1839 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1840 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1843 init_output_filter(ofilter, o, oc);
1845 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1847 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1848 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1850 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1852 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1854 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1857 switch (ist->st->codec->codec_type) {
1858 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1859 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1860 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1861 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1862 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1864 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1865 map->file_index, map->stream_index);
1872 /* handle attached files */
1873 for (i = 0; i < o->nb_attachments; i++) {
1875 uint8_t *attachment;
1879 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1880 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1884 if ((len = avio_size(pb)) <= 0) {
1885 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1889 if (!(attachment = av_malloc(len))) {
1890 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1894 avio_read(pb, attachment, len);
1896 ost = new_attachment_stream(o, oc, -1);
1897 ost->stream_copy = 0;
1898 ost->attachment_filename = o->attachments[i];
1900 ost->st->codec->extradata = attachment;
1901 ost->st->codec->extradata_size = len;
1903 p = strrchr(o->attachments[i], '/');
1904 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1908 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1909 AVDictionaryEntry *e;
1910 ost = output_streams[i];
1912 if ((ost->stream_copy || ost->attachment_filename)
1913 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1914 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1915 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1919 /* check if all codec options have been used */
1920 unused_opts = strip_specifiers(o->g->codec_opts);
1921 for (i = of->ost_index; i < nb_output_streams; i++) {
1923 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1924 AV_DICT_IGNORE_SUFFIX)))
1925 av_dict_set(&unused_opts, e->key, NULL, 0);
1929 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1930 const AVClass *class = avcodec_get_class();
1931 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1932 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1935 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1936 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1937 "output file #%d (%s) is not an encoding option.\n", e->key,
1938 option->help ? option->help : "", nb_output_files - 1,
1943 // gop_timecode is injected by generic code but not always used
1944 if (!strcmp(e->key, "gop_timecode"))
1947 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1948 "output file #%d (%s) has not been used for any stream. The most "
1949 "likely reason is either wrong type (e.g. a video option with "
1950 "no video streams) or that it is a private option of some encoder "
1951 "which was not actually used for any stream.\n", e->key,
1952 option->help ? option->help : "", nb_output_files - 1, filename);
1954 av_dict_free(&unused_opts);
1956 /* check filename in case of an image number is expected */
1957 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1958 if (!av_filename_number_test(oc->filename)) {
1959 print_error(oc->filename, AVERROR(EINVAL));
1964 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1965 /* test if it already exists to avoid losing precious files */
1966 assert_file_overwrite(filename);
1969 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1970 &oc->interrupt_callback,
1972 print_error(filename, err);
1975 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1976 assert_file_overwrite(filename);
1978 if (o->mux_preload) {
1980 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1981 av_dict_set(&of->opts, "preload", buf, 0);
1983 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1986 for (i = 0; i < o->nb_metadata_map; i++) {
1988 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1990 if (in_file_index >= nb_input_files) {
1991 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1994 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1995 in_file_index >= 0 ?
1996 input_files[in_file_index]->ctx : NULL, o);
2000 if (o->chapters_input_file >= nb_input_files) {
2001 if (o->chapters_input_file == INT_MAX) {
2002 /* copy chapters from the first input file that has them*/
2003 o->chapters_input_file = -1;
2004 for (i = 0; i < nb_input_files; i++)
2005 if (input_files[i]->ctx->nb_chapters) {
2006 o->chapters_input_file = i;
2010 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2011 o->chapters_input_file);
2015 if (o->chapters_input_file >= 0)
2016 copy_chapters(input_files[o->chapters_input_file], of,
2017 !o->metadata_chapters_manual);
2019 /* copy global metadata by default */
2020 if (!o->metadata_global_manual && nb_input_files){
2021 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2022 AV_DICT_DONT_OVERWRITE);
2023 if(o->recording_time != INT64_MAX)
2024 av_dict_set(&oc->metadata, "duration", NULL, 0);
2025 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2027 if (!o->metadata_streams_manual)
2028 for (i = of->ost_index; i < nb_output_streams; i++) {
2030 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2032 ist = input_streams[output_streams[i]->source_index];
2033 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2036 /* process manually set metadata */
2037 for (i = 0; i < o->nb_metadata; i++) {
2040 const char *stream_spec;
2041 int index = 0, j, ret = 0;
2043 val = strchr(o->metadata[i].u.str, '=');
2045 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2046 o->metadata[i].u.str);
2051 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2053 for (j = 0; j < oc->nb_streams; j++) {
2054 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2055 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2066 if (index < 0 || index >= oc->nb_chapters) {
2067 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2070 m = &oc->chapters[index]->metadata;
2073 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2076 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2083 static int opt_target(void *optctx, const char *opt, const char *arg)
2085 OptionsContext *o = optctx;
2086 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2087 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2089 if (!strncmp(arg, "pal-", 4)) {
2092 } else if (!strncmp(arg, "ntsc-", 5)) {
2095 } else if (!strncmp(arg, "film-", 5)) {
2099 /* Try to determine PAL/NTSC by peeking in the input files */
2100 if (nb_input_files) {
2102 for (j = 0; j < nb_input_files; j++) {
2103 for (i = 0; i < input_files[j]->nb_streams; i++) {
2104 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2105 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2107 fr = c->time_base.den * 1000 / c->time_base.num;
2111 } else if ((fr == 29970) || (fr == 23976)) {
2116 if (norm != UNKNOWN)
2120 if (norm != UNKNOWN)
2121 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2124 if (norm == UNKNOWN) {
2125 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2126 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2127 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2131 if (!strcmp(arg, "vcd")) {
2132 opt_video_codec(o, "c:v", "mpeg1video");
2133 opt_audio_codec(o, "c:a", "mp2");
2134 parse_option(o, "f", "vcd", options);
2135 av_dict_set(&o->g->codec_opts, "b:v", arg, AV_DICT_DONT_OVERWRITE);
2137 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2138 parse_option(o, "r", frame_rates[norm], options);
2139 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2141 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2142 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2143 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2144 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2146 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2147 parse_option(o, "ar", "44100", options);
2148 parse_option(o, "ac", "2", options);
2150 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2151 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2153 /* We have to offset the PTS, so that it is consistent with the SCR.
2154 SCR starts at 36000, but the first two packs contain only padding
2155 and the first pack from the other stream, respectively, may also have
2156 been written before.
2157 So the real data starts at SCR 36000+3*1200. */
2158 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2159 } else if (!strcmp(arg, "svcd")) {
2161 opt_video_codec(o, "c:v", "mpeg2video");
2162 opt_audio_codec(o, "c:a", "mp2");
2163 parse_option(o, "f", "svcd", options);
2165 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2166 parse_option(o, "r", frame_rates[norm], options);
2167 parse_option(o, "pix_fmt", "yuv420p", options);
2168 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2170 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2171 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2172 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2173 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2174 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2176 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2177 parse_option(o, "ar", "44100", options);
2179 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2181 } else if (!strcmp(arg, "dvd")) {
2183 opt_video_codec(o, "c:v", "mpeg2video");
2184 opt_audio_codec(o, "c:a", "ac3");
2185 parse_option(o, "f", "dvd", options);
2187 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2188 parse_option(o, "r", frame_rates[norm], options);
2189 parse_option(o, "pix_fmt", "yuv420p", options);
2190 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2192 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2193 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2194 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2195 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2197 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.
2198 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2200 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2201 parse_option(o, "ar", "48000", options);
2203 } else if (!strncmp(arg, "dv", 2)) {
2205 parse_option(o, "f", "dv", options);
2207 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2208 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2209 norm == PAL ? "yuv420p" : "yuv411p", options);
2210 parse_option(o, "r", frame_rates[norm], options);
2212 parse_option(o, "ar", "48000", options);
2213 parse_option(o, "ac", "2", options);
2216 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2217 return AVERROR(EINVAL);
2222 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2224 av_free (vstats_filename);
2225 vstats_filename = av_strdup (arg);
2229 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2232 time_t today2 = time(NULL);
2233 struct tm *today = localtime(&today2);
2235 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2237 return opt_vstats_file(NULL, opt, filename);
2240 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2242 OptionsContext *o = optctx;
2243 return parse_option(o, "frames:v", arg, options);
2246 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2248 OptionsContext *o = optctx;
2249 return parse_option(o, "frames:a", arg, options);
2252 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2254 OptionsContext *o = optctx;
2255 return parse_option(o, "frames:d", arg, options);
2258 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2261 AVDictionary *cbak = codec_opts;
2262 AVDictionary *fbak = format_opts;
2266 ret = opt_default(NULL, opt, arg);
2268 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2269 av_dict_copy(&o->g->format_opts, format_opts, 0);
2270 av_dict_free(&codec_opts);
2271 av_dict_free(&format_opts);
2278 static int opt_preset(void *optctx, const char *opt, const char *arg)
2280 OptionsContext *o = optctx;
2282 char filename[1000], line[1000], tmp_line[1000];
2283 const char *codec_name = NULL;
2287 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2289 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2290 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2291 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2293 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2297 while (fgets(line, sizeof(line), f)) {
2298 char *key = tmp_line, *value, *endptr;
2300 if (strcspn(line, "#\n\r") == 0)
2302 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2303 if (!av_strtok(key, "=", &value) ||
2304 !av_strtok(value, "\r\n", &endptr)) {
2305 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2308 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2310 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2311 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2312 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2313 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2314 else if (opt_default_new(o, key, value) < 0) {
2315 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2316 filename, line, key, value);
2326 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2328 OptionsContext *o = optctx;
2329 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2330 int ret = parse_option(o, s, arg, options);
2335 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2337 OptionsContext *o = optctx;
2338 if(!strcmp(opt, "b")){
2339 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2340 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2343 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2347 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2349 OptionsContext *o = optctx;
2352 if(!strcmp(opt, "qscale")){
2353 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2354 return parse_option(o, "q:v", arg, options);
2356 s = av_asprintf("q%s", opt + 6);
2357 ret = parse_option(o, s, arg, options);
2362 static int opt_profile(void *optctx, const char *opt, const char *arg)
2364 OptionsContext *o = optctx;
2365 if(!strcmp(opt, "profile")){
2366 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2367 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2370 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2374 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2376 OptionsContext *o = optctx;
2377 return parse_option(o, "filter:v", arg, options);
2380 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2382 OptionsContext *o = optctx;
2383 return parse_option(o, "filter:a", arg, options);
2386 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2388 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2389 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2390 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2391 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2393 if (video_sync_method == VSYNC_AUTO)
2394 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2398 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2400 OptionsContext *o = optctx;
2401 char *tcr = av_asprintf("timecode=%s", arg);
2402 int ret = parse_option(o, "metadata:g", tcr, options);
2404 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2409 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2411 OptionsContext *o = optctx;
2412 char layout_str[32];
2415 int ret, channels, ac_str_size;
2418 layout = av_get_channel_layout(arg);
2420 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2421 return AVERROR(EINVAL);
2423 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2424 ret = opt_default_new(o, opt, layout_str);
2428 /* set 'ac' option based on channel layout */
2429 channels = av_get_channel_layout_nb_channels(layout);
2430 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2431 stream_str = strchr(opt, ':');
2432 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2433 ac_str = av_mallocz(ac_str_size);
2435 return AVERROR(ENOMEM);
2436 av_strlcpy(ac_str, "ac", 3);
2438 av_strlcat(ac_str, stream_str, ac_str_size);
2439 ret = parse_option(o, ac_str, layout_str, options);
2445 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2447 OptionsContext *o = optctx;
2448 return parse_option(o, "q:a", arg, options);
2451 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2453 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2454 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2455 return AVERROR(ENOMEM);
2456 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2457 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2458 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2459 return AVERROR(ENOMEM);
2463 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2465 uint8_t *graph_desc = read_file(arg);
2467 return AVERROR(EINVAL);
2469 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2470 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2471 return AVERROR(ENOMEM);
2472 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2473 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2477 void show_help_default(const char *opt, const char *arg)
2479 /* per-file options have at least one of those set */
2480 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2481 int show_advanced = 0, show_avoptions = 0;
2484 if (!strcmp(opt, "long"))
2486 else if (!strcmp(opt, "full"))
2487 show_advanced = show_avoptions = 1;
2489 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2494 printf("Getting help:\n"
2495 " -h -- print basic options\n"
2496 " -h long -- print more options\n"
2497 " -h full -- print all options (including all format and codec specific options, very long)\n"
2498 " See man %s for detailed description of the options.\n"
2499 "\n", program_name);
2501 show_help_options(options, "Print help / information / capabilities:",
2504 show_help_options(options, "Global options (affect whole program "
2505 "instead of just one file:",
2506 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2508 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2509 per_file | OPT_EXIT, 0);
2511 show_help_options(options, "Per-file main options:", 0,
2512 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2513 OPT_EXIT, per_file);
2515 show_help_options(options, "Advanced per-file options:",
2516 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2518 show_help_options(options, "Video options:",
2519 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2521 show_help_options(options, "Advanced Video options:",
2522 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2524 show_help_options(options, "Audio options:",
2525 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2527 show_help_options(options, "Advanced Audio options:",
2528 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2529 show_help_options(options, "Subtitle options:",
2530 OPT_SUBTITLE, 0, 0);
2533 if (show_avoptions) {
2534 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2535 show_help_children(avcodec_get_class(), flags);
2536 show_help_children(avformat_get_class(), flags);
2538 show_help_children(sws_get_class(), flags);
2540 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2541 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2545 void show_usage(void)
2547 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2548 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2549 av_log(NULL, AV_LOG_INFO, "\n");
2557 static const OptionGroupDef groups[] = {
2558 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2559 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2562 static int open_files(OptionGroupList *l, const char *inout,
2563 int (*open_file)(OptionsContext*, const char*))
2567 for (i = 0; i < l->nb_groups; i++) {
2568 OptionGroup *g = &l->groups[i];
2574 ret = parse_optgroup(&o, g);
2576 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2577 "%s.\n", inout, g->arg);
2581 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2582 ret = open_file(&o, g->arg);
2585 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2589 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2595 int ffmpeg_parse_options(int argc, char **argv)
2597 OptionParseContext octx;
2601 memset(&octx, 0, sizeof(octx));
2603 /* split the commandline into an internal representation */
2604 ret = split_commandline(&octx, argc, argv, options, groups,
2605 FF_ARRAY_ELEMS(groups));
2607 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2611 /* apply global options */
2612 ret = parse_optgroup(NULL, &octx.global_opts);
2614 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2618 /* open input files */
2619 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2621 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2625 /* open output files */
2626 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2628 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2633 uninit_parse_context(&octx);
2635 av_strerror(ret, error, sizeof(error));
2636 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2641 static int opt_progress(void *optctx, const char *opt, const char *arg)
2643 AVIOContext *avio = NULL;
2646 if (!strcmp(arg, "-"))
2648 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2650 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2651 arg, av_err2str(ret));
2654 progress_avio = avio;
2658 #define OFFSET(x) offsetof(OptionsContext, x)
2659 const OptionDef options[] = {
2661 #include "cmdutils_common_opts.h"
2662 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2663 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2664 "force format", "fmt" },
2665 { "y", OPT_BOOL, { &file_overwrite },
2666 "overwrite output files" },
2667 { "n", OPT_BOOL, { &no_file_overwrite },
2668 "never overwrite output files" },
2669 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2670 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2671 "codec name", "codec" },
2672 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2673 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2674 "codec name", "codec" },
2675 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2676 OPT_OUTPUT, { .off = OFFSET(presets) },
2677 "preset name", "preset" },
2678 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2679 OPT_OUTPUT, { .func_arg = opt_map },
2680 "set input stream mapping",
2681 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2682 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2683 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2684 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2685 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2686 "set metadata information of outfile from infile",
2687 "outfile[,metadata]:infile[,metadata]" },
2688 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2689 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2690 "set chapters mapping", "input_file_index" },
2691 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2692 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2693 "record or transcode \"duration\" seconds of audio/video",
2695 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2696 "record or transcode stop time", "time_stop" },
2697 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2698 "set the limit file size in bytes", "limit_size" },
2699 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2700 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2701 "set the start time offset", "time_off" },
2702 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2703 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2704 "enable/disable accurate seeking with -ss" },
2705 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2706 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2707 "set the input ts offset", "time_off" },
2708 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2709 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2710 "set the input ts scale", "scale" },
2711 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2712 "set the recording timestamp ('now' to set the current time)", "time" },
2713 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2714 "add metadata", "string=string" },
2715 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2716 OPT_OUTPUT, { .func_arg = opt_data_frames },
2717 "set the number of data frames to record", "number" },
2718 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2719 "add timings for benchmarking" },
2720 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2721 "add timings for each task" },
2722 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2723 "write program-readable progress information", "url" },
2724 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2725 "enable or disable interaction on standard input" },
2726 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2727 "set max runtime in seconds", "limit" },
2728 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2729 "dump each input packet" },
2730 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2731 "when dumping packets, also dump the payload" },
2732 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2733 OPT_INPUT, { .off = OFFSET(rate_emu) },
2734 "read input at native frame rate", "" },
2735 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2736 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2737 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2738 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2739 "video sync method", "" },
2740 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2741 "audio sync method", "" },
2742 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2743 "audio drift threshold", "threshold" },
2744 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2745 "copy timestamps" },
2746 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2747 "copy input stream time base when stream copying", "mode" },
2748 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2749 OPT_OUTPUT, { .off = OFFSET(shortest) },
2750 "finish encoding within shortest input" },
2751 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2752 OPT_OUTPUT, { .off = OFFSET(apad) },
2754 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2755 "timestamp discontinuity delta threshold", "threshold" },
2756 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2757 "timestamp error delta threshold", "threshold" },
2758 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2759 "exit on error", "error" },
2760 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2761 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2762 "copy initial non-keyframes" },
2763 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2764 "copy or discard frames before start time" },
2765 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2766 "set the number of frames to record", "number" },
2767 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2768 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2769 "force codec tag/fourcc", "fourcc/tag" },
2770 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2771 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2772 "use fixed quality scale (VBR)", "q" },
2773 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2774 OPT_OUTPUT, { .func_arg = opt_qscale },
2775 "use fixed quality scale (VBR)", "q" },
2776 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2777 "set profile", "profile" },
2778 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2779 "set stream filtergraph", "filter_graph" },
2780 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2781 "read stream filtergraph description from a file", "filename" },
2782 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2783 "reinit filtergraph on input parameter changes", "" },
2784 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2785 "create a complex filtergraph", "graph_description" },
2786 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2787 "create a complex filtergraph", "graph_description" },
2788 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2789 "read complex filtergraph description from a file", "filename" },
2790 { "stats", OPT_BOOL, { &print_stats },
2791 "print progress report during encoding", },
2792 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2793 OPT_OUTPUT, { .func_arg = opt_attach },
2794 "add an attachment to the output file", "filename" },
2795 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2796 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2797 "extract an attachment into a file", "filename" },
2798 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2799 "print timestamp debugging info" },
2800 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2801 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2804 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2805 "set the number of video frames to record", "number" },
2806 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2807 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2808 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2809 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2810 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2811 "set frame size (WxH or abbreviation)", "size" },
2812 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2813 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2814 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2815 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2816 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2817 "set pixel format", "format" },
2818 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2819 "set the number of bits per raw sample", "number" },
2820 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2821 "deprecated use -g 1" },
2822 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2824 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2825 "discard threshold", "n" },
2826 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2827 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2828 "rate control override for specific intervals", "override" },
2829 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2830 OPT_OUTPUT, { .func_arg = opt_video_codec },
2831 "force video codec ('copy' to copy stream)", "codec" },
2832 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2834 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2836 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2837 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2838 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2839 "select the pass number (1 to 3)", "n" },
2840 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2841 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2842 "select two pass log file name prefix", "prefix" },
2843 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2844 "this option is deprecated, use the yadif filter instead" },
2845 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2846 "calculate PSNR of compressed frames" },
2847 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2848 "dump video coding statistics to file" },
2849 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2850 "dump video coding statistics to file", "file" },
2851 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2852 "set video filters", "filter_graph" },
2853 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2854 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2855 "specify intra matrix coeffs", "matrix" },
2856 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2857 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2858 "specify inter matrix coeffs", "matrix" },
2859 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2860 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2861 "top=1/bottom=0/auto=-1 field first", "" },
2862 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2863 "intra_dc_precision", "precision" },
2864 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2865 OPT_OUTPUT, { .func_arg = opt_old2new },
2866 "force video tag/fourcc", "fourcc/tag" },
2867 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2868 "show QP histogram" },
2869 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2870 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2871 "force the selected framerate, disable the best supported framerate selection" },
2872 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2873 OPT_OUTPUT, { .func_arg = opt_streamid },
2874 "set the value of an outfile streamid", "streamIndex:value" },
2875 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2876 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2877 "force key frames at specified timestamps", "timestamps" },
2878 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2879 "video bitrate (please use -b:v)", "bitrate" },
2880 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2881 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2882 "use HW accelerated decoding", "hwaccel name" },
2883 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2884 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2885 "select a device for HW acceleration" "devicename" },
2888 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2889 "set the number of audio frames to record", "number" },
2890 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2891 "set audio quality (codec-specific)", "quality", },
2892 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2893 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2894 "set audio sampling rate (in Hz)", "rate" },
2895 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2896 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2897 "set number of audio channels", "channels" },
2898 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2900 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2901 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2902 "force audio codec ('copy' to copy stream)", "codec" },
2903 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2904 OPT_OUTPUT, { .func_arg = opt_old2new },
2905 "force audio tag/fourcc", "fourcc/tag" },
2906 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2907 "change audio volume (256=normal)" , "volume" },
2908 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2909 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2910 "set sample format", "format" },
2911 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2912 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2913 "set channel layout", "layout" },
2914 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2915 "set audio filters", "filter_graph" },
2916 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2917 "set the maximum number of channels to try to guess the channel layout" },
2919 /* subtitle options */
2920 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2921 "disable subtitle" },
2922 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2923 "force subtitle codec ('copy' to copy stream)", "codec" },
2924 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2925 , "force subtitle tag/fourcc", "fourcc/tag" },
2926 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2927 "fix subtitles duration" },
2928 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2929 "set canvas size (WxH or abbreviation)", "size" },
2932 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2933 "deprecated, use -channel", "channel" },
2934 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2935 "deprecated, use -standard", "standard" },
2936 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2939 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2940 "set the maximum demux-decode delay", "seconds" },
2941 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2942 "set the initial demux-decode delay", "seconds" },
2943 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2944 "override the options from ffserver", "" },
2946 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2947 "A comma-separated list of bitstream filters", "bitstream_filters" },
2948 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2949 "deprecated", "audio bitstream_filters" },
2950 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2951 "deprecated", "video bitstream_filters" },
2953 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2954 "set the audio options to the indicated preset", "preset" },
2955 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2956 "set the video options to the indicated preset", "preset" },
2957 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2958 "set the subtitle options to the indicated preset", "preset" },
2959 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2960 "set options from indicated preset file", "filename" },
2961 /* data codec support */
2962 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2963 "force data codec ('copy' to copy stream)", "codec" },
2964 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },