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;
1155 ost->last_mux_dts_plus_duration = AV_NOPTS_VALUE;
1160 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1163 const char *p = str;
1170 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1177 /* read file contents into a string */
1178 static uint8_t *read_file(const char *filename)
1180 AVIOContext *pb = NULL;
1181 AVIOContext *dyn_buf = NULL;
1182 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1183 uint8_t buf[1024], *str;
1186 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1190 ret = avio_open_dyn_buf(&dyn_buf);
1195 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1196 avio_write(dyn_buf, buf, ret);
1197 avio_w8(dyn_buf, 0);
1200 ret = avio_close_dyn_buf(dyn_buf, &str);
1206 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1209 AVStream *st = ost->st;
1211 if (ost->filters_script && ost->filters) {
1212 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1213 "output stream #%d:%d.\n", nb_output_files, st->index);
1217 if (ost->filters_script)
1218 return read_file(ost->filters_script);
1219 else if (ost->filters)
1220 return av_strdup(ost->filters);
1222 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1226 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1227 const OutputStream *ost, enum AVMediaType type)
1229 if (ost->filters_script || ost->filters) {
1230 av_log(NULL, AV_LOG_ERROR,
1231 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1232 "Filtering and streamcopy cannot be used together.\n",
1233 ost->filters ? "Filtergraph" : "Filtergraph script",
1234 ost->filters ? ost->filters : ost->filters_script,
1235 av_get_media_type_string(type), ost->file_index, ost->index);
1240 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1244 AVCodecContext *video_enc;
1245 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1247 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1249 video_enc = st->codec;
1251 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1252 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1253 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1257 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1258 if (frame_aspect_ratio) {
1260 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1261 q.num <= 0 || q.den <= 0) {
1262 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1265 ost->frame_aspect_ratio = q;
1268 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1269 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1271 if (!ost->stream_copy) {
1272 const char *p = NULL;
1273 char *frame_size = NULL;
1274 char *frame_pix_fmt = NULL;
1275 char *intra_matrix = NULL, *inter_matrix = NULL;
1276 char *chroma_intra_matrix = NULL;
1280 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1281 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1282 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1286 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1287 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1288 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1289 ost->keep_pix_fmt = 1;
1290 if (!*++frame_pix_fmt)
1291 frame_pix_fmt = NULL;
1293 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1294 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1297 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1300 video_enc->gop_size = 0;
1301 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1303 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1304 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1307 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1309 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1310 if (chroma_intra_matrix) {
1311 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1313 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1316 av_codec_set_chroma_intra_matrix(video_enc, p);
1317 parse_matrix_coeffs(p, chroma_intra_matrix);
1319 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1321 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1322 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1325 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1328 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1329 for (i = 0; p; i++) {
1331 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1333 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1336 /* FIXME realloc failure */
1337 video_enc->rc_override =
1338 av_realloc(video_enc->rc_override,
1339 sizeof(RcOverride) * (i + 1));
1340 video_enc->rc_override[i].start_frame = start;
1341 video_enc->rc_override[i].end_frame = end;
1343 video_enc->rc_override[i].qscale = q;
1344 video_enc->rc_override[i].quality_factor = 1.0;
1347 video_enc->rc_override[i].qscale = 0;
1348 video_enc->rc_override[i].quality_factor = -q/100.0;
1353 video_enc->rc_override_count = i;
1354 video_enc->intra_dc_precision = intra_dc_precision - 8;
1357 video_enc->flags|= CODEC_FLAG_PSNR;
1360 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1363 video_enc->flags |= CODEC_FLAG_PASS1;
1364 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1367 video_enc->flags |= CODEC_FLAG_PASS2;
1368 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1372 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1373 if (ost->logfile_prefix &&
1374 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1377 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1378 if (ost->forced_keyframes)
1379 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1381 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1383 ost->top_field_first = -1;
1384 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1387 ost->avfilter = get_ost_filters(o, oc, ost);
1391 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1394 if (ost->stream_copy)
1395 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1400 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1405 AVCodecContext *audio_enc;
1407 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1410 audio_enc = st->codec;
1411 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1413 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1414 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1416 if (!ost->stream_copy) {
1417 char *sample_fmt = NULL;
1419 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1421 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1423 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1424 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1428 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1430 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1431 ost->apad = av_strdup(ost->apad);
1433 ost->avfilter = get_ost_filters(o, oc, ost);
1437 /* check for channel mapping for this audio stream */
1438 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1439 AudioChannelMap *map = &o->audio_channel_maps[n];
1440 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1441 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1444 if (map->channel_idx == -1) {
1446 } else if (ost->source_index < 0) {
1447 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1448 ost->file_index, ost->st->index);
1451 ist = input_streams[ost->source_index];
1454 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1455 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1456 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1458 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1459 ost->file_index, ost->st->index);
1465 if (ost->stream_copy)
1466 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1471 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1475 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1476 if (!ost->stream_copy) {
1477 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1484 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1486 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1487 ost->stream_copy = 1;
1492 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1496 AVCodecContext *subtitle_enc;
1498 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1500 subtitle_enc = st->codec;
1502 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1504 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1506 if (!ost->stream_copy) {
1507 char *frame_size = NULL;
1509 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1510 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1511 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1519 /* arg format is "output-stream-index:streamid-value". */
1520 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1522 OptionsContext *o = optctx;
1527 av_strlcpy(idx_str, arg, sizeof(idx_str));
1528 p = strchr(idx_str, ':');
1530 av_log(NULL, AV_LOG_FATAL,
1531 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1536 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1537 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1538 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1542 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1544 AVFormatContext *is = ifile->ctx;
1545 AVFormatContext *os = ofile->ctx;
1549 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1551 return AVERROR(ENOMEM);
1554 for (i = 0; i < is->nb_chapters; i++) {
1555 AVChapter *in_ch = is->chapters[i], *out_ch;
1556 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1557 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1558 AV_TIME_BASE_Q, in_ch->time_base);
1559 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1560 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1563 if (in_ch->end < ts_off)
1565 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1568 out_ch = av_mallocz(sizeof(AVChapter));
1570 return AVERROR(ENOMEM);
1572 out_ch->id = in_ch->id;
1573 out_ch->time_base = in_ch->time_base;
1574 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1575 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1578 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1580 os->chapters[os->nb_chapters++] = out_ch;
1585 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1588 AVFormatContext *ic = avformat_alloc_context();
1590 ic->interrupt_callback = int_cb;
1591 err = avformat_open_input(&ic, filename, NULL, NULL);
1594 /* copy stream format */
1595 for(i=0;i<ic->nb_streams;i++) {
1599 AVCodecContext *avctx;
1601 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1602 ost = new_output_stream(o, s, codec->type, -1);
1607 // FIXME: a more elegant solution is needed
1608 memcpy(st, ic->streams[i], sizeof(AVStream));
1610 st->info = av_malloc(sizeof(*st->info));
1611 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1613 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1615 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1616 choose_sample_fmt(st, codec);
1617 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1618 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1621 avformat_close_input(&ic);
1625 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1626 AVFormatContext *oc)
1630 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1631 ofilter->out_tmp->pad_idx)) {
1632 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1633 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1635 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1640 ost->source_index = -1;
1641 ost->filter = ofilter;
1645 if (ost->stream_copy) {
1646 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1647 "which is fed from a complex filtergraph. Filtering and streamcopy "
1648 "cannot be used together.\n", ost->file_index, ost->index);
1652 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1653 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1654 av_log(NULL, AV_LOG_ERROR,
1655 "%s '%s' was specified through the %s option "
1656 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1657 "%s and -filter_complex cannot be used together for the same stream.\n",
1658 ost->filters ? "Filtergraph" : "Filtergraph script",
1659 ost->filters ? ost->filters : ost->filters_script,
1660 opt, ost->file_index, ost->index, opt);
1664 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1665 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1668 avfilter_inout_free(&ofilter->out_tmp);
1671 static int configure_complex_filters(void)
1675 for (i = 0; i < nb_filtergraphs; i++)
1676 if (!filtergraphs[i]->graph &&
1677 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1682 static int open_output_file(OptionsContext *o, const char *filename)
1684 AVFormatContext *oc;
1686 AVOutputFormat *file_oformat;
1690 AVDictionary *unused_opts = NULL;
1691 AVDictionaryEntry *e = NULL;
1693 if (configure_complex_filters() < 0) {
1694 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1698 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1699 o->stop_time = INT64_MAX;
1700 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1703 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1704 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1705 if (o->stop_time <= start_time) {
1706 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1707 o->stop_time = INT64_MAX;
1709 o->recording_time = o->stop_time - start_time;
1713 GROW_ARRAY(output_files, nb_output_files);
1714 of = av_mallocz(sizeof(*of));
1717 output_files[nb_output_files - 1] = of;
1719 of->ost_index = nb_output_streams;
1720 of->recording_time = o->recording_time;
1721 of->start_time = o->start_time;
1722 of->limit_filesize = o->limit_filesize;
1723 of->shortest = o->shortest;
1724 av_dict_copy(&of->opts, o->g->format_opts, 0);
1726 if (!strcmp(filename, "-"))
1729 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1731 print_error(filename, err);
1736 if (o->recording_time != INT64_MAX)
1737 oc->duration = o->recording_time;
1739 file_oformat= oc->oformat;
1740 oc->interrupt_callback = int_cb;
1742 /* create streams for all unlabeled output pads */
1743 for (i = 0; i < nb_filtergraphs; i++) {
1744 FilterGraph *fg = filtergraphs[i];
1745 for (j = 0; j < fg->nb_outputs; j++) {
1746 OutputFilter *ofilter = fg->outputs[j];
1748 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1751 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1752 ofilter->out_tmp->pad_idx)) {
1753 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1754 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1755 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1757 init_output_filter(ofilter, o, oc);
1761 /* ffserver seeking with date=... needs a date reference */
1762 if (!strcmp(file_oformat->name, "ffm") &&
1763 av_strstart(filename, "http:", NULL)) {
1764 int err = parse_option(o, "metadata", "creation_time=now", options);
1766 print_error(filename, err);
1771 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1772 av_strstart(filename, "http:", NULL)) {
1774 /* special case for files sent to ffserver: we get the stream
1775 parameters from ffserver */
1776 int err = read_ffserver_streams(o, oc, filename);
1778 print_error(filename, err);
1781 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1782 ost = output_streams[j];
1783 for (i = 0; i < nb_input_streams; i++) {
1784 ist = input_streams[i];
1785 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1787 ost->source_index= i;
1788 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1789 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1791 ist->st->discard = AVDISCARD_NONE;
1796 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));
1800 } else if (!o->nb_stream_maps) {
1801 char *subtitle_codec_name = NULL;
1802 /* pick the "best" stream of each type */
1804 /* video: highest resolution */
1805 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1806 int area = 0, idx = -1;
1807 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1808 for (i = 0; i < nb_input_streams; i++) {
1810 ist = input_streams[i];
1811 new_area = ist->st->codec->width * ist->st->codec->height;
1812 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1814 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1816 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1823 new_video_stream(o, oc, idx);
1826 /* audio: most channels */
1827 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1828 int channels = 0, idx = -1;
1829 for (i = 0; i < nb_input_streams; i++) {
1830 ist = input_streams[i];
1831 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1832 ist->st->codec->channels > channels) {
1833 channels = ist->st->codec->channels;
1838 new_audio_stream(o, oc, idx);
1841 /* subtitles: pick first */
1842 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1843 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1844 for (i = 0; i < nb_input_streams; i++)
1845 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1846 new_subtitle_stream(o, oc, i);
1850 /* do something with data? */
1852 for (i = 0; i < o->nb_stream_maps; i++) {
1853 StreamMap *map = &o->stream_maps[i];
1858 if (map->linklabel) {
1860 OutputFilter *ofilter = NULL;
1863 for (j = 0; j < nb_filtergraphs; j++) {
1864 fg = filtergraphs[j];
1865 for (k = 0; k < fg->nb_outputs; k++) {
1866 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1867 if (out && !strcmp(out->name, map->linklabel)) {
1868 ofilter = fg->outputs[k];
1875 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1876 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1879 init_output_filter(ofilter, o, oc);
1881 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1883 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1884 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1886 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1888 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1890 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1893 switch (ist->st->codec->codec_type) {
1894 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1895 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1896 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1897 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1898 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1900 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1901 map->file_index, map->stream_index);
1908 /* handle attached files */
1909 for (i = 0; i < o->nb_attachments; i++) {
1911 uint8_t *attachment;
1915 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1916 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1920 if ((len = avio_size(pb)) <= 0) {
1921 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1925 if (!(attachment = av_malloc(len))) {
1926 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1930 avio_read(pb, attachment, len);
1932 ost = new_attachment_stream(o, oc, -1);
1933 ost->stream_copy = 0;
1934 ost->attachment_filename = o->attachments[i];
1936 ost->st->codec->extradata = attachment;
1937 ost->st->codec->extradata_size = len;
1939 p = strrchr(o->attachments[i], '/');
1940 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1944 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1945 AVDictionaryEntry *e;
1946 ost = output_streams[i];
1948 if ((ost->stream_copy || ost->attachment_filename)
1949 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1950 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1951 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1955 /* check if all codec options have been used */
1956 unused_opts = strip_specifiers(o->g->codec_opts);
1957 for (i = of->ost_index; i < nb_output_streams; i++) {
1959 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1960 AV_DICT_IGNORE_SUFFIX)))
1961 av_dict_set(&unused_opts, e->key, NULL, 0);
1965 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1966 const AVClass *class = avcodec_get_class();
1967 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1968 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1971 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1972 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1973 "output file #%d (%s) is not an encoding option.\n", e->key,
1974 option->help ? option->help : "", nb_output_files - 1,
1979 // gop_timecode is injected by generic code but not always used
1980 if (!strcmp(e->key, "gop_timecode"))
1983 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1984 "output file #%d (%s) has not been used for any stream. The most "
1985 "likely reason is either wrong type (e.g. a video option with "
1986 "no video streams) or that it is a private option of some encoder "
1987 "which was not actually used for any stream.\n", e->key,
1988 option->help ? option->help : "", nb_output_files - 1, filename);
1990 av_dict_free(&unused_opts);
1992 /* check filename in case of an image number is expected */
1993 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1994 if (!av_filename_number_test(oc->filename)) {
1995 print_error(oc->filename, AVERROR(EINVAL));
2000 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2001 /* test if it already exists to avoid losing precious files */
2002 assert_file_overwrite(filename);
2005 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2006 &oc->interrupt_callback,
2008 print_error(filename, err);
2011 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2012 assert_file_overwrite(filename);
2014 if (o->mux_preload) {
2016 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
2017 av_dict_set(&of->opts, "preload", buf, 0);
2019 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2022 for (i = 0; i < o->nb_metadata_map; i++) {
2024 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2026 if (in_file_index >= nb_input_files) {
2027 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2030 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2031 in_file_index >= 0 ?
2032 input_files[in_file_index]->ctx : NULL, o);
2036 if (o->chapters_input_file >= nb_input_files) {
2037 if (o->chapters_input_file == INT_MAX) {
2038 /* copy chapters from the first input file that has them*/
2039 o->chapters_input_file = -1;
2040 for (i = 0; i < nb_input_files; i++)
2041 if (input_files[i]->ctx->nb_chapters) {
2042 o->chapters_input_file = i;
2046 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2047 o->chapters_input_file);
2051 if (o->chapters_input_file >= 0)
2052 copy_chapters(input_files[o->chapters_input_file], of,
2053 !o->metadata_chapters_manual);
2055 /* copy global metadata by default */
2056 if (!o->metadata_global_manual && nb_input_files){
2057 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2058 AV_DICT_DONT_OVERWRITE);
2059 if(o->recording_time != INT64_MAX)
2060 av_dict_set(&oc->metadata, "duration", NULL, 0);
2061 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2063 if (!o->metadata_streams_manual)
2064 for (i = of->ost_index; i < nb_output_streams; i++) {
2066 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2068 ist = input_streams[output_streams[i]->source_index];
2069 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2070 if (!output_streams[i]->stream_copy)
2071 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2074 /* process manually set metadata */
2075 for (i = 0; i < o->nb_metadata; i++) {
2078 const char *stream_spec;
2079 int index = 0, j, ret = 0;
2081 val = strchr(o->metadata[i].u.str, '=');
2083 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2084 o->metadata[i].u.str);
2089 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2091 for (j = 0; j < oc->nb_streams; j++) {
2092 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2093 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2104 if (index < 0 || index >= oc->nb_chapters) {
2105 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2108 m = &oc->chapters[index]->metadata;
2111 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2114 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2121 static int opt_target(void *optctx, const char *opt, const char *arg)
2123 OptionsContext *o = optctx;
2124 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2125 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2127 if (!strncmp(arg, "pal-", 4)) {
2130 } else if (!strncmp(arg, "ntsc-", 5)) {
2133 } else if (!strncmp(arg, "film-", 5)) {
2137 /* Try to determine PAL/NTSC by peeking in the input files */
2138 if (nb_input_files) {
2140 for (j = 0; j < nb_input_files; j++) {
2141 for (i = 0; i < input_files[j]->nb_streams; i++) {
2142 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2143 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2145 fr = c->time_base.den * 1000 / c->time_base.num;
2149 } else if ((fr == 29970) || (fr == 23976)) {
2154 if (norm != UNKNOWN)
2158 if (norm != UNKNOWN)
2159 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2162 if (norm == UNKNOWN) {
2163 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2164 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2165 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2169 if (!strcmp(arg, "vcd")) {
2170 opt_video_codec(o, "c:v", "mpeg1video");
2171 opt_audio_codec(o, "c:a", "mp2");
2172 parse_option(o, "f", "vcd", options);
2174 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2175 parse_option(o, "r", frame_rates[norm], options);
2176 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2178 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2179 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2180 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2181 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2183 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2184 parse_option(o, "ar", "44100", options);
2185 parse_option(o, "ac", "2", options);
2187 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2188 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2190 /* We have to offset the PTS, so that it is consistent with the SCR.
2191 SCR starts at 36000, but the first two packs contain only padding
2192 and the first pack from the other stream, respectively, may also have
2193 been written before.
2194 So the real data starts at SCR 36000+3*1200. */
2195 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2196 } else if (!strcmp(arg, "svcd")) {
2198 opt_video_codec(o, "c:v", "mpeg2video");
2199 opt_audio_codec(o, "c:a", "mp2");
2200 parse_option(o, "f", "svcd", options);
2202 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2203 parse_option(o, "r", frame_rates[norm], options);
2204 parse_option(o, "pix_fmt", "yuv420p", options);
2205 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2207 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2208 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2209 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2210 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2211 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2213 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2214 parse_option(o, "ar", "44100", options);
2216 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2218 } else if (!strcmp(arg, "dvd")) {
2220 opt_video_codec(o, "c:v", "mpeg2video");
2221 opt_audio_codec(o, "c:a", "ac3");
2222 parse_option(o, "f", "dvd", options);
2224 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2225 parse_option(o, "r", frame_rates[norm], options);
2226 parse_option(o, "pix_fmt", "yuv420p", options);
2227 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2229 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2230 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2231 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2232 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2234 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.
2235 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2237 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2238 parse_option(o, "ar", "48000", options);
2240 } else if (!strncmp(arg, "dv", 2)) {
2242 parse_option(o, "f", "dv", options);
2244 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2245 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2246 norm == PAL ? "yuv420p" : "yuv411p", options);
2247 parse_option(o, "r", frame_rates[norm], options);
2249 parse_option(o, "ar", "48000", options);
2250 parse_option(o, "ac", "2", options);
2253 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2254 return AVERROR(EINVAL);
2259 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2261 av_free (vstats_filename);
2262 vstats_filename = av_strdup (arg);
2266 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2269 time_t today2 = time(NULL);
2270 struct tm *today = localtime(&today2);
2272 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2274 return opt_vstats_file(NULL, opt, filename);
2277 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2279 OptionsContext *o = optctx;
2280 return parse_option(o, "frames:v", arg, options);
2283 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2285 OptionsContext *o = optctx;
2286 return parse_option(o, "frames:a", arg, options);
2289 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2291 OptionsContext *o = optctx;
2292 return parse_option(o, "frames:d", arg, options);
2295 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2298 AVDictionary *cbak = codec_opts;
2299 AVDictionary *fbak = format_opts;
2303 ret = opt_default(NULL, opt, arg);
2305 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2306 av_dict_copy(&o->g->format_opts, format_opts, 0);
2307 av_dict_free(&codec_opts);
2308 av_dict_free(&format_opts);
2315 static int opt_preset(void *optctx, const char *opt, const char *arg)
2317 OptionsContext *o = optctx;
2319 char filename[1000], line[1000], tmp_line[1000];
2320 const char *codec_name = NULL;
2324 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2326 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2327 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2328 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2330 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2334 while (fgets(line, sizeof(line), f)) {
2335 char *key = tmp_line, *value, *endptr;
2337 if (strcspn(line, "#\n\r") == 0)
2339 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2340 if (!av_strtok(key, "=", &value) ||
2341 !av_strtok(value, "\r\n", &endptr)) {
2342 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2345 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2347 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2348 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2349 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2350 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2351 else if (opt_default_new(o, key, value) < 0) {
2352 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2353 filename, line, key, value);
2363 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2365 OptionsContext *o = optctx;
2366 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2367 int ret = parse_option(o, s, arg, options);
2372 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2374 OptionsContext *o = optctx;
2375 if(!strcmp(opt, "b")){
2376 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2377 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2380 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2384 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2386 OptionsContext *o = optctx;
2389 if(!strcmp(opt, "qscale")){
2390 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2391 return parse_option(o, "q:v", arg, options);
2393 s = av_asprintf("q%s", opt + 6);
2394 ret = parse_option(o, s, arg, options);
2399 static int opt_profile(void *optctx, const char *opt, const char *arg)
2401 OptionsContext *o = optctx;
2402 if(!strcmp(opt, "profile")){
2403 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2404 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2407 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2411 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2413 OptionsContext *o = optctx;
2414 return parse_option(o, "filter:v", arg, options);
2417 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2419 OptionsContext *o = optctx;
2420 return parse_option(o, "filter:a", arg, options);
2423 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2425 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2426 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2427 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2428 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2430 if (video_sync_method == VSYNC_AUTO)
2431 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2435 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2437 OptionsContext *o = optctx;
2438 char *tcr = av_asprintf("timecode=%s", arg);
2439 int ret = parse_option(o, "metadata:g", tcr, options);
2441 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2446 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2448 OptionsContext *o = optctx;
2449 char layout_str[32];
2452 int ret, channels, ac_str_size;
2455 layout = av_get_channel_layout(arg);
2457 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2458 return AVERROR(EINVAL);
2460 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2461 ret = opt_default_new(o, opt, layout_str);
2465 /* set 'ac' option based on channel layout */
2466 channels = av_get_channel_layout_nb_channels(layout);
2467 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2468 stream_str = strchr(opt, ':');
2469 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2470 ac_str = av_mallocz(ac_str_size);
2472 return AVERROR(ENOMEM);
2473 av_strlcpy(ac_str, "ac", 3);
2475 av_strlcat(ac_str, stream_str, ac_str_size);
2476 ret = parse_option(o, ac_str, layout_str, options);
2482 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2484 OptionsContext *o = optctx;
2485 return parse_option(o, "q:a", arg, options);
2488 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2490 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2491 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2492 return AVERROR(ENOMEM);
2493 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2494 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2495 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2496 return AVERROR(ENOMEM);
2500 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2502 uint8_t *graph_desc = read_file(arg);
2504 return AVERROR(EINVAL);
2506 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2507 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2508 return AVERROR(ENOMEM);
2509 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2510 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2514 void show_help_default(const char *opt, const char *arg)
2516 /* per-file options have at least one of those set */
2517 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2518 int show_advanced = 0, show_avoptions = 0;
2521 if (!strcmp(opt, "long"))
2523 else if (!strcmp(opt, "full"))
2524 show_advanced = show_avoptions = 1;
2526 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2531 printf("Getting help:\n"
2532 " -h -- print basic options\n"
2533 " -h long -- print more options\n"
2534 " -h full -- print all options (including all format and codec specific options, very long)\n"
2535 " See man %s for detailed description of the options.\n"
2536 "\n", program_name);
2538 show_help_options(options, "Print help / information / capabilities:",
2541 show_help_options(options, "Global options (affect whole program "
2542 "instead of just one file:",
2543 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2545 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2546 per_file | OPT_EXIT, 0);
2548 show_help_options(options, "Per-file main options:", 0,
2549 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2550 OPT_EXIT, per_file);
2552 show_help_options(options, "Advanced per-file options:",
2553 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2555 show_help_options(options, "Video options:",
2556 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2558 show_help_options(options, "Advanced Video options:",
2559 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2561 show_help_options(options, "Audio options:",
2562 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2564 show_help_options(options, "Advanced Audio options:",
2565 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2566 show_help_options(options, "Subtitle options:",
2567 OPT_SUBTITLE, 0, 0);
2570 if (show_avoptions) {
2571 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2572 show_help_children(avcodec_get_class(), flags);
2573 show_help_children(avformat_get_class(), flags);
2575 show_help_children(sws_get_class(), flags);
2577 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2578 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2582 void show_usage(void)
2584 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2585 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2586 av_log(NULL, AV_LOG_INFO, "\n");
2594 static const OptionGroupDef groups[] = {
2595 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2596 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2599 static int open_files(OptionGroupList *l, const char *inout,
2600 int (*open_file)(OptionsContext*, const char*))
2604 for (i = 0; i < l->nb_groups; i++) {
2605 OptionGroup *g = &l->groups[i];
2611 ret = parse_optgroup(&o, g);
2613 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2614 "%s.\n", inout, g->arg);
2618 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2619 ret = open_file(&o, g->arg);
2622 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2626 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2632 int ffmpeg_parse_options(int argc, char **argv)
2634 OptionParseContext octx;
2638 memset(&octx, 0, sizeof(octx));
2640 /* split the commandline into an internal representation */
2641 ret = split_commandline(&octx, argc, argv, options, groups,
2642 FF_ARRAY_ELEMS(groups));
2644 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2648 /* apply global options */
2649 ret = parse_optgroup(NULL, &octx.global_opts);
2651 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2655 /* open input files */
2656 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2658 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2662 /* open output files */
2663 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2665 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2670 uninit_parse_context(&octx);
2672 av_strerror(ret, error, sizeof(error));
2673 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2678 static int opt_progress(void *optctx, const char *opt, const char *arg)
2680 AVIOContext *avio = NULL;
2683 if (!strcmp(arg, "-"))
2685 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2687 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2688 arg, av_err2str(ret));
2691 progress_avio = avio;
2695 #define OFFSET(x) offsetof(OptionsContext, x)
2696 const OptionDef options[] = {
2698 #include "cmdutils_common_opts.h"
2699 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2700 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2701 "force format", "fmt" },
2702 { "y", OPT_BOOL, { &file_overwrite },
2703 "overwrite output files" },
2704 { "n", OPT_BOOL, { &no_file_overwrite },
2705 "never overwrite output files" },
2706 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2707 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2708 "codec name", "codec" },
2709 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2710 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2711 "codec name", "codec" },
2712 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2713 OPT_OUTPUT, { .off = OFFSET(presets) },
2714 "preset name", "preset" },
2715 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2716 OPT_OUTPUT, { .func_arg = opt_map },
2717 "set input stream mapping",
2718 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2719 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2720 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2721 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2722 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2723 "set metadata information of outfile from infile",
2724 "outfile[,metadata]:infile[,metadata]" },
2725 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2726 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2727 "set chapters mapping", "input_file_index" },
2728 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2729 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2730 "record or transcode \"duration\" seconds of audio/video",
2732 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2733 "record or transcode stop time", "time_stop" },
2734 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2735 "set the limit file size in bytes", "limit_size" },
2736 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2737 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2738 "set the start time offset", "time_off" },
2739 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2740 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2741 "enable/disable accurate seeking with -ss" },
2742 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2743 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2744 "set the input ts offset", "time_off" },
2745 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2746 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2747 "set the input ts scale", "scale" },
2748 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2749 "set the recording timestamp ('now' to set the current time)", "time" },
2750 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2751 "add metadata", "string=string" },
2752 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2753 OPT_OUTPUT, { .func_arg = opt_data_frames },
2754 "set the number of data frames to record", "number" },
2755 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2756 "add timings for benchmarking" },
2757 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2758 "add timings for each task" },
2759 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2760 "write program-readable progress information", "url" },
2761 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2762 "enable or disable interaction on standard input" },
2763 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2764 "set max runtime in seconds", "limit" },
2765 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2766 "dump each input packet" },
2767 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2768 "when dumping packets, also dump the payload" },
2769 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2770 OPT_INPUT, { .off = OFFSET(rate_emu) },
2771 "read input at native frame rate", "" },
2772 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2773 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2774 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2775 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2776 "video sync method", "" },
2777 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2778 "audio sync method", "" },
2779 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2780 "audio drift threshold", "threshold" },
2781 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2782 "copy timestamps" },
2783 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2784 "copy input stream time base when stream copying", "mode" },
2785 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2786 OPT_OUTPUT, { .off = OFFSET(shortest) },
2787 "finish encoding within shortest input" },
2788 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2789 OPT_OUTPUT, { .off = OFFSET(apad) },
2791 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2792 "timestamp discontinuity delta threshold", "threshold" },
2793 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2794 "timestamp error delta threshold", "threshold" },
2795 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2796 "exit on error", "error" },
2797 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2798 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2799 "copy initial non-keyframes" },
2800 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2801 "copy or discard frames before start time" },
2802 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2803 "set the number of frames to record", "number" },
2804 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2805 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2806 "force codec tag/fourcc", "fourcc/tag" },
2807 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2808 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2809 "use fixed quality scale (VBR)", "q" },
2810 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2811 OPT_OUTPUT, { .func_arg = opt_qscale },
2812 "use fixed quality scale (VBR)", "q" },
2813 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2814 "set profile", "profile" },
2815 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2816 "set stream filtergraph", "filter_graph" },
2817 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2818 "read stream filtergraph description from a file", "filename" },
2819 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2820 "reinit filtergraph on input parameter changes", "" },
2821 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2822 "create a complex filtergraph", "graph_description" },
2823 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2824 "create a complex filtergraph", "graph_description" },
2825 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2826 "read complex filtergraph description from a file", "filename" },
2827 { "stats", OPT_BOOL, { &print_stats },
2828 "print progress report during encoding", },
2829 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2830 OPT_OUTPUT, { .func_arg = opt_attach },
2831 "add an attachment to the output file", "filename" },
2832 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2833 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2834 "extract an attachment into a file", "filename" },
2835 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2836 "print timestamp debugging info" },
2837 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2838 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2841 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2842 "set the number of video frames to record", "number" },
2843 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2844 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2845 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2846 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2847 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2848 "set frame size (WxH or abbreviation)", "size" },
2849 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2850 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2851 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2852 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2853 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2854 "set pixel format", "format" },
2855 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2856 "set the number of bits per raw sample", "number" },
2857 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2858 "deprecated use -g 1" },
2859 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2861 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2862 "discard threshold", "n" },
2863 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2864 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2865 "rate control override for specific intervals", "override" },
2866 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2867 OPT_OUTPUT, { .func_arg = opt_video_codec },
2868 "force video codec ('copy' to copy stream)", "codec" },
2869 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2871 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2873 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2874 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2875 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2876 "select the pass number (1 to 3)", "n" },
2877 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2878 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2879 "select two pass log file name prefix", "prefix" },
2880 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2881 "this option is deprecated, use the yadif filter instead" },
2882 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2883 "calculate PSNR of compressed frames" },
2884 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2885 "dump video coding statistics to file" },
2886 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2887 "dump video coding statistics to file", "file" },
2888 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2889 "set video filters", "filter_graph" },
2890 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2891 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2892 "specify intra matrix coeffs", "matrix" },
2893 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2894 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2895 "specify inter matrix coeffs", "matrix" },
2896 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2897 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2898 "specify intra matrix coeffs", "matrix" },
2899 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2900 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2901 "top=1/bottom=0/auto=-1 field first", "" },
2902 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2903 "intra_dc_precision", "precision" },
2904 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2905 OPT_OUTPUT, { .func_arg = opt_old2new },
2906 "force video tag/fourcc", "fourcc/tag" },
2907 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2908 "show QP histogram" },
2909 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2910 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2911 "force the selected framerate, disable the best supported framerate selection" },
2912 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2913 OPT_OUTPUT, { .func_arg = opt_streamid },
2914 "set the value of an outfile streamid", "streamIndex:value" },
2915 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2916 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2917 "force key frames at specified timestamps", "timestamps" },
2918 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2919 "video bitrate (please use -b:v)", "bitrate" },
2920 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2921 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2922 "use HW accelerated decoding", "hwaccel name" },
2923 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2924 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2925 "select a device for HW acceleration" "devicename" },
2928 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2929 "set the number of audio frames to record", "number" },
2930 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2931 "set audio quality (codec-specific)", "quality", },
2932 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2933 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2934 "set audio sampling rate (in Hz)", "rate" },
2935 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2936 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2937 "set number of audio channels", "channels" },
2938 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2940 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2941 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2942 "force audio codec ('copy' to copy stream)", "codec" },
2943 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2944 OPT_OUTPUT, { .func_arg = opt_old2new },
2945 "force audio tag/fourcc", "fourcc/tag" },
2946 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2947 "change audio volume (256=normal)" , "volume" },
2948 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2949 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2950 "set sample format", "format" },
2951 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2952 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2953 "set channel layout", "layout" },
2954 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2955 "set audio filters", "filter_graph" },
2956 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2957 "set the maximum number of channels to try to guess the channel layout" },
2959 /* subtitle options */
2960 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2961 "disable subtitle" },
2962 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2963 "force subtitle codec ('copy' to copy stream)", "codec" },
2964 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2965 , "force subtitle tag/fourcc", "fourcc/tag" },
2966 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2967 "fix subtitles duration" },
2968 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2969 "set canvas size (WxH or abbreviation)", "size" },
2972 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2973 "deprecated, use -channel", "channel" },
2974 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2975 "deprecated, use -standard", "standard" },
2976 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2979 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2980 "set the maximum demux-decode delay", "seconds" },
2981 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2982 "set the initial demux-decode delay", "seconds" },
2983 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2984 "override the options from ffserver", "" },
2986 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2987 "A comma-separated list of bitstream filters", "bitstream_filters" },
2988 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2989 "deprecated", "audio bitstream_filters" },
2990 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2991 "deprecated", "video bitstream_filters" },
2993 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2994 "set the audio options to the indicated preset", "preset" },
2995 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2996 "set the video options to the indicated preset", "preset" },
2997 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2998 "set the subtitle options to the indicated preset", "preset" },
2999 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3000 "set options from indicated preset file", "filename" },
3001 /* data codec support */
3002 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3003 "force data codec ('copy' to copy stream)", "codec" },
3004 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },