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 },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
81 float audio_drift_threshold = 0.1;
82 float dts_delta_threshold = 10;
83 float dts_error_threshold = 3600*30;
85 int audio_volume = 256;
86 int audio_sync_method = 0;
87 int video_sync_method = VSYNC_AUTO;
88 int do_deinterlace = 0;
90 int do_benchmark_all = 0;
96 int exit_on_error = 0;
99 int stdin_interaction = 1;
100 int frame_bits_per_raw_sample = 0;
101 float max_error_rate = 2.0/3;
104 static int intra_only = 0;
105 static int file_overwrite = 0;
106 static int no_file_overwrite = 0;
107 static int video_discard = 0;
108 static int intra_dc_precision = 8;
109 static int do_psnr = 0;
110 static int input_sync;
111 static int override_ffserver = 0;
113 static void uninit_options(OptionsContext *o)
115 const OptionDef *po = options;
118 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
120 void *dst = (uint8_t*)o + po->u.off;
122 if (po->flags & OPT_SPEC) {
123 SpecifierOpt **so = dst;
124 int i, *count = (int*)(so + 1);
125 for (i = 0; i < *count; i++) {
126 av_freep(&(*so)[i].specifier);
127 if (po->flags & OPT_STRING)
128 av_freep(&(*so)[i].u.str);
132 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
137 for (i = 0; i < o->nb_stream_maps; i++)
138 av_freep(&o->stream_maps[i].linklabel);
139 av_freep(&o->stream_maps);
140 av_freep(&o->audio_channel_maps);
141 av_freep(&o->streamid_map);
142 av_freep(&o->attachments);
145 static void init_options(OptionsContext *o)
147 memset(o, 0, sizeof(*o));
149 o->stop_time = INT64_MAX;
150 o->mux_max_delay = 0.7;
151 o->start_time = AV_NOPTS_VALUE;
152 o->recording_time = INT64_MAX;
153 o->limit_filesize = UINT64_MAX;
154 o->chapters_input_file = INT_MAX;
155 o->accurate_seek = 1;
158 /* return a copy of the input with the stream specifiers removed from the keys */
159 static AVDictionary *strip_specifiers(AVDictionary *dict)
161 AVDictionaryEntry *e = NULL;
162 AVDictionary *ret = NULL;
164 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
165 char *p = strchr(e->key, ':');
169 av_dict_set(&ret, e->key, e->value, 0);
176 static int opt_sameq(void *optctx, const char *opt, const char *arg)
178 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
179 "If you are looking for an option to preserve the quality (which is not "
180 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
182 return AVERROR(EINVAL);
185 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
187 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
188 return opt_default(optctx, "channel", arg);
191 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
193 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
194 return opt_default(optctx, "standard", arg);
197 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
199 OptionsContext *o = optctx;
200 return parse_option(o, "codec:a", arg, options);
203 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
205 OptionsContext *o = optctx;
206 return parse_option(o, "codec:v", arg, options);
209 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
211 OptionsContext *o = optctx;
212 return parse_option(o, "codec:s", arg, options);
215 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
217 OptionsContext *o = optctx;
218 return parse_option(o, "codec:d", arg, options);
221 static int opt_map(void *optctx, const char *opt, const char *arg)
223 OptionsContext *o = optctx;
225 int i, negative = 0, file_idx;
226 int sync_file_idx = -1, sync_stream_idx = 0;
234 map = av_strdup(arg);
236 /* parse sync stream first, just pick first matching stream */
237 if (sync = strchr(map, ',')) {
239 sync_file_idx = strtol(sync + 1, &sync, 0);
240 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
241 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
246 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
247 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
248 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
252 if (i == input_files[sync_file_idx]->nb_streams) {
253 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
254 "match any streams.\n", arg);
261 /* this mapping refers to lavfi output */
262 const char *c = map + 1;
263 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
264 m = &o->stream_maps[o->nb_stream_maps - 1];
265 m->linklabel = av_get_token(&c, "]");
267 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
271 file_idx = strtol(map, &p, 0);
272 if (file_idx >= nb_input_files || file_idx < 0) {
273 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
277 /* disable some already defined maps */
278 for (i = 0; i < o->nb_stream_maps; i++) {
279 m = &o->stream_maps[i];
280 if (file_idx == m->file_index &&
281 check_stream_specifier(input_files[m->file_index]->ctx,
282 input_files[m->file_index]->ctx->streams[m->stream_index],
283 *p == ':' ? p + 1 : p) > 0)
287 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
288 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
289 *p == ':' ? p + 1 : p) <= 0)
291 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
292 m = &o->stream_maps[o->nb_stream_maps - 1];
294 m->file_index = file_idx;
297 if (sync_file_idx >= 0) {
298 m->sync_file_index = sync_file_idx;
299 m->sync_stream_index = sync_stream_idx;
301 m->sync_file_index = file_idx;
302 m->sync_stream_index = i;
308 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
316 static int opt_attach(void *optctx, const char *opt, const char *arg)
318 OptionsContext *o = optctx;
319 GROW_ARRAY(o->attachments, o->nb_attachments);
320 o->attachments[o->nb_attachments - 1] = arg;
324 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
326 OptionsContext *o = optctx;
331 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
332 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
334 /* muted channel syntax */
335 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
336 if ((n == 1 || n == 3) && m->channel_idx == -1) {
337 m->file_idx = m->stream_idx = -1;
339 m->ofile_idx = m->ostream_idx = -1;
344 n = sscanf(arg, "%d.%d.%d:%d.%d",
345 &m->file_idx, &m->stream_idx, &m->channel_idx,
346 &m->ofile_idx, &m->ostream_idx);
348 if (n != 3 && n != 5) {
349 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
350 "[file.stream.channel|-1][:syncfile:syncstream]\n");
354 if (n != 5) // only file.stream.channel specified
355 m->ofile_idx = m->ostream_idx = -1;
358 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
359 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
363 if (m->stream_idx < 0 ||
364 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
365 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
366 m->file_idx, m->stream_idx);
369 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
370 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
371 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
372 m->file_idx, m->stream_idx);
375 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
376 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
377 m->file_idx, m->stream_idx, m->channel_idx);
384 * Parse a metadata specifier passed as 'arg' parameter.
385 * @param arg metadata string to parse
386 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
387 * @param index for type c/p, chapter/program index is written here
388 * @param stream_spec for type s, the stream specifier is written here
390 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
398 if (*(++arg) && *arg != ':') {
399 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
402 *stream_spec = *arg == ':' ? arg + 1 : "";
407 *index = strtol(++arg, NULL, 0);
410 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
417 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
419 AVDictionary **meta_in = NULL;
420 AVDictionary **meta_out = NULL;
422 char type_in, type_out;
423 const char *istream_spec = NULL, *ostream_spec = NULL;
424 int idx_in = 0, idx_out = 0;
426 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
427 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
430 if (type_out == 'g' || !*outspec)
431 o->metadata_global_manual = 1;
432 if (type_out == 's' || !*outspec)
433 o->metadata_streams_manual = 1;
434 if (type_out == 'c' || !*outspec)
435 o->metadata_chapters_manual = 1;
439 if (type_in == 'g' || type_out == 'g')
440 o->metadata_global_manual = 1;
441 if (type_in == 's' || type_out == 's')
442 o->metadata_streams_manual = 1;
443 if (type_in == 'c' || type_out == 'c')
444 o->metadata_chapters_manual = 1;
446 /* ic is NULL when just disabling automatic mappings */
450 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
451 if ((index) < 0 || (index) >= (nb_elems)) {\
452 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
457 #define SET_DICT(type, meta, context, index)\
460 meta = &context->metadata;\
463 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
464 meta = &context->chapters[index]->metadata;\
467 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
468 meta = &context->programs[index]->metadata;\
471 break; /* handled separately below */ \
472 default: av_assert0(0);\
475 SET_DICT(type_in, meta_in, ic, idx_in);
476 SET_DICT(type_out, meta_out, oc, idx_out);
478 /* for input streams choose first matching stream */
479 if (type_in == 's') {
480 for (i = 0; i < ic->nb_streams; i++) {
481 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
482 meta_in = &ic->streams[i]->metadata;
488 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
493 if (type_out == 's') {
494 for (i = 0; i < oc->nb_streams; i++) {
495 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
496 meta_out = &oc->streams[i]->metadata;
497 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
502 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
507 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
509 OptionsContext *o = optctx;
511 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
512 struct tm time = *gmtime((time_t*)&recording_timestamp);
513 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
514 parse_option(o, "metadata", buf, options);
516 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
517 "tag instead.\n", opt);
521 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
523 const AVCodecDescriptor *desc;
524 const char *codec_string = encoder ? "encoder" : "decoder";
528 avcodec_find_encoder_by_name(name) :
529 avcodec_find_decoder_by_name(name);
531 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
532 codec = encoder ? avcodec_find_encoder(desc->id) :
533 avcodec_find_decoder(desc->id);
535 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
536 codec_string, codec->name, desc->name);
540 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
543 if (codec->type != type) {
544 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
550 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
552 char *codec_name = NULL;
554 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
556 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
557 st->codec->codec_id = codec->id;
560 return avcodec_find_decoder(st->codec->codec_id);
563 /* Add all the streams from the given input file to the global
564 * list of input streams. */
565 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
569 for (i = 0; i < ic->nb_streams; i++) {
570 AVStream *st = ic->streams[i];
571 AVCodecContext *dec = st->codec;
572 InputStream *ist = av_mallocz(sizeof(*ist));
573 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
574 char *codec_tag = NULL;
580 GROW_ARRAY(input_streams, nb_input_streams);
581 input_streams[nb_input_streams - 1] = ist;
584 ist->file_index = nb_input_files;
586 st->discard = AVDISCARD_ALL;
589 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
591 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
593 uint32_t tag = strtol(codec_tag, &next, 0);
595 tag = AV_RL32(codec_tag);
596 st->codec->codec_tag = tag;
599 ist->dec = choose_decoder(o, ic, st);
600 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
602 ist->reinit_filters = -1;
603 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
605 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
607 switch (dec->codec_type) {
608 case AVMEDIA_TYPE_VIDEO:
610 ist->dec = avcodec_find_decoder(dec->codec_id);
611 if (av_codec_get_lowres(dec)) {
612 dec->flags |= CODEC_FLAG_EMU_EDGE;
615 ist->resample_height = dec->height;
616 ist->resample_width = dec->width;
617 ist->resample_pix_fmt = dec->pix_fmt;
619 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
620 if (framerate && av_parse_video_rate(&ist->framerate,
622 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
627 ist->top_field_first = -1;
628 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
630 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
632 if (!strcmp(hwaccel, "none"))
633 ist->hwaccel_id = HWACCEL_NONE;
634 else if (!strcmp(hwaccel, "auto"))
635 ist->hwaccel_id = HWACCEL_AUTO;
638 for (i = 0; hwaccels[i].name; i++) {
639 if (!strcmp(hwaccels[i].name, hwaccel)) {
640 ist->hwaccel_id = hwaccels[i].id;
645 if (!ist->hwaccel_id) {
646 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
648 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
649 for (i = 0; hwaccels[i].name; i++)
650 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
651 av_log(NULL, AV_LOG_FATAL, "\n");
657 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
658 if (hwaccel_device) {
659 ist->hwaccel_device = av_strdup(hwaccel_device);
660 if (!ist->hwaccel_device)
663 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
666 case AVMEDIA_TYPE_AUDIO:
667 ist->guess_layout_max = INT_MAX;
668 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
669 guess_input_channel_layout(ist);
671 ist->resample_sample_fmt = dec->sample_fmt;
672 ist->resample_sample_rate = dec->sample_rate;
673 ist->resample_channels = dec->channels;
674 ist->resample_channel_layout = dec->channel_layout;
677 case AVMEDIA_TYPE_DATA:
678 case AVMEDIA_TYPE_SUBTITLE: {
679 char *canvas_size = NULL;
681 ist->dec = avcodec_find_decoder(dec->codec_id);
682 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
683 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
685 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
686 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
691 case AVMEDIA_TYPE_ATTACHMENT:
692 case AVMEDIA_TYPE_UNKNOWN:
700 static void assert_file_overwrite(const char *filename)
702 if (file_overwrite && no_file_overwrite) {
703 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
707 if (!file_overwrite) {
708 const char *proto_name = avio_find_protocol_name(filename);
709 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
710 if (stdin_interaction && !no_file_overwrite) {
711 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
714 signal(SIGINT, SIG_DFL);
716 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
722 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
729 static void dump_attachment(AVStream *st, const char *filename)
732 AVIOContext *out = NULL;
733 AVDictionaryEntry *e;
735 if (!st->codec->extradata_size) {
736 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
737 nb_input_files - 1, st->index);
740 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
743 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
744 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
748 assert_file_overwrite(filename);
750 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
751 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
756 avio_write(out, st->codec->extradata, st->codec->extradata_size);
761 static int open_input_file(OptionsContext *o, const char *filename)
765 AVInputFormat *file_iformat = NULL;
770 AVDictionary *unused_opts = NULL;
771 AVDictionaryEntry *e = NULL;
772 int orig_nb_streams; // number of streams before avformat_find_stream_info
773 char * video_codec_name = NULL;
774 char * audio_codec_name = NULL;
775 char *subtitle_codec_name = NULL;
778 if (!(file_iformat = av_find_input_format(o->format))) {
779 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
784 if (!strcmp(filename, "-"))
787 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
788 strcmp(filename, "/dev/stdin");
790 /* get default parameters from command line */
791 ic = avformat_alloc_context();
793 print_error(filename, AVERROR(ENOMEM));
796 if (o->nb_audio_sample_rate) {
797 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
798 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
800 if (o->nb_audio_channels) {
801 /* because we set audio_channels based on both the "ac" and
802 * "channel_layout" options, we need to check that the specified
803 * demuxer actually has the "channels" option before setting it */
804 if (file_iformat && file_iformat->priv_class &&
805 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
806 AV_OPT_SEARCH_FAKE_OBJ)) {
807 snprintf(buf, sizeof(buf), "%d",
808 o->audio_channels[o->nb_audio_channels - 1].u.i);
809 av_dict_set(&o->g->format_opts, "channels", buf, 0);
812 if (o->nb_frame_rates) {
813 /* set the format-level framerate option;
814 * this is important for video grabbers, e.g. x11 */
815 if (file_iformat && file_iformat->priv_class &&
816 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
817 AV_OPT_SEARCH_FAKE_OBJ)) {
818 av_dict_set(&o->g->format_opts, "framerate",
819 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
822 if (o->nb_frame_sizes) {
823 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
825 if (o->nb_frame_pix_fmts)
826 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
828 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
829 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
830 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
832 ic->video_codec_id = video_codec_name ?
833 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
834 ic->audio_codec_id = audio_codec_name ?
835 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
836 ic->subtitle_codec_id= subtitle_codec_name ?
837 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
839 if (video_codec_name)
840 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
841 if (audio_codec_name)
842 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
843 if (subtitle_codec_name)
844 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
846 ic->flags |= AVFMT_FLAG_NONBLOCK;
847 ic->interrupt_callback = int_cb;
849 /* open the input file with generic avformat function */
850 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
852 print_error(filename, err);
855 assert_avoptions(o->g->format_opts);
857 /* apply forced codec ids */
858 for (i = 0; i < ic->nb_streams; i++)
859 choose_decoder(o, ic, ic->streams[i]);
861 /* Set AVCodecContext options for avformat_find_stream_info */
862 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
863 orig_nb_streams = ic->nb_streams;
865 /* If not enough info to get the stream parameters, we decode the
866 first frames to get it. (used in mpeg case for example) */
867 ret = avformat_find_stream_info(ic, opts);
869 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
870 avformat_close_input(&ic);
874 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
875 /* add the stream start time */
876 if (ic->start_time != AV_NOPTS_VALUE)
877 timestamp += ic->start_time;
879 /* if seeking requested, we execute it */
880 if (o->start_time != AV_NOPTS_VALUE) {
881 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
883 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
884 filename, (double)timestamp / AV_TIME_BASE);
888 /* update the current parameters so that they match the one of the input stream */
889 add_input_streams(o, ic);
891 /* dump the file content */
892 av_dump_format(ic, nb_input_files, filename, 0);
894 GROW_ARRAY(input_files, nb_input_files);
895 f = av_mallocz(sizeof(*f));
898 input_files[nb_input_files - 1] = f;
901 f->ist_index = nb_input_streams - ic->nb_streams;
902 f->start_time = o->start_time;
903 f->recording_time = o->recording_time;
904 f->input_ts_offset = o->input_ts_offset;
905 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
906 f->nb_streams = ic->nb_streams;
907 f->rate_emu = o->rate_emu;
908 f->accurate_seek = o->accurate_seek;
910 /* check if all codec options have been used */
911 unused_opts = strip_specifiers(o->g->codec_opts);
912 for (i = f->ist_index; i < nb_input_streams; i++) {
914 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
915 AV_DICT_IGNORE_SUFFIX)))
916 av_dict_set(&unused_opts, e->key, NULL, 0);
920 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
921 const AVClass *class = avcodec_get_class();
922 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
923 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
924 const AVClass *fclass = avformat_get_class();
925 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
926 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
927 if (!option || foption)
931 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
932 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
933 "input file #%d (%s) is not a decoding option.\n", e->key,
934 option->help ? option->help : "", nb_input_files - 1,
939 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
940 "input file #%d (%s) has not been used for any stream. The most "
941 "likely reason is either wrong type (e.g. a video option with "
942 "no video streams) or that it is a private option of some decoder "
943 "which was not actually used for any stream.\n", e->key,
944 option->help ? option->help : "", nb_input_files - 1, filename);
946 av_dict_free(&unused_opts);
948 for (i = 0; i < o->nb_dump_attachment; i++) {
951 for (j = 0; j < ic->nb_streams; j++) {
952 AVStream *st = ic->streams[j];
954 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
955 dump_attachment(st, o->dump_attachment[i].u.str);
959 for (i = 0; i < orig_nb_streams; i++)
960 av_dict_free(&opts[i]);
966 static uint8_t *get_line(AVIOContext *s)
972 if (avio_open_dyn_buf(&line) < 0) {
973 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
977 while ((c = avio_r8(s)) && c != '\n')
980 avio_close_dyn_buf(line, &buf);
985 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
989 const char *base[3] = { getenv("AVCONV_DATADIR"),
994 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
998 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
999 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1000 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1003 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1004 i != 1 ? "" : "/.avconv", preset_name);
1005 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1011 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1013 char *codec_name = NULL;
1015 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1017 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1018 NULL, ost->st->codec->codec_type);
1019 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1020 } else if (!strcmp(codec_name, "copy"))
1021 ost->stream_copy = 1;
1023 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1024 ost->st->codec->codec_id = ost->enc->id;
1028 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1031 AVStream *st = avformat_new_stream(oc, NULL);
1032 int idx = oc->nb_streams - 1, ret = 0;
1033 char *bsf = NULL, *next, *codec_tag = NULL;
1034 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1039 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1043 if (oc->nb_streams - 1 < o->nb_streamid_map)
1044 st->id = o->streamid_map[oc->nb_streams - 1];
1046 GROW_ARRAY(output_streams, nb_output_streams);
1047 if (!(ost = av_mallocz(sizeof(*ost))))
1049 output_streams[nb_output_streams - 1] = ost;
1051 ost->file_index = nb_output_files - 1;
1054 st->codec->codec_type = type;
1055 choose_encoder(o, oc, ost);
1057 AVIOContext *s = NULL;
1058 char *buf = NULL, *arg = NULL, *preset = NULL;
1060 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1062 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1063 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1066 if (!buf[0] || buf[0] == '#') {
1070 if (!(arg = strchr(buf, '='))) {
1071 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1075 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1077 } while (!s->eof_reached);
1081 av_log(NULL, AV_LOG_FATAL,
1082 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1083 preset, ost->file_index, ost->index);
1087 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1090 avcodec_get_context_defaults3(st->codec, ost->enc);
1091 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1093 ost->max_frames = INT64_MAX;
1094 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1095 for (i = 0; i<o->nb_max_frames; i++) {
1096 char *p = o->max_frames[i].specifier;
1097 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1098 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1103 ost->copy_prior_start = -1;
1104 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1106 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1108 if (next = strchr(bsf, ','))
1110 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1111 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1115 bsfc_prev->next = bsfc;
1117 ost->bitstream_filters = bsfc;
1123 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1125 uint32_t tag = strtol(codec_tag, &next, 0);
1127 tag = AV_RL32(codec_tag);
1128 st->codec->codec_tag = tag;
1131 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1133 st->codec->flags |= CODEC_FLAG_QSCALE;
1134 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1137 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1138 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1140 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1142 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1143 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1144 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1146 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1148 ost->source_index = source_index;
1149 if (source_index >= 0) {
1150 ost->sync_ist = input_streams[source_index];
1151 input_streams[source_index]->discard = 0;
1152 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1154 ost->last_mux_dts = AV_NOPTS_VALUE;
1159 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1162 const char *p = str;
1169 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1176 /* read file contents into a string */
1177 static uint8_t *read_file(const char *filename)
1179 AVIOContext *pb = NULL;
1180 AVIOContext *dyn_buf = NULL;
1181 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1182 uint8_t buf[1024], *str;
1185 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1189 ret = avio_open_dyn_buf(&dyn_buf);
1194 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1195 avio_write(dyn_buf, buf, ret);
1196 avio_w8(dyn_buf, 0);
1199 ret = avio_close_dyn_buf(dyn_buf, &str);
1205 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1208 AVStream *st = ost->st;
1210 if (ost->filters_script && ost->filters) {
1211 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1212 "output stream #%d:%d.\n", nb_output_files, st->index);
1216 if (ost->filters_script)
1217 return read_file(ost->filters_script);
1218 else if (ost->filters)
1219 return av_strdup(ost->filters);
1221 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1225 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1226 const OutputStream *ost, enum AVMediaType type)
1228 if (ost->filters_script || ost->filters) {
1229 av_log(NULL, AV_LOG_ERROR,
1230 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1231 "Filtering and streamcopy cannot be used together.\n",
1232 ost->filters ? "Filtergraph" : "Filtergraph script",
1233 ost->filters ? ost->filters : ost->filters_script,
1234 av_get_media_type_string(type), ost->file_index, ost->index);
1239 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1243 AVCodecContext *video_enc;
1244 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1246 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1248 video_enc = st->codec;
1250 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1251 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1252 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1256 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1257 if (frame_aspect_ratio) {
1259 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1260 q.num <= 0 || q.den <= 0) {
1261 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1264 ost->frame_aspect_ratio = q;
1267 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1268 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1270 if (!ost->stream_copy) {
1271 const char *p = NULL;
1272 char *frame_size = NULL;
1273 char *frame_pix_fmt = NULL;
1274 char *intra_matrix = NULL, *inter_matrix = NULL;
1275 char *chroma_intra_matrix = NULL;
1279 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1280 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1281 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1285 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1286 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1287 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1288 ost->keep_pix_fmt = 1;
1289 if (!*++frame_pix_fmt)
1290 frame_pix_fmt = NULL;
1292 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1293 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1296 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1299 video_enc->gop_size = 0;
1300 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1302 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1303 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1306 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1308 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1309 if (chroma_intra_matrix) {
1310 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1312 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1315 av_codec_set_chroma_intra_matrix(video_enc, p);
1316 parse_matrix_coeffs(p, chroma_intra_matrix);
1318 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1320 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1321 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1324 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1327 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1328 for (i = 0; p; i++) {
1330 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1332 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1335 /* FIXME realloc failure */
1336 video_enc->rc_override =
1337 av_realloc(video_enc->rc_override,
1338 sizeof(RcOverride) * (i + 1));
1339 video_enc->rc_override[i].start_frame = start;
1340 video_enc->rc_override[i].end_frame = end;
1342 video_enc->rc_override[i].qscale = q;
1343 video_enc->rc_override[i].quality_factor = 1.0;
1346 video_enc->rc_override[i].qscale = 0;
1347 video_enc->rc_override[i].quality_factor = -q/100.0;
1352 video_enc->rc_override_count = i;
1353 video_enc->intra_dc_precision = intra_dc_precision - 8;
1356 video_enc->flags|= CODEC_FLAG_PSNR;
1359 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1362 video_enc->flags |= CODEC_FLAG_PASS1;
1363 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1366 video_enc->flags |= CODEC_FLAG_PASS2;
1367 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1371 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1372 if (ost->logfile_prefix &&
1373 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1376 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1377 if (ost->forced_keyframes)
1378 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1380 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1382 ost->top_field_first = -1;
1383 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1386 ost->avfilter = get_ost_filters(o, oc, ost);
1390 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1393 if (ost->stream_copy)
1394 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1399 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1404 AVCodecContext *audio_enc;
1406 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1409 audio_enc = st->codec;
1410 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1412 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1413 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1415 if (!ost->stream_copy) {
1416 char *sample_fmt = NULL;
1418 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1420 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1422 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1423 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1427 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1429 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1430 ost->apad = av_strdup(ost->apad);
1432 ost->avfilter = get_ost_filters(o, oc, ost);
1436 /* check for channel mapping for this audio stream */
1437 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1438 AudioChannelMap *map = &o->audio_channel_maps[n];
1439 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1440 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1443 if (map->channel_idx == -1) {
1445 } else if (ost->source_index < 0) {
1446 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1447 ost->file_index, ost->st->index);
1450 ist = input_streams[ost->source_index];
1453 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1454 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1455 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1457 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1458 ost->file_index, ost->st->index);
1464 if (ost->stream_copy)
1465 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1470 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1474 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1475 if (!ost->stream_copy) {
1476 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1483 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1485 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1486 ost->stream_copy = 1;
1491 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1495 AVCodecContext *subtitle_enc;
1497 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1499 subtitle_enc = st->codec;
1501 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1503 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1505 if (!ost->stream_copy) {
1506 char *frame_size = NULL;
1508 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1509 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1510 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1518 /* arg format is "output-stream-index:streamid-value". */
1519 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1521 OptionsContext *o = optctx;
1526 av_strlcpy(idx_str, arg, sizeof(idx_str));
1527 p = strchr(idx_str, ':');
1529 av_log(NULL, AV_LOG_FATAL,
1530 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1535 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1536 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1537 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1541 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1543 AVFormatContext *is = ifile->ctx;
1544 AVFormatContext *os = ofile->ctx;
1548 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1550 return AVERROR(ENOMEM);
1553 for (i = 0; i < is->nb_chapters; i++) {
1554 AVChapter *in_ch = is->chapters[i], *out_ch;
1555 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1556 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1557 AV_TIME_BASE_Q, in_ch->time_base);
1558 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1559 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1562 if (in_ch->end < ts_off)
1564 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1567 out_ch = av_mallocz(sizeof(AVChapter));
1569 return AVERROR(ENOMEM);
1571 out_ch->id = in_ch->id;
1572 out_ch->time_base = in_ch->time_base;
1573 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1574 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1577 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1579 os->chapters[os->nb_chapters++] = out_ch;
1584 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1587 AVFormatContext *ic = avformat_alloc_context();
1589 ic->interrupt_callback = int_cb;
1590 err = avformat_open_input(&ic, filename, NULL, NULL);
1593 /* copy stream format */
1594 for(i=0;i<ic->nb_streams;i++) {
1598 AVCodecContext *avctx;
1600 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1601 ost = new_output_stream(o, s, codec->type, -1);
1606 // FIXME: a more elegant solution is needed
1607 memcpy(st, ic->streams[i], sizeof(AVStream));
1609 st->info = av_malloc(sizeof(*st->info));
1610 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1612 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1614 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1615 choose_sample_fmt(st, codec);
1616 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1617 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1620 avformat_close_input(&ic);
1624 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1625 AVFormatContext *oc)
1629 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1630 ofilter->out_tmp->pad_idx)) {
1631 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1632 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1634 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1639 ost->source_index = -1;
1640 ost->filter = ofilter;
1644 if (ost->stream_copy) {
1645 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1646 "which is fed from a complex filtergraph. Filtering and streamcopy "
1647 "cannot be used together.\n", ost->file_index, ost->index);
1651 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1652 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1653 av_log(NULL, AV_LOG_ERROR,
1654 "%s '%s' was specified through the %s option "
1655 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1656 "%s and -filter_complex cannot be used together for the same stream.\n",
1657 ost->filters ? "Filtergraph" : "Filtergraph script",
1658 ost->filters ? ost->filters : ost->filters_script,
1659 opt, ost->file_index, ost->index, opt);
1663 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1664 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1667 avfilter_inout_free(&ofilter->out_tmp);
1670 static int configure_complex_filters(void)
1674 for (i = 0; i < nb_filtergraphs; i++)
1675 if (!filtergraphs[i]->graph &&
1676 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1681 static int open_output_file(OptionsContext *o, const char *filename)
1683 AVFormatContext *oc;
1685 AVOutputFormat *file_oformat;
1689 AVDictionary *unused_opts = NULL;
1690 AVDictionaryEntry *e = NULL;
1692 if (configure_complex_filters() < 0) {
1693 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1697 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1698 o->stop_time = INT64_MAX;
1699 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1702 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1703 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1704 if (o->stop_time <= start_time) {
1705 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1706 o->stop_time = INT64_MAX;
1708 o->recording_time = o->stop_time - start_time;
1712 GROW_ARRAY(output_files, nb_output_files);
1713 of = av_mallocz(sizeof(*of));
1716 output_files[nb_output_files - 1] = of;
1718 of->ost_index = nb_output_streams;
1719 of->recording_time = o->recording_time;
1720 of->start_time = o->start_time;
1721 of->limit_filesize = o->limit_filesize;
1722 of->shortest = o->shortest;
1723 av_dict_copy(&of->opts, o->g->format_opts, 0);
1725 if (!strcmp(filename, "-"))
1728 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1730 print_error(filename, err);
1735 if (o->recording_time != INT64_MAX)
1736 oc->duration = o->recording_time;
1738 file_oformat= oc->oformat;
1739 oc->interrupt_callback = int_cb;
1741 /* create streams for all unlabeled output pads */
1742 for (i = 0; i < nb_filtergraphs; i++) {
1743 FilterGraph *fg = filtergraphs[i];
1744 for (j = 0; j < fg->nb_outputs; j++) {
1745 OutputFilter *ofilter = fg->outputs[j];
1747 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1750 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1751 ofilter->out_tmp->pad_idx)) {
1752 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1753 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1754 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1756 init_output_filter(ofilter, o, oc);
1760 /* ffserver seeking with date=... needs a date reference */
1761 if (!strcmp(file_oformat->name, "ffm") &&
1762 av_strstart(filename, "http:", NULL)) {
1763 int err = parse_option(o, "metadata", "creation_time=now", options);
1765 print_error(filename, err);
1770 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1771 av_strstart(filename, "http:", NULL)) {
1773 /* special case for files sent to ffserver: we get the stream
1774 parameters from ffserver */
1775 int err = read_ffserver_streams(o, oc, filename);
1777 print_error(filename, err);
1780 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1781 ost = output_streams[j];
1782 for (i = 0; i < nb_input_streams; i++) {
1783 ist = input_streams[i];
1784 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1786 ost->source_index= i;
1787 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1788 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1790 ist->st->discard = AVDISCARD_NONE;
1795 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));
1799 } else if (!o->nb_stream_maps) {
1800 char *subtitle_codec_name = NULL;
1801 /* pick the "best" stream of each type */
1803 /* video: highest resolution */
1804 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1805 int area = 0, idx = -1;
1806 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1807 for (i = 0; i < nb_input_streams; i++) {
1809 ist = input_streams[i];
1810 new_area = ist->st->codec->width * ist->st->codec->height;
1811 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1813 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1815 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1822 new_video_stream(o, oc, idx);
1825 /* audio: most channels */
1826 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1827 int channels = 0, idx = -1;
1828 for (i = 0; i < nb_input_streams; i++) {
1829 ist = input_streams[i];
1830 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1831 ist->st->codec->channels > channels) {
1832 channels = ist->st->codec->channels;
1837 new_audio_stream(o, oc, idx);
1840 /* subtitles: pick first */
1841 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1842 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1843 for (i = 0; i < nb_input_streams; i++)
1844 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1845 new_subtitle_stream(o, oc, i);
1849 /* do something with data? */
1851 for (i = 0; i < o->nb_stream_maps; i++) {
1852 StreamMap *map = &o->stream_maps[i];
1857 if (map->linklabel) {
1859 OutputFilter *ofilter = NULL;
1862 for (j = 0; j < nb_filtergraphs; j++) {
1863 fg = filtergraphs[j];
1864 for (k = 0; k < fg->nb_outputs; k++) {
1865 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1866 if (out && !strcmp(out->name, map->linklabel)) {
1867 ofilter = fg->outputs[k];
1874 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1875 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1878 init_output_filter(ofilter, o, oc);
1880 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1882 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1883 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1885 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1887 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1889 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1892 switch (ist->st->codec->codec_type) {
1893 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1894 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1895 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1896 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1897 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1899 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1900 map->file_index, map->stream_index);
1907 /* handle attached files */
1908 for (i = 0; i < o->nb_attachments; i++) {
1910 uint8_t *attachment;
1914 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1915 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1919 if ((len = avio_size(pb)) <= 0) {
1920 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1924 if (!(attachment = av_malloc(len))) {
1925 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1929 avio_read(pb, attachment, len);
1931 ost = new_attachment_stream(o, oc, -1);
1932 ost->stream_copy = 0;
1933 ost->attachment_filename = o->attachments[i];
1935 ost->st->codec->extradata = attachment;
1936 ost->st->codec->extradata_size = len;
1938 p = strrchr(o->attachments[i], '/');
1939 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1943 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1944 AVDictionaryEntry *e;
1945 ost = output_streams[i];
1947 if ((ost->stream_copy || ost->attachment_filename)
1948 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1949 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1950 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1954 /* check if all codec options have been used */
1955 unused_opts = strip_specifiers(o->g->codec_opts);
1956 for (i = of->ost_index; i < nb_output_streams; i++) {
1958 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1959 AV_DICT_IGNORE_SUFFIX)))
1960 av_dict_set(&unused_opts, e->key, NULL, 0);
1964 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1965 const AVClass *class = avcodec_get_class();
1966 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1967 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1970 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1971 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1972 "output file #%d (%s) is not an encoding option.\n", e->key,
1973 option->help ? option->help : "", nb_output_files - 1,
1978 // gop_timecode is injected by generic code but not always used
1979 if (!strcmp(e->key, "gop_timecode"))
1982 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1983 "output file #%d (%s) has not been used for any stream. The most "
1984 "likely reason is either wrong type (e.g. a video option with "
1985 "no video streams) or that it is a private option of some encoder "
1986 "which was not actually used for any stream.\n", e->key,
1987 option->help ? option->help : "", nb_output_files - 1, filename);
1989 av_dict_free(&unused_opts);
1991 /* check filename in case of an image number is expected */
1992 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1993 if (!av_filename_number_test(oc->filename)) {
1994 print_error(oc->filename, AVERROR(EINVAL));
1999 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2000 /* test if it already exists to avoid losing precious files */
2001 assert_file_overwrite(filename);
2004 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2005 &oc->interrupt_callback,
2007 print_error(filename, err);
2010 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2011 assert_file_overwrite(filename);
2013 if (o->mux_preload) {
2015 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
2016 av_dict_set(&of->opts, "preload", buf, 0);
2018 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2021 for (i = 0; i < o->nb_metadata_map; i++) {
2023 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2025 if (in_file_index >= nb_input_files) {
2026 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2029 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2030 in_file_index >= 0 ?
2031 input_files[in_file_index]->ctx : NULL, o);
2035 if (o->chapters_input_file >= nb_input_files) {
2036 if (o->chapters_input_file == INT_MAX) {
2037 /* copy chapters from the first input file that has them*/
2038 o->chapters_input_file = -1;
2039 for (i = 0; i < nb_input_files; i++)
2040 if (input_files[i]->ctx->nb_chapters) {
2041 o->chapters_input_file = i;
2045 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2046 o->chapters_input_file);
2050 if (o->chapters_input_file >= 0)
2051 copy_chapters(input_files[o->chapters_input_file], of,
2052 !o->metadata_chapters_manual);
2054 /* copy global metadata by default */
2055 if (!o->metadata_global_manual && nb_input_files){
2056 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2057 AV_DICT_DONT_OVERWRITE);
2058 if(o->recording_time != INT64_MAX)
2059 av_dict_set(&oc->metadata, "duration", NULL, 0);
2060 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2062 if (!o->metadata_streams_manual)
2063 for (i = of->ost_index; i < nb_output_streams; i++) {
2065 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2067 ist = input_streams[output_streams[i]->source_index];
2068 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2069 if (!output_streams[i]->stream_copy)
2070 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2073 /* process manually set metadata */
2074 for (i = 0; i < o->nb_metadata; i++) {
2077 const char *stream_spec;
2078 int index = 0, j, ret = 0;
2080 val = strchr(o->metadata[i].u.str, '=');
2082 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2083 o->metadata[i].u.str);
2088 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2090 for (j = 0; j < oc->nb_streams; j++) {
2091 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2092 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2103 if (index < 0 || index >= oc->nb_chapters) {
2104 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2107 m = &oc->chapters[index]->metadata;
2110 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2113 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2120 static int opt_target(void *optctx, const char *opt, const char *arg)
2122 OptionsContext *o = optctx;
2123 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2124 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2126 if (!strncmp(arg, "pal-", 4)) {
2129 } else if (!strncmp(arg, "ntsc-", 5)) {
2132 } else if (!strncmp(arg, "film-", 5)) {
2136 /* Try to determine PAL/NTSC by peeking in the input files */
2137 if (nb_input_files) {
2139 for (j = 0; j < nb_input_files; j++) {
2140 for (i = 0; i < input_files[j]->nb_streams; i++) {
2141 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2142 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2144 fr = c->time_base.den * 1000 / c->time_base.num;
2148 } else if ((fr == 29970) || (fr == 23976)) {
2153 if (norm != UNKNOWN)
2157 if (norm != UNKNOWN)
2158 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2161 if (norm == UNKNOWN) {
2162 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2163 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2164 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2168 if (!strcmp(arg, "vcd")) {
2169 opt_video_codec(o, "c:v", "mpeg1video");
2170 opt_audio_codec(o, "c:a", "mp2");
2171 parse_option(o, "f", "vcd", options);
2173 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2174 parse_option(o, "r", frame_rates[norm], options);
2175 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2177 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2178 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2179 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2180 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2182 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2183 parse_option(o, "ar", "44100", options);
2184 parse_option(o, "ac", "2", options);
2186 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2187 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2189 /* We have to offset the PTS, so that it is consistent with the SCR.
2190 SCR starts at 36000, but the first two packs contain only padding
2191 and the first pack from the other stream, respectively, may also have
2192 been written before.
2193 So the real data starts at SCR 36000+3*1200. */
2194 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2195 } else if (!strcmp(arg, "svcd")) {
2197 opt_video_codec(o, "c:v", "mpeg2video");
2198 opt_audio_codec(o, "c:a", "mp2");
2199 parse_option(o, "f", "svcd", options);
2201 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2202 parse_option(o, "r", frame_rates[norm], options);
2203 parse_option(o, "pix_fmt", "yuv420p", options);
2204 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2206 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2207 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2208 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2209 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2210 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2212 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2213 parse_option(o, "ar", "44100", options);
2215 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2217 } else if (!strcmp(arg, "dvd")) {
2219 opt_video_codec(o, "c:v", "mpeg2video");
2220 opt_audio_codec(o, "c:a", "ac3");
2221 parse_option(o, "f", "dvd", options);
2223 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2224 parse_option(o, "r", frame_rates[norm], options);
2225 parse_option(o, "pix_fmt", "yuv420p", options);
2226 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2228 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2229 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2230 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2231 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2233 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.
2234 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2236 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2237 parse_option(o, "ar", "48000", options);
2239 } else if (!strncmp(arg, "dv", 2)) {
2241 parse_option(o, "f", "dv", options);
2243 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2244 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2245 norm == PAL ? "yuv420p" : "yuv411p", options);
2246 parse_option(o, "r", frame_rates[norm], options);
2248 parse_option(o, "ar", "48000", options);
2249 parse_option(o, "ac", "2", options);
2252 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2253 return AVERROR(EINVAL);
2258 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2260 av_free (vstats_filename);
2261 vstats_filename = av_strdup (arg);
2265 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2268 time_t today2 = time(NULL);
2269 struct tm *today = localtime(&today2);
2271 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2273 return opt_vstats_file(NULL, opt, filename);
2276 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2278 OptionsContext *o = optctx;
2279 return parse_option(o, "frames:v", arg, options);
2282 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2284 OptionsContext *o = optctx;
2285 return parse_option(o, "frames:a", arg, options);
2288 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2290 OptionsContext *o = optctx;
2291 return parse_option(o, "frames:d", arg, options);
2294 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2297 AVDictionary *cbak = codec_opts;
2298 AVDictionary *fbak = format_opts;
2302 ret = opt_default(NULL, opt, arg);
2304 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2305 av_dict_copy(&o->g->format_opts, format_opts, 0);
2306 av_dict_free(&codec_opts);
2307 av_dict_free(&format_opts);
2314 static int opt_preset(void *optctx, const char *opt, const char *arg)
2316 OptionsContext *o = optctx;
2318 char filename[1000], line[1000], tmp_line[1000];
2319 const char *codec_name = NULL;
2323 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2325 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2326 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2327 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2329 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2333 while (fgets(line, sizeof(line), f)) {
2334 char *key = tmp_line, *value, *endptr;
2336 if (strcspn(line, "#\n\r") == 0)
2338 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2339 if (!av_strtok(key, "=", &value) ||
2340 !av_strtok(value, "\r\n", &endptr)) {
2341 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2344 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2346 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2347 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2348 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2349 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2350 else if (opt_default_new(o, key, value) < 0) {
2351 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2352 filename, line, key, value);
2362 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2364 OptionsContext *o = optctx;
2365 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2366 int ret = parse_option(o, s, arg, options);
2371 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2373 OptionsContext *o = optctx;
2374 if(!strcmp(opt, "b")){
2375 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2376 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2379 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2383 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2385 OptionsContext *o = optctx;
2388 if(!strcmp(opt, "qscale")){
2389 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2390 return parse_option(o, "q:v", arg, options);
2392 s = av_asprintf("q%s", opt + 6);
2393 ret = parse_option(o, s, arg, options);
2398 static int opt_profile(void *optctx, const char *opt, const char *arg)
2400 OptionsContext *o = optctx;
2401 if(!strcmp(opt, "profile")){
2402 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2403 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2406 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2410 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2412 OptionsContext *o = optctx;
2413 return parse_option(o, "filter:v", arg, options);
2416 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2418 OptionsContext *o = optctx;
2419 return parse_option(o, "filter:a", arg, options);
2422 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2424 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2425 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2426 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2427 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2429 if (video_sync_method == VSYNC_AUTO)
2430 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2434 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2436 OptionsContext *o = optctx;
2437 char *tcr = av_asprintf("timecode=%s", arg);
2438 int ret = parse_option(o, "metadata:g", tcr, options);
2440 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2445 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2447 OptionsContext *o = optctx;
2448 char layout_str[32];
2451 int ret, channels, ac_str_size;
2454 layout = av_get_channel_layout(arg);
2456 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2457 return AVERROR(EINVAL);
2459 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2460 ret = opt_default_new(o, opt, layout_str);
2464 /* set 'ac' option based on channel layout */
2465 channels = av_get_channel_layout_nb_channels(layout);
2466 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2467 stream_str = strchr(opt, ':');
2468 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2469 ac_str = av_mallocz(ac_str_size);
2471 return AVERROR(ENOMEM);
2472 av_strlcpy(ac_str, "ac", 3);
2474 av_strlcat(ac_str, stream_str, ac_str_size);
2475 ret = parse_option(o, ac_str, layout_str, options);
2481 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2483 OptionsContext *o = optctx;
2484 return parse_option(o, "q:a", arg, options);
2487 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2489 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2490 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2491 return AVERROR(ENOMEM);
2492 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2493 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2494 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2495 return AVERROR(ENOMEM);
2499 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2501 uint8_t *graph_desc = read_file(arg);
2503 return AVERROR(EINVAL);
2505 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2506 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2507 return AVERROR(ENOMEM);
2508 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2509 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2513 void show_help_default(const char *opt, const char *arg)
2515 /* per-file options have at least one of those set */
2516 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2517 int show_advanced = 0, show_avoptions = 0;
2520 if (!strcmp(opt, "long"))
2522 else if (!strcmp(opt, "full"))
2523 show_advanced = show_avoptions = 1;
2525 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2530 printf("Getting help:\n"
2531 " -h -- print basic options\n"
2532 " -h long -- print more options\n"
2533 " -h full -- print all options (including all format and codec specific options, very long)\n"
2534 " See man %s for detailed description of the options.\n"
2535 "\n", program_name);
2537 show_help_options(options, "Print help / information / capabilities:",
2540 show_help_options(options, "Global options (affect whole program "
2541 "instead of just one file:",
2542 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2544 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2545 per_file | OPT_EXIT, 0);
2547 show_help_options(options, "Per-file main options:", 0,
2548 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2549 OPT_EXIT, per_file);
2551 show_help_options(options, "Advanced per-file options:",
2552 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2554 show_help_options(options, "Video options:",
2555 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2557 show_help_options(options, "Advanced Video options:",
2558 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2560 show_help_options(options, "Audio options:",
2561 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2563 show_help_options(options, "Advanced Audio options:",
2564 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2565 show_help_options(options, "Subtitle options:",
2566 OPT_SUBTITLE, 0, 0);
2569 if (show_avoptions) {
2570 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2571 show_help_children(avcodec_get_class(), flags);
2572 show_help_children(avformat_get_class(), flags);
2574 show_help_children(sws_get_class(), flags);
2576 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2577 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2581 void show_usage(void)
2583 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2584 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2585 av_log(NULL, AV_LOG_INFO, "\n");
2593 static const OptionGroupDef groups[] = {
2594 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2595 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2598 static int open_files(OptionGroupList *l, const char *inout,
2599 int (*open_file)(OptionsContext*, const char*))
2603 for (i = 0; i < l->nb_groups; i++) {
2604 OptionGroup *g = &l->groups[i];
2610 ret = parse_optgroup(&o, g);
2612 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2613 "%s.\n", inout, g->arg);
2617 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2618 ret = open_file(&o, g->arg);
2621 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2625 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2631 int ffmpeg_parse_options(int argc, char **argv)
2633 OptionParseContext octx;
2637 memset(&octx, 0, sizeof(octx));
2639 /* split the commandline into an internal representation */
2640 ret = split_commandline(&octx, argc, argv, options, groups,
2641 FF_ARRAY_ELEMS(groups));
2643 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2647 /* apply global options */
2648 ret = parse_optgroup(NULL, &octx.global_opts);
2650 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2654 /* open input files */
2655 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2657 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2661 /* open output files */
2662 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2664 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2669 uninit_parse_context(&octx);
2671 av_strerror(ret, error, sizeof(error));
2672 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2677 static int opt_progress(void *optctx, const char *opt, const char *arg)
2679 AVIOContext *avio = NULL;
2682 if (!strcmp(arg, "-"))
2684 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2686 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2687 arg, av_err2str(ret));
2690 progress_avio = avio;
2694 #define OFFSET(x) offsetof(OptionsContext, x)
2695 const OptionDef options[] = {
2697 #include "cmdutils_common_opts.h"
2698 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2699 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2700 "force format", "fmt" },
2701 { "y", OPT_BOOL, { &file_overwrite },
2702 "overwrite output files" },
2703 { "n", OPT_BOOL, { &no_file_overwrite },
2704 "never overwrite output files" },
2705 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2706 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2707 "codec name", "codec" },
2708 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2709 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2710 "codec name", "codec" },
2711 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2712 OPT_OUTPUT, { .off = OFFSET(presets) },
2713 "preset name", "preset" },
2714 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2715 OPT_OUTPUT, { .func_arg = opt_map },
2716 "set input stream mapping",
2717 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2718 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2719 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2720 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2721 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2722 "set metadata information of outfile from infile",
2723 "outfile[,metadata]:infile[,metadata]" },
2724 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2725 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2726 "set chapters mapping", "input_file_index" },
2727 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2728 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2729 "record or transcode \"duration\" seconds of audio/video",
2731 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2732 "record or transcode stop time", "time_stop" },
2733 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2734 "set the limit file size in bytes", "limit_size" },
2735 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2736 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2737 "set the start time offset", "time_off" },
2738 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2739 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2740 "enable/disable accurate seeking with -ss" },
2741 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2742 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2743 "set the input ts offset", "time_off" },
2744 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2745 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2746 "set the input ts scale", "scale" },
2747 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2748 "set the recording timestamp ('now' to set the current time)", "time" },
2749 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2750 "add metadata", "string=string" },
2751 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2752 OPT_OUTPUT, { .func_arg = opt_data_frames },
2753 "set the number of data frames to record", "number" },
2754 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2755 "add timings for benchmarking" },
2756 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2757 "add timings for each task" },
2758 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2759 "write program-readable progress information", "url" },
2760 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2761 "enable or disable interaction on standard input" },
2762 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2763 "set max runtime in seconds", "limit" },
2764 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2765 "dump each input packet" },
2766 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2767 "when dumping packets, also dump the payload" },
2768 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2769 OPT_INPUT, { .off = OFFSET(rate_emu) },
2770 "read input at native frame rate", "" },
2771 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2772 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2773 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2774 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2775 "video sync method", "" },
2776 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2777 "audio sync method", "" },
2778 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2779 "audio drift threshold", "threshold" },
2780 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2781 "copy timestamps" },
2782 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2783 "copy input stream time base when stream copying", "mode" },
2784 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2785 OPT_OUTPUT, { .off = OFFSET(shortest) },
2786 "finish encoding within shortest input" },
2787 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2788 OPT_OUTPUT, { .off = OFFSET(apad) },
2790 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2791 "timestamp discontinuity delta threshold", "threshold" },
2792 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2793 "timestamp error delta threshold", "threshold" },
2794 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2795 "exit on error", "error" },
2796 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2797 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2798 "copy initial non-keyframes" },
2799 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2800 "copy or discard frames before start time" },
2801 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2802 "set the number of frames to record", "number" },
2803 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2804 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2805 "force codec tag/fourcc", "fourcc/tag" },
2806 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2807 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2808 "use fixed quality scale (VBR)", "q" },
2809 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2810 OPT_OUTPUT, { .func_arg = opt_qscale },
2811 "use fixed quality scale (VBR)", "q" },
2812 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2813 "set profile", "profile" },
2814 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2815 "set stream filtergraph", "filter_graph" },
2816 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2817 "read stream filtergraph description from a file", "filename" },
2818 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2819 "reinit filtergraph on input parameter changes", "" },
2820 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2821 "create a complex filtergraph", "graph_description" },
2822 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2823 "create a complex filtergraph", "graph_description" },
2824 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2825 "read complex filtergraph description from a file", "filename" },
2826 { "stats", OPT_BOOL, { &print_stats },
2827 "print progress report during encoding", },
2828 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2829 OPT_OUTPUT, { .func_arg = opt_attach },
2830 "add an attachment to the output file", "filename" },
2831 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2832 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2833 "extract an attachment into a file", "filename" },
2834 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2835 "print timestamp debugging info" },
2836 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2837 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2840 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2841 "set the number of video frames to record", "number" },
2842 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2843 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2844 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2845 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2846 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2847 "set frame size (WxH or abbreviation)", "size" },
2848 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2849 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2850 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2851 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2852 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2853 "set pixel format", "format" },
2854 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2855 "set the number of bits per raw sample", "number" },
2856 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2857 "deprecated use -g 1" },
2858 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2860 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2861 "discard threshold", "n" },
2862 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2863 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2864 "rate control override for specific intervals", "override" },
2865 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2866 OPT_OUTPUT, { .func_arg = opt_video_codec },
2867 "force video codec ('copy' to copy stream)", "codec" },
2868 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2870 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2872 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2873 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2874 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2875 "select the pass number (1 to 3)", "n" },
2876 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2877 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2878 "select two pass log file name prefix", "prefix" },
2879 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2880 "this option is deprecated, use the yadif filter instead" },
2881 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2882 "calculate PSNR of compressed frames" },
2883 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2884 "dump video coding statistics to file" },
2885 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2886 "dump video coding statistics to file", "file" },
2887 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2888 "set video filters", "filter_graph" },
2889 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2890 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2891 "specify intra matrix coeffs", "matrix" },
2892 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2893 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2894 "specify inter matrix coeffs", "matrix" },
2895 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2896 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2897 "specify intra matrix coeffs", "matrix" },
2898 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2899 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2900 "top=1/bottom=0/auto=-1 field first", "" },
2901 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2902 "intra_dc_precision", "precision" },
2903 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2904 OPT_OUTPUT, { .func_arg = opt_old2new },
2905 "force video tag/fourcc", "fourcc/tag" },
2906 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2907 "show QP histogram" },
2908 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2909 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2910 "force the selected framerate, disable the best supported framerate selection" },
2911 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2912 OPT_OUTPUT, { .func_arg = opt_streamid },
2913 "set the value of an outfile streamid", "streamIndex:value" },
2914 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2915 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2916 "force key frames at specified timestamps", "timestamps" },
2917 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2918 "video bitrate (please use -b:v)", "bitrate" },
2919 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2920 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2921 "use HW accelerated decoding", "hwaccel name" },
2922 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2923 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2924 "select a device for HW acceleration" "devicename" },
2927 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2928 "set the number of audio frames to record", "number" },
2929 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2930 "set audio quality (codec-specific)", "quality", },
2931 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2932 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2933 "set audio sampling rate (in Hz)", "rate" },
2934 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2935 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2936 "set number of audio channels", "channels" },
2937 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2939 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2940 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2941 "force audio codec ('copy' to copy stream)", "codec" },
2942 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2943 OPT_OUTPUT, { .func_arg = opt_old2new },
2944 "force audio tag/fourcc", "fourcc/tag" },
2945 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2946 "change audio volume (256=normal)" , "volume" },
2947 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2948 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2949 "set sample format", "format" },
2950 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2951 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2952 "set channel layout", "layout" },
2953 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2954 "set audio filters", "filter_graph" },
2955 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2956 "set the maximum number of channels to try to guess the channel layout" },
2958 /* subtitle options */
2959 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2960 "disable subtitle" },
2961 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2962 "force subtitle codec ('copy' to copy stream)", "codec" },
2963 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2964 , "force subtitle tag/fourcc", "fourcc/tag" },
2965 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2966 "fix subtitles duration" },
2967 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2968 "set canvas size (WxH or abbreviation)", "size" },
2971 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2972 "deprecated, use -channel", "channel" },
2973 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2974 "deprecated, use -standard", "standard" },
2975 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2978 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2979 "set the maximum demux-decode delay", "seconds" },
2980 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2981 "set the initial demux-decode delay", "seconds" },
2982 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2983 "override the options from ffserver", "" },
2985 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2986 "A comma-separated list of bitstream filters", "bitstream_filters" },
2987 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2988 "deprecated", "audio bitstream_filters" },
2989 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2990 "deprecated", "video bitstream_filters" },
2992 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2993 "set the audio options to the indicated preset", "preset" },
2994 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2995 "set the video options to the indicated preset", "preset" },
2996 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2997 "set the subtitle options to the indicated preset", "preset" },
2998 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2999 "set options from indicated preset file", "filename" },
3000 /* data codec support */
3001 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3002 "force data codec ('copy' to copy stream)", "codec" },
3003 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },