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;
790 AVDictionary *unused_opts = NULL;
791 AVDictionaryEntry *e = NULL;
792 int orig_nb_streams; // number of streams before avformat_find_stream_info
793 char * video_codec_name = NULL;
794 char * audio_codec_name = NULL;
795 char *subtitle_codec_name = NULL;
798 if (!(file_iformat = av_find_input_format(o->format))) {
799 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
804 if (!strcmp(filename, "-"))
807 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
808 strcmp(filename, "/dev/stdin");
810 /* get default parameters from command line */
811 ic = avformat_alloc_context();
813 print_error(filename, AVERROR(ENOMEM));
816 if (o->nb_audio_sample_rate) {
817 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
818 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
820 if (o->nb_audio_channels) {
821 /* because we set audio_channels based on both the "ac" and
822 * "channel_layout" options, we need to check that the specified
823 * demuxer actually has the "channels" option before setting it */
824 if (file_iformat && file_iformat->priv_class &&
825 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
826 AV_OPT_SEARCH_FAKE_OBJ)) {
827 snprintf(buf, sizeof(buf), "%d",
828 o->audio_channels[o->nb_audio_channels - 1].u.i);
829 av_dict_set(&o->g->format_opts, "channels", buf, 0);
832 if (o->nb_frame_rates) {
833 /* set the format-level framerate option;
834 * this is important for video grabbers, e.g. x11 */
835 if (file_iformat && file_iformat->priv_class &&
836 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
837 AV_OPT_SEARCH_FAKE_OBJ)) {
838 av_dict_set(&o->g->format_opts, "framerate",
839 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
842 if (o->nb_frame_sizes) {
843 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
845 if (o->nb_frame_pix_fmts)
846 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
848 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
849 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
850 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
852 ic->video_codec_id = video_codec_name ?
853 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
854 ic->audio_codec_id = audio_codec_name ?
855 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
856 ic->subtitle_codec_id= subtitle_codec_name ?
857 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
859 if (video_codec_name)
860 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
861 if (audio_codec_name)
862 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
863 if (subtitle_codec_name)
864 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
866 ic->flags |= AVFMT_FLAG_NONBLOCK;
867 ic->interrupt_callback = int_cb;
869 /* open the input file with generic avformat function */
870 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
872 print_error(filename, err);
875 assert_avoptions(o->g->format_opts);
877 /* apply forced codec ids */
878 for (i = 0; i < ic->nb_streams; i++)
879 choose_decoder(o, ic, ic->streams[i]);
881 /* Set AVCodecContext options for avformat_find_stream_info */
882 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
883 orig_nb_streams = ic->nb_streams;
885 /* If not enough info to get the stream parameters, we decode the
886 first frames to get it. (used in mpeg case for example) */
887 ret = avformat_find_stream_info(ic, opts);
889 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
890 if (ic->nb_streams == 0) {
891 avformat_close_input(&ic);
896 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
897 /* add the stream start time */
898 if (ic->start_time != AV_NOPTS_VALUE)
899 timestamp += ic->start_time;
901 /* if seeking requested, we execute it */
902 if (o->start_time != AV_NOPTS_VALUE) {
903 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
905 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
906 filename, (double)timestamp / AV_TIME_BASE);
910 /* update the current parameters so that they match the one of the input stream */
911 add_input_streams(o, ic);
913 /* dump the file content */
914 av_dump_format(ic, nb_input_files, filename, 0);
916 GROW_ARRAY(input_files, nb_input_files);
917 f = av_mallocz(sizeof(*f));
920 input_files[nb_input_files - 1] = f;
923 f->ist_index = nb_input_streams - ic->nb_streams;
924 f->start_time = o->start_time;
925 f->recording_time = o->recording_time;
926 f->input_ts_offset = o->input_ts_offset;
927 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
928 f->nb_streams = ic->nb_streams;
929 f->rate_emu = o->rate_emu;
930 f->accurate_seek = o->accurate_seek;
932 /* check if all codec options have been used */
933 unused_opts = strip_specifiers(o->g->codec_opts);
934 for (i = f->ist_index; i < nb_input_streams; i++) {
936 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
937 AV_DICT_IGNORE_SUFFIX)))
938 av_dict_set(&unused_opts, e->key, NULL, 0);
942 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
943 const AVClass *class = avcodec_get_class();
944 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
945 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
946 const AVClass *fclass = avformat_get_class();
947 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
948 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
949 if (!option || foption)
953 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
954 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
955 "input file #%d (%s) is not a decoding option.\n", e->key,
956 option->help ? option->help : "", nb_input_files - 1,
961 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
962 "input file #%d (%s) has not been used for any stream. The most "
963 "likely reason is either wrong type (e.g. a video option with "
964 "no video streams) or that it is a private option of some decoder "
965 "which was not actually used for any stream.\n", e->key,
966 option->help ? option->help : "", nb_input_files - 1, filename);
968 av_dict_free(&unused_opts);
970 for (i = 0; i < o->nb_dump_attachment; i++) {
973 for (j = 0; j < ic->nb_streams; j++) {
974 AVStream *st = ic->streams[j];
976 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
977 dump_attachment(st, o->dump_attachment[i].u.str);
981 for (i = 0; i < orig_nb_streams; i++)
982 av_dict_free(&opts[i]);
988 static uint8_t *get_line(AVIOContext *s)
994 if (avio_open_dyn_buf(&line) < 0) {
995 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
999 while ((c = avio_r8(s)) && c != '\n')
1002 avio_close_dyn_buf(line, &buf);
1007 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1010 char filename[1000];
1011 const char *base[3] = { getenv("AVCONV_DATADIR"),
1016 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1020 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1021 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1022 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1025 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1026 i != 1 ? "" : "/.avconv", preset_name);
1027 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1033 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1035 char *codec_name = NULL;
1037 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1039 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1040 NULL, ost->st->codec->codec_type);
1041 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1042 } else if (!strcmp(codec_name, "copy"))
1043 ost->stream_copy = 1;
1045 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1046 ost->st->codec->codec_id = ost->enc->id;
1050 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1053 AVStream *st = avformat_new_stream(oc, NULL);
1054 int idx = oc->nb_streams - 1, ret = 0;
1055 char *bsf = NULL, *next, *codec_tag = NULL;
1056 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1061 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1065 if (oc->nb_streams - 1 < o->nb_streamid_map)
1066 st->id = o->streamid_map[oc->nb_streams - 1];
1068 GROW_ARRAY(output_streams, nb_output_streams);
1069 if (!(ost = av_mallocz(sizeof(*ost))))
1071 output_streams[nb_output_streams - 1] = ost;
1073 ost->file_index = nb_output_files - 1;
1076 st->codec->codec_type = type;
1077 choose_encoder(o, oc, ost);
1079 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1080 if (!ost->enc_ctx) {
1081 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1084 ost->enc_ctx->codec_type = type;
1087 AVIOContext *s = NULL;
1088 char *buf = NULL, *arg = NULL, *preset = NULL;
1090 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1092 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1093 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1096 if (!buf[0] || buf[0] == '#') {
1100 if (!(arg = strchr(buf, '='))) {
1101 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1105 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1107 } while (!s->eof_reached);
1111 av_log(NULL, AV_LOG_FATAL,
1112 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1113 preset, ost->file_index, ost->index);
1117 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1120 ost->max_frames = INT64_MAX;
1121 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1122 for (i = 0; i<o->nb_max_frames; i++) {
1123 char *p = o->max_frames[i].specifier;
1124 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1125 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1130 ost->copy_prior_start = -1;
1131 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1133 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1135 if (next = strchr(bsf, ','))
1137 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1138 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1142 bsfc_prev->next = bsfc;
1144 ost->bitstream_filters = bsfc;
1150 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1152 uint32_t tag = strtol(codec_tag, &next, 0);
1154 tag = AV_RL32(codec_tag);
1155 ost->enc_ctx->codec_tag = tag;
1158 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1160 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1161 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1164 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1165 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1167 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1169 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1170 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1171 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1173 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1175 ost->source_index = source_index;
1176 if (source_index >= 0) {
1177 ost->sync_ist = input_streams[source_index];
1178 input_streams[source_index]->discard = 0;
1179 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1181 ost->last_mux_dts = AV_NOPTS_VALUE;
1186 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1189 const char *p = str;
1196 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1203 /* read file contents into a string */
1204 static uint8_t *read_file(const char *filename)
1206 AVIOContext *pb = NULL;
1207 AVIOContext *dyn_buf = NULL;
1208 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1209 uint8_t buf[1024], *str;
1212 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1216 ret = avio_open_dyn_buf(&dyn_buf);
1221 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1222 avio_write(dyn_buf, buf, ret);
1223 avio_w8(dyn_buf, 0);
1226 ret = avio_close_dyn_buf(dyn_buf, &str);
1232 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1235 AVStream *st = ost->st;
1237 if (ost->filters_script && ost->filters) {
1238 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1239 "output stream #%d:%d.\n", nb_output_files, st->index);
1243 if (ost->filters_script)
1244 return read_file(ost->filters_script);
1245 else if (ost->filters)
1246 return av_strdup(ost->filters);
1248 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1252 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1253 const OutputStream *ost, enum AVMediaType type)
1255 if (ost->filters_script || ost->filters) {
1256 av_log(NULL, AV_LOG_ERROR,
1257 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1258 "Filtering and streamcopy cannot be used together.\n",
1259 ost->filters ? "Filtergraph" : "Filtergraph script",
1260 ost->filters ? ost->filters : ost->filters_script,
1261 av_get_media_type_string(type), ost->file_index, ost->index);
1266 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1270 AVCodecContext *video_enc;
1271 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1273 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1275 video_enc = ost->enc_ctx;
1277 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1278 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1279 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1283 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1284 if (frame_aspect_ratio) {
1286 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1287 q.num <= 0 || q.den <= 0) {
1288 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1291 ost->frame_aspect_ratio = q;
1294 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1295 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1297 if (!ost->stream_copy) {
1298 const char *p = NULL;
1299 char *frame_size = NULL;
1300 char *frame_pix_fmt = NULL;
1301 char *intra_matrix = NULL, *inter_matrix = NULL;
1302 char *chroma_intra_matrix = NULL;
1306 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1307 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1308 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1312 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1313 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1314 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1315 ost->keep_pix_fmt = 1;
1316 if (!*++frame_pix_fmt)
1317 frame_pix_fmt = NULL;
1319 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1320 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1323 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1326 video_enc->gop_size = 0;
1327 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1329 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1330 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1333 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1335 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1336 if (chroma_intra_matrix) {
1337 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1339 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1342 av_codec_set_chroma_intra_matrix(video_enc, p);
1343 parse_matrix_coeffs(p, chroma_intra_matrix);
1345 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1347 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1348 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1351 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1354 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1355 for (i = 0; p; i++) {
1357 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1359 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1362 /* FIXME realloc failure */
1363 video_enc->rc_override =
1364 av_realloc(video_enc->rc_override,
1365 sizeof(RcOverride) * (i + 1));
1366 video_enc->rc_override[i].start_frame = start;
1367 video_enc->rc_override[i].end_frame = end;
1369 video_enc->rc_override[i].qscale = q;
1370 video_enc->rc_override[i].quality_factor = 1.0;
1373 video_enc->rc_override[i].qscale = 0;
1374 video_enc->rc_override[i].quality_factor = -q/100.0;
1379 video_enc->rc_override_count = i;
1382 video_enc->flags|= CODEC_FLAG_PSNR;
1385 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1388 video_enc->flags |= CODEC_FLAG_PASS1;
1389 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1392 video_enc->flags |= CODEC_FLAG_PASS2;
1393 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1397 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1398 if (ost->logfile_prefix &&
1399 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1402 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1403 if (ost->forced_keyframes)
1404 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1406 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1408 ost->top_field_first = -1;
1409 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1412 ost->avfilter = get_ost_filters(o, oc, ost);
1416 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1419 if (ost->stream_copy)
1420 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1425 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1430 AVCodecContext *audio_enc;
1432 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1435 audio_enc = ost->enc_ctx;
1436 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1438 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1439 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1441 if (!ost->stream_copy) {
1442 char *sample_fmt = NULL;
1444 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1446 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1448 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1449 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1453 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1455 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1456 ost->apad = av_strdup(ost->apad);
1458 ost->avfilter = get_ost_filters(o, oc, ost);
1462 /* check for channel mapping for this audio stream */
1463 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1464 AudioChannelMap *map = &o->audio_channel_maps[n];
1465 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1466 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1469 if (map->channel_idx == -1) {
1471 } else if (ost->source_index < 0) {
1472 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1473 ost->file_index, ost->st->index);
1476 ist = input_streams[ost->source_index];
1479 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1480 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1481 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1483 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1484 ost->file_index, ost->st->index);
1490 if (ost->stream_copy)
1491 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1496 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1500 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1501 if (!ost->stream_copy) {
1502 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1509 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1511 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1512 ost->stream_copy = 1;
1517 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1521 AVCodecContext *subtitle_enc;
1523 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1525 subtitle_enc = ost->enc_ctx;
1527 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1529 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1531 if (!ost->stream_copy) {
1532 char *frame_size = NULL;
1534 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1535 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1536 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1544 /* arg format is "output-stream-index:streamid-value". */
1545 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1547 OptionsContext *o = optctx;
1552 av_strlcpy(idx_str, arg, sizeof(idx_str));
1553 p = strchr(idx_str, ':');
1555 av_log(NULL, AV_LOG_FATAL,
1556 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1561 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1562 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1563 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1567 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1569 AVFormatContext *is = ifile->ctx;
1570 AVFormatContext *os = ofile->ctx;
1574 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1576 return AVERROR(ENOMEM);
1579 for (i = 0; i < is->nb_chapters; i++) {
1580 AVChapter *in_ch = is->chapters[i], *out_ch;
1581 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1582 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1583 AV_TIME_BASE_Q, in_ch->time_base);
1584 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1585 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1588 if (in_ch->end < ts_off)
1590 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1593 out_ch = av_mallocz(sizeof(AVChapter));
1595 return AVERROR(ENOMEM);
1597 out_ch->id = in_ch->id;
1598 out_ch->time_base = in_ch->time_base;
1599 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1600 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1603 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1605 os->chapters[os->nb_chapters++] = out_ch;
1610 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1613 AVFormatContext *ic = avformat_alloc_context();
1615 ic->interrupt_callback = int_cb;
1616 err = avformat_open_input(&ic, filename, NULL, NULL);
1619 /* copy stream format */
1620 for(i=0;i<ic->nb_streams;i++) {
1624 AVCodecContext *avctx;
1626 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1627 ost = new_output_stream(o, s, codec->type, -1);
1632 // FIXME: a more elegant solution is needed
1633 memcpy(st, ic->streams[i], sizeof(AVStream));
1635 st->info = av_malloc(sizeof(*st->info));
1636 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1638 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1640 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1641 choose_sample_fmt(st, codec);
1642 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1643 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1644 avcodec_copy_context(ost->enc_ctx, st->codec);
1647 avformat_close_input(&ic);
1651 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1652 AVFormatContext *oc)
1656 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1657 ofilter->out_tmp->pad_idx)) {
1658 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1659 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1661 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1666 ost->source_index = -1;
1667 ost->filter = ofilter;
1671 if (ost->stream_copy) {
1672 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1673 "which is fed from a complex filtergraph. Filtering and streamcopy "
1674 "cannot be used together.\n", ost->file_index, ost->index);
1678 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1679 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1680 av_log(NULL, AV_LOG_ERROR,
1681 "%s '%s' was specified through the %s option "
1682 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1683 "%s and -filter_complex cannot be used together for the same stream.\n",
1684 ost->filters ? "Filtergraph" : "Filtergraph script",
1685 ost->filters ? ost->filters : ost->filters_script,
1686 opt, ost->file_index, ost->index, opt);
1690 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1691 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1694 avfilter_inout_free(&ofilter->out_tmp);
1697 static int configure_complex_filters(void)
1701 for (i = 0; i < nb_filtergraphs; i++)
1702 if (!filtergraphs[i]->graph &&
1703 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1708 static int open_output_file(OptionsContext *o, const char *filename)
1710 AVFormatContext *oc;
1712 AVOutputFormat *file_oformat;
1716 AVDictionary *unused_opts = NULL;
1717 AVDictionaryEntry *e = NULL;
1719 if (configure_complex_filters() < 0) {
1720 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1724 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1725 o->stop_time = INT64_MAX;
1726 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1729 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1730 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1731 if (o->stop_time <= start_time) {
1732 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1733 o->stop_time = INT64_MAX;
1735 o->recording_time = o->stop_time - start_time;
1739 GROW_ARRAY(output_files, nb_output_files);
1740 of = av_mallocz(sizeof(*of));
1743 output_files[nb_output_files - 1] = of;
1745 of->ost_index = nb_output_streams;
1746 of->recording_time = o->recording_time;
1747 of->start_time = o->start_time;
1748 of->limit_filesize = o->limit_filesize;
1749 of->shortest = o->shortest;
1750 av_dict_copy(&of->opts, o->g->format_opts, 0);
1752 if (!strcmp(filename, "-"))
1755 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1757 print_error(filename, err);
1762 if (o->recording_time != INT64_MAX)
1763 oc->duration = o->recording_time;
1765 file_oformat= oc->oformat;
1766 oc->interrupt_callback = int_cb;
1768 /* create streams for all unlabeled output pads */
1769 for (i = 0; i < nb_filtergraphs; i++) {
1770 FilterGraph *fg = filtergraphs[i];
1771 for (j = 0; j < fg->nb_outputs; j++) {
1772 OutputFilter *ofilter = fg->outputs[j];
1774 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1777 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1778 ofilter->out_tmp->pad_idx)) {
1779 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1780 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1781 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1783 init_output_filter(ofilter, o, oc);
1787 /* ffserver seeking with date=... needs a date reference */
1788 if (!strcmp(file_oformat->name, "ffm") &&
1789 av_strstart(filename, "http:", NULL)) {
1790 int err = parse_option(o, "metadata", "creation_time=now", options);
1792 print_error(filename, err);
1797 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1798 av_strstart(filename, "http:", NULL)) {
1800 /* special case for files sent to ffserver: we get the stream
1801 parameters from ffserver */
1802 int err = read_ffserver_streams(o, oc, filename);
1804 print_error(filename, err);
1807 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1808 ost = output_streams[j];
1809 for (i = 0; i < nb_input_streams; i++) {
1810 ist = input_streams[i];
1811 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1813 ost->source_index= i;
1814 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1815 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1817 ist->st->discard = ist->user_set_discard;
1822 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));
1826 } else if (!o->nb_stream_maps) {
1827 char *subtitle_codec_name = NULL;
1828 /* pick the "best" stream of each type */
1830 /* video: highest resolution */
1831 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1832 int area = 0, idx = -1;
1833 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1834 for (i = 0; i < nb_input_streams; i++) {
1836 ist = input_streams[i];
1837 new_area = ist->st->codec->width * ist->st->codec->height;
1838 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1840 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1842 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1849 new_video_stream(o, oc, idx);
1852 /* audio: most channels */
1853 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1854 int channels = 0, idx = -1;
1855 for (i = 0; i < nb_input_streams; i++) {
1856 ist = input_streams[i];
1857 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1858 ist->st->codec->channels > channels) {
1859 channels = ist->st->codec->channels;
1864 new_audio_stream(o, oc, idx);
1867 /* subtitles: pick first */
1868 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1869 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1870 for (i = 0; i < nb_input_streams; i++)
1871 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1872 new_subtitle_stream(o, oc, i);
1876 /* do something with data? */
1878 for (i = 0; i < o->nb_stream_maps; i++) {
1879 StreamMap *map = &o->stream_maps[i];
1884 if (map->linklabel) {
1886 OutputFilter *ofilter = NULL;
1889 for (j = 0; j < nb_filtergraphs; j++) {
1890 fg = filtergraphs[j];
1891 for (k = 0; k < fg->nb_outputs; k++) {
1892 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1893 if (out && !strcmp(out->name, map->linklabel)) {
1894 ofilter = fg->outputs[k];
1901 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1902 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1905 init_output_filter(ofilter, o, oc);
1907 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1909 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1910 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1912 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1914 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1916 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1919 switch (ist->st->codec->codec_type) {
1920 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1921 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1922 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1923 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1924 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1926 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1927 map->file_index, map->stream_index);
1934 /* handle attached files */
1935 for (i = 0; i < o->nb_attachments; i++) {
1937 uint8_t *attachment;
1941 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1942 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1946 if ((len = avio_size(pb)) <= 0) {
1947 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1951 if (!(attachment = av_malloc(len))) {
1952 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1956 avio_read(pb, attachment, len);
1958 ost = new_attachment_stream(o, oc, -1);
1959 ost->stream_copy = 0;
1960 ost->attachment_filename = o->attachments[i];
1962 ost->enc_ctx->extradata = attachment;
1963 ost->enc_ctx->extradata_size = len;
1965 p = strrchr(o->attachments[i], '/');
1966 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1970 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1971 AVDictionaryEntry *e;
1972 ost = output_streams[i];
1974 if ((ost->stream_copy || ost->attachment_filename)
1975 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1976 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1977 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1981 /* check if all codec options have been used */
1982 unused_opts = strip_specifiers(o->g->codec_opts);
1983 for (i = of->ost_index; i < nb_output_streams; i++) {
1985 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1986 AV_DICT_IGNORE_SUFFIX)))
1987 av_dict_set(&unused_opts, e->key, NULL, 0);
1991 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1992 const AVClass *class = avcodec_get_class();
1993 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1994 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1997 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1998 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1999 "output file #%d (%s) is not an encoding option.\n", e->key,
2000 option->help ? option->help : "", nb_output_files - 1,
2005 // gop_timecode is injected by generic code but not always used
2006 if (!strcmp(e->key, "gop_timecode"))
2009 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2010 "output file #%d (%s) has not been used for any stream. The most "
2011 "likely reason is either wrong type (e.g. a video option with "
2012 "no video streams) or that it is a private option of some encoder "
2013 "which was not actually used for any stream.\n", e->key,
2014 option->help ? option->help : "", nb_output_files - 1, filename);
2016 av_dict_free(&unused_opts);
2018 /* check filename in case of an image number is expected */
2019 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2020 if (!av_filename_number_test(oc->filename)) {
2021 print_error(oc->filename, AVERROR(EINVAL));
2026 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2027 /* test if it already exists to avoid losing precious files */
2028 assert_file_overwrite(filename);
2031 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2032 &oc->interrupt_callback,
2034 print_error(filename, err);
2037 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2038 assert_file_overwrite(filename);
2040 if (o->mux_preload) {
2042 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
2043 av_dict_set(&of->opts, "preload", buf, 0);
2045 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2048 for (i = 0; i < o->nb_metadata_map; i++) {
2050 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2052 if (in_file_index >= nb_input_files) {
2053 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2056 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2057 in_file_index >= 0 ?
2058 input_files[in_file_index]->ctx : NULL, o);
2062 if (o->chapters_input_file >= nb_input_files) {
2063 if (o->chapters_input_file == INT_MAX) {
2064 /* copy chapters from the first input file that has them*/
2065 o->chapters_input_file = -1;
2066 for (i = 0; i < nb_input_files; i++)
2067 if (input_files[i]->ctx->nb_chapters) {
2068 o->chapters_input_file = i;
2072 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2073 o->chapters_input_file);
2077 if (o->chapters_input_file >= 0)
2078 copy_chapters(input_files[o->chapters_input_file], of,
2079 !o->metadata_chapters_manual);
2081 /* copy global metadata by default */
2082 if (!o->metadata_global_manual && nb_input_files){
2083 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2084 AV_DICT_DONT_OVERWRITE);
2085 if(o->recording_time != INT64_MAX)
2086 av_dict_set(&oc->metadata, "duration", NULL, 0);
2087 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2089 if (!o->metadata_streams_manual)
2090 for (i = of->ost_index; i < nb_output_streams; i++) {
2092 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2094 ist = input_streams[output_streams[i]->source_index];
2095 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2096 if (!output_streams[i]->stream_copy)
2097 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2100 /* process manually set metadata */
2101 for (i = 0; i < o->nb_metadata; i++) {
2104 const char *stream_spec;
2105 int index = 0, j, ret = 0;
2107 val = strchr(o->metadata[i].u.str, '=');
2109 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2110 o->metadata[i].u.str);
2115 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2117 for (j = 0; j < oc->nb_streams; j++) {
2118 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2119 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2130 if (index < 0 || index >= oc->nb_chapters) {
2131 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2134 m = &oc->chapters[index]->metadata;
2137 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2140 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2147 static int opt_target(void *optctx, const char *opt, const char *arg)
2149 OptionsContext *o = optctx;
2150 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2151 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2153 if (!strncmp(arg, "pal-", 4)) {
2156 } else if (!strncmp(arg, "ntsc-", 5)) {
2159 } else if (!strncmp(arg, "film-", 5)) {
2163 /* Try to determine PAL/NTSC by peeking in the input files */
2164 if (nb_input_files) {
2166 for (j = 0; j < nb_input_files; j++) {
2167 for (i = 0; i < input_files[j]->nb_streams; i++) {
2168 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2169 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2171 fr = c->time_base.den * 1000 / c->time_base.num;
2175 } else if ((fr == 29970) || (fr == 23976)) {
2180 if (norm != UNKNOWN)
2184 if (norm != UNKNOWN)
2185 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2188 if (norm == UNKNOWN) {
2189 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2190 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2191 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2195 if (!strcmp(arg, "vcd")) {
2196 opt_video_codec(o, "c:v", "mpeg1video");
2197 opt_audio_codec(o, "c:a", "mp2");
2198 parse_option(o, "f", "vcd", options);
2200 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2201 parse_option(o, "r", frame_rates[norm], options);
2202 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2204 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2205 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2206 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2207 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2209 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2210 parse_option(o, "ar", "44100", options);
2211 parse_option(o, "ac", "2", options);
2213 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2214 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2216 /* We have to offset the PTS, so that it is consistent with the SCR.
2217 SCR starts at 36000, but the first two packs contain only padding
2218 and the first pack from the other stream, respectively, may also have
2219 been written before.
2220 So the real data starts at SCR 36000+3*1200. */
2221 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2222 } else if (!strcmp(arg, "svcd")) {
2224 opt_video_codec(o, "c:v", "mpeg2video");
2225 opt_audio_codec(o, "c:a", "mp2");
2226 parse_option(o, "f", "svcd", options);
2228 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2229 parse_option(o, "r", frame_rates[norm], options);
2230 parse_option(o, "pix_fmt", "yuv420p", options);
2231 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2233 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2234 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2235 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2236 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2237 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2239 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2240 parse_option(o, "ar", "44100", options);
2242 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2244 } else if (!strcmp(arg, "dvd")) {
2246 opt_video_codec(o, "c:v", "mpeg2video");
2247 opt_audio_codec(o, "c:a", "ac3");
2248 parse_option(o, "f", "dvd", options);
2250 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2251 parse_option(o, "r", frame_rates[norm], options);
2252 parse_option(o, "pix_fmt", "yuv420p", options);
2253 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2255 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2256 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2257 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2258 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2260 av_dict_set(&o->g->format_opts, "packetsize", "2048", AV_DICT_DONT_OVERWRITE); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2261 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2263 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2264 parse_option(o, "ar", "48000", options);
2266 } else if (!strncmp(arg, "dv", 2)) {
2268 parse_option(o, "f", "dv", options);
2270 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2271 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2272 norm == PAL ? "yuv420p" : "yuv411p", options);
2273 parse_option(o, "r", frame_rates[norm], options);
2275 parse_option(o, "ar", "48000", options);
2276 parse_option(o, "ac", "2", options);
2279 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2280 return AVERROR(EINVAL);
2285 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2287 av_free (vstats_filename);
2288 vstats_filename = av_strdup (arg);
2292 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2295 time_t today2 = time(NULL);
2296 struct tm *today = localtime(&today2);
2298 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2300 return opt_vstats_file(NULL, opt, filename);
2303 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2305 OptionsContext *o = optctx;
2306 return parse_option(o, "frames:v", arg, options);
2309 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2311 OptionsContext *o = optctx;
2312 return parse_option(o, "frames:a", arg, options);
2315 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2317 OptionsContext *o = optctx;
2318 return parse_option(o, "frames:d", arg, options);
2321 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2324 AVDictionary *cbak = codec_opts;
2325 AVDictionary *fbak = format_opts;
2329 ret = opt_default(NULL, opt, arg);
2331 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2332 av_dict_copy(&o->g->format_opts, format_opts, 0);
2333 av_dict_free(&codec_opts);
2334 av_dict_free(&format_opts);
2341 static int opt_preset(void *optctx, const char *opt, const char *arg)
2343 OptionsContext *o = optctx;
2345 char filename[1000], line[1000], tmp_line[1000];
2346 const char *codec_name = NULL;
2350 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2352 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2353 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2354 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2356 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2360 while (fgets(line, sizeof(line), f)) {
2361 char *key = tmp_line, *value, *endptr;
2363 if (strcspn(line, "#\n\r") == 0)
2365 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2366 if (!av_strtok(key, "=", &value) ||
2367 !av_strtok(value, "\r\n", &endptr)) {
2368 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2371 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2373 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2374 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2375 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2376 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2377 else if (opt_default_new(o, key, value) < 0) {
2378 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2379 filename, line, key, value);
2389 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2391 OptionsContext *o = optctx;
2392 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2393 int ret = parse_option(o, s, arg, options);
2398 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2400 OptionsContext *o = optctx;
2402 if(!strcmp(opt, "ab")){
2403 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2405 } else if(!strcmp(opt, "b")){
2406 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2407 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2410 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2414 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2416 OptionsContext *o = optctx;
2419 if(!strcmp(opt, "qscale")){
2420 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2421 return parse_option(o, "q:v", arg, options);
2423 s = av_asprintf("q%s", opt + 6);
2424 ret = parse_option(o, s, arg, options);
2429 static int opt_profile(void *optctx, const char *opt, const char *arg)
2431 OptionsContext *o = optctx;
2432 if(!strcmp(opt, "profile")){
2433 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2434 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2437 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2441 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2443 OptionsContext *o = optctx;
2444 return parse_option(o, "filter:v", arg, options);
2447 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2449 OptionsContext *o = optctx;
2450 return parse_option(o, "filter:a", arg, options);
2453 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2455 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2456 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2457 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2458 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2460 if (video_sync_method == VSYNC_AUTO)
2461 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2465 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2467 OptionsContext *o = optctx;
2468 char *tcr = av_asprintf("timecode=%s", arg);
2469 int ret = parse_option(o, "metadata:g", tcr, options);
2471 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2476 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2478 OptionsContext *o = optctx;
2479 char layout_str[32];
2482 int ret, channels, ac_str_size;
2485 layout = av_get_channel_layout(arg);
2487 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2488 return AVERROR(EINVAL);
2490 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2491 ret = opt_default_new(o, opt, layout_str);
2495 /* set 'ac' option based on channel layout */
2496 channels = av_get_channel_layout_nb_channels(layout);
2497 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2498 stream_str = strchr(opt, ':');
2499 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2500 ac_str = av_mallocz(ac_str_size);
2502 return AVERROR(ENOMEM);
2503 av_strlcpy(ac_str, "ac", 3);
2505 av_strlcat(ac_str, stream_str, ac_str_size);
2506 ret = parse_option(o, ac_str, layout_str, options);
2512 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2514 OptionsContext *o = optctx;
2515 return parse_option(o, "q:a", arg, options);
2518 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2520 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2521 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2522 return AVERROR(ENOMEM);
2523 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2524 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2525 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2526 return AVERROR(ENOMEM);
2530 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2532 uint8_t *graph_desc = read_file(arg);
2534 return AVERROR(EINVAL);
2536 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2537 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2538 return AVERROR(ENOMEM);
2539 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2540 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2544 void show_help_default(const char *opt, const char *arg)
2546 /* per-file options have at least one of those set */
2547 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2548 int show_advanced = 0, show_avoptions = 0;
2551 if (!strcmp(opt, "long"))
2553 else if (!strcmp(opt, "full"))
2554 show_advanced = show_avoptions = 1;
2556 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2561 printf("Getting help:\n"
2562 " -h -- print basic options\n"
2563 " -h long -- print more options\n"
2564 " -h full -- print all options (including all format and codec specific options, very long)\n"
2565 " See man %s for detailed description of the options.\n"
2566 "\n", program_name);
2568 show_help_options(options, "Print help / information / capabilities:",
2571 show_help_options(options, "Global options (affect whole program "
2572 "instead of just one file:",
2573 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2575 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2576 per_file | OPT_EXIT, 0);
2578 show_help_options(options, "Per-file main options:", 0,
2579 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2580 OPT_EXIT, per_file);
2582 show_help_options(options, "Advanced per-file options:",
2583 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2585 show_help_options(options, "Video options:",
2586 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2588 show_help_options(options, "Advanced Video options:",
2589 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2591 show_help_options(options, "Audio options:",
2592 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2594 show_help_options(options, "Advanced Audio options:",
2595 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2596 show_help_options(options, "Subtitle options:",
2597 OPT_SUBTITLE, 0, 0);
2600 if (show_avoptions) {
2601 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2602 show_help_children(avcodec_get_class(), flags);
2603 show_help_children(avformat_get_class(), flags);
2605 show_help_children(sws_get_class(), flags);
2607 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2608 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2612 void show_usage(void)
2614 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2615 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2616 av_log(NULL, AV_LOG_INFO, "\n");
2624 static const OptionGroupDef groups[] = {
2625 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2626 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2629 static int open_files(OptionGroupList *l, const char *inout,
2630 int (*open_file)(OptionsContext*, const char*))
2634 for (i = 0; i < l->nb_groups; i++) {
2635 OptionGroup *g = &l->groups[i];
2641 ret = parse_optgroup(&o, g);
2643 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2644 "%s.\n", inout, g->arg);
2648 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2649 ret = open_file(&o, g->arg);
2652 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2656 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2662 int ffmpeg_parse_options(int argc, char **argv)
2664 OptionParseContext octx;
2668 memset(&octx, 0, sizeof(octx));
2670 /* split the commandline into an internal representation */
2671 ret = split_commandline(&octx, argc, argv, options, groups,
2672 FF_ARRAY_ELEMS(groups));
2674 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2678 /* apply global options */
2679 ret = parse_optgroup(NULL, &octx.global_opts);
2681 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2685 /* open input files */
2686 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2688 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2692 /* open output files */
2693 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2695 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2700 uninit_parse_context(&octx);
2702 av_strerror(ret, error, sizeof(error));
2703 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2708 static int opt_progress(void *optctx, const char *opt, const char *arg)
2710 AVIOContext *avio = NULL;
2713 if (!strcmp(arg, "-"))
2715 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2717 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2718 arg, av_err2str(ret));
2721 progress_avio = avio;
2725 #define OFFSET(x) offsetof(OptionsContext, x)
2726 const OptionDef options[] = {
2728 #include "cmdutils_common_opts.h"
2729 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2730 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2731 "force format", "fmt" },
2732 { "y", OPT_BOOL, { &file_overwrite },
2733 "overwrite output files" },
2734 { "n", OPT_BOOL, { &no_file_overwrite },
2735 "never overwrite output files" },
2736 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2737 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2738 "codec name", "codec" },
2739 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2740 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2741 "codec name", "codec" },
2742 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2743 OPT_OUTPUT, { .off = OFFSET(presets) },
2744 "preset name", "preset" },
2745 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2746 OPT_OUTPUT, { .func_arg = opt_map },
2747 "set input stream mapping",
2748 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2749 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2750 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2751 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2752 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2753 "set metadata information of outfile from infile",
2754 "outfile[,metadata]:infile[,metadata]" },
2755 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2756 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2757 "set chapters mapping", "input_file_index" },
2758 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2759 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2760 "record or transcode \"duration\" seconds of audio/video",
2762 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2763 "record or transcode stop time", "time_stop" },
2764 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2765 "set the limit file size in bytes", "limit_size" },
2766 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2767 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2768 "set the start time offset", "time_off" },
2769 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2770 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2771 "enable/disable accurate seeking with -ss" },
2772 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2773 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2774 "set the input ts offset", "time_off" },
2775 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2776 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2777 "set the input ts scale", "scale" },
2778 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2779 "set the recording timestamp ('now' to set the current time)", "time" },
2780 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2781 "add metadata", "string=string" },
2782 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2783 OPT_OUTPUT, { .func_arg = opt_data_frames },
2784 "set the number of data frames to record", "number" },
2785 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2786 "add timings for benchmarking" },
2787 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2788 "add timings for each task" },
2789 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2790 "write program-readable progress information", "url" },
2791 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2792 "enable or disable interaction on standard input" },
2793 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2794 "set max runtime in seconds", "limit" },
2795 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2796 "dump each input packet" },
2797 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2798 "when dumping packets, also dump the payload" },
2799 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2800 OPT_INPUT, { .off = OFFSET(rate_emu) },
2801 "read input at native frame rate", "" },
2802 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2803 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2804 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2805 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2806 "video sync method", "" },
2807 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2808 "audio sync method", "" },
2809 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2810 "audio drift threshold", "threshold" },
2811 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2812 "copy timestamps" },
2813 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2814 "copy input stream time base when stream copying", "mode" },
2815 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2816 OPT_OUTPUT, { .off = OFFSET(shortest) },
2817 "finish encoding within shortest input" },
2818 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2819 OPT_OUTPUT, { .off = OFFSET(apad) },
2821 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2822 "timestamp discontinuity delta threshold", "threshold" },
2823 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2824 "timestamp error delta threshold", "threshold" },
2825 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2826 "exit on error", "error" },
2827 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2828 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2829 "copy initial non-keyframes" },
2830 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2831 "copy or discard frames before start time" },
2832 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2833 "set the number of frames to record", "number" },
2834 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2835 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2836 "force codec tag/fourcc", "fourcc/tag" },
2837 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2838 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2839 "use fixed quality scale (VBR)", "q" },
2840 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2841 OPT_OUTPUT, { .func_arg = opt_qscale },
2842 "use fixed quality scale (VBR)", "q" },
2843 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2844 "set profile", "profile" },
2845 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2846 "set stream filtergraph", "filter_graph" },
2847 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2848 "read stream filtergraph description from a file", "filename" },
2849 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2850 "reinit filtergraph on input parameter changes", "" },
2851 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2852 "create a complex filtergraph", "graph_description" },
2853 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2854 "create a complex filtergraph", "graph_description" },
2855 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2856 "read complex filtergraph description from a file", "filename" },
2857 { "stats", OPT_BOOL, { &print_stats },
2858 "print progress report during encoding", },
2859 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2860 OPT_OUTPUT, { .func_arg = opt_attach },
2861 "add an attachment to the output file", "filename" },
2862 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2863 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2864 "extract an attachment into a file", "filename" },
2865 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2866 "print timestamp debugging info" },
2867 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2868 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2869 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2870 OPT_INPUT, { .off = OFFSET(discard) },
2874 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2875 "set the number of video frames to record", "number" },
2876 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2877 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2878 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2879 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2880 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2881 "set frame size (WxH or abbreviation)", "size" },
2882 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2883 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2884 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2885 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2886 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2887 "set pixel format", "format" },
2888 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2889 "set the number of bits per raw sample", "number" },
2890 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2891 "deprecated use -g 1" },
2892 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2894 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2895 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2896 "rate control override for specific intervals", "override" },
2897 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2898 OPT_OUTPUT, { .func_arg = opt_video_codec },
2899 "force video codec ('copy' to copy stream)", "codec" },
2900 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2902 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2904 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2905 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2906 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2907 "select the pass number (1 to 3)", "n" },
2908 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2909 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2910 "select two pass log file name prefix", "prefix" },
2911 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2912 "this option is deprecated, use the yadif filter instead" },
2913 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2914 "calculate PSNR of compressed frames" },
2915 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2916 "dump video coding statistics to file" },
2917 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2918 "dump video coding statistics to file", "file" },
2919 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2920 "set video filters", "filter_graph" },
2921 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2922 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2923 "specify intra matrix coeffs", "matrix" },
2924 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2925 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2926 "specify inter matrix coeffs", "matrix" },
2927 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2928 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2929 "specify intra matrix coeffs", "matrix" },
2930 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2931 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2932 "top=1/bottom=0/auto=-1 field first", "" },
2933 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2934 OPT_OUTPUT, { .func_arg = opt_old2new },
2935 "force video tag/fourcc", "fourcc/tag" },
2936 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2937 "show QP histogram" },
2938 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2939 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2940 "force the selected framerate, disable the best supported framerate selection" },
2941 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2942 OPT_OUTPUT, { .func_arg = opt_streamid },
2943 "set the value of an outfile streamid", "streamIndex:value" },
2944 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2945 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2946 "force key frames at specified timestamps", "timestamps" },
2947 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2948 "audio bitrate (please use -b:a)", "bitrate" },
2949 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2950 "video bitrate (please use -b:v)", "bitrate" },
2951 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2952 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2953 "use HW accelerated decoding", "hwaccel name" },
2954 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2955 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2956 "select a device for HW acceleration" "devicename" },
2959 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2960 "set the number of audio frames to record", "number" },
2961 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2962 "set audio quality (codec-specific)", "quality", },
2963 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2964 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2965 "set audio sampling rate (in Hz)", "rate" },
2966 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2967 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2968 "set number of audio channels", "channels" },
2969 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2971 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2972 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2973 "force audio codec ('copy' to copy stream)", "codec" },
2974 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2975 OPT_OUTPUT, { .func_arg = opt_old2new },
2976 "force audio tag/fourcc", "fourcc/tag" },
2977 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2978 "change audio volume (256=normal)" , "volume" },
2979 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2980 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2981 "set sample format", "format" },
2982 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2983 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2984 "set channel layout", "layout" },
2985 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2986 "set audio filters", "filter_graph" },
2987 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2988 "set the maximum number of channels to try to guess the channel layout" },
2990 /* subtitle options */
2991 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2992 "disable subtitle" },
2993 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2994 "force subtitle codec ('copy' to copy stream)", "codec" },
2995 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2996 , "force subtitle tag/fourcc", "fourcc/tag" },
2997 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2998 "fix subtitles duration" },
2999 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3000 "set canvas size (WxH or abbreviation)", "size" },
3003 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3004 "deprecated, use -channel", "channel" },
3005 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3006 "deprecated, use -standard", "standard" },
3007 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3010 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3011 "set the maximum demux-decode delay", "seconds" },
3012 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3013 "set the initial demux-decode delay", "seconds" },
3014 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3015 "override the options from ffserver", "" },
3017 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3018 "A comma-separated list of bitstream filters", "bitstream_filters" },
3019 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3020 "deprecated", "audio bitstream_filters" },
3021 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3022 "deprecated", "video bitstream_filters" },
3024 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3025 "set the audio options to the indicated preset", "preset" },
3026 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3027 "set the video options to the indicated preset", "preset" },
3028 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3029 "set the subtitle options to the indicated preset", "preset" },
3030 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3031 "set options from indicated preset file", "filename" },
3032 /* data codec support */
3033 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3034 "force data codec ('copy' to copy stream)", "codec" },
3035 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },