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