2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
73 char *vstats_filename;
75 float audio_drift_threshold = 0.1;
76 float dts_delta_threshold = 10;
77 float dts_error_threshold = 3600*30;
79 int audio_volume = 256;
80 int audio_sync_method = 0;
81 int video_sync_method = VSYNC_AUTO;
82 int do_deinterlace = 0;
84 int do_benchmark_all = 0;
90 int exit_on_error = 0;
93 int stdin_interaction = 1;
94 int frame_bits_per_raw_sample = 0;
95 float max_error_rate = 2.0/3;
98 static int intra_only = 0;
99 static int file_overwrite = 0;
100 static int no_file_overwrite = 0;
101 static int video_discard = 0;
102 static int intra_dc_precision = 8;
103 static int do_psnr = 0;
104 static int input_sync;
105 static int override_ffserver = 0;
107 static void uninit_options(OptionsContext *o)
109 const OptionDef *po = options;
112 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
114 void *dst = (uint8_t*)o + po->u.off;
116 if (po->flags & OPT_SPEC) {
117 SpecifierOpt **so = dst;
118 int i, *count = (int*)(so + 1);
119 for (i = 0; i < *count; i++) {
120 av_freep(&(*so)[i].specifier);
121 if (po->flags & OPT_STRING)
122 av_freep(&(*so)[i].u.str);
126 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
131 for (i = 0; i < o->nb_stream_maps; i++)
132 av_freep(&o->stream_maps[i].linklabel);
133 av_freep(&o->stream_maps);
134 av_freep(&o->audio_channel_maps);
135 av_freep(&o->streamid_map);
136 av_freep(&o->attachments);
139 static void init_options(OptionsContext *o)
141 memset(o, 0, sizeof(*o));
143 o->stop_time = INT64_MAX;
144 o->mux_max_delay = 0.7;
145 o->start_time = AV_NOPTS_VALUE;
146 o->recording_time = INT64_MAX;
147 o->limit_filesize = UINT64_MAX;
148 o->chapters_input_file = INT_MAX;
149 o->accurate_seek = 1;
152 /* return a copy of the input with the stream specifiers removed from the keys */
153 static AVDictionary *strip_specifiers(AVDictionary *dict)
155 AVDictionaryEntry *e = NULL;
156 AVDictionary *ret = NULL;
158 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
159 char *p = strchr(e->key, ':');
163 av_dict_set(&ret, e->key, e->value, 0);
170 static int opt_sameq(void *optctx, const char *opt, const char *arg)
172 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
173 "If you are looking for an option to preserve the quality (which is not "
174 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
176 return AVERROR(EINVAL);
179 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
181 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
182 return opt_default(optctx, "channel", arg);
185 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
187 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
188 return opt_default(optctx, "standard", arg);
191 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
193 OptionsContext *o = optctx;
194 return parse_option(o, "codec:a", arg, options);
197 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
199 OptionsContext *o = optctx;
200 return parse_option(o, "codec:v", arg, options);
203 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
205 OptionsContext *o = optctx;
206 return parse_option(o, "codec:s", arg, options);
209 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
211 OptionsContext *o = optctx;
212 return parse_option(o, "codec:d", arg, options);
215 static int opt_map(void *optctx, const char *opt, const char *arg)
217 OptionsContext *o = optctx;
219 int i, negative = 0, file_idx;
220 int sync_file_idx = -1, sync_stream_idx = 0;
228 map = av_strdup(arg);
230 /* parse sync stream first, just pick first matching stream */
231 if (sync = strchr(map, ',')) {
233 sync_file_idx = strtol(sync + 1, &sync, 0);
234 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
235 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
240 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
241 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
242 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
246 if (i == input_files[sync_file_idx]->nb_streams) {
247 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
248 "match any streams.\n", arg);
255 /* this mapping refers to lavfi output */
256 const char *c = map + 1;
257 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
258 m = &o->stream_maps[o->nb_stream_maps - 1];
259 m->linklabel = av_get_token(&c, "]");
261 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
265 file_idx = strtol(map, &p, 0);
266 if (file_idx >= nb_input_files || file_idx < 0) {
267 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
271 /* disable some already defined maps */
272 for (i = 0; i < o->nb_stream_maps; i++) {
273 m = &o->stream_maps[i];
274 if (file_idx == m->file_index &&
275 check_stream_specifier(input_files[m->file_index]->ctx,
276 input_files[m->file_index]->ctx->streams[m->stream_index],
277 *p == ':' ? p + 1 : p) > 0)
281 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
282 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
283 *p == ':' ? p + 1 : p) <= 0)
285 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
286 m = &o->stream_maps[o->nb_stream_maps - 1];
288 m->file_index = file_idx;
291 if (sync_file_idx >= 0) {
292 m->sync_file_index = sync_file_idx;
293 m->sync_stream_index = sync_stream_idx;
295 m->sync_file_index = file_idx;
296 m->sync_stream_index = i;
302 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
310 static int opt_attach(void *optctx, const char *opt, const char *arg)
312 OptionsContext *o = optctx;
313 GROW_ARRAY(o->attachments, o->nb_attachments);
314 o->attachments[o->nb_attachments - 1] = arg;
318 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
320 OptionsContext *o = optctx;
325 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
326 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
328 /* muted channel syntax */
329 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
330 if ((n == 1 || n == 3) && m->channel_idx == -1) {
331 m->file_idx = m->stream_idx = -1;
333 m->ofile_idx = m->ostream_idx = -1;
338 n = sscanf(arg, "%d.%d.%d:%d.%d",
339 &m->file_idx, &m->stream_idx, &m->channel_idx,
340 &m->ofile_idx, &m->ostream_idx);
342 if (n != 3 && n != 5) {
343 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
344 "[file.stream.channel|-1][:syncfile:syncstream]\n");
348 if (n != 5) // only file.stream.channel specified
349 m->ofile_idx = m->ostream_idx = -1;
352 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
353 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
357 if (m->stream_idx < 0 ||
358 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
359 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
360 m->file_idx, m->stream_idx);
363 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
364 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
365 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
366 m->file_idx, m->stream_idx);
369 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
370 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
371 m->file_idx, m->stream_idx, m->channel_idx);
378 * Parse a metadata specifier passed as 'arg' parameter.
379 * @param arg metadata string to parse
380 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
381 * @param index for type c/p, chapter/program index is written here
382 * @param stream_spec for type s, the stream specifier is written here
384 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
392 if (*(++arg) && *arg != ':') {
393 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
396 *stream_spec = *arg == ':' ? arg + 1 : "";
401 *index = strtol(++arg, NULL, 0);
404 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
411 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
413 AVDictionary **meta_in = NULL;
414 AVDictionary **meta_out = NULL;
416 char type_in, type_out;
417 const char *istream_spec = NULL, *ostream_spec = NULL;
418 int idx_in = 0, idx_out = 0;
420 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
421 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
424 if (type_out == 'g' || !*outspec)
425 o->metadata_global_manual = 1;
426 if (type_out == 's' || !*outspec)
427 o->metadata_streams_manual = 1;
428 if (type_out == 'c' || !*outspec)
429 o->metadata_chapters_manual = 1;
433 if (type_in == 'g' || type_out == 'g')
434 o->metadata_global_manual = 1;
435 if (type_in == 's' || type_out == 's')
436 o->metadata_streams_manual = 1;
437 if (type_in == 'c' || type_out == 'c')
438 o->metadata_chapters_manual = 1;
440 /* ic is NULL when just disabling automatic mappings */
444 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
445 if ((index) < 0 || (index) >= (nb_elems)) {\
446 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
451 #define SET_DICT(type, meta, context, index)\
454 meta = &context->metadata;\
457 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
458 meta = &context->chapters[index]->metadata;\
461 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
462 meta = &context->programs[index]->metadata;\
465 break; /* handled separately below */ \
466 default: av_assert0(0);\
469 SET_DICT(type_in, meta_in, ic, idx_in);
470 SET_DICT(type_out, meta_out, oc, idx_out);
472 /* for input streams choose first matching stream */
473 if (type_in == 's') {
474 for (i = 0; i < ic->nb_streams; i++) {
475 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
476 meta_in = &ic->streams[i]->metadata;
482 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
487 if (type_out == 's') {
488 for (i = 0; i < oc->nb_streams; i++) {
489 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
490 meta_out = &oc->streams[i]->metadata;
491 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
496 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
501 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
503 OptionsContext *o = optctx;
505 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
506 struct tm time = *gmtime((time_t*)&recording_timestamp);
507 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
508 parse_option(o, "metadata", buf, options);
510 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
511 "tag instead.\n", opt);
515 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
517 const AVCodecDescriptor *desc;
518 const char *codec_string = encoder ? "encoder" : "decoder";
522 avcodec_find_encoder_by_name(name) :
523 avcodec_find_decoder_by_name(name);
525 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
526 codec = encoder ? avcodec_find_encoder(desc->id) :
527 avcodec_find_decoder(desc->id);
529 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
530 codec_string, codec->name, desc->name);
534 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
537 if (codec->type != type) {
538 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
544 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
546 char *codec_name = NULL;
548 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
550 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
551 st->codec->codec_id = codec->id;
554 return avcodec_find_decoder(st->codec->codec_id);
557 /* Add all the streams from the given input file to the global
558 * list of input streams. */
559 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
562 char *next, *codec_tag = NULL;
564 for (i = 0; i < ic->nb_streams; i++) {
565 AVStream *st = ic->streams[i];
566 AVCodecContext *dec = st->codec;
567 InputStream *ist = av_mallocz(sizeof(*ist));
568 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
573 GROW_ARRAY(input_streams, nb_input_streams);
574 input_streams[nb_input_streams - 1] = ist;
577 ist->file_index = nb_input_files;
579 st->discard = AVDISCARD_ALL;
582 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
584 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
586 uint32_t tag = strtol(codec_tag, &next, 0);
588 tag = AV_RL32(codec_tag);
589 st->codec->codec_tag = tag;
592 ist->dec = choose_decoder(o, ic, st);
593 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
595 ist->reinit_filters = -1;
596 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
598 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
600 switch (dec->codec_type) {
601 case AVMEDIA_TYPE_VIDEO:
603 ist->dec = avcodec_find_decoder(dec->codec_id);
604 if (av_codec_get_lowres(dec)) {
605 dec->flags |= CODEC_FLAG_EMU_EDGE;
608 ist->resample_height = dec->height;
609 ist->resample_width = dec->width;
610 ist->resample_pix_fmt = dec->pix_fmt;
612 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
613 if (framerate && av_parse_video_rate(&ist->framerate,
615 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
620 ist->top_field_first = -1;
621 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
623 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
625 if (!strcmp(hwaccel, "none"))
626 ist->hwaccel_id = HWACCEL_NONE;
627 else if (!strcmp(hwaccel, "auto"))
628 ist->hwaccel_id = HWACCEL_AUTO;
631 for (i = 0; hwaccels[i].name; i++) {
632 if (!strcmp(hwaccels[i].name, hwaccel)) {
633 ist->hwaccel_id = hwaccels[i].id;
638 if (!ist->hwaccel_id) {
639 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
641 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
642 for (i = 0; hwaccels[i].name; i++)
643 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
644 av_log(NULL, AV_LOG_FATAL, "\n");
650 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
651 if (hwaccel_device) {
652 ist->hwaccel_device = av_strdup(hwaccel_device);
653 if (!ist->hwaccel_device)
656 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
659 case AVMEDIA_TYPE_AUDIO:
660 ist->guess_layout_max = INT_MAX;
661 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
662 guess_input_channel_layout(ist);
664 ist->resample_sample_fmt = dec->sample_fmt;
665 ist->resample_sample_rate = dec->sample_rate;
666 ist->resample_channels = dec->channels;
667 ist->resample_channel_layout = dec->channel_layout;
670 case AVMEDIA_TYPE_DATA:
671 case AVMEDIA_TYPE_SUBTITLE: {
672 char *canvas_size = NULL;
674 ist->dec = avcodec_find_decoder(dec->codec_id);
675 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
676 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
678 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
679 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
684 case AVMEDIA_TYPE_ATTACHMENT:
685 case AVMEDIA_TYPE_UNKNOWN:
693 static void assert_file_overwrite(const char *filename)
695 if (file_overwrite && no_file_overwrite) {
696 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
700 if (!file_overwrite &&
701 (strchr(filename, ':') == NULL || filename[1] == ':' ||
702 av_strstart(filename, "file:", NULL))) {
703 if (avio_check(filename, 0) == 0) {
704 if (stdin_interaction && !no_file_overwrite) {
705 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
708 signal(SIGINT, SIG_DFL);
710 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
716 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
723 static void dump_attachment(AVStream *st, const char *filename)
726 AVIOContext *out = NULL;
727 AVDictionaryEntry *e;
729 if (!st->codec->extradata_size) {
730 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
731 nb_input_files - 1, st->index);
734 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
737 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
738 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
742 assert_file_overwrite(filename);
744 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
745 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
750 avio_write(out, st->codec->extradata, st->codec->extradata_size);
755 static int open_input_file(OptionsContext *o, const char *filename)
759 AVInputFormat *file_iformat = NULL;
764 AVDictionary *unused_opts = NULL;
765 AVDictionaryEntry *e = NULL;
766 int orig_nb_streams; // number of streams before avformat_find_stream_info
767 char * video_codec_name = NULL;
768 char * audio_codec_name = NULL;
769 char *subtitle_codec_name = NULL;
772 if (!(file_iformat = av_find_input_format(o->format))) {
773 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
778 if (!strcmp(filename, "-"))
781 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
782 strcmp(filename, "/dev/stdin");
784 /* get default parameters from command line */
785 ic = avformat_alloc_context();
787 print_error(filename, AVERROR(ENOMEM));
790 if (o->nb_audio_sample_rate) {
791 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
792 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
794 if (o->nb_audio_channels) {
795 /* because we set audio_channels based on both the "ac" and
796 * "channel_layout" options, we need to check that the specified
797 * demuxer actually has the "channels" option before setting it */
798 if (file_iformat && file_iformat->priv_class &&
799 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
800 AV_OPT_SEARCH_FAKE_OBJ)) {
801 snprintf(buf, sizeof(buf), "%d",
802 o->audio_channels[o->nb_audio_channels - 1].u.i);
803 av_dict_set(&o->g->format_opts, "channels", buf, 0);
806 if (o->nb_frame_rates) {
807 /* set the format-level framerate option;
808 * this is important for video grabbers, e.g. x11 */
809 if (file_iformat && file_iformat->priv_class &&
810 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
811 AV_OPT_SEARCH_FAKE_OBJ)) {
812 av_dict_set(&o->g->format_opts, "framerate",
813 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
816 if (o->nb_frame_sizes) {
817 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
819 if (o->nb_frame_pix_fmts)
820 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
822 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
823 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
824 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
826 ic->video_codec_id = video_codec_name ?
827 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
828 ic->audio_codec_id = audio_codec_name ?
829 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
830 ic->subtitle_codec_id= subtitle_codec_name ?
831 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
833 if (video_codec_name)
834 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
835 if (audio_codec_name)
836 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
837 if (subtitle_codec_name)
838 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
840 ic->flags |= AVFMT_FLAG_NONBLOCK;
841 ic->interrupt_callback = int_cb;
843 /* open the input file with generic avformat function */
844 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
846 print_error(filename, err);
849 assert_avoptions(o->g->format_opts);
851 /* apply forced codec ids */
852 for (i = 0; i < ic->nb_streams; i++)
853 choose_decoder(o, ic, ic->streams[i]);
855 /* Set AVCodecContext options for avformat_find_stream_info */
856 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
857 orig_nb_streams = ic->nb_streams;
859 /* If not enough info to get the stream parameters, we decode the
860 first frames to get it. (used in mpeg case for example) */
861 ret = avformat_find_stream_info(ic, opts);
863 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
864 avformat_close_input(&ic);
868 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
869 /* add the stream start time */
870 if (ic->start_time != AV_NOPTS_VALUE)
871 timestamp += ic->start_time;
873 /* if seeking requested, we execute it */
874 if (o->start_time != AV_NOPTS_VALUE) {
875 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
877 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
878 filename, (double)timestamp / AV_TIME_BASE);
882 /* update the current parameters so that they match the one of the input stream */
883 add_input_streams(o, ic);
885 /* dump the file content */
886 av_dump_format(ic, nb_input_files, filename, 0);
888 GROW_ARRAY(input_files, nb_input_files);
889 f = av_mallocz(sizeof(*f));
892 input_files[nb_input_files - 1] = f;
895 f->ist_index = nb_input_streams - ic->nb_streams;
896 f->start_time = o->start_time;
897 f->recording_time = o->recording_time;
898 f->input_ts_offset = o->input_ts_offset;
899 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
900 f->nb_streams = ic->nb_streams;
901 f->rate_emu = o->rate_emu;
902 f->accurate_seek = o->accurate_seek;
904 /* check if all codec options have been used */
905 unused_opts = strip_specifiers(o->g->codec_opts);
906 for (i = f->ist_index; i < nb_input_streams; i++) {
908 while ((e = av_dict_get(input_streams[i]->opts, "", e,
909 AV_DICT_IGNORE_SUFFIX)))
910 av_dict_set(&unused_opts, e->key, NULL, 0);
914 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
915 const AVClass *class = avcodec_get_class();
916 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
917 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
920 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
921 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
922 "input file #%d (%s) is not a decoding option.\n", e->key,
923 option->help ? option->help : "", nb_input_files - 1,
928 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
929 "input file #%d (%s) has not been used for any stream. The most "
930 "likely reason is either wrong type (e.g. a video option with "
931 "no video streams) or that it is a private option of some decoder "
932 "which was not actually used for any stream.\n", e->key,
933 option->help ? option->help : "", nb_input_files - 1, filename);
935 av_dict_free(&unused_opts);
937 for (i = 0; i < o->nb_dump_attachment; i++) {
940 for (j = 0; j < ic->nb_streams; j++) {
941 AVStream *st = ic->streams[j];
943 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
944 dump_attachment(st, o->dump_attachment[i].u.str);
948 for (i = 0; i < orig_nb_streams; i++)
949 av_dict_free(&opts[i]);
955 static uint8_t *get_line(AVIOContext *s)
961 if (avio_open_dyn_buf(&line) < 0) {
962 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
966 while ((c = avio_r8(s)) && c != '\n')
969 avio_close_dyn_buf(line, &buf);
974 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
978 const char *base[3] = { getenv("AVCONV_DATADIR"),
983 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
987 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
988 i != 1 ? "" : "/.avconv", codec_name, preset_name);
989 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
992 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
993 i != 1 ? "" : "/.avconv", preset_name);
994 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1000 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1002 char *codec_name = NULL;
1004 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1006 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1007 NULL, ost->st->codec->codec_type);
1008 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1009 } else if (!strcmp(codec_name, "copy"))
1010 ost->stream_copy = 1;
1012 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1013 ost->st->codec->codec_id = ost->enc->id;
1017 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1020 AVStream *st = avformat_new_stream(oc, NULL);
1021 int idx = oc->nb_streams - 1, ret = 0;
1022 char *bsf = NULL, *next, *codec_tag = NULL;
1023 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1028 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1032 if (oc->nb_streams - 1 < o->nb_streamid_map)
1033 st->id = o->streamid_map[oc->nb_streams - 1];
1035 GROW_ARRAY(output_streams, nb_output_streams);
1036 if (!(ost = av_mallocz(sizeof(*ost))))
1038 output_streams[nb_output_streams - 1] = ost;
1040 ost->file_index = nb_output_files - 1;
1043 st->codec->codec_type = type;
1044 choose_encoder(o, oc, ost);
1046 AVIOContext *s = NULL;
1047 char *buf = NULL, *arg = NULL, *preset = NULL;
1049 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1051 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1052 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1055 if (!buf[0] || buf[0] == '#') {
1059 if (!(arg = strchr(buf, '='))) {
1060 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1064 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1066 } while (!s->eof_reached);
1070 av_log(NULL, AV_LOG_FATAL,
1071 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1072 preset, ost->file_index, ost->index);
1076 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1079 avcodec_get_context_defaults3(st->codec, ost->enc);
1080 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1082 ost->max_frames = INT64_MAX;
1083 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1084 for (i = 0; i<o->nb_max_frames; i++) {
1085 char *p = o->max_frames[i].specifier;
1086 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1087 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1092 ost->copy_prior_start = -1;
1093 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1095 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1097 if (next = strchr(bsf, ','))
1099 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1100 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1104 bsfc_prev->next = bsfc;
1106 ost->bitstream_filters = bsfc;
1112 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1114 uint32_t tag = strtol(codec_tag, &next, 0);
1116 tag = AV_RL32(codec_tag);
1117 st->codec->codec_tag = tag;
1120 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1122 st->codec->flags |= CODEC_FLAG_QSCALE;
1123 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1126 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1127 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1129 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1131 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1132 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1133 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1135 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1137 ost->source_index = source_index;
1138 if (source_index >= 0) {
1139 ost->sync_ist = input_streams[source_index];
1140 input_streams[source_index]->discard = 0;
1141 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1143 ost->last_mux_dts = AV_NOPTS_VALUE;
1148 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1151 const char *p = str;
1158 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1165 /* read file contents into a string */
1166 static uint8_t *read_file(const char *filename)
1168 AVIOContext *pb = NULL;
1169 AVIOContext *dyn_buf = NULL;
1170 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1171 uint8_t buf[1024], *str;
1174 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1178 ret = avio_open_dyn_buf(&dyn_buf);
1183 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1184 avio_write(dyn_buf, buf, ret);
1185 avio_w8(dyn_buf, 0);
1188 ret = avio_close_dyn_buf(dyn_buf, &str);
1194 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1197 AVStream *st = ost->st;
1199 if (ost->filters_script && ost->filters) {
1200 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1201 "output stream #%d:%d.\n", nb_output_files, st->index);
1205 if (ost->filters_script)
1206 return read_file(ost->filters_script);
1207 else if (ost->filters)
1208 return av_strdup(ost->filters);
1210 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1214 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1215 const OutputStream *ost, enum AVMediaType type)
1217 if (ost->filters_script || ost->filters) {
1218 av_log(NULL, AV_LOG_ERROR,
1219 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1220 "Filtering and streamcopy cannot be used together.\n",
1221 ost->filters ? "Filtergraph" : "Filtergraph script",
1222 ost->filters ? ost->filters : ost->filters_script,
1223 av_get_media_type_string(type), ost->file_index, ost->index);
1228 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1232 AVCodecContext *video_enc;
1233 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1235 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1237 video_enc = st->codec;
1239 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1240 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1241 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1245 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1246 if (frame_aspect_ratio) {
1248 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1249 q.num <= 0 || q.den <= 0) {
1250 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1253 ost->frame_aspect_ratio = q;
1256 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1257 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1259 if (!ost->stream_copy) {
1260 const char *p = NULL;
1261 char *frame_size = NULL;
1262 char *frame_pix_fmt = NULL;
1263 char *intra_matrix = NULL, *inter_matrix = NULL;
1267 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1268 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1269 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1273 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1274 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1275 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1276 ost->keep_pix_fmt = 1;
1277 if (!*++frame_pix_fmt)
1278 frame_pix_fmt = NULL;
1280 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1281 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1284 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1287 video_enc->gop_size = 0;
1288 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1290 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1291 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1294 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1296 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1298 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1299 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1302 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1305 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1306 for (i = 0; p; i++) {
1308 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1310 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1313 /* FIXME realloc failure */
1314 video_enc->rc_override =
1315 av_realloc(video_enc->rc_override,
1316 sizeof(RcOverride) * (i + 1));
1317 video_enc->rc_override[i].start_frame = start;
1318 video_enc->rc_override[i].end_frame = end;
1320 video_enc->rc_override[i].qscale = q;
1321 video_enc->rc_override[i].quality_factor = 1.0;
1324 video_enc->rc_override[i].qscale = 0;
1325 video_enc->rc_override[i].quality_factor = -q/100.0;
1330 video_enc->rc_override_count = i;
1331 video_enc->intra_dc_precision = intra_dc_precision - 8;
1334 video_enc->flags|= CODEC_FLAG_PSNR;
1337 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1340 video_enc->flags |= CODEC_FLAG_PASS1;
1341 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1344 video_enc->flags |= CODEC_FLAG_PASS2;
1345 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1349 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1350 if (ost->logfile_prefix &&
1351 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1354 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1355 if (ost->forced_keyframes)
1356 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1358 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1360 ost->top_field_first = -1;
1361 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1364 ost->avfilter = get_ost_filters(o, oc, ost);
1368 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1371 if (ost->stream_copy)
1372 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1377 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1382 AVCodecContext *audio_enc;
1384 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1387 audio_enc = st->codec;
1388 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1390 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1391 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1393 if (!ost->stream_copy) {
1394 char *sample_fmt = NULL;
1396 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1398 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1400 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1401 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1405 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1407 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1408 ost->apad = av_strdup(ost->apad);
1410 ost->avfilter = get_ost_filters(o, oc, ost);
1414 /* check for channel mapping for this audio stream */
1415 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1416 AudioChannelMap *map = &o->audio_channel_maps[n];
1417 InputStream *ist = input_streams[ost->source_index];
1418 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1419 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1420 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1421 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1422 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1424 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1425 ost->file_index, ost->st->index);
1430 if (ost->stream_copy)
1431 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1436 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1440 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1441 if (!ost->stream_copy) {
1442 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1449 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1451 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1452 ost->stream_copy = 1;
1457 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1461 AVCodecContext *subtitle_enc;
1463 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1465 subtitle_enc = st->codec;
1467 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1469 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1471 if (!ost->stream_copy) {
1472 char *frame_size = NULL;
1474 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1475 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1476 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1484 /* arg format is "output-stream-index:streamid-value". */
1485 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1487 OptionsContext *o = optctx;
1492 av_strlcpy(idx_str, arg, sizeof(idx_str));
1493 p = strchr(idx_str, ':');
1495 av_log(NULL, AV_LOG_FATAL,
1496 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1501 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1502 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1503 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1507 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1509 AVFormatContext *is = ifile->ctx;
1510 AVFormatContext *os = ofile->ctx;
1514 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1516 return AVERROR(ENOMEM);
1519 for (i = 0; i < is->nb_chapters; i++) {
1520 AVChapter *in_ch = is->chapters[i], *out_ch;
1521 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1522 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1523 AV_TIME_BASE_Q, in_ch->time_base);
1524 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1525 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1528 if (in_ch->end < ts_off)
1530 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1533 out_ch = av_mallocz(sizeof(AVChapter));
1535 return AVERROR(ENOMEM);
1537 out_ch->id = in_ch->id;
1538 out_ch->time_base = in_ch->time_base;
1539 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1540 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1543 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1545 os->chapters[os->nb_chapters++] = out_ch;
1550 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1553 AVFormatContext *ic = avformat_alloc_context();
1555 ic->interrupt_callback = int_cb;
1556 err = avformat_open_input(&ic, filename, NULL, NULL);
1559 /* copy stream format */
1560 for(i=0;i<ic->nb_streams;i++) {
1564 AVCodecContext *avctx;
1566 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1567 ost = new_output_stream(o, s, codec->type, -1);
1572 // FIXME: a more elegant solution is needed
1573 memcpy(st, ic->streams[i], sizeof(AVStream));
1575 st->info = av_malloc(sizeof(*st->info));
1576 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1578 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1580 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1581 choose_sample_fmt(st, codec);
1582 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1583 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1586 avformat_close_input(&ic);
1590 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1591 AVFormatContext *oc)
1595 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1596 ofilter->out_tmp->pad_idx)) {
1597 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1598 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1600 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1605 ost->source_index = -1;
1606 ost->filter = ofilter;
1610 if (ost->stream_copy) {
1611 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1612 "which is fed from a complex filtergraph. Filtering and streamcopy "
1613 "cannot be used together.\n", ost->file_index, ost->index);
1617 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1618 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1619 av_log(NULL, AV_LOG_ERROR,
1620 "%s '%s' was specified through the %s option "
1621 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1622 "%s and -filter_complex cannot be used together for the same stream.\n",
1623 ost->filters ? "Filtergraph" : "Filtergraph script",
1624 ost->filters ? ost->filters : ost->filters_script,
1625 opt, ost->file_index, ost->index, opt);
1629 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1630 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1633 avfilter_inout_free(&ofilter->out_tmp);
1636 static int configure_complex_filters(void)
1640 for (i = 0; i < nb_filtergraphs; i++)
1641 if (!filtergraphs[i]->graph &&
1642 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1647 static int open_output_file(OptionsContext *o, const char *filename)
1649 AVFormatContext *oc;
1651 AVOutputFormat *file_oformat;
1655 AVDictionary *unused_opts = NULL;
1656 AVDictionaryEntry *e = NULL;
1658 if (configure_complex_filters() < 0) {
1659 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1663 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1664 o->stop_time = INT64_MAX;
1665 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1668 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1669 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1670 if (o->stop_time <= start_time) {
1671 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1672 o->stop_time = INT64_MAX;
1674 o->recording_time = o->stop_time - start_time;
1678 GROW_ARRAY(output_files, nb_output_files);
1679 of = av_mallocz(sizeof(*of));
1682 output_files[nb_output_files - 1] = of;
1684 of->ost_index = nb_output_streams;
1685 of->recording_time = o->recording_time;
1686 of->start_time = o->start_time;
1687 of->limit_filesize = o->limit_filesize;
1688 of->shortest = o->shortest;
1689 av_dict_copy(&of->opts, o->g->format_opts, 0);
1691 if (!strcmp(filename, "-"))
1694 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1696 print_error(filename, err);
1701 if (o->recording_time != INT64_MAX)
1702 oc->duration = o->recording_time;
1704 file_oformat= oc->oformat;
1705 oc->interrupt_callback = int_cb;
1707 /* create streams for all unlabeled output pads */
1708 for (i = 0; i < nb_filtergraphs; i++) {
1709 FilterGraph *fg = filtergraphs[i];
1710 for (j = 0; j < fg->nb_outputs; j++) {
1711 OutputFilter *ofilter = fg->outputs[j];
1713 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1716 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1717 ofilter->out_tmp->pad_idx)) {
1718 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1719 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1720 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1722 init_output_filter(ofilter, o, oc);
1726 /* ffserver seeking with date=... needs a date reference */
1727 if (!strcmp(file_oformat->name, "ffm") &&
1728 av_strstart(filename, "http:", NULL)) {
1729 int err = parse_option(o, "metadata", "creation_time=now", options);
1731 print_error(filename, err);
1736 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1737 av_strstart(filename, "http:", NULL)) {
1739 /* special case for files sent to ffserver: we get the stream
1740 parameters from ffserver */
1741 int err = read_ffserver_streams(o, oc, filename);
1743 print_error(filename, err);
1746 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1747 ost = output_streams[j];
1748 for (i = 0; i < nb_input_streams; i++) {
1749 ist = input_streams[i];
1750 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1752 ost->source_index= i;
1753 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1754 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1756 ist->st->discard = AVDISCARD_NONE;
1761 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));
1765 } else if (!o->nb_stream_maps) {
1766 char *subtitle_codec_name = NULL;
1767 /* pick the "best" stream of each type */
1769 /* video: highest resolution */
1770 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1771 int area = 0, idx = -1;
1772 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1773 for (i = 0; i < nb_input_streams; i++) {
1775 ist = input_streams[i];
1776 new_area = ist->st->codec->width * ist->st->codec->height;
1777 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1779 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1781 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1788 new_video_stream(o, oc, idx);
1791 /* audio: most channels */
1792 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1793 int channels = 0, idx = -1;
1794 for (i = 0; i < nb_input_streams; i++) {
1795 ist = input_streams[i];
1796 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1797 ist->st->codec->channels > channels) {
1798 channels = ist->st->codec->channels;
1803 new_audio_stream(o, oc, idx);
1806 /* subtitles: pick first */
1807 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1808 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1809 for (i = 0; i < nb_input_streams; i++)
1810 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1811 new_subtitle_stream(o, oc, i);
1815 /* do something with data? */
1817 for (i = 0; i < o->nb_stream_maps; i++) {
1818 StreamMap *map = &o->stream_maps[i];
1823 if (map->linklabel) {
1825 OutputFilter *ofilter = NULL;
1828 for (j = 0; j < nb_filtergraphs; j++) {
1829 fg = filtergraphs[j];
1830 for (k = 0; k < fg->nb_outputs; k++) {
1831 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1832 if (out && !strcmp(out->name, map->linklabel)) {
1833 ofilter = fg->outputs[k];
1840 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1841 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1844 init_output_filter(ofilter, o, oc);
1846 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1848 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1849 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1851 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1853 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1855 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1858 switch (ist->st->codec->codec_type) {
1859 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1860 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1861 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1862 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1863 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1865 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1866 map->file_index, map->stream_index);
1873 /* handle attached files */
1874 for (i = 0; i < o->nb_attachments; i++) {
1876 uint8_t *attachment;
1880 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1881 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1885 if ((len = avio_size(pb)) <= 0) {
1886 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1890 if (!(attachment = av_malloc(len))) {
1891 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1895 avio_read(pb, attachment, len);
1897 ost = new_attachment_stream(o, oc, -1);
1898 ost->stream_copy = 0;
1899 ost->attachment_filename = o->attachments[i];
1901 ost->st->codec->extradata = attachment;
1902 ost->st->codec->extradata_size = len;
1904 p = strrchr(o->attachments[i], '/');
1905 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1909 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1910 AVDictionaryEntry *e;
1911 ost = output_streams[i];
1913 if ((ost->stream_copy || ost->attachment_filename)
1914 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1915 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1916 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1920 /* check if all codec options have been used */
1921 unused_opts = strip_specifiers(o->g->codec_opts);
1922 for (i = of->ost_index; i < nb_output_streams; i++) {
1924 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1925 AV_DICT_IGNORE_SUFFIX)))
1926 av_dict_set(&unused_opts, e->key, NULL, 0);
1930 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1931 const AVClass *class = avcodec_get_class();
1932 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1933 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1936 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1937 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1938 "output file #%d (%s) is not an encoding option.\n", e->key,
1939 option->help ? option->help : "", nb_output_files - 1,
1944 // gop_timecode is injected by generic code but not always used
1945 if (!strcmp(e->key, "gop_timecode"))
1948 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1949 "output file #%d (%s) has not been used for any stream. The most "
1950 "likely reason is either wrong type (e.g. a video option with "
1951 "no video streams) or that it is a private option of some encoder "
1952 "which was not actually used for any stream.\n", e->key,
1953 option->help ? option->help : "", nb_output_files - 1, filename);
1955 av_dict_free(&unused_opts);
1957 /* check filename in case of an image number is expected */
1958 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1959 if (!av_filename_number_test(oc->filename)) {
1960 print_error(oc->filename, AVERROR(EINVAL));
1965 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1966 /* test if it already exists to avoid losing precious files */
1967 assert_file_overwrite(filename);
1970 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1971 &oc->interrupt_callback,
1973 print_error(filename, err);
1976 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1977 assert_file_overwrite(filename);
1979 if (o->mux_preload) {
1981 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1982 av_dict_set(&of->opts, "preload", buf, 0);
1984 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1987 for (i = 0; i < o->nb_metadata_map; i++) {
1989 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1991 if (in_file_index >= nb_input_files) {
1992 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1995 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1996 in_file_index >= 0 ?
1997 input_files[in_file_index]->ctx : NULL, o);
2001 if (o->chapters_input_file >= nb_input_files) {
2002 if (o->chapters_input_file == INT_MAX) {
2003 /* copy chapters from the first input file that has them*/
2004 o->chapters_input_file = -1;
2005 for (i = 0; i < nb_input_files; i++)
2006 if (input_files[i]->ctx->nb_chapters) {
2007 o->chapters_input_file = i;
2011 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2012 o->chapters_input_file);
2016 if (o->chapters_input_file >= 0)
2017 copy_chapters(input_files[o->chapters_input_file], of,
2018 !o->metadata_chapters_manual);
2020 /* copy global metadata by default */
2021 if (!o->metadata_global_manual && nb_input_files){
2022 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2023 AV_DICT_DONT_OVERWRITE);
2024 if(o->recording_time != INT64_MAX)
2025 av_dict_set(&oc->metadata, "duration", NULL, 0);
2026 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2028 if (!o->metadata_streams_manual)
2029 for (i = of->ost_index; i < nb_output_streams; i++) {
2031 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2033 ist = input_streams[output_streams[i]->source_index];
2034 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2037 /* process manually set metadata */
2038 for (i = 0; i < o->nb_metadata; i++) {
2041 const char *stream_spec;
2042 int index = 0, j, ret = 0;
2044 val = strchr(o->metadata[i].u.str, '=');
2046 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2047 o->metadata[i].u.str);
2052 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2054 for (j = 0; j < oc->nb_streams; j++) {
2055 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2056 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2067 if (index < 0 || index >= oc->nb_chapters) {
2068 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2071 m = &oc->chapters[index]->metadata;
2074 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2077 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2084 static int opt_target(void *optctx, const char *opt, const char *arg)
2086 OptionsContext *o = optctx;
2087 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2088 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2090 if (!strncmp(arg, "pal-", 4)) {
2093 } else if (!strncmp(arg, "ntsc-", 5)) {
2096 } else if (!strncmp(arg, "film-", 5)) {
2100 /* Try to determine PAL/NTSC by peeking in the input files */
2101 if (nb_input_files) {
2103 for (j = 0; j < nb_input_files; j++) {
2104 for (i = 0; i < input_files[j]->nb_streams; i++) {
2105 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2106 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2108 fr = c->time_base.den * 1000 / c->time_base.num;
2112 } else if ((fr == 29970) || (fr == 23976)) {
2117 if (norm != UNKNOWN)
2121 if (norm != UNKNOWN)
2122 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2125 if (norm == UNKNOWN) {
2126 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2127 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2128 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2132 if (!strcmp(arg, "vcd")) {
2133 opt_video_codec(o, "c:v", "mpeg1video");
2134 opt_audio_codec(o, "c:a", "mp2");
2135 parse_option(o, "f", "vcd", options);
2136 av_dict_set(&o->g->codec_opts, "b:v", arg, AV_DICT_DONT_OVERWRITE);
2138 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2139 parse_option(o, "r", frame_rates[norm], options);
2140 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2142 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2143 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2144 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2145 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2147 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2148 parse_option(o, "ar", "44100", options);
2149 parse_option(o, "ac", "2", options);
2151 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2152 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2154 /* We have to offset the PTS, so that it is consistent with the SCR.
2155 SCR starts at 36000, but the first two packs contain only padding
2156 and the first pack from the other stream, respectively, may also have
2157 been written before.
2158 So the real data starts at SCR 36000+3*1200. */
2159 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2160 } else if (!strcmp(arg, "svcd")) {
2162 opt_video_codec(o, "c:v", "mpeg2video");
2163 opt_audio_codec(o, "c:a", "mp2");
2164 parse_option(o, "f", "svcd", options);
2166 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2167 parse_option(o, "r", frame_rates[norm], options);
2168 parse_option(o, "pix_fmt", "yuv420p", options);
2169 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2171 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2172 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2173 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2174 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2175 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2177 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2178 parse_option(o, "ar", "44100", options);
2180 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2182 } else if (!strcmp(arg, "dvd")) {
2184 opt_video_codec(o, "c:v", "mpeg2video");
2185 opt_audio_codec(o, "c:a", "ac3");
2186 parse_option(o, "f", "dvd", options);
2188 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2189 parse_option(o, "r", frame_rates[norm], options);
2190 parse_option(o, "pix_fmt", "yuv420p", options);
2191 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2193 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2194 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2195 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2196 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2198 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.
2199 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2201 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2202 parse_option(o, "ar", "48000", options);
2204 } else if (!strncmp(arg, "dv", 2)) {
2206 parse_option(o, "f", "dv", options);
2208 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2209 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2210 norm == PAL ? "yuv420p" : "yuv411p", options);
2211 parse_option(o, "r", frame_rates[norm], options);
2213 parse_option(o, "ar", "48000", options);
2214 parse_option(o, "ac", "2", options);
2217 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2218 return AVERROR(EINVAL);
2223 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2225 av_free (vstats_filename);
2226 vstats_filename = av_strdup (arg);
2230 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2233 time_t today2 = time(NULL);
2234 struct tm *today = localtime(&today2);
2236 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2238 return opt_vstats_file(NULL, opt, filename);
2241 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2243 OptionsContext *o = optctx;
2244 return parse_option(o, "frames:v", arg, options);
2247 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2249 OptionsContext *o = optctx;
2250 return parse_option(o, "frames:a", arg, options);
2253 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2255 OptionsContext *o = optctx;
2256 return parse_option(o, "frames:d", arg, options);
2259 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2262 AVDictionary *cbak = codec_opts;
2263 AVDictionary *fbak = format_opts;
2267 ret = opt_default(NULL, opt, arg);
2269 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2270 av_dict_copy(&o->g->format_opts, format_opts, 0);
2271 av_dict_free(&codec_opts);
2272 av_dict_free(&format_opts);
2279 static int opt_preset(void *optctx, const char *opt, const char *arg)
2281 OptionsContext *o = optctx;
2283 char filename[1000], line[1000], tmp_line[1000];
2284 const char *codec_name = NULL;
2288 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2290 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2291 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2292 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2294 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2298 while (fgets(line, sizeof(line), f)) {
2299 char *key = tmp_line, *value, *endptr;
2301 if (strcspn(line, "#\n\r") == 0)
2303 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2304 if (!av_strtok(key, "=", &value) ||
2305 !av_strtok(value, "\r\n", &endptr)) {
2306 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2309 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2311 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2312 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2313 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2314 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2315 else if (opt_default_new(o, key, value) < 0) {
2316 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2317 filename, line, key, value);
2327 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2329 OptionsContext *o = optctx;
2330 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2331 int ret = parse_option(o, s, arg, options);
2336 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2338 OptionsContext *o = optctx;
2339 if(!strcmp(opt, "b")){
2340 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2341 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2344 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2348 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2350 OptionsContext *o = optctx;
2353 if(!strcmp(opt, "qscale")){
2354 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2355 return parse_option(o, "q:v", arg, options);
2357 s = av_asprintf("q%s", opt + 6);
2358 ret = parse_option(o, s, arg, options);
2363 static int opt_profile(void *optctx, const char *opt, const char *arg)
2365 OptionsContext *o = optctx;
2366 if(!strcmp(opt, "profile")){
2367 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2368 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2371 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2375 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2377 OptionsContext *o = optctx;
2378 return parse_option(o, "filter:v", arg, options);
2381 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2383 OptionsContext *o = optctx;
2384 return parse_option(o, "filter:a", arg, options);
2387 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2389 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2390 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2391 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2392 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2394 if (video_sync_method == VSYNC_AUTO)
2395 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2399 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2401 OptionsContext *o = optctx;
2402 char *tcr = av_asprintf("timecode=%s", arg);
2403 int ret = parse_option(o, "metadata:g", tcr, options);
2405 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2410 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2412 OptionsContext *o = optctx;
2413 char layout_str[32];
2416 int ret, channels, ac_str_size;
2419 layout = av_get_channel_layout(arg);
2421 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2422 return AVERROR(EINVAL);
2424 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2425 ret = opt_default_new(o, opt, layout_str);
2429 /* set 'ac' option based on channel layout */
2430 channels = av_get_channel_layout_nb_channels(layout);
2431 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2432 stream_str = strchr(opt, ':');
2433 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2434 ac_str = av_mallocz(ac_str_size);
2436 return AVERROR(ENOMEM);
2437 av_strlcpy(ac_str, "ac", 3);
2439 av_strlcat(ac_str, stream_str, ac_str_size);
2440 ret = parse_option(o, ac_str, layout_str, options);
2446 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2448 OptionsContext *o = optctx;
2449 return parse_option(o, "q:a", arg, options);
2452 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2454 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2455 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2456 return AVERROR(ENOMEM);
2457 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2458 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2459 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2460 return AVERROR(ENOMEM);
2464 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2466 uint8_t *graph_desc = read_file(arg);
2468 return AVERROR(EINVAL);
2470 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2471 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2472 return AVERROR(ENOMEM);
2473 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2474 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2478 void show_help_default(const char *opt, const char *arg)
2480 /* per-file options have at least one of those set */
2481 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2482 int show_advanced = 0, show_avoptions = 0;
2485 if (!strcmp(opt, "long"))
2487 else if (!strcmp(opt, "full"))
2488 show_advanced = show_avoptions = 1;
2490 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2495 printf("Getting help:\n"
2496 " -h -- print basic options\n"
2497 " -h long -- print more options\n"
2498 " -h full -- print all options (including all format and codec specific options, very long)\n"
2499 " See man %s for detailed description of the options.\n"
2500 "\n", program_name);
2502 show_help_options(options, "Print help / information / capabilities:",
2505 show_help_options(options, "Global options (affect whole program "
2506 "instead of just one file:",
2507 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2509 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2510 per_file | OPT_EXIT, 0);
2512 show_help_options(options, "Per-file main options:", 0,
2513 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2514 OPT_EXIT, per_file);
2516 show_help_options(options, "Advanced per-file options:",
2517 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2519 show_help_options(options, "Video options:",
2520 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2522 show_help_options(options, "Advanced Video options:",
2523 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2525 show_help_options(options, "Audio options:",
2526 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2528 show_help_options(options, "Advanced Audio options:",
2529 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2530 show_help_options(options, "Subtitle options:",
2531 OPT_SUBTITLE, 0, 0);
2534 if (show_avoptions) {
2535 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2536 show_help_children(avcodec_get_class(), flags);
2537 show_help_children(avformat_get_class(), flags);
2539 show_help_children(sws_get_class(), flags);
2541 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2542 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2546 void show_usage(void)
2548 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2549 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2550 av_log(NULL, AV_LOG_INFO, "\n");
2558 static const OptionGroupDef groups[] = {
2559 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2560 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2563 static int open_files(OptionGroupList *l, const char *inout,
2564 int (*open_file)(OptionsContext*, const char*))
2568 for (i = 0; i < l->nb_groups; i++) {
2569 OptionGroup *g = &l->groups[i];
2575 ret = parse_optgroup(&o, g);
2577 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2578 "%s.\n", inout, g->arg);
2582 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2583 ret = open_file(&o, g->arg);
2586 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2590 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2596 int ffmpeg_parse_options(int argc, char **argv)
2598 OptionParseContext octx;
2602 memset(&octx, 0, sizeof(octx));
2604 /* split the commandline into an internal representation */
2605 ret = split_commandline(&octx, argc, argv, options, groups,
2606 FF_ARRAY_ELEMS(groups));
2608 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2612 /* apply global options */
2613 ret = parse_optgroup(NULL, &octx.global_opts);
2615 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2619 /* open input files */
2620 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2622 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2626 /* open output files */
2627 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2629 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2634 uninit_parse_context(&octx);
2636 av_strerror(ret, error, sizeof(error));
2637 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2642 static int opt_progress(void *optctx, const char *opt, const char *arg)
2644 AVIOContext *avio = NULL;
2647 if (!strcmp(arg, "-"))
2649 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2651 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2652 arg, av_err2str(ret));
2655 progress_avio = avio;
2659 #define OFFSET(x) offsetof(OptionsContext, x)
2660 const OptionDef options[] = {
2662 #include "cmdutils_common_opts.h"
2663 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2664 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2665 "force format", "fmt" },
2666 { "y", OPT_BOOL, { &file_overwrite },
2667 "overwrite output files" },
2668 { "n", OPT_BOOL, { &no_file_overwrite },
2669 "never overwrite output files" },
2670 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2671 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2672 "codec name", "codec" },
2673 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2674 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2675 "codec name", "codec" },
2676 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2677 OPT_OUTPUT, { .off = OFFSET(presets) },
2678 "preset name", "preset" },
2679 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2680 OPT_OUTPUT, { .func_arg = opt_map },
2681 "set input stream mapping",
2682 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2683 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2684 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2685 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2686 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2687 "set metadata information of outfile from infile",
2688 "outfile[,metadata]:infile[,metadata]" },
2689 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2690 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2691 "set chapters mapping", "input_file_index" },
2692 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2693 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2694 "record or transcode \"duration\" seconds of audio/video",
2696 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2697 "record or transcode stop time", "time_stop" },
2698 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2699 "set the limit file size in bytes", "limit_size" },
2700 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2701 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2702 "set the start time offset", "time_off" },
2703 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2704 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2705 "enable/disable accurate seeking with -ss" },
2706 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2707 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2708 "set the input ts offset", "time_off" },
2709 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2710 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2711 "set the input ts scale", "scale" },
2712 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2713 "set the recording timestamp ('now' to set the current time)", "time" },
2714 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2715 "add metadata", "string=string" },
2716 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2717 OPT_OUTPUT, { .func_arg = opt_data_frames },
2718 "set the number of data frames to record", "number" },
2719 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2720 "add timings for benchmarking" },
2721 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2722 "add timings for each task" },
2723 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2724 "write program-readable progress information", "url" },
2725 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2726 "enable or disable interaction on standard input" },
2727 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2728 "set max runtime in seconds", "limit" },
2729 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2730 "dump each input packet" },
2731 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2732 "when dumping packets, also dump the payload" },
2733 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2734 OPT_INPUT, { .off = OFFSET(rate_emu) },
2735 "read input at native frame rate", "" },
2736 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2737 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2738 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2739 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2740 "video sync method", "" },
2741 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2742 "audio sync method", "" },
2743 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2744 "audio drift threshold", "threshold" },
2745 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2746 "copy timestamps" },
2747 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2748 "copy input stream time base when stream copying", "mode" },
2749 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2750 OPT_OUTPUT, { .off = OFFSET(shortest) },
2751 "finish encoding within shortest input" },
2752 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2753 OPT_OUTPUT, { .off = OFFSET(apad) },
2755 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2756 "timestamp discontinuity delta threshold", "threshold" },
2757 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2758 "timestamp error delta threshold", "threshold" },
2759 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2760 "exit on error", "error" },
2761 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2762 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2763 "copy initial non-keyframes" },
2764 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2765 "copy or discard frames before start time" },
2766 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2767 "set the number of frames to record", "number" },
2768 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2769 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2770 "force codec tag/fourcc", "fourcc/tag" },
2771 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2772 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2773 "use fixed quality scale (VBR)", "q" },
2774 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2775 OPT_OUTPUT, { .func_arg = opt_qscale },
2776 "use fixed quality scale (VBR)", "q" },
2777 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2778 "set profile", "profile" },
2779 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2780 "set stream filtergraph", "filter_graph" },
2781 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2782 "read stream filtergraph description from a file", "filename" },
2783 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2784 "reinit filtergraph on input parameter changes", "" },
2785 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2786 "create a complex filtergraph", "graph_description" },
2787 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2788 "create a complex filtergraph", "graph_description" },
2789 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2790 "read complex filtergraph description from a file", "filename" },
2791 { "stats", OPT_BOOL, { &print_stats },
2792 "print progress report during encoding", },
2793 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2794 OPT_OUTPUT, { .func_arg = opt_attach },
2795 "add an attachment to the output file", "filename" },
2796 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2797 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2798 "extract an attachment into a file", "filename" },
2799 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2800 "print timestamp debugging info" },
2801 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2802 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2805 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2806 "set the number of video frames to record", "number" },
2807 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2808 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2809 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2810 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2811 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2812 "set frame size (WxH or abbreviation)", "size" },
2813 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2814 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2815 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2816 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2817 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2818 "set pixel format", "format" },
2819 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2820 "set the number of bits per raw sample", "number" },
2821 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2822 "deprecated use -g 1" },
2823 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2825 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2826 "discard threshold", "n" },
2827 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2828 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2829 "rate control override for specific intervals", "override" },
2830 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2831 OPT_OUTPUT, { .func_arg = opt_video_codec },
2832 "force video codec ('copy' to copy stream)", "codec" },
2833 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2835 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2837 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2838 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2839 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2840 "select the pass number (1 to 3)", "n" },
2841 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2842 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2843 "select two pass log file name prefix", "prefix" },
2844 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2845 "this option is deprecated, use the yadif filter instead" },
2846 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2847 "calculate PSNR of compressed frames" },
2848 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2849 "dump video coding statistics to file" },
2850 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2851 "dump video coding statistics to file", "file" },
2852 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2853 "set video filters", "filter_graph" },
2854 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2855 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2856 "specify intra matrix coeffs", "matrix" },
2857 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2858 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2859 "specify inter matrix coeffs", "matrix" },
2860 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2861 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2862 "top=1/bottom=0/auto=-1 field first", "" },
2863 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2864 "intra_dc_precision", "precision" },
2865 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2866 OPT_OUTPUT, { .func_arg = opt_old2new },
2867 "force video tag/fourcc", "fourcc/tag" },
2868 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2869 "show QP histogram" },
2870 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2871 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2872 "force the selected framerate, disable the best supported framerate selection" },
2873 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2874 OPT_OUTPUT, { .func_arg = opt_streamid },
2875 "set the value of an outfile streamid", "streamIndex:value" },
2876 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2877 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2878 "force key frames at specified timestamps", "timestamps" },
2879 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2880 "video bitrate (please use -b:v)", "bitrate" },
2881 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2882 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2883 "use HW accelerated decoding", "hwaccel name" },
2884 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2885 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2886 "select a device for HW acceleration" "devicename" },
2889 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2890 "set the number of audio frames to record", "number" },
2891 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2892 "set audio quality (codec-specific)", "quality", },
2893 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2894 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2895 "set audio sampling rate (in Hz)", "rate" },
2896 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2897 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2898 "set number of audio channels", "channels" },
2899 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2901 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2902 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2903 "force audio codec ('copy' to copy stream)", "codec" },
2904 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2905 OPT_OUTPUT, { .func_arg = opt_old2new },
2906 "force audio tag/fourcc", "fourcc/tag" },
2907 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2908 "change audio volume (256=normal)" , "volume" },
2909 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2910 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2911 "set sample format", "format" },
2912 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2913 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2914 "set channel layout", "layout" },
2915 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2916 "set audio filters", "filter_graph" },
2917 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2918 "set the maximum number of channels to try to guess the channel layout" },
2920 /* subtitle options */
2921 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2922 "disable subtitle" },
2923 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2924 "force subtitle codec ('copy' to copy stream)", "codec" },
2925 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2926 , "force subtitle tag/fourcc", "fourcc/tag" },
2927 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2928 "fix subtitles duration" },
2929 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2930 "set canvas size (WxH or abbreviation)", "size" },
2933 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2934 "deprecated, use -channel", "channel" },
2935 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2936 "deprecated, use -standard", "standard" },
2937 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2940 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2941 "set the maximum demux-decode delay", "seconds" },
2942 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2943 "set the initial demux-decode delay", "seconds" },
2944 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2945 "override the options from ffserver", "" },
2947 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2948 "A comma-separated list of bitstream filters", "bitstream_filters" },
2949 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2950 "deprecated", "audio bitstream_filters" },
2951 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2952 "deprecated", "video bitstream_filters" },
2954 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2955 "set the audio options to the indicated preset", "preset" },
2956 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2957 "set the video options to the indicated preset", "preset" },
2958 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2959 "set the subtitle options to the indicated preset", "preset" },
2960 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2961 "set options from indicated preset file", "filename" },
2962 /* data codec support */
2963 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2964 "force data codec ('copy' to copy stream)", "codec" },
2965 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },