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 do_psnr = 0;
108 static int input_sync;
109 static int override_ffserver = 0;
111 static void uninit_options(OptionsContext *o)
113 const OptionDef *po = options;
116 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
118 void *dst = (uint8_t*)o + po->u.off;
120 if (po->flags & OPT_SPEC) {
121 SpecifierOpt **so = dst;
122 int i, *count = (int*)(so + 1);
123 for (i = 0; i < *count; i++) {
124 av_freep(&(*so)[i].specifier);
125 if (po->flags & OPT_STRING)
126 av_freep(&(*so)[i].u.str);
130 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
135 for (i = 0; i < o->nb_stream_maps; i++)
136 av_freep(&o->stream_maps[i].linklabel);
137 av_freep(&o->stream_maps);
138 av_freep(&o->audio_channel_maps);
139 av_freep(&o->streamid_map);
140 av_freep(&o->attachments);
143 static void init_options(OptionsContext *o)
145 memset(o, 0, sizeof(*o));
147 o->stop_time = INT64_MAX;
148 o->mux_max_delay = 0.7;
149 o->start_time = AV_NOPTS_VALUE;
150 o->recording_time = INT64_MAX;
151 o->limit_filesize = UINT64_MAX;
152 o->chapters_input_file = INT_MAX;
153 o->accurate_seek = 1;
156 /* return a copy of the input with the stream specifiers removed from the keys */
157 static AVDictionary *strip_specifiers(AVDictionary *dict)
159 AVDictionaryEntry *e = NULL;
160 AVDictionary *ret = NULL;
162 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
163 char *p = strchr(e->key, ':');
167 av_dict_set(&ret, e->key, e->value, 0);
174 static int opt_sameq(void *optctx, const char *opt, const char *arg)
176 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
177 "If you are looking for an option to preserve the quality (which is not "
178 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
180 return AVERROR(EINVAL);
183 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
185 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
186 return opt_default(optctx, "channel", arg);
189 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
191 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
192 return opt_default(optctx, "standard", arg);
195 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
197 OptionsContext *o = optctx;
198 return parse_option(o, "codec:a", arg, options);
201 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
203 OptionsContext *o = optctx;
204 return parse_option(o, "codec:v", arg, options);
207 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
209 OptionsContext *o = optctx;
210 return parse_option(o, "codec:s", arg, options);
213 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
215 OptionsContext *o = optctx;
216 return parse_option(o, "codec:d", arg, options);
219 static int opt_map(void *optctx, const char *opt, const char *arg)
221 OptionsContext *o = optctx;
223 int i, negative = 0, file_idx;
224 int sync_file_idx = -1, sync_stream_idx = 0;
232 map = av_strdup(arg);
234 /* parse sync stream first, just pick first matching stream */
235 if (sync = strchr(map, ',')) {
237 sync_file_idx = strtol(sync + 1, &sync, 0);
238 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
239 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
244 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
245 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
246 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
250 if (i == input_files[sync_file_idx]->nb_streams) {
251 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
252 "match any streams.\n", arg);
259 /* this mapping refers to lavfi output */
260 const char *c = map + 1;
261 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
262 m = &o->stream_maps[o->nb_stream_maps - 1];
263 m->linklabel = av_get_token(&c, "]");
265 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
269 file_idx = strtol(map, &p, 0);
270 if (file_idx >= nb_input_files || file_idx < 0) {
271 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
275 /* disable some already defined maps */
276 for (i = 0; i < o->nb_stream_maps; i++) {
277 m = &o->stream_maps[i];
278 if (file_idx == m->file_index &&
279 check_stream_specifier(input_files[m->file_index]->ctx,
280 input_files[m->file_index]->ctx->streams[m->stream_index],
281 *p == ':' ? p + 1 : p) > 0)
285 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
286 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
287 *p == ':' ? p + 1 : p) <= 0)
289 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
290 m = &o->stream_maps[o->nb_stream_maps - 1];
292 m->file_index = file_idx;
295 if (sync_file_idx >= 0) {
296 m->sync_file_index = sync_file_idx;
297 m->sync_stream_index = sync_stream_idx;
299 m->sync_file_index = file_idx;
300 m->sync_stream_index = i;
306 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
314 static int opt_attach(void *optctx, const char *opt, const char *arg)
316 OptionsContext *o = optctx;
317 GROW_ARRAY(o->attachments, o->nb_attachments);
318 o->attachments[o->nb_attachments - 1] = arg;
322 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
324 OptionsContext *o = optctx;
329 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
330 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
332 /* muted channel syntax */
333 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
334 if ((n == 1 || n == 3) && m->channel_idx == -1) {
335 m->file_idx = m->stream_idx = -1;
337 m->ofile_idx = m->ostream_idx = -1;
342 n = sscanf(arg, "%d.%d.%d:%d.%d",
343 &m->file_idx, &m->stream_idx, &m->channel_idx,
344 &m->ofile_idx, &m->ostream_idx);
346 if (n != 3 && n != 5) {
347 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
348 "[file.stream.channel|-1][:syncfile:syncstream]\n");
352 if (n != 5) // only file.stream.channel specified
353 m->ofile_idx = m->ostream_idx = -1;
356 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
357 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
361 if (m->stream_idx < 0 ||
362 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
363 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
364 m->file_idx, m->stream_idx);
367 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
368 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
369 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
370 m->file_idx, m->stream_idx);
373 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
374 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
375 m->file_idx, m->stream_idx, m->channel_idx);
382 * Parse a metadata specifier passed as 'arg' parameter.
383 * @param arg metadata string to parse
384 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
385 * @param index for type c/p, chapter/program index is written here
386 * @param stream_spec for type s, the stream specifier is written here
388 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
396 if (*(++arg) && *arg != ':') {
397 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
400 *stream_spec = *arg == ':' ? arg + 1 : "";
405 *index = strtol(++arg, NULL, 0);
408 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
415 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
417 AVDictionary **meta_in = NULL;
418 AVDictionary **meta_out = NULL;
420 char type_in, type_out;
421 const char *istream_spec = NULL, *ostream_spec = NULL;
422 int idx_in = 0, idx_out = 0;
424 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
425 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
428 if (type_out == 'g' || !*outspec)
429 o->metadata_global_manual = 1;
430 if (type_out == 's' || !*outspec)
431 o->metadata_streams_manual = 1;
432 if (type_out == 'c' || !*outspec)
433 o->metadata_chapters_manual = 1;
437 if (type_in == 'g' || type_out == 'g')
438 o->metadata_global_manual = 1;
439 if (type_in == 's' || type_out == 's')
440 o->metadata_streams_manual = 1;
441 if (type_in == 'c' || type_out == 'c')
442 o->metadata_chapters_manual = 1;
444 /* ic is NULL when just disabling automatic mappings */
448 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
449 if ((index) < 0 || (index) >= (nb_elems)) {\
450 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
455 #define SET_DICT(type, meta, context, index)\
458 meta = &context->metadata;\
461 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
462 meta = &context->chapters[index]->metadata;\
465 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
466 meta = &context->programs[index]->metadata;\
469 break; /* handled separately below */ \
470 default: av_assert0(0);\
473 SET_DICT(type_in, meta_in, ic, idx_in);
474 SET_DICT(type_out, meta_out, oc, idx_out);
476 /* for input streams choose first matching stream */
477 if (type_in == 's') {
478 for (i = 0; i < ic->nb_streams; i++) {
479 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
480 meta_in = &ic->streams[i]->metadata;
486 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
491 if (type_out == 's') {
492 for (i = 0; i < oc->nb_streams; i++) {
493 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
494 meta_out = &oc->streams[i]->metadata;
495 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
500 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
505 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
507 OptionsContext *o = optctx;
509 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
510 struct tm time = *gmtime((time_t*)&recording_timestamp);
511 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
512 parse_option(o, "metadata", buf, options);
514 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
515 "tag instead.\n", opt);
519 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
521 const AVCodecDescriptor *desc;
522 const char *codec_string = encoder ? "encoder" : "decoder";
526 avcodec_find_encoder_by_name(name) :
527 avcodec_find_decoder_by_name(name);
529 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
530 codec = encoder ? avcodec_find_encoder(desc->id) :
531 avcodec_find_decoder(desc->id);
533 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
534 codec_string, codec->name, desc->name);
538 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
541 if (codec->type != type) {
542 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
548 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
550 char *codec_name = NULL;
552 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
554 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
555 st->codec->codec_id = codec->id;
558 return avcodec_find_decoder(st->codec->codec_id);
561 /* Add all the streams from the given input file to the global
562 * list of input streams. */
563 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
567 for (i = 0; i < ic->nb_streams; i++) {
568 AVStream *st = ic->streams[i];
569 AVCodecContext *dec = st->codec;
570 InputStream *ist = av_mallocz(sizeof(*ist));
571 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
572 char *codec_tag = NULL;
574 char *discard_str = NULL;
575 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
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 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
606 ist->user_set_discard = AVDISCARD_NONE;
607 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
608 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
613 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
615 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
617 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
621 ret = avcodec_copy_context(ist->dec_ctx, dec);
623 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
627 switch (dec->codec_type) {
628 case AVMEDIA_TYPE_VIDEO:
630 ist->dec = avcodec_find_decoder(dec->codec_id);
631 if (av_codec_get_lowres(dec)) {
632 dec->flags |= CODEC_FLAG_EMU_EDGE;
635 ist->resample_height = ist->dec_ctx->height;
636 ist->resample_width = ist->dec_ctx->width;
637 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
639 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
640 if (framerate && av_parse_video_rate(&ist->framerate,
642 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
647 ist->top_field_first = -1;
648 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
650 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
652 if (!strcmp(hwaccel, "none"))
653 ist->hwaccel_id = HWACCEL_NONE;
654 else if (!strcmp(hwaccel, "auto"))
655 ist->hwaccel_id = HWACCEL_AUTO;
658 for (i = 0; hwaccels[i].name; i++) {
659 if (!strcmp(hwaccels[i].name, hwaccel)) {
660 ist->hwaccel_id = hwaccels[i].id;
665 if (!ist->hwaccel_id) {
666 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
668 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
669 for (i = 0; hwaccels[i].name; i++)
670 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
671 av_log(NULL, AV_LOG_FATAL, "\n");
677 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
678 if (hwaccel_device) {
679 ist->hwaccel_device = av_strdup(hwaccel_device);
680 if (!ist->hwaccel_device)
683 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
686 case AVMEDIA_TYPE_AUDIO:
687 ist->guess_layout_max = INT_MAX;
688 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
689 guess_input_channel_layout(ist);
691 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
692 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
693 ist->resample_channels = ist->dec_ctx->channels;
694 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
697 case AVMEDIA_TYPE_DATA:
698 case AVMEDIA_TYPE_SUBTITLE: {
699 char *canvas_size = NULL;
701 ist->dec = avcodec_find_decoder(dec->codec_id);
702 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
703 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
705 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
706 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
711 case AVMEDIA_TYPE_ATTACHMENT:
712 case AVMEDIA_TYPE_UNKNOWN:
720 static void assert_file_overwrite(const char *filename)
722 if (file_overwrite && no_file_overwrite) {
723 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
727 if (!file_overwrite) {
728 const char *proto_name = avio_find_protocol_name(filename);
729 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
730 if (stdin_interaction && !no_file_overwrite) {
731 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
734 signal(SIGINT, SIG_DFL);
736 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
742 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
749 static void dump_attachment(AVStream *st, const char *filename)
752 AVIOContext *out = NULL;
753 AVDictionaryEntry *e;
755 if (!st->codec->extradata_size) {
756 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
757 nb_input_files - 1, st->index);
760 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
763 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
764 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
768 assert_file_overwrite(filename);
770 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
771 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
776 avio_write(out, st->codec->extradata, st->codec->extradata_size);
781 static int open_input_file(OptionsContext *o, const char *filename)
785 AVInputFormat *file_iformat = NULL;
789 AVDictionary *unused_opts = NULL;
790 AVDictionaryEntry *e = NULL;
791 int orig_nb_streams; // number of streams before avformat_find_stream_info
792 char * video_codec_name = NULL;
793 char * audio_codec_name = NULL;
794 char *subtitle_codec_name = NULL;
797 if (!(file_iformat = av_find_input_format(o->format))) {
798 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
803 if (!strcmp(filename, "-"))
806 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
807 strcmp(filename, "/dev/stdin");
809 /* get default parameters from command line */
810 ic = avformat_alloc_context();
812 print_error(filename, AVERROR(ENOMEM));
815 if (o->nb_audio_sample_rate) {
816 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
818 if (o->nb_audio_channels) {
819 /* because we set audio_channels based on both the "ac" and
820 * "channel_layout" options, we need to check that the specified
821 * demuxer actually has the "channels" option before setting it */
822 if (file_iformat && file_iformat->priv_class &&
823 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
824 AV_OPT_SEARCH_FAKE_OBJ)) {
825 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
828 if (o->nb_frame_rates) {
829 /* set the format-level framerate option;
830 * this is important for video grabbers, e.g. x11 */
831 if (file_iformat && file_iformat->priv_class &&
832 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
833 AV_OPT_SEARCH_FAKE_OBJ)) {
834 av_dict_set(&o->g->format_opts, "framerate",
835 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
838 if (o->nb_frame_sizes) {
839 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
841 if (o->nb_frame_pix_fmts)
842 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
844 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
845 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
846 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
848 ic->video_codec_id = video_codec_name ?
849 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
850 ic->audio_codec_id = audio_codec_name ?
851 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
852 ic->subtitle_codec_id= subtitle_codec_name ?
853 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
855 if (video_codec_name)
856 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
857 if (audio_codec_name)
858 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
859 if (subtitle_codec_name)
860 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
862 ic->flags |= AVFMT_FLAG_NONBLOCK;
863 ic->interrupt_callback = int_cb;
865 /* open the input file with generic avformat function */
866 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
868 print_error(filename, err);
871 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
872 assert_avoptions(o->g->format_opts);
874 /* apply forced codec ids */
875 for (i = 0; i < ic->nb_streams; i++)
876 choose_decoder(o, ic, ic->streams[i]);
878 /* Set AVCodecContext options for avformat_find_stream_info */
879 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
880 orig_nb_streams = ic->nb_streams;
882 /* If not enough info to get the stream parameters, we decode the
883 first frames to get it. (used in mpeg case for example) */
884 ret = avformat_find_stream_info(ic, opts);
886 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
887 if (ic->nb_streams == 0) {
888 avformat_close_input(&ic);
893 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
894 /* add the stream start time */
895 if (ic->start_time != AV_NOPTS_VALUE)
896 timestamp += ic->start_time;
898 /* if seeking requested, we execute it */
899 if (o->start_time != AV_NOPTS_VALUE) {
900 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
902 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
903 filename, (double)timestamp / AV_TIME_BASE);
907 /* update the current parameters so that they match the one of the input stream */
908 add_input_streams(o, ic);
910 /* dump the file content */
911 av_dump_format(ic, nb_input_files, filename, 0);
913 GROW_ARRAY(input_files, nb_input_files);
914 f = av_mallocz(sizeof(*f));
917 input_files[nb_input_files - 1] = f;
920 f->ist_index = nb_input_streams - ic->nb_streams;
921 f->start_time = o->start_time;
922 f->recording_time = o->recording_time;
923 f->input_ts_offset = o->input_ts_offset;
924 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
925 f->nb_streams = ic->nb_streams;
926 f->rate_emu = o->rate_emu;
927 f->accurate_seek = o->accurate_seek;
929 /* check if all codec options have been used */
930 unused_opts = strip_specifiers(o->g->codec_opts);
931 for (i = f->ist_index; i < nb_input_streams; i++) {
933 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
934 AV_DICT_IGNORE_SUFFIX)))
935 av_dict_set(&unused_opts, e->key, NULL, 0);
939 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
940 const AVClass *class = avcodec_get_class();
941 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
942 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
943 const AVClass *fclass = avformat_get_class();
944 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
945 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
946 if (!option || foption)
950 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
951 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
952 "input file #%d (%s) is not a decoding option.\n", e->key,
953 option->help ? option->help : "", nb_input_files - 1,
958 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
959 "input file #%d (%s) has not been used for any stream. The most "
960 "likely reason is either wrong type (e.g. a video option with "
961 "no video streams) or that it is a private option of some decoder "
962 "which was not actually used for any stream.\n", e->key,
963 option->help ? option->help : "", nb_input_files - 1, filename);
965 av_dict_free(&unused_opts);
967 for (i = 0; i < o->nb_dump_attachment; i++) {
970 for (j = 0; j < ic->nb_streams; j++) {
971 AVStream *st = ic->streams[j];
973 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
974 dump_attachment(st, o->dump_attachment[i].u.str);
978 for (i = 0; i < orig_nb_streams; i++)
979 av_dict_free(&opts[i]);
985 static uint8_t *get_line(AVIOContext *s)
991 if (avio_open_dyn_buf(&line) < 0) {
992 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
996 while ((c = avio_r8(s)) && c != '\n')
999 avio_close_dyn_buf(line, &buf);
1004 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1007 char filename[1000];
1008 const char *base[3] = { getenv("AVCONV_DATADIR"),
1013 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1017 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1018 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1019 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1022 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1023 i != 1 ? "" : "/.avconv", preset_name);
1024 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1030 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1032 char *codec_name = NULL;
1034 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1036 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1037 NULL, ost->st->codec->codec_type);
1038 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1039 } else if (!strcmp(codec_name, "copy"))
1040 ost->stream_copy = 1;
1042 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1043 ost->st->codec->codec_id = ost->enc->id;
1047 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1050 AVStream *st = avformat_new_stream(oc, NULL);
1051 int idx = oc->nb_streams - 1, ret = 0;
1052 char *bsf = NULL, *next, *codec_tag = NULL;
1053 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1058 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1062 if (oc->nb_streams - 1 < o->nb_streamid_map)
1063 st->id = o->streamid_map[oc->nb_streams - 1];
1065 GROW_ARRAY(output_streams, nb_output_streams);
1066 if (!(ost = av_mallocz(sizeof(*ost))))
1068 output_streams[nb_output_streams - 1] = ost;
1070 ost->file_index = nb_output_files - 1;
1073 st->codec->codec_type = type;
1074 choose_encoder(o, oc, ost);
1076 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1077 if (!ost->enc_ctx) {
1078 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1081 ost->enc_ctx->codec_type = type;
1084 AVIOContext *s = NULL;
1085 char *buf = NULL, *arg = NULL, *preset = NULL;
1087 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1089 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1090 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1093 if (!buf[0] || buf[0] == '#') {
1097 if (!(arg = strchr(buf, '='))) {
1098 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1102 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1104 } while (!s->eof_reached);
1108 av_log(NULL, AV_LOG_FATAL,
1109 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1110 preset, ost->file_index, ost->index);
1114 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1117 ost->max_frames = INT64_MAX;
1118 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1119 for (i = 0; i<o->nb_max_frames; i++) {
1120 char *p = o->max_frames[i].specifier;
1121 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1122 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1127 ost->copy_prior_start = -1;
1128 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1130 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1132 if (next = strchr(bsf, ','))
1134 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1135 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1139 bsfc_prev->next = bsfc;
1141 ost->bitstream_filters = bsfc;
1147 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1149 uint32_t tag = strtol(codec_tag, &next, 0);
1151 tag = AV_RL32(codec_tag);
1152 ost->enc_ctx->codec_tag = tag;
1155 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1157 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1158 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1161 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1162 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1164 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1166 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1167 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1168 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1170 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1172 ost->source_index = source_index;
1173 if (source_index >= 0) {
1174 ost->sync_ist = input_streams[source_index];
1175 input_streams[source_index]->discard = 0;
1176 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1178 ost->last_mux_dts = AV_NOPTS_VALUE;
1183 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1186 const char *p = str;
1193 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1200 /* read file contents into a string */
1201 static uint8_t *read_file(const char *filename)
1203 AVIOContext *pb = NULL;
1204 AVIOContext *dyn_buf = NULL;
1205 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1206 uint8_t buf[1024], *str;
1209 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1213 ret = avio_open_dyn_buf(&dyn_buf);
1218 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1219 avio_write(dyn_buf, buf, ret);
1220 avio_w8(dyn_buf, 0);
1223 ret = avio_close_dyn_buf(dyn_buf, &str);
1229 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1232 AVStream *st = ost->st;
1234 if (ost->filters_script && ost->filters) {
1235 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1236 "output stream #%d:%d.\n", nb_output_files, st->index);
1240 if (ost->filters_script)
1241 return read_file(ost->filters_script);
1242 else if (ost->filters)
1243 return av_strdup(ost->filters);
1245 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1249 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1250 const OutputStream *ost, enum AVMediaType type)
1252 if (ost->filters_script || ost->filters) {
1253 av_log(NULL, AV_LOG_ERROR,
1254 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1255 "Filtering and streamcopy cannot be used together.\n",
1256 ost->filters ? "Filtergraph" : "Filtergraph script",
1257 ost->filters ? ost->filters : ost->filters_script,
1258 av_get_media_type_string(type), ost->file_index, ost->index);
1263 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1267 AVCodecContext *video_enc;
1268 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1270 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1272 video_enc = ost->enc_ctx;
1274 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1275 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1276 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1280 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1281 if (frame_aspect_ratio) {
1283 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1284 q.num <= 0 || q.den <= 0) {
1285 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1288 ost->frame_aspect_ratio = q;
1291 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1292 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1294 if (!ost->stream_copy) {
1295 const char *p = NULL;
1296 char *frame_size = NULL;
1297 char *frame_pix_fmt = NULL;
1298 char *intra_matrix = NULL, *inter_matrix = NULL;
1299 char *chroma_intra_matrix = NULL;
1303 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1304 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1305 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1309 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1310 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1311 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1312 ost->keep_pix_fmt = 1;
1313 if (!*++frame_pix_fmt)
1314 frame_pix_fmt = NULL;
1316 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1317 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1320 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1323 video_enc->gop_size = 0;
1324 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1326 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1327 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1330 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1332 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1333 if (chroma_intra_matrix) {
1334 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1336 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1339 av_codec_set_chroma_intra_matrix(video_enc, p);
1340 parse_matrix_coeffs(p, chroma_intra_matrix);
1342 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1344 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1345 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1348 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1351 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1352 for (i = 0; p; i++) {
1354 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1356 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1359 /* FIXME realloc failure */
1360 video_enc->rc_override =
1361 av_realloc(video_enc->rc_override,
1362 sizeof(RcOverride) * (i + 1));
1363 video_enc->rc_override[i].start_frame = start;
1364 video_enc->rc_override[i].end_frame = end;
1366 video_enc->rc_override[i].qscale = q;
1367 video_enc->rc_override[i].quality_factor = 1.0;
1370 video_enc->rc_override[i].qscale = 0;
1371 video_enc->rc_override[i].quality_factor = -q/100.0;
1376 video_enc->rc_override_count = i;
1379 video_enc->flags|= CODEC_FLAG_PSNR;
1382 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1385 video_enc->flags |= CODEC_FLAG_PASS1;
1386 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1389 video_enc->flags |= CODEC_FLAG_PASS2;
1390 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1394 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1395 if (ost->logfile_prefix &&
1396 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1399 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1400 if (ost->forced_keyframes)
1401 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1403 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1405 ost->top_field_first = -1;
1406 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1409 ost->avfilter = get_ost_filters(o, oc, ost);
1413 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1416 if (ost->stream_copy)
1417 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1422 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1427 AVCodecContext *audio_enc;
1429 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1432 audio_enc = ost->enc_ctx;
1433 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1435 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1436 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1438 if (!ost->stream_copy) {
1439 char *sample_fmt = NULL;
1441 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1443 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1445 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1446 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1450 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1452 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1453 ost->apad = av_strdup(ost->apad);
1455 ost->avfilter = get_ost_filters(o, oc, ost);
1459 /* check for channel mapping for this audio stream */
1460 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1461 AudioChannelMap *map = &o->audio_channel_maps[n];
1462 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1463 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1466 if (map->channel_idx == -1) {
1468 } else if (ost->source_index < 0) {
1469 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1470 ost->file_index, ost->st->index);
1473 ist = input_streams[ost->source_index];
1476 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1477 if (av_reallocp_array(&ost->audio_channels_map,
1478 ost->audio_channels_mapped + 1,
1479 sizeof(*ost->audio_channels_map)
1483 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1489 if (ost->stream_copy)
1490 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1495 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1499 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1500 if (!ost->stream_copy) {
1501 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1508 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1510 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1511 ost->stream_copy = 1;
1516 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1520 AVCodecContext *subtitle_enc;
1522 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1524 subtitle_enc = ost->enc_ctx;
1526 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1528 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1530 if (!ost->stream_copy) {
1531 char *frame_size = NULL;
1533 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1534 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1535 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1543 /* arg format is "output-stream-index:streamid-value". */
1544 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1546 OptionsContext *o = optctx;
1551 av_strlcpy(idx_str, arg, sizeof(idx_str));
1552 p = strchr(idx_str, ':');
1554 av_log(NULL, AV_LOG_FATAL,
1555 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1560 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1561 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1562 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1566 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1568 AVFormatContext *is = ifile->ctx;
1569 AVFormatContext *os = ofile->ctx;
1573 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1575 return AVERROR(ENOMEM);
1578 for (i = 0; i < is->nb_chapters; i++) {
1579 AVChapter *in_ch = is->chapters[i], *out_ch;
1580 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1581 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1582 AV_TIME_BASE_Q, in_ch->time_base);
1583 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1584 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1587 if (in_ch->end < ts_off)
1589 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1592 out_ch = av_mallocz(sizeof(AVChapter));
1594 return AVERROR(ENOMEM);
1596 out_ch->id = in_ch->id;
1597 out_ch->time_base = in_ch->time_base;
1598 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1599 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1602 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1604 os->chapters[os->nb_chapters++] = out_ch;
1609 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1612 AVFormatContext *ic = avformat_alloc_context();
1614 ic->interrupt_callback = int_cb;
1615 err = avformat_open_input(&ic, filename, NULL, NULL);
1618 /* copy stream format */
1619 for(i=0;i<ic->nb_streams;i++) {
1623 AVCodecContext *avctx;
1625 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1627 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1628 return AVERROR(EINVAL);
1630 ost = new_output_stream(o, s, codec->type, -1);
1635 // FIXME: a more elegant solution is needed
1636 memcpy(st, ic->streams[i], sizeof(AVStream));
1638 st->info = av_malloc(sizeof(*st->info));
1639 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1641 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1643 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1644 choose_sample_fmt(st, codec);
1645 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1646 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1647 avcodec_copy_context(ost->enc_ctx, st->codec);
1650 avformat_close_input(&ic);
1654 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1655 AVFormatContext *oc)
1659 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1660 ofilter->out_tmp->pad_idx)) {
1661 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1662 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1664 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1669 ost->source_index = -1;
1670 ost->filter = ofilter;
1674 if (ost->stream_copy) {
1675 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1676 "which is fed from a complex filtergraph. Filtering and streamcopy "
1677 "cannot be used together.\n", ost->file_index, ost->index);
1681 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1682 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1683 av_log(NULL, AV_LOG_ERROR,
1684 "%s '%s' was specified through the %s option "
1685 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1686 "%s and -filter_complex cannot be used together for the same stream.\n",
1687 ost->filters ? "Filtergraph" : "Filtergraph script",
1688 ost->filters ? ost->filters : ost->filters_script,
1689 opt, ost->file_index, ost->index, opt);
1693 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1694 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1697 avfilter_inout_free(&ofilter->out_tmp);
1700 static int configure_complex_filters(void)
1704 for (i = 0; i < nb_filtergraphs; i++)
1705 if (!filtergraphs[i]->graph &&
1706 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1711 static int open_output_file(OptionsContext *o, const char *filename)
1713 AVFormatContext *oc;
1715 AVOutputFormat *file_oformat;
1719 AVDictionary *unused_opts = NULL;
1720 AVDictionaryEntry *e = NULL;
1722 if (configure_complex_filters() < 0) {
1723 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1727 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1728 o->stop_time = INT64_MAX;
1729 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1732 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1733 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1734 if (o->stop_time <= start_time) {
1735 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1738 o->recording_time = o->stop_time - start_time;
1742 GROW_ARRAY(output_files, nb_output_files);
1743 of = av_mallocz(sizeof(*of));
1746 output_files[nb_output_files - 1] = of;
1748 of->ost_index = nb_output_streams;
1749 of->recording_time = o->recording_time;
1750 of->start_time = o->start_time;
1751 of->limit_filesize = o->limit_filesize;
1752 of->shortest = o->shortest;
1753 av_dict_copy(&of->opts, o->g->format_opts, 0);
1755 if (!strcmp(filename, "-"))
1758 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1760 print_error(filename, err);
1765 if (o->recording_time != INT64_MAX)
1766 oc->duration = o->recording_time;
1768 file_oformat= oc->oformat;
1769 oc->interrupt_callback = int_cb;
1771 /* create streams for all unlabeled output pads */
1772 for (i = 0; i < nb_filtergraphs; i++) {
1773 FilterGraph *fg = filtergraphs[i];
1774 for (j = 0; j < fg->nb_outputs; j++) {
1775 OutputFilter *ofilter = fg->outputs[j];
1777 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1780 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1781 ofilter->out_tmp->pad_idx)) {
1782 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1783 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1784 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1786 init_output_filter(ofilter, o, oc);
1790 /* ffserver seeking with date=... needs a date reference */
1791 if (!strcmp(file_oformat->name, "ffm") &&
1792 av_strstart(filename, "http:", NULL)) {
1793 int err = parse_option(o, "metadata", "creation_time=now", options);
1795 print_error(filename, err);
1800 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1801 av_strstart(filename, "http:", NULL)) {
1803 /* special case for files sent to ffserver: we get the stream
1804 parameters from ffserver */
1805 int err = read_ffserver_streams(o, oc, filename);
1807 print_error(filename, err);
1810 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1811 ost = output_streams[j];
1812 for (i = 0; i < nb_input_streams; i++) {
1813 ist = input_streams[i];
1814 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1816 ost->source_index= i;
1817 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1818 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1820 ist->st->discard = ist->user_set_discard;
1825 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));
1829 } else if (!o->nb_stream_maps) {
1830 char *subtitle_codec_name = NULL;
1831 /* pick the "best" stream of each type */
1833 /* video: highest resolution */
1834 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1835 int area = 0, idx = -1;
1836 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1837 for (i = 0; i < nb_input_streams; i++) {
1839 ist = input_streams[i];
1840 new_area = ist->st->codec->width * ist->st->codec->height;
1841 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1843 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1845 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1852 new_video_stream(o, oc, idx);
1855 /* audio: most channels */
1856 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1857 int channels = 0, idx = -1;
1858 for (i = 0; i < nb_input_streams; i++) {
1859 ist = input_streams[i];
1860 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1861 ist->st->codec->channels > channels) {
1862 channels = ist->st->codec->channels;
1867 new_audio_stream(o, oc, idx);
1870 /* subtitles: pick first */
1871 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1872 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1873 for (i = 0; i < nb_input_streams; i++)
1874 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1875 AVCodecDescriptor const *input_descriptor =
1876 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1877 AVCodecDescriptor const *output_descriptor = NULL;
1878 AVCodec const *output_codec =
1879 avcodec_find_encoder(oc->oformat->subtitle_codec);
1880 int input_props = 0, output_props = 0;
1882 output_descriptor = avcodec_descriptor_get(output_codec->id);
1883 if (input_descriptor)
1884 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1885 if (output_descriptor)
1886 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1887 if (subtitle_codec_name ||
1888 input_props & output_props ||
1889 // Map dvb teletext which has neither property to any output subtitle encoder
1890 input_descriptor && output_descriptor &&
1891 (!input_descriptor->props ||
1892 !output_descriptor->props)) {
1893 new_subtitle_stream(o, oc, i);
1898 /* do something with data? */
1900 for (i = 0; i < o->nb_stream_maps; i++) {
1901 StreamMap *map = &o->stream_maps[i];
1906 if (map->linklabel) {
1908 OutputFilter *ofilter = NULL;
1911 for (j = 0; j < nb_filtergraphs; j++) {
1912 fg = filtergraphs[j];
1913 for (k = 0; k < fg->nb_outputs; k++) {
1914 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1915 if (out && !strcmp(out->name, map->linklabel)) {
1916 ofilter = fg->outputs[k];
1923 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1924 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1927 init_output_filter(ofilter, o, oc);
1929 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1931 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1932 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1934 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1936 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1938 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1941 switch (ist->st->codec->codec_type) {
1942 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1943 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1944 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1945 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1946 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1948 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1949 map->file_index, map->stream_index);
1956 /* handle attached files */
1957 for (i = 0; i < o->nb_attachments; i++) {
1959 uint8_t *attachment;
1963 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1964 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1968 if ((len = avio_size(pb)) <= 0) {
1969 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1973 if (!(attachment = av_malloc(len))) {
1974 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1978 avio_read(pb, attachment, len);
1980 ost = new_attachment_stream(o, oc, -1);
1981 ost->stream_copy = 0;
1982 ost->attachment_filename = o->attachments[i];
1984 ost->enc_ctx->extradata = attachment;
1985 ost->enc_ctx->extradata_size = len;
1987 p = strrchr(o->attachments[i], '/');
1988 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1992 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1993 AVDictionaryEntry *e;
1994 ost = output_streams[i];
1996 if ((ost->stream_copy || ost->attachment_filename)
1997 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1998 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1999 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2003 /* check if all codec options have been used */
2004 unused_opts = strip_specifiers(o->g->codec_opts);
2005 for (i = of->ost_index; i < nb_output_streams; i++) {
2007 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2008 AV_DICT_IGNORE_SUFFIX)))
2009 av_dict_set(&unused_opts, e->key, NULL, 0);
2013 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2014 const AVClass *class = avcodec_get_class();
2015 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2016 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2017 const AVClass *fclass = avformat_get_class();
2018 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2019 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2020 if (!option || foption)
2024 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2025 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2026 "output file #%d (%s) is not an encoding option.\n", e->key,
2027 option->help ? option->help : "", nb_output_files - 1,
2032 // gop_timecode is injected by generic code but not always used
2033 if (!strcmp(e->key, "gop_timecode"))
2036 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2037 "output file #%d (%s) has not been used for any stream. The most "
2038 "likely reason is either wrong type (e.g. a video option with "
2039 "no video streams) or that it is a private option of some encoder "
2040 "which was not actually used for any stream.\n", e->key,
2041 option->help ? option->help : "", nb_output_files - 1, filename);
2043 av_dict_free(&unused_opts);
2045 /* check filename in case of an image number is expected */
2046 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2047 if (!av_filename_number_test(oc->filename)) {
2048 print_error(oc->filename, AVERROR(EINVAL));
2053 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2054 /* test if it already exists to avoid losing precious files */
2055 assert_file_overwrite(filename);
2058 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2059 &oc->interrupt_callback,
2061 print_error(filename, err);
2064 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2065 assert_file_overwrite(filename);
2067 if (o->mux_preload) {
2068 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2070 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2073 for (i = 0; i < o->nb_metadata_map; i++) {
2075 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2077 if (in_file_index >= nb_input_files) {
2078 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2081 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2082 in_file_index >= 0 ?
2083 input_files[in_file_index]->ctx : NULL, o);
2087 if (o->chapters_input_file >= nb_input_files) {
2088 if (o->chapters_input_file == INT_MAX) {
2089 /* copy chapters from the first input file that has them*/
2090 o->chapters_input_file = -1;
2091 for (i = 0; i < nb_input_files; i++)
2092 if (input_files[i]->ctx->nb_chapters) {
2093 o->chapters_input_file = i;
2097 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2098 o->chapters_input_file);
2102 if (o->chapters_input_file >= 0)
2103 copy_chapters(input_files[o->chapters_input_file], of,
2104 !o->metadata_chapters_manual);
2106 /* copy global metadata by default */
2107 if (!o->metadata_global_manual && nb_input_files){
2108 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2109 AV_DICT_DONT_OVERWRITE);
2110 if(o->recording_time != INT64_MAX)
2111 av_dict_set(&oc->metadata, "duration", NULL, 0);
2112 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2114 if (!o->metadata_streams_manual)
2115 for (i = of->ost_index; i < nb_output_streams; i++) {
2117 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2119 ist = input_streams[output_streams[i]->source_index];
2120 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2121 if (!output_streams[i]->stream_copy)
2122 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2125 /* process manually set metadata */
2126 for (i = 0; i < o->nb_metadata; i++) {
2129 const char *stream_spec;
2130 int index = 0, j, ret = 0;
2132 val = strchr(o->metadata[i].u.str, '=');
2134 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2135 o->metadata[i].u.str);
2140 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2142 for (j = 0; j < oc->nb_streams; j++) {
2143 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2144 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2155 if (index < 0 || index >= oc->nb_chapters) {
2156 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2159 m = &oc->chapters[index]->metadata;
2162 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2165 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2172 static int opt_target(void *optctx, const char *opt, const char *arg)
2174 OptionsContext *o = optctx;
2175 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2176 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2178 if (!strncmp(arg, "pal-", 4)) {
2181 } else if (!strncmp(arg, "ntsc-", 5)) {
2184 } else if (!strncmp(arg, "film-", 5)) {
2188 /* Try to determine PAL/NTSC by peeking in the input files */
2189 if (nb_input_files) {
2191 for (j = 0; j < nb_input_files; j++) {
2192 for (i = 0; i < input_files[j]->nb_streams; i++) {
2193 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2194 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2197 fr = c->time_base.den * 1000 / c->time_base.num;
2201 } else if ((fr == 29970) || (fr == 23976)) {
2206 if (norm != UNKNOWN)
2210 if (norm != UNKNOWN)
2211 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2214 if (norm == UNKNOWN) {
2215 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2216 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2217 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2221 if (!strcmp(arg, "vcd")) {
2222 opt_video_codec(o, "c:v", "mpeg1video");
2223 opt_audio_codec(o, "c:a", "mp2");
2224 parse_option(o, "f", "vcd", options);
2226 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2227 parse_option(o, "r", frame_rates[norm], options);
2228 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2230 opt_default(NULL, "b:v", "1150000");
2231 opt_default(NULL, "maxrate", "1150000");
2232 opt_default(NULL, "minrate", "1150000");
2233 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2235 opt_default(NULL, "b:a", "224000");
2236 parse_option(o, "ar", "44100", options);
2237 parse_option(o, "ac", "2", options);
2239 opt_default(NULL, "packetsize", "2324");
2240 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2242 /* We have to offset the PTS, so that it is consistent with the SCR.
2243 SCR starts at 36000, but the first two packs contain only padding
2244 and the first pack from the other stream, respectively, may also have
2245 been written before.
2246 So the real data starts at SCR 36000+3*1200. */
2247 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2248 } else if (!strcmp(arg, "svcd")) {
2250 opt_video_codec(o, "c:v", "mpeg2video");
2251 opt_audio_codec(o, "c:a", "mp2");
2252 parse_option(o, "f", "svcd", options);
2254 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2255 parse_option(o, "r", frame_rates[norm], options);
2256 parse_option(o, "pix_fmt", "yuv420p", options);
2257 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2259 opt_default(NULL, "b:v", "2040000");
2260 opt_default(NULL, "maxrate", "2516000");
2261 opt_default(NULL, "minrate", "0"); // 1145000;
2262 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2263 opt_default(NULL, "scan_offset", "1");
2265 opt_default(NULL, "b:a", "224000");
2266 parse_option(o, "ar", "44100", options);
2268 opt_default(NULL, "packetsize", "2324");
2270 } else if (!strcmp(arg, "dvd")) {
2272 opt_video_codec(o, "c:v", "mpeg2video");
2273 opt_audio_codec(o, "c:a", "ac3");
2274 parse_option(o, "f", "dvd", options);
2276 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2277 parse_option(o, "r", frame_rates[norm], options);
2278 parse_option(o, "pix_fmt", "yuv420p", options);
2279 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2281 opt_default(NULL, "b:v", "6000000");
2282 opt_default(NULL, "maxrate", "9000000");
2283 opt_default(NULL, "minrate", "0"); // 1500000;
2284 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2286 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2287 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2289 opt_default(NULL, "b:a", "448000");
2290 parse_option(o, "ar", "48000", options);
2292 } else if (!strncmp(arg, "dv", 2)) {
2294 parse_option(o, "f", "dv", options);
2296 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2297 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2298 norm == PAL ? "yuv420p" : "yuv411p", options);
2299 parse_option(o, "r", frame_rates[norm], options);
2301 parse_option(o, "ar", "48000", options);
2302 parse_option(o, "ac", "2", options);
2305 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2306 return AVERROR(EINVAL);
2309 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2310 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2315 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2317 av_free (vstats_filename);
2318 vstats_filename = av_strdup (arg);
2322 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2325 time_t today2 = time(NULL);
2326 struct tm *today = localtime(&today2);
2328 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2330 return opt_vstats_file(NULL, opt, filename);
2333 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2335 OptionsContext *o = optctx;
2336 return parse_option(o, "frames:v", arg, options);
2339 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2341 OptionsContext *o = optctx;
2342 return parse_option(o, "frames:a", arg, options);
2345 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2347 OptionsContext *o = optctx;
2348 return parse_option(o, "frames:d", arg, options);
2351 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2354 AVDictionary *cbak = codec_opts;
2355 AVDictionary *fbak = format_opts;
2359 ret = opt_default(NULL, opt, arg);
2361 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2362 av_dict_copy(&o->g->format_opts, format_opts, 0);
2363 av_dict_free(&codec_opts);
2364 av_dict_free(&format_opts);
2371 static int opt_preset(void *optctx, const char *opt, const char *arg)
2373 OptionsContext *o = optctx;
2375 char filename[1000], line[1000], tmp_line[1000];
2376 const char *codec_name = NULL;
2380 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2382 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2383 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2384 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2386 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2390 while (fgets(line, sizeof(line), f)) {
2391 char *key = tmp_line, *value, *endptr;
2393 if (strcspn(line, "#\n\r") == 0)
2395 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2396 if (!av_strtok(key, "=", &value) ||
2397 !av_strtok(value, "\r\n", &endptr)) {
2398 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2401 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2403 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2404 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2405 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2406 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2407 else if (opt_default_new(o, key, value) < 0) {
2408 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2409 filename, line, key, value);
2419 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2421 OptionsContext *o = optctx;
2422 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2423 int ret = parse_option(o, s, arg, options);
2428 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2430 OptionsContext *o = optctx;
2432 if(!strcmp(opt, "ab")){
2433 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2435 } else if(!strcmp(opt, "b")){
2436 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2437 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2440 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2444 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2446 OptionsContext *o = optctx;
2449 if(!strcmp(opt, "qscale")){
2450 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2451 return parse_option(o, "q:v", arg, options);
2453 s = av_asprintf("q%s", opt + 6);
2454 ret = parse_option(o, s, arg, options);
2459 static int opt_profile(void *optctx, const char *opt, const char *arg)
2461 OptionsContext *o = optctx;
2462 if(!strcmp(opt, "profile")){
2463 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2464 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2467 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2471 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2473 OptionsContext *o = optctx;
2474 return parse_option(o, "filter:v", arg, options);
2477 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2479 OptionsContext *o = optctx;
2480 return parse_option(o, "filter:a", arg, options);
2483 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2485 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2486 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2487 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2488 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2490 if (video_sync_method == VSYNC_AUTO)
2491 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2495 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2497 OptionsContext *o = optctx;
2498 char *tcr = av_asprintf("timecode=%s", arg);
2499 int ret = parse_option(o, "metadata:g", tcr, options);
2501 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2506 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2508 OptionsContext *o = optctx;
2509 char layout_str[32];
2512 int ret, channels, ac_str_size;
2515 layout = av_get_channel_layout(arg);
2517 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2518 return AVERROR(EINVAL);
2520 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2521 ret = opt_default_new(o, opt, layout_str);
2525 /* set 'ac' option based on channel layout */
2526 channels = av_get_channel_layout_nb_channels(layout);
2527 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2528 stream_str = strchr(opt, ':');
2529 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2530 ac_str = av_mallocz(ac_str_size);
2532 return AVERROR(ENOMEM);
2533 av_strlcpy(ac_str, "ac", 3);
2535 av_strlcat(ac_str, stream_str, ac_str_size);
2536 ret = parse_option(o, ac_str, layout_str, options);
2542 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2544 OptionsContext *o = optctx;
2545 return parse_option(o, "q:a", arg, options);
2548 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2550 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2551 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2552 return AVERROR(ENOMEM);
2553 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2554 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2555 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2556 return AVERROR(ENOMEM);
2560 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2562 uint8_t *graph_desc = read_file(arg);
2564 return AVERROR(EINVAL);
2566 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2567 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2568 return AVERROR(ENOMEM);
2569 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2570 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2574 void show_help_default(const char *opt, const char *arg)
2576 /* per-file options have at least one of those set */
2577 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2578 int show_advanced = 0, show_avoptions = 0;
2581 if (!strcmp(opt, "long"))
2583 else if (!strcmp(opt, "full"))
2584 show_advanced = show_avoptions = 1;
2586 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2591 printf("Getting help:\n"
2592 " -h -- print basic options\n"
2593 " -h long -- print more options\n"
2594 " -h full -- print all options (including all format and codec specific options, very long)\n"
2595 " See man %s for detailed description of the options.\n"
2596 "\n", program_name);
2598 show_help_options(options, "Print help / information / capabilities:",
2601 show_help_options(options, "Global options (affect whole program "
2602 "instead of just one file:",
2603 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2605 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2606 per_file | OPT_EXIT, 0);
2608 show_help_options(options, "Per-file main options:", 0,
2609 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2610 OPT_EXIT, per_file);
2612 show_help_options(options, "Advanced per-file options:",
2613 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2615 show_help_options(options, "Video options:",
2616 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2618 show_help_options(options, "Advanced Video options:",
2619 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2621 show_help_options(options, "Audio options:",
2622 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2624 show_help_options(options, "Advanced Audio options:",
2625 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2626 show_help_options(options, "Subtitle options:",
2627 OPT_SUBTITLE, 0, 0);
2630 if (show_avoptions) {
2631 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2632 show_help_children(avcodec_get_class(), flags);
2633 show_help_children(avformat_get_class(), flags);
2635 show_help_children(sws_get_class(), flags);
2637 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2638 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2642 void show_usage(void)
2644 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2645 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2646 av_log(NULL, AV_LOG_INFO, "\n");
2654 static const OptionGroupDef groups[] = {
2655 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2656 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2659 static int open_files(OptionGroupList *l, const char *inout,
2660 int (*open_file)(OptionsContext*, const char*))
2664 for (i = 0; i < l->nb_groups; i++) {
2665 OptionGroup *g = &l->groups[i];
2671 ret = parse_optgroup(&o, g);
2673 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2674 "%s.\n", inout, g->arg);
2678 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2679 ret = open_file(&o, g->arg);
2682 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2686 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2692 int ffmpeg_parse_options(int argc, char **argv)
2694 OptionParseContext octx;
2698 memset(&octx, 0, sizeof(octx));
2700 /* split the commandline into an internal representation */
2701 ret = split_commandline(&octx, argc, argv, options, groups,
2702 FF_ARRAY_ELEMS(groups));
2704 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2708 /* apply global options */
2709 ret = parse_optgroup(NULL, &octx.global_opts);
2711 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2715 /* open input files */
2716 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2718 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2722 /* open output files */
2723 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2725 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2730 uninit_parse_context(&octx);
2732 av_strerror(ret, error, sizeof(error));
2733 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2738 static int opt_progress(void *optctx, const char *opt, const char *arg)
2740 AVIOContext *avio = NULL;
2743 if (!strcmp(arg, "-"))
2745 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2747 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2748 arg, av_err2str(ret));
2751 progress_avio = avio;
2755 #define OFFSET(x) offsetof(OptionsContext, x)
2756 const OptionDef options[] = {
2758 #include "cmdutils_common_opts.h"
2759 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2760 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2761 "force format", "fmt" },
2762 { "y", OPT_BOOL, { &file_overwrite },
2763 "overwrite output files" },
2764 { "n", OPT_BOOL, { &no_file_overwrite },
2765 "never overwrite output files" },
2766 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2767 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2768 "codec name", "codec" },
2769 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2770 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2771 "codec name", "codec" },
2772 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2773 OPT_OUTPUT, { .off = OFFSET(presets) },
2774 "preset name", "preset" },
2775 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2776 OPT_OUTPUT, { .func_arg = opt_map },
2777 "set input stream mapping",
2778 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2779 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2780 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2781 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2782 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2783 "set metadata information of outfile from infile",
2784 "outfile[,metadata]:infile[,metadata]" },
2785 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2786 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2787 "set chapters mapping", "input_file_index" },
2788 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2789 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2790 "record or transcode \"duration\" seconds of audio/video",
2792 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2793 "record or transcode stop time", "time_stop" },
2794 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2795 "set the limit file size in bytes", "limit_size" },
2796 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2797 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2798 "set the start time offset", "time_off" },
2799 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2800 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2801 "enable/disable accurate seeking with -ss" },
2802 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2803 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2804 "set the input ts offset", "time_off" },
2805 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2806 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2807 "set the input ts scale", "scale" },
2808 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2809 "set the recording timestamp ('now' to set the current time)", "time" },
2810 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2811 "add metadata", "string=string" },
2812 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2813 OPT_OUTPUT, { .func_arg = opt_data_frames },
2814 "set the number of data frames to record", "number" },
2815 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2816 "add timings for benchmarking" },
2817 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2818 "add timings for each task" },
2819 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2820 "write program-readable progress information", "url" },
2821 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2822 "enable or disable interaction on standard input" },
2823 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2824 "set max runtime in seconds", "limit" },
2825 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2826 "dump each input packet" },
2827 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2828 "when dumping packets, also dump the payload" },
2829 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2830 OPT_INPUT, { .off = OFFSET(rate_emu) },
2831 "read input at native frame rate", "" },
2832 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2833 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2834 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2835 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2836 "video sync method", "" },
2837 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2838 "audio sync method", "" },
2839 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2840 "audio drift threshold", "threshold" },
2841 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2842 "copy timestamps" },
2843 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2844 "copy input stream time base when stream copying", "mode" },
2845 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2846 OPT_OUTPUT, { .off = OFFSET(shortest) },
2847 "finish encoding within shortest input" },
2848 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2849 OPT_OUTPUT, { .off = OFFSET(apad) },
2851 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2852 "timestamp discontinuity delta threshold", "threshold" },
2853 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2854 "timestamp error delta threshold", "threshold" },
2855 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2856 "exit on error", "error" },
2857 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2858 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2859 "copy initial non-keyframes" },
2860 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2861 "copy or discard frames before start time" },
2862 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2863 "set the number of frames to record", "number" },
2864 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2865 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2866 "force codec tag/fourcc", "fourcc/tag" },
2867 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2868 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2869 "use fixed quality scale (VBR)", "q" },
2870 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2871 OPT_OUTPUT, { .func_arg = opt_qscale },
2872 "use fixed quality scale (VBR)", "q" },
2873 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2874 "set profile", "profile" },
2875 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2876 "set stream filtergraph", "filter_graph" },
2877 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2878 "read stream filtergraph description from a file", "filename" },
2879 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2880 "reinit filtergraph on input parameter changes", "" },
2881 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2882 "create a complex filtergraph", "graph_description" },
2883 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2884 "create a complex filtergraph", "graph_description" },
2885 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2886 "read complex filtergraph description from a file", "filename" },
2887 { "stats", OPT_BOOL, { &print_stats },
2888 "print progress report during encoding", },
2889 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2890 OPT_OUTPUT, { .func_arg = opt_attach },
2891 "add an attachment to the output file", "filename" },
2892 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2893 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2894 "extract an attachment into a file", "filename" },
2895 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2896 "print timestamp debugging info" },
2897 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2898 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2899 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2900 OPT_INPUT, { .off = OFFSET(discard) },
2904 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2905 "set the number of video frames to record", "number" },
2906 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2907 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2908 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2909 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2910 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2911 "set frame size (WxH or abbreviation)", "size" },
2912 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2913 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2914 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2915 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2916 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2917 "set pixel format", "format" },
2918 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2919 "set the number of bits per raw sample", "number" },
2920 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2921 "deprecated use -g 1" },
2922 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2924 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2925 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2926 "rate control override for specific intervals", "override" },
2927 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2928 OPT_OUTPUT, { .func_arg = opt_video_codec },
2929 "force video codec ('copy' to copy stream)", "codec" },
2930 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2932 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2934 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2935 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2936 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2937 "select the pass number (1 to 3)", "n" },
2938 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2939 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2940 "select two pass log file name prefix", "prefix" },
2941 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2942 "this option is deprecated, use the yadif filter instead" },
2943 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2944 "calculate PSNR of compressed frames" },
2945 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2946 "dump video coding statistics to file" },
2947 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2948 "dump video coding statistics to file", "file" },
2949 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2950 "set video filters", "filter_graph" },
2951 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2952 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2953 "specify intra matrix coeffs", "matrix" },
2954 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2955 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2956 "specify inter matrix coeffs", "matrix" },
2957 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2958 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2959 "specify intra matrix coeffs", "matrix" },
2960 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2961 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2962 "top=1/bottom=0/auto=-1 field first", "" },
2963 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2964 OPT_OUTPUT, { .func_arg = opt_old2new },
2965 "force video tag/fourcc", "fourcc/tag" },
2966 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2967 "show QP histogram" },
2968 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2969 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2970 "force the selected framerate, disable the best supported framerate selection" },
2971 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2972 OPT_OUTPUT, { .func_arg = opt_streamid },
2973 "set the value of an outfile streamid", "streamIndex:value" },
2974 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2975 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2976 "force key frames at specified timestamps", "timestamps" },
2977 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2978 "audio bitrate (please use -b:a)", "bitrate" },
2979 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2980 "video bitrate (please use -b:v)", "bitrate" },
2981 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2982 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2983 "use HW accelerated decoding", "hwaccel name" },
2984 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2985 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2986 "select a device for HW acceleration" "devicename" },
2988 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
2992 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2993 "set the number of audio frames to record", "number" },
2994 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2995 "set audio quality (codec-specific)", "quality", },
2996 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2997 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2998 "set audio sampling rate (in Hz)", "rate" },
2999 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3000 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3001 "set number of audio channels", "channels" },
3002 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3004 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3005 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3006 "force audio codec ('copy' to copy stream)", "codec" },
3007 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3008 OPT_OUTPUT, { .func_arg = opt_old2new },
3009 "force audio tag/fourcc", "fourcc/tag" },
3010 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3011 "change audio volume (256=normal)" , "volume" },
3012 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3013 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3014 "set sample format", "format" },
3015 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3016 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3017 "set channel layout", "layout" },
3018 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3019 "set audio filters", "filter_graph" },
3020 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3021 "set the maximum number of channels to try to guess the channel layout" },
3023 /* subtitle options */
3024 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3025 "disable subtitle" },
3026 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3027 "force subtitle codec ('copy' to copy stream)", "codec" },
3028 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3029 , "force subtitle tag/fourcc", "fourcc/tag" },
3030 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3031 "fix subtitles duration" },
3032 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3033 "set canvas size (WxH or abbreviation)", "size" },
3036 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3037 "deprecated, use -channel", "channel" },
3038 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3039 "deprecated, use -standard", "standard" },
3040 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3043 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3044 "set the maximum demux-decode delay", "seconds" },
3045 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3046 "set the initial demux-decode delay", "seconds" },
3047 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3048 "override the options from ffserver", "" },
3050 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3051 "A comma-separated list of bitstream filters", "bitstream_filters" },
3052 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3053 "deprecated", "audio bitstream_filters" },
3054 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3055 "deprecated", "video bitstream_filters" },
3057 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3058 "set the audio options to the indicated preset", "preset" },
3059 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3060 "set the video options to the indicated preset", "preset" },
3061 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3062 "set the subtitle options to the indicated preset", "preset" },
3063 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3064 "set options from indicated preset file", "filename" },
3065 /* data codec support */
3066 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3067 "force data codec ('copy' to copy stream)", "codec" },
3068 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },