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"
43 #include "libavutil/time_internal.h"
45 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
47 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
50 for (i = 0; i < o->nb_ ## name; i++) {\
51 char *spec = o->name[i].specifier;\
52 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
53 outvar = o->name[i].u.type;\
59 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
62 for (i = 0; i < o->nb_ ## name; i++) {\
63 char *spec = o->name[i].specifier;\
64 if (!strcmp(spec, mediatype))\
65 outvar = o->name[i].u.type;\
69 const HWAccel hwaccels[] = {
71 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
74 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
77 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
82 char *vstats_filename;
85 float audio_drift_threshold = 0.1;
86 float dts_delta_threshold = 10;
87 float dts_error_threshold = 3600*30;
89 int audio_volume = 256;
90 int audio_sync_method = 0;
91 int video_sync_method = VSYNC_AUTO;
92 float frame_drop_threshold = 0;
93 int do_deinterlace = 0;
95 int do_benchmark_all = 0;
99 int start_at_zero = 0;
102 int exit_on_error = 0;
103 int print_stats = -1;
105 int stdin_interaction = 1;
106 int frame_bits_per_raw_sample = 0;
107 float max_error_rate = 2.0/3;
110 static int intra_only = 0;
111 static int file_overwrite = 0;
112 static int no_file_overwrite = 0;
113 static int do_psnr = 0;
114 static int input_sync;
115 static int override_ffserver = 0;
116 static int input_stream_potentially_available = 0;
117 static int ignore_unknown_streams = 0;
118 static int copy_unknown_streams = 0;
120 static void uninit_options(OptionsContext *o)
122 const OptionDef *po = options;
125 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
127 void *dst = (uint8_t*)o + po->u.off;
129 if (po->flags & OPT_SPEC) {
130 SpecifierOpt **so = dst;
131 int i, *count = (int*)(so + 1);
132 for (i = 0; i < *count; i++) {
133 av_freep(&(*so)[i].specifier);
134 if (po->flags & OPT_STRING)
135 av_freep(&(*so)[i].u.str);
139 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
144 for (i = 0; i < o->nb_stream_maps; i++)
145 av_freep(&o->stream_maps[i].linklabel);
146 av_freep(&o->stream_maps);
147 av_freep(&o->audio_channel_maps);
148 av_freep(&o->streamid_map);
149 av_freep(&o->attachments);
152 static void init_options(OptionsContext *o)
154 memset(o, 0, sizeof(*o));
156 o->stop_time = INT64_MAX;
157 o->mux_max_delay = 0.7;
158 o->start_time = AV_NOPTS_VALUE;
159 o->recording_time = INT64_MAX;
160 o->limit_filesize = UINT64_MAX;
161 o->chapters_input_file = INT_MAX;
162 o->accurate_seek = 1;
165 /* return a copy of the input with the stream specifiers removed from the keys */
166 static AVDictionary *strip_specifiers(AVDictionary *dict)
168 AVDictionaryEntry *e = NULL;
169 AVDictionary *ret = NULL;
171 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
172 char *p = strchr(e->key, ':');
176 av_dict_set(&ret, e->key, e->value, 0);
183 static int opt_sameq(void *optctx, const char *opt, const char *arg)
185 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
186 "If you are looking for an option to preserve the quality (which is not "
187 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
189 return AVERROR(EINVAL);
192 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
194 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
195 return opt_default(optctx, "channel", arg);
198 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
200 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
201 return opt_default(optctx, "standard", arg);
204 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
206 OptionsContext *o = optctx;
207 return parse_option(o, "codec:a", arg, options);
210 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
212 OptionsContext *o = optctx;
213 return parse_option(o, "codec:v", arg, options);
216 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
218 OptionsContext *o = optctx;
219 return parse_option(o, "codec:s", arg, options);
222 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
224 OptionsContext *o = optctx;
225 return parse_option(o, "codec:d", arg, options);
228 static int opt_map(void *optctx, const char *opt, const char *arg)
230 OptionsContext *o = optctx;
232 int i, negative = 0, file_idx;
233 int sync_file_idx = -1, sync_stream_idx = 0;
242 map = av_strdup(arg);
244 return AVERROR(ENOMEM);
246 /* parse sync stream first, just pick first matching stream */
247 if (sync = strchr(map, ',')) {
249 sync_file_idx = strtol(sync + 1, &sync, 0);
250 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
251 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
256 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
257 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
258 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
262 if (i == input_files[sync_file_idx]->nb_streams) {
263 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
264 "match any streams.\n", arg);
271 /* this mapping refers to lavfi output */
272 const char *c = map + 1;
273 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
274 m = &o->stream_maps[o->nb_stream_maps - 1];
275 m->linklabel = av_get_token(&c, "]");
277 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
281 if (allow_unused = strchr(map, '?'))
283 file_idx = strtol(map, &p, 0);
284 if (file_idx >= nb_input_files || file_idx < 0) {
285 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
289 /* disable some already defined maps */
290 for (i = 0; i < o->nb_stream_maps; i++) {
291 m = &o->stream_maps[i];
292 if (file_idx == m->file_index &&
293 check_stream_specifier(input_files[m->file_index]->ctx,
294 input_files[m->file_index]->ctx->streams[m->stream_index],
295 *p == ':' ? p + 1 : p) > 0)
299 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
300 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
301 *p == ':' ? p + 1 : p) <= 0)
303 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
304 m = &o->stream_maps[o->nb_stream_maps - 1];
306 m->file_index = file_idx;
309 if (sync_file_idx >= 0) {
310 m->sync_file_index = sync_file_idx;
311 m->sync_stream_index = sync_stream_idx;
313 m->sync_file_index = file_idx;
314 m->sync_stream_index = i;
321 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
323 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
324 "To ignore this, add a trailing '?' to the map.\n", arg);
333 static int opt_attach(void *optctx, const char *opt, const char *arg)
335 OptionsContext *o = optctx;
336 GROW_ARRAY(o->attachments, o->nb_attachments);
337 o->attachments[o->nb_attachments - 1] = arg;
341 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
343 OptionsContext *o = optctx;
348 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
349 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
351 /* muted channel syntax */
352 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
353 if ((n == 1 || n == 3) && m->channel_idx == -1) {
354 m->file_idx = m->stream_idx = -1;
356 m->ofile_idx = m->ostream_idx = -1;
361 n = sscanf(arg, "%d.%d.%d:%d.%d",
362 &m->file_idx, &m->stream_idx, &m->channel_idx,
363 &m->ofile_idx, &m->ostream_idx);
365 if (n != 3 && n != 5) {
366 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
367 "[file.stream.channel|-1][:syncfile:syncstream]\n");
371 if (n != 5) // only file.stream.channel specified
372 m->ofile_idx = m->ostream_idx = -1;
375 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
376 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
380 if (m->stream_idx < 0 ||
381 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
382 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
383 m->file_idx, m->stream_idx);
386 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
387 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
388 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
389 m->file_idx, m->stream_idx);
392 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
393 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
394 m->file_idx, m->stream_idx, m->channel_idx);
400 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
402 av_free(sdp_filename);
403 sdp_filename = av_strdup(arg);
408 * Parse a metadata specifier passed as 'arg' parameter.
409 * @param arg metadata string to parse
410 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
411 * @param index for type c/p, chapter/program index is written here
412 * @param stream_spec for type s, the stream specifier is written here
414 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
422 if (*(++arg) && *arg != ':') {
423 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
426 *stream_spec = *arg == ':' ? arg + 1 : "";
431 *index = strtol(++arg, NULL, 0);
434 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
441 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
443 AVDictionary **meta_in = NULL;
444 AVDictionary **meta_out = NULL;
446 char type_in, type_out;
447 const char *istream_spec = NULL, *ostream_spec = NULL;
448 int idx_in = 0, idx_out = 0;
450 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
451 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
454 if (type_out == 'g' || !*outspec)
455 o->metadata_global_manual = 1;
456 if (type_out == 's' || !*outspec)
457 o->metadata_streams_manual = 1;
458 if (type_out == 'c' || !*outspec)
459 o->metadata_chapters_manual = 1;
463 if (type_in == 'g' || type_out == 'g')
464 o->metadata_global_manual = 1;
465 if (type_in == 's' || type_out == 's')
466 o->metadata_streams_manual = 1;
467 if (type_in == 'c' || type_out == 'c')
468 o->metadata_chapters_manual = 1;
470 /* ic is NULL when just disabling automatic mappings */
474 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
475 if ((index) < 0 || (index) >= (nb_elems)) {\
476 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
481 #define SET_DICT(type, meta, context, index)\
484 meta = &context->metadata;\
487 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
488 meta = &context->chapters[index]->metadata;\
491 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
492 meta = &context->programs[index]->metadata;\
495 break; /* handled separately below */ \
496 default: av_assert0(0);\
499 SET_DICT(type_in, meta_in, ic, idx_in);
500 SET_DICT(type_out, meta_out, oc, idx_out);
502 /* for input streams choose first matching stream */
503 if (type_in == 's') {
504 for (i = 0; i < ic->nb_streams; i++) {
505 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
506 meta_in = &ic->streams[i]->metadata;
512 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
517 if (type_out == 's') {
518 for (i = 0; i < oc->nb_streams; i++) {
519 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
520 meta_out = &oc->streams[i]->metadata;
521 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
526 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
531 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
533 OptionsContext *o = optctx;
535 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
536 struct tm time = *gmtime((time_t*)&recording_timestamp);
537 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
539 parse_option(o, "metadata", buf, options);
541 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
542 "tag instead.\n", opt);
546 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
548 const AVCodecDescriptor *desc;
549 const char *codec_string = encoder ? "encoder" : "decoder";
553 avcodec_find_encoder_by_name(name) :
554 avcodec_find_decoder_by_name(name);
556 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
557 codec = encoder ? avcodec_find_encoder(desc->id) :
558 avcodec_find_decoder(desc->id);
560 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
561 codec_string, codec->name, desc->name);
565 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
568 if (codec->type != type) {
569 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
575 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
577 char *codec_name = NULL;
579 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
581 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
582 st->codec->codec_id = codec->id;
585 return avcodec_find_decoder(st->codec->codec_id);
588 /* Add all the streams from the given input file to the global
589 * list of input streams. */
590 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
594 for (i = 0; i < ic->nb_streams; i++) {
595 AVStream *st = ic->streams[i];
596 AVCodecContext *dec = st->codec;
597 InputStream *ist = av_mallocz(sizeof(*ist));
598 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
599 char *codec_tag = NULL;
601 char *discard_str = NULL;
602 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
607 GROW_ARRAY(input_streams, nb_input_streams);
608 input_streams[nb_input_streams - 1] = ist;
611 ist->file_index = nb_input_files;
613 st->discard = AVDISCARD_ALL;
616 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
619 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
621 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
623 uint32_t tag = strtol(codec_tag, &next, 0);
625 tag = AV_RL32(codec_tag);
626 st->codec->codec_tag = tag;
629 ist->dec = choose_decoder(o, ic, st);
630 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
632 ist->reinit_filters = -1;
633 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
635 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
636 ist->user_set_discard = AVDISCARD_NONE;
637 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
638 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
643 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
645 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
647 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
651 ret = avcodec_copy_context(ist->dec_ctx, dec);
653 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
657 switch (dec->codec_type) {
658 case AVMEDIA_TYPE_VIDEO:
660 ist->dec = avcodec_find_decoder(dec->codec_id);
661 if (av_codec_get_lowres(dec)) {
662 dec->flags |= CODEC_FLAG_EMU_EDGE;
665 ist->resample_height = ist->dec_ctx->height;
666 ist->resample_width = ist->dec_ctx->width;
667 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
669 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
670 if (framerate && av_parse_video_rate(&ist->framerate,
672 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
677 ist->top_field_first = -1;
678 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
680 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
682 if (!strcmp(hwaccel, "none"))
683 ist->hwaccel_id = HWACCEL_NONE;
684 else if (!strcmp(hwaccel, "auto"))
685 ist->hwaccel_id = HWACCEL_AUTO;
688 for (i = 0; hwaccels[i].name; i++) {
689 if (!strcmp(hwaccels[i].name, hwaccel)) {
690 ist->hwaccel_id = hwaccels[i].id;
695 if (!ist->hwaccel_id) {
696 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
698 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
699 for (i = 0; hwaccels[i].name; i++)
700 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
701 av_log(NULL, AV_LOG_FATAL, "\n");
707 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
708 if (hwaccel_device) {
709 ist->hwaccel_device = av_strdup(hwaccel_device);
710 if (!ist->hwaccel_device)
713 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
716 case AVMEDIA_TYPE_AUDIO:
717 ist->guess_layout_max = INT_MAX;
718 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
719 guess_input_channel_layout(ist);
721 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
722 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
723 ist->resample_channels = ist->dec_ctx->channels;
724 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
727 case AVMEDIA_TYPE_DATA:
728 case AVMEDIA_TYPE_SUBTITLE: {
729 char *canvas_size = NULL;
731 ist->dec = avcodec_find_decoder(dec->codec_id);
732 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
733 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
735 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
736 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
741 case AVMEDIA_TYPE_ATTACHMENT:
742 case AVMEDIA_TYPE_UNKNOWN:
750 static void assert_file_overwrite(const char *filename)
752 if (file_overwrite && no_file_overwrite) {
753 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
757 if (!file_overwrite) {
758 const char *proto_name = avio_find_protocol_name(filename);
759 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
760 if (stdin_interaction && !no_file_overwrite) {
761 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
764 signal(SIGINT, SIG_DFL);
766 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
772 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
779 static void dump_attachment(AVStream *st, const char *filename)
782 AVIOContext *out = NULL;
783 AVDictionaryEntry *e;
785 if (!st->codec->extradata_size) {
786 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
787 nb_input_files - 1, st->index);
790 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
793 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
794 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
798 assert_file_overwrite(filename);
800 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
801 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
806 avio_write(out, st->codec->extradata, st->codec->extradata_size);
811 static int open_input_file(OptionsContext *o, const char *filename)
815 AVInputFormat *file_iformat = NULL;
819 AVDictionary *unused_opts = NULL;
820 AVDictionaryEntry *e = NULL;
821 int orig_nb_streams; // number of streams before avformat_find_stream_info
822 char * video_codec_name = NULL;
823 char * audio_codec_name = NULL;
824 char *subtitle_codec_name = NULL;
825 char * data_codec_name = NULL;
826 int scan_all_pmts_set = 0;
829 if (!(file_iformat = av_find_input_format(o->format))) {
830 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
835 if (!strcmp(filename, "-"))
838 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
839 strcmp(filename, "/dev/stdin");
841 /* get default parameters from command line */
842 ic = avformat_alloc_context();
844 print_error(filename, AVERROR(ENOMEM));
847 if (o->nb_audio_sample_rate) {
848 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
850 if (o->nb_audio_channels) {
851 /* because we set audio_channels based on both the "ac" and
852 * "channel_layout" options, we need to check that the specified
853 * demuxer actually has the "channels" option before setting it */
854 if (file_iformat && file_iformat->priv_class &&
855 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
856 AV_OPT_SEARCH_FAKE_OBJ)) {
857 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
860 if (o->nb_frame_rates) {
861 /* set the format-level framerate option;
862 * this is important for video grabbers, e.g. x11 */
863 if (file_iformat && file_iformat->priv_class &&
864 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
865 AV_OPT_SEARCH_FAKE_OBJ)) {
866 av_dict_set(&o->g->format_opts, "framerate",
867 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
870 if (o->nb_frame_sizes) {
871 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
873 if (o->nb_frame_pix_fmts)
874 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
876 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
877 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
878 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
879 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
881 ic->video_codec_id = video_codec_name ?
882 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
883 ic->audio_codec_id = audio_codec_name ?
884 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
885 ic->subtitle_codec_id= subtitle_codec_name ?
886 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
887 ic->data_codec_id = data_codec_name ?
888 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
890 if (video_codec_name)
891 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
892 if (audio_codec_name)
893 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
894 if (subtitle_codec_name)
895 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
897 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
899 ic->flags |= AVFMT_FLAG_NONBLOCK;
900 ic->interrupt_callback = int_cb;
902 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
903 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
904 scan_all_pmts_set = 1;
906 /* open the input file with generic avformat function */
907 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
909 print_error(filename, err);
912 if (scan_all_pmts_set)
913 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
914 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
915 assert_avoptions(o->g->format_opts);
917 /* apply forced codec ids */
918 for (i = 0; i < ic->nb_streams; i++)
919 choose_decoder(o, ic, ic->streams[i]);
921 /* Set AVCodecContext options for avformat_find_stream_info */
922 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
923 orig_nb_streams = ic->nb_streams;
925 /* If not enough info to get the stream parameters, we decode the
926 first frames to get it. (used in mpeg case for example) */
927 ret = avformat_find_stream_info(ic, opts);
929 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
930 if (ic->nb_streams == 0) {
931 avformat_close_input(&ic);
936 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
937 /* add the stream start time */
938 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
939 timestamp += ic->start_time;
941 /* if seeking requested, we execute it */
942 if (o->start_time != AV_NOPTS_VALUE) {
943 int64_t seek_timestamp = timestamp;
945 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
946 int dts_heuristic = 0;
947 for (i=0; i<ic->nb_streams; i++) {
948 AVCodecContext *avctx = ic->streams[i]->codec;
949 if (avctx->has_b_frames)
953 seek_timestamp -= 3*AV_TIME_BASE / 23;
956 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
958 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
959 filename, (double)timestamp / AV_TIME_BASE);
963 /* update the current parameters so that they match the one of the input stream */
964 add_input_streams(o, ic);
966 /* dump the file content */
967 av_dump_format(ic, nb_input_files, filename, 0);
969 GROW_ARRAY(input_files, nb_input_files);
970 f = av_mallocz(sizeof(*f));
973 input_files[nb_input_files - 1] = f;
976 f->ist_index = nb_input_streams - ic->nb_streams;
977 f->start_time = o->start_time;
978 f->recording_time = o->recording_time;
979 f->input_ts_offset = o->input_ts_offset;
980 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
981 f->nb_streams = ic->nb_streams;
982 f->rate_emu = o->rate_emu;
983 f->accurate_seek = o->accurate_seek;
985 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
988 /* check if all codec options have been used */
989 unused_opts = strip_specifiers(o->g->codec_opts);
990 for (i = f->ist_index; i < nb_input_streams; i++) {
992 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
993 AV_DICT_IGNORE_SUFFIX)))
994 av_dict_set(&unused_opts, e->key, NULL, 0);
998 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
999 const AVClass *class = avcodec_get_class();
1000 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1001 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1002 const AVClass *fclass = avformat_get_class();
1003 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1004 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1005 if (!option || foption)
1009 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1010 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1011 "input file #%d (%s) is not a decoding option.\n", e->key,
1012 option->help ? option->help : "", nb_input_files - 1,
1017 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1018 "input file #%d (%s) has not been used for any stream. The most "
1019 "likely reason is either wrong type (e.g. a video option with "
1020 "no video streams) or that it is a private option of some decoder "
1021 "which was not actually used for any stream.\n", e->key,
1022 option->help ? option->help : "", nb_input_files - 1, filename);
1024 av_dict_free(&unused_opts);
1026 for (i = 0; i < o->nb_dump_attachment; i++) {
1029 for (j = 0; j < ic->nb_streams; j++) {
1030 AVStream *st = ic->streams[j];
1032 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1033 dump_attachment(st, o->dump_attachment[i].u.str);
1037 for (i = 0; i < orig_nb_streams; i++)
1038 av_dict_free(&opts[i]);
1041 input_stream_potentially_available = 1;
1046 static uint8_t *get_line(AVIOContext *s)
1052 if (avio_open_dyn_buf(&line) < 0) {
1053 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1057 while ((c = avio_r8(s)) && c != '\n')
1060 avio_close_dyn_buf(line, &buf);
1065 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1068 char filename[1000];
1069 const char *base[3] = { getenv("AVCONV_DATADIR"),
1074 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1078 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1079 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1080 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1083 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1084 i != 1 ? "" : "/.avconv", preset_name);
1085 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1091 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1093 char *codec_name = NULL;
1095 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1097 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1098 NULL, ost->st->codec->codec_type);
1099 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1100 } else if (!strcmp(codec_name, "copy"))
1101 ost->stream_copy = 1;
1103 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1104 ost->st->codec->codec_id = ost->enc->id;
1108 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1111 AVStream *st = avformat_new_stream(oc, NULL);
1112 int idx = oc->nb_streams - 1, ret = 0;
1113 char *bsf = NULL, *next, *codec_tag = NULL;
1114 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1119 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1123 if (oc->nb_streams - 1 < o->nb_streamid_map)
1124 st->id = o->streamid_map[oc->nb_streams - 1];
1126 GROW_ARRAY(output_streams, nb_output_streams);
1127 if (!(ost = av_mallocz(sizeof(*ost))))
1129 output_streams[nb_output_streams - 1] = ost;
1131 ost->file_index = nb_output_files - 1;
1134 st->codec->codec_type = type;
1135 choose_encoder(o, oc, ost);
1137 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1138 if (!ost->enc_ctx) {
1139 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1142 ost->enc_ctx->codec_type = type;
1145 AVIOContext *s = NULL;
1146 char *buf = NULL, *arg = NULL, *preset = NULL;
1148 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1150 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1151 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1154 if (!buf[0] || buf[0] == '#') {
1158 if (!(arg = strchr(buf, '='))) {
1159 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1163 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1165 } while (!s->eof_reached);
1169 av_log(NULL, AV_LOG_FATAL,
1170 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1171 preset, ost->file_index, ost->index);
1175 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1178 ost->max_frames = INT64_MAX;
1179 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1180 for (i = 0; i<o->nb_max_frames; i++) {
1181 char *p = o->max_frames[i].specifier;
1182 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1183 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1188 ost->copy_prior_start = -1;
1189 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1191 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1194 if (next = strchr(bsf, ','))
1196 if (arg = strchr(bsf, '='))
1198 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1199 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1203 bsfc_prev->next = bsfc;
1205 ost->bitstream_filters = bsfc;
1206 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1212 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1214 uint32_t tag = strtol(codec_tag, &next, 0);
1216 tag = AV_RL32(codec_tag);
1217 ost->st->codec->codec_tag =
1218 ost->enc_ctx->codec_tag = tag;
1221 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1223 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1224 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1227 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1228 ost->disposition = av_strdup(ost->disposition);
1230 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1231 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1233 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1235 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1236 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1237 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1239 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1241 ost->source_index = source_index;
1242 if (source_index >= 0) {
1243 ost->sync_ist = input_streams[source_index];
1244 input_streams[source_index]->discard = 0;
1245 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1247 ost->last_mux_dts = AV_NOPTS_VALUE;
1252 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1255 const char *p = str;
1262 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1269 /* read file contents into a string */
1270 static uint8_t *read_file(const char *filename)
1272 AVIOContext *pb = NULL;
1273 AVIOContext *dyn_buf = NULL;
1274 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1275 uint8_t buf[1024], *str;
1278 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1282 ret = avio_open_dyn_buf(&dyn_buf);
1287 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1288 avio_write(dyn_buf, buf, ret);
1289 avio_w8(dyn_buf, 0);
1292 ret = avio_close_dyn_buf(dyn_buf, &str);
1298 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1301 AVStream *st = ost->st;
1303 if (ost->filters_script && ost->filters) {
1304 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1305 "output stream #%d:%d.\n", nb_output_files, st->index);
1309 if (ost->filters_script)
1310 return read_file(ost->filters_script);
1311 else if (ost->filters)
1312 return av_strdup(ost->filters);
1314 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1318 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1319 const OutputStream *ost, enum AVMediaType type)
1321 if (ost->filters_script || ost->filters) {
1322 av_log(NULL, AV_LOG_ERROR,
1323 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1324 "Filtering and streamcopy cannot be used together.\n",
1325 ost->filters ? "Filtergraph" : "Filtergraph script",
1326 ost->filters ? ost->filters : ost->filters_script,
1327 av_get_media_type_string(type), ost->file_index, ost->index);
1332 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1336 AVCodecContext *video_enc;
1337 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1339 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1341 video_enc = ost->enc_ctx;
1343 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1344 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1345 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1348 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1349 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1351 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1352 if (frame_aspect_ratio) {
1354 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1355 q.num <= 0 || q.den <= 0) {
1356 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1359 ost->frame_aspect_ratio = q;
1362 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1363 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1365 if (!ost->stream_copy) {
1366 const char *p = NULL;
1367 char *frame_size = NULL;
1368 char *frame_pix_fmt = NULL;
1369 char *intra_matrix = NULL, *inter_matrix = NULL;
1370 char *chroma_intra_matrix = NULL;
1374 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1375 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1376 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1380 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1381 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1382 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1383 ost->keep_pix_fmt = 1;
1384 if (!*++frame_pix_fmt)
1385 frame_pix_fmt = NULL;
1387 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1388 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1391 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1394 video_enc->gop_size = 0;
1395 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1397 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1398 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1401 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1403 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1404 if (chroma_intra_matrix) {
1405 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1407 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1410 av_codec_set_chroma_intra_matrix(video_enc, p);
1411 parse_matrix_coeffs(p, chroma_intra_matrix);
1413 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1415 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1416 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1419 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1422 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1423 for (i = 0; p; i++) {
1425 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1427 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1430 video_enc->rc_override =
1431 av_realloc_array(video_enc->rc_override,
1432 i + 1, sizeof(RcOverride));
1433 if (!video_enc->rc_override) {
1434 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1437 video_enc->rc_override[i].start_frame = start;
1438 video_enc->rc_override[i].end_frame = end;
1440 video_enc->rc_override[i].qscale = q;
1441 video_enc->rc_override[i].quality_factor = 1.0;
1444 video_enc->rc_override[i].qscale = 0;
1445 video_enc->rc_override[i].quality_factor = -q/100.0;
1450 video_enc->rc_override_count = i;
1453 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1456 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1459 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1460 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1463 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1464 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1468 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1469 if (ost->logfile_prefix &&
1470 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1474 char logfilename[1024];
1477 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1478 ost->logfile_prefix ? ost->logfile_prefix :
1479 DEFAULT_PASS_LOGFILENAME_PREFIX,
1481 if (!strcmp(ost->enc->name, "libx264")) {
1482 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1484 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1485 char *logbuffer = read_file(logfilename);
1488 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1492 video_enc->stats_in = logbuffer;
1494 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1495 f = av_fopen_utf8(logfilename, "wb");
1497 av_log(NULL, AV_LOG_FATAL,
1498 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1499 logfilename, strerror(errno));
1507 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1508 if (ost->forced_keyframes)
1509 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1511 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1513 ost->top_field_first = -1;
1514 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1517 ost->avfilter = get_ost_filters(o, oc, ost);
1521 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1524 if (ost->stream_copy)
1525 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1530 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1535 AVCodecContext *audio_enc;
1537 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1540 audio_enc = ost->enc_ctx;
1541 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1543 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1544 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1546 if (!ost->stream_copy) {
1547 char *sample_fmt = NULL;
1549 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1551 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1553 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1554 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1558 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1560 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1561 ost->apad = av_strdup(ost->apad);
1563 ost->avfilter = get_ost_filters(o, oc, ost);
1567 /* check for channel mapping for this audio stream */
1568 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1569 AudioChannelMap *map = &o->audio_channel_maps[n];
1570 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1571 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1574 if (map->channel_idx == -1) {
1576 } else if (ost->source_index < 0) {
1577 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1578 ost->file_index, ost->st->index);
1581 ist = input_streams[ost->source_index];
1584 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1585 if (av_reallocp_array(&ost->audio_channels_map,
1586 ost->audio_channels_mapped + 1,
1587 sizeof(*ost->audio_channels_map)
1591 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1597 if (ost->stream_copy)
1598 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1603 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1607 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1608 if (!ost->stream_copy) {
1609 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1616 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1620 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1621 if (!ost->stream_copy) {
1622 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1629 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1631 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1632 ost->stream_copy = 1;
1637 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1641 AVCodecContext *subtitle_enc;
1643 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1645 subtitle_enc = ost->enc_ctx;
1647 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1649 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1651 if (!ost->stream_copy) {
1652 char *frame_size = NULL;
1654 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1655 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1656 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1664 /* arg format is "output-stream-index:streamid-value". */
1665 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1667 OptionsContext *o = optctx;
1672 av_strlcpy(idx_str, arg, sizeof(idx_str));
1673 p = strchr(idx_str, ':');
1675 av_log(NULL, AV_LOG_FATAL,
1676 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1681 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1682 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1683 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1687 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1689 AVFormatContext *is = ifile->ctx;
1690 AVFormatContext *os = ofile->ctx;
1694 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1696 return AVERROR(ENOMEM);
1699 for (i = 0; i < is->nb_chapters; i++) {
1700 AVChapter *in_ch = is->chapters[i], *out_ch;
1701 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1702 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1703 AV_TIME_BASE_Q, in_ch->time_base);
1704 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1705 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1708 if (in_ch->end < ts_off)
1710 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1713 out_ch = av_mallocz(sizeof(AVChapter));
1715 return AVERROR(ENOMEM);
1717 out_ch->id = in_ch->id;
1718 out_ch->time_base = in_ch->time_base;
1719 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1720 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1723 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1725 os->chapters[os->nb_chapters++] = out_ch;
1730 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1733 AVFormatContext *ic = avformat_alloc_context();
1735 ic->interrupt_callback = int_cb;
1736 err = avformat_open_input(&ic, filename, NULL, NULL);
1739 /* copy stream format */
1740 for(i=0;i<ic->nb_streams;i++) {
1744 const char *enc_config;
1746 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1748 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1749 return AVERROR(EINVAL);
1751 if (codec->type == AVMEDIA_TYPE_AUDIO)
1752 opt_audio_codec(o, "c:a", codec->name);
1753 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1754 opt_video_codec(o, "c:v", codec->name);
1755 ost = new_output_stream(o, s, codec->type, -1);
1758 avcodec_get_context_defaults3(st->codec, codec);
1759 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1761 AVDictionary *opts = NULL;
1762 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1763 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1764 av_dict_free(&opts);
1767 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1768 choose_sample_fmt(st, codec);
1769 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1770 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1771 avcodec_copy_context(ost->enc_ctx, st->codec);
1773 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1776 avformat_close_input(&ic);
1780 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1781 AVFormatContext *oc)
1785 switch (ofilter->type) {
1786 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1787 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1789 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1794 ost->source_index = -1;
1795 ost->filter = ofilter;
1799 if (ost->stream_copy) {
1800 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1801 "which is fed from a complex filtergraph. Filtering and streamcopy "
1802 "cannot be used together.\n", ost->file_index, ost->index);
1806 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1807 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1808 av_log(NULL, AV_LOG_ERROR,
1809 "%s '%s' was specified through the %s option "
1810 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1811 "%s and -filter_complex cannot be used together for the same stream.\n",
1812 ost->filters ? "Filtergraph" : "Filtergraph script",
1813 ost->filters ? ost->filters : ost->filters_script,
1814 opt, ost->file_index, ost->index, opt);
1818 avfilter_inout_free(&ofilter->out_tmp);
1821 static int init_complex_filters(void)
1825 for (i = 0; i < nb_filtergraphs; i++) {
1826 ret = init_complex_filtergraph(filtergraphs[i]);
1833 static int configure_complex_filters(void)
1837 for (i = 0; i < nb_filtergraphs; i++)
1838 if (!filtergraphs[i]->graph &&
1839 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1844 static int open_output_file(OptionsContext *o, const char *filename)
1846 AVFormatContext *oc;
1848 AVOutputFormat *file_oformat;
1852 AVDictionary *unused_opts = NULL;
1853 AVDictionaryEntry *e = NULL;
1856 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1857 o->stop_time = INT64_MAX;
1858 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1861 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1862 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1863 if (o->stop_time <= start_time) {
1864 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1867 o->recording_time = o->stop_time - start_time;
1871 GROW_ARRAY(output_files, nb_output_files);
1872 of = av_mallocz(sizeof(*of));
1875 output_files[nb_output_files - 1] = of;
1877 of->ost_index = nb_output_streams;
1878 of->recording_time = o->recording_time;
1879 of->start_time = o->start_time;
1880 of->limit_filesize = o->limit_filesize;
1881 of->shortest = o->shortest;
1882 av_dict_copy(&of->opts, o->g->format_opts, 0);
1884 if (!strcmp(filename, "-"))
1887 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1889 print_error(filename, err);
1894 if (o->recording_time != INT64_MAX)
1895 oc->duration = o->recording_time;
1897 file_oformat= oc->oformat;
1898 oc->interrupt_callback = int_cb;
1900 /* create streams for all unlabeled output pads */
1901 for (i = 0; i < nb_filtergraphs; i++) {
1902 FilterGraph *fg = filtergraphs[i];
1903 for (j = 0; j < fg->nb_outputs; j++) {
1904 OutputFilter *ofilter = fg->outputs[j];
1906 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1909 switch (ofilter->type) {
1910 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1911 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1912 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1914 init_output_filter(ofilter, o, oc);
1918 /* ffserver seeking with date=... needs a date reference */
1919 if (!strcmp(file_oformat->name, "ffm") &&
1920 av_strstart(filename, "http:", NULL)) {
1921 int err = parse_option(o, "metadata", "creation_time=now", options);
1923 print_error(filename, err);
1928 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1929 av_strstart(filename, "http:", NULL)) {
1931 /* special case for files sent to ffserver: we get the stream
1932 parameters from ffserver */
1933 int err = read_ffserver_streams(o, oc, filename);
1935 print_error(filename, err);
1938 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1939 ost = output_streams[j];
1940 for (i = 0; i < nb_input_streams; i++) {
1941 ist = input_streams[i];
1942 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1944 ost->source_index= i;
1945 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1946 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1948 ist->st->discard = ist->user_set_discard;
1953 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));
1957 } else if (!o->nb_stream_maps) {
1958 char *subtitle_codec_name = NULL;
1959 /* pick the "best" stream of each type */
1961 /* video: highest resolution */
1962 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1963 int area = 0, idx = -1;
1964 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1965 for (i = 0; i < nb_input_streams; i++) {
1967 ist = input_streams[i];
1968 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
1969 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1971 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1973 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1980 new_video_stream(o, oc, idx);
1983 /* audio: most channels */
1984 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1985 int channels = 0, idx = -1;
1986 for (i = 0; i < nb_input_streams; i++) {
1987 ist = input_streams[i];
1988 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1989 ist->st->codec->channels > channels) {
1990 channels = ist->st->codec->channels;
1995 new_audio_stream(o, oc, idx);
1998 /* subtitles: pick first */
1999 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2000 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2001 for (i = 0; i < nb_input_streams; i++)
2002 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2003 AVCodecDescriptor const *input_descriptor =
2004 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2005 AVCodecDescriptor const *output_descriptor = NULL;
2006 AVCodec const *output_codec =
2007 avcodec_find_encoder(oc->oformat->subtitle_codec);
2008 int input_props = 0, output_props = 0;
2010 output_descriptor = avcodec_descriptor_get(output_codec->id);
2011 if (input_descriptor)
2012 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2013 if (output_descriptor)
2014 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2015 if (subtitle_codec_name ||
2016 input_props & output_props ||
2017 // Map dvb teletext which has neither property to any output subtitle encoder
2018 input_descriptor && output_descriptor &&
2019 (!input_descriptor->props ||
2020 !output_descriptor->props)) {
2021 new_subtitle_stream(o, oc, i);
2026 /* Data only if codec id match */
2027 if (!o->data_disable ) {
2028 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2029 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2030 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2031 && input_streams[i]->st->codec->codec_id == codec_id )
2032 new_data_stream(o, oc, i);
2036 for (i = 0; i < o->nb_stream_maps; i++) {
2037 StreamMap *map = &o->stream_maps[i];
2042 if (map->linklabel) {
2044 OutputFilter *ofilter = NULL;
2047 for (j = 0; j < nb_filtergraphs; j++) {
2048 fg = filtergraphs[j];
2049 for (k = 0; k < fg->nb_outputs; k++) {
2050 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2051 if (out && !strcmp(out->name, map->linklabel)) {
2052 ofilter = fg->outputs[k];
2059 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2060 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2063 init_output_filter(ofilter, o, oc);
2065 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2067 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2068 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2070 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2072 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2074 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2078 switch (ist->st->codec->codec_type) {
2079 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2080 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2081 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2082 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2083 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2084 case AVMEDIA_TYPE_UNKNOWN:
2085 if (copy_unknown_streams) {
2086 ost = new_unknown_stream (o, oc, src_idx);
2090 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2091 "Cannot map stream #%d:%d - unsupported type.\n",
2092 map->file_index, map->stream_index);
2093 if (!ignore_unknown_streams) {
2094 av_log(NULL, AV_LOG_FATAL,
2095 "If you want unsupported types ignored instead "
2096 "of failing, please use the -ignore_unknown option\n"
2097 "If you want them copied, please use -copy_unknown\n");
2102 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2103 + map->sync_stream_index];
2108 /* handle attached files */
2109 for (i = 0; i < o->nb_attachments; i++) {
2111 uint8_t *attachment;
2115 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2116 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2120 if ((len = avio_size(pb)) <= 0) {
2121 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2125 if (!(attachment = av_malloc(len))) {
2126 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2130 avio_read(pb, attachment, len);
2132 ost = new_attachment_stream(o, oc, -1);
2133 ost->stream_copy = 1;
2134 ost->attachment_filename = o->attachments[i];
2136 ost->st->codec->extradata = attachment;
2137 ost->st->codec->extradata_size = len;
2139 p = strrchr(o->attachments[i], '/');
2140 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2144 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2145 AVDictionaryEntry *e;
2146 ost = output_streams[i];
2148 if ((ost->stream_copy || ost->attachment_filename)
2149 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2150 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2151 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2155 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2156 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2157 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2161 /* check if all codec options have been used */
2162 unused_opts = strip_specifiers(o->g->codec_opts);
2163 for (i = of->ost_index; i < nb_output_streams; i++) {
2165 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2166 AV_DICT_IGNORE_SUFFIX)))
2167 av_dict_set(&unused_opts, e->key, NULL, 0);
2171 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2172 const AVClass *class = avcodec_get_class();
2173 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2174 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2175 const AVClass *fclass = avformat_get_class();
2176 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2177 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2178 if (!option || foption)
2182 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2183 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2184 "output file #%d (%s) is not an encoding option.\n", e->key,
2185 option->help ? option->help : "", nb_output_files - 1,
2190 // gop_timecode is injected by generic code but not always used
2191 if (!strcmp(e->key, "gop_timecode"))
2194 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2195 "output file #%d (%s) has not been used for any stream. The most "
2196 "likely reason is either wrong type (e.g. a video option with "
2197 "no video streams) or that it is a private option of some encoder "
2198 "which was not actually used for any stream.\n", e->key,
2199 option->help ? option->help : "", nb_output_files - 1, filename);
2201 av_dict_free(&unused_opts);
2203 /* set the encoding/decoding_needed flags */
2204 for (i = of->ost_index; i < nb_output_streams; i++) {
2205 OutputStream *ost = output_streams[i];
2207 ost->encoding_needed = !ost->stream_copy;
2208 if (ost->encoding_needed && ost->source_index >= 0) {
2209 InputStream *ist = input_streams[ost->source_index];
2210 ist->decoding_needed |= DECODING_FOR_OST;
2214 /* check filename in case of an image number is expected */
2215 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2216 if (!av_filename_number_test(oc->filename)) {
2217 print_error(oc->filename, AVERROR(EINVAL));
2222 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2223 av_log(NULL, AV_LOG_ERROR,
2224 "No input streams but output needs an input stream\n");
2228 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2229 /* test if it already exists to avoid losing precious files */
2230 assert_file_overwrite(filename);
2233 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2234 &oc->interrupt_callback,
2236 print_error(filename, err);
2239 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2240 assert_file_overwrite(filename);
2242 if (o->mux_preload) {
2243 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2245 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2248 for (i = 0; i < o->nb_metadata_map; i++) {
2250 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2252 if (in_file_index >= nb_input_files) {
2253 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2256 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2257 in_file_index >= 0 ?
2258 input_files[in_file_index]->ctx : NULL, o);
2262 if (o->chapters_input_file >= nb_input_files) {
2263 if (o->chapters_input_file == INT_MAX) {
2264 /* copy chapters from the first input file that has them*/
2265 o->chapters_input_file = -1;
2266 for (i = 0; i < nb_input_files; i++)
2267 if (input_files[i]->ctx->nb_chapters) {
2268 o->chapters_input_file = i;
2272 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2273 o->chapters_input_file);
2277 if (o->chapters_input_file >= 0)
2278 copy_chapters(input_files[o->chapters_input_file], of,
2279 !o->metadata_chapters_manual);
2281 /* copy global metadata by default */
2282 if (!o->metadata_global_manual && nb_input_files){
2283 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2284 AV_DICT_DONT_OVERWRITE);
2285 if(o->recording_time != INT64_MAX)
2286 av_dict_set(&oc->metadata, "duration", NULL, 0);
2287 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2289 if (!o->metadata_streams_manual)
2290 for (i = of->ost_index; i < nb_output_streams; i++) {
2292 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2294 ist = input_streams[output_streams[i]->source_index];
2295 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2296 if (!output_streams[i]->stream_copy) {
2297 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2298 if (ist->autorotate)
2299 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2303 /* process manually set metadata */
2304 for (i = 0; i < o->nb_metadata; i++) {
2307 const char *stream_spec;
2308 int index = 0, j, ret = 0;
2311 val = strchr(o->metadata[i].u.str, '=');
2313 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2314 o->metadata[i].u.str);
2319 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2320 !strcmp(val, "now")) {
2321 time_t now = time(0);
2322 struct tm *ptm, tmbuf;
2323 ptm = localtime_r(&now, &tmbuf);
2325 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2330 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2332 for (j = 0; j < oc->nb_streams; j++) {
2333 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2334 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2335 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2336 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2337 ost->rotate_overridden = 1;
2349 if (index < 0 || index >= oc->nb_chapters) {
2350 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2353 m = &oc->chapters[index]->metadata;
2356 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2359 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2366 static int opt_target(void *optctx, const char *opt, const char *arg)
2368 OptionsContext *o = optctx;
2369 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2370 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2372 if (!strncmp(arg, "pal-", 4)) {
2375 } else if (!strncmp(arg, "ntsc-", 5)) {
2378 } else if (!strncmp(arg, "film-", 5)) {
2382 /* Try to determine PAL/NTSC by peeking in the input files */
2383 if (nb_input_files) {
2385 for (j = 0; j < nb_input_files; j++) {
2386 for (i = 0; i < input_files[j]->nb_streams; i++) {
2387 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2388 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2391 fr = c->time_base.den * 1000 / c->time_base.num;
2395 } else if ((fr == 29970) || (fr == 23976)) {
2400 if (norm != UNKNOWN)
2404 if (norm != UNKNOWN)
2405 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2408 if (norm == UNKNOWN) {
2409 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2410 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2411 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2415 if (!strcmp(arg, "vcd")) {
2416 opt_video_codec(o, "c:v", "mpeg1video");
2417 opt_audio_codec(o, "c:a", "mp2");
2418 parse_option(o, "f", "vcd", options);
2420 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2421 parse_option(o, "r", frame_rates[norm], options);
2422 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2424 opt_default(NULL, "b:v", "1150000");
2425 opt_default(NULL, "maxrate:v", "1150000");
2426 opt_default(NULL, "minrate:v", "1150000");
2427 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2429 opt_default(NULL, "b:a", "224000");
2430 parse_option(o, "ar", "44100", options);
2431 parse_option(o, "ac", "2", options);
2433 opt_default(NULL, "packetsize", "2324");
2434 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2436 /* We have to offset the PTS, so that it is consistent with the SCR.
2437 SCR starts at 36000, but the first two packs contain only padding
2438 and the first pack from the other stream, respectively, may also have
2439 been written before.
2440 So the real data starts at SCR 36000+3*1200. */
2441 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2442 } else if (!strcmp(arg, "svcd")) {
2444 opt_video_codec(o, "c:v", "mpeg2video");
2445 opt_audio_codec(o, "c:a", "mp2");
2446 parse_option(o, "f", "svcd", options);
2448 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2449 parse_option(o, "r", frame_rates[norm], options);
2450 parse_option(o, "pix_fmt", "yuv420p", options);
2451 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2453 opt_default(NULL, "b:v", "2040000");
2454 opt_default(NULL, "maxrate:v", "2516000");
2455 opt_default(NULL, "minrate:v", "0"); // 1145000;
2456 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2457 opt_default(NULL, "scan_offset", "1");
2459 opt_default(NULL, "b:a", "224000");
2460 parse_option(o, "ar", "44100", options);
2462 opt_default(NULL, "packetsize", "2324");
2464 } else if (!strcmp(arg, "dvd")) {
2466 opt_video_codec(o, "c:v", "mpeg2video");
2467 opt_audio_codec(o, "c:a", "ac3");
2468 parse_option(o, "f", "dvd", options);
2470 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2471 parse_option(o, "r", frame_rates[norm], options);
2472 parse_option(o, "pix_fmt", "yuv420p", options);
2473 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2475 opt_default(NULL, "b:v", "6000000");
2476 opt_default(NULL, "maxrate:v", "9000000");
2477 opt_default(NULL, "minrate:v", "0"); // 1500000;
2478 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2480 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2481 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2483 opt_default(NULL, "b:a", "448000");
2484 parse_option(o, "ar", "48000", options);
2486 } else if (!strncmp(arg, "dv", 2)) {
2488 parse_option(o, "f", "dv", options);
2490 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2491 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2492 norm == PAL ? "yuv420p" : "yuv411p", options);
2493 parse_option(o, "r", frame_rates[norm], options);
2495 parse_option(o, "ar", "48000", options);
2496 parse_option(o, "ac", "2", options);
2499 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2500 return AVERROR(EINVAL);
2503 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2504 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2509 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2511 av_free (vstats_filename);
2512 vstats_filename = av_strdup (arg);
2516 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2519 time_t today2 = time(NULL);
2520 struct tm *today = localtime(&today2);
2522 if (!today) { // maybe tomorrow
2523 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2527 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2529 return opt_vstats_file(NULL, opt, filename);
2532 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2534 OptionsContext *o = optctx;
2535 return parse_option(o, "frames:v", arg, options);
2538 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2540 OptionsContext *o = optctx;
2541 return parse_option(o, "frames:a", arg, options);
2544 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2546 OptionsContext *o = optctx;
2547 return parse_option(o, "frames:d", arg, options);
2550 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2553 AVDictionary *cbak = codec_opts;
2554 AVDictionary *fbak = format_opts;
2558 ret = opt_default(NULL, opt, arg);
2560 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2561 av_dict_copy(&o->g->format_opts, format_opts, 0);
2562 av_dict_free(&codec_opts);
2563 av_dict_free(&format_opts);
2570 static int opt_preset(void *optctx, const char *opt, const char *arg)
2572 OptionsContext *o = optctx;
2574 char filename[1000], line[1000], tmp_line[1000];
2575 const char *codec_name = NULL;
2579 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2581 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2582 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2583 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2585 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2589 while (fgets(line, sizeof(line), f)) {
2590 char *key = tmp_line, *value, *endptr;
2592 if (strcspn(line, "#\n\r") == 0)
2594 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2595 if (!av_strtok(key, "=", &value) ||
2596 !av_strtok(value, "\r\n", &endptr)) {
2597 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2600 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2602 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2603 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2604 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2605 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2606 else if (opt_default_new(o, key, value) < 0) {
2607 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2608 filename, line, key, value);
2618 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2620 OptionsContext *o = optctx;
2621 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2622 int ret = parse_option(o, s, arg, options);
2627 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2629 OptionsContext *o = optctx;
2631 if(!strcmp(opt, "ab")){
2632 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2634 } else if(!strcmp(opt, "b")){
2635 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2636 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2639 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2643 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2645 OptionsContext *o = optctx;
2648 if(!strcmp(opt, "qscale")){
2649 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2650 return parse_option(o, "q:v", arg, options);
2652 s = av_asprintf("q%s", opt + 6);
2653 ret = parse_option(o, s, arg, options);
2658 static int opt_profile(void *optctx, const char *opt, const char *arg)
2660 OptionsContext *o = optctx;
2661 if(!strcmp(opt, "profile")){
2662 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2663 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2666 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2670 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2672 OptionsContext *o = optctx;
2673 return parse_option(o, "filter:v", arg, options);
2676 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2678 OptionsContext *o = optctx;
2679 return parse_option(o, "filter:a", arg, options);
2682 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2684 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2685 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2686 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2687 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2689 if (video_sync_method == VSYNC_AUTO)
2690 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2694 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2696 OptionsContext *o = optctx;
2697 char *tcr = av_asprintf("timecode=%s", arg);
2698 int ret = parse_option(o, "metadata:g", tcr, options);
2700 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2705 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2707 OptionsContext *o = optctx;
2708 char layout_str[32];
2711 int ret, channels, ac_str_size;
2714 layout = av_get_channel_layout(arg);
2716 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2717 return AVERROR(EINVAL);
2719 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2720 ret = opt_default_new(o, opt, layout_str);
2724 /* set 'ac' option based on channel layout */
2725 channels = av_get_channel_layout_nb_channels(layout);
2726 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2727 stream_str = strchr(opt, ':');
2728 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2729 ac_str = av_mallocz(ac_str_size);
2731 return AVERROR(ENOMEM);
2732 av_strlcpy(ac_str, "ac", 3);
2734 av_strlcat(ac_str, stream_str, ac_str_size);
2735 ret = parse_option(o, ac_str, layout_str, options);
2741 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2743 OptionsContext *o = optctx;
2744 return parse_option(o, "q:a", arg, options);
2747 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2749 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2750 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2751 return AVERROR(ENOMEM);
2752 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2753 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2754 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2755 return AVERROR(ENOMEM);
2757 input_stream_potentially_available = 1;
2762 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2764 uint8_t *graph_desc = read_file(arg);
2766 return AVERROR(EINVAL);
2768 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2769 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2770 return AVERROR(ENOMEM);
2771 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2772 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2774 input_stream_potentially_available = 1;
2779 void show_help_default(const char *opt, const char *arg)
2781 /* per-file options have at least one of those set */
2782 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2783 int show_advanced = 0, show_avoptions = 0;
2786 if (!strcmp(opt, "long"))
2788 else if (!strcmp(opt, "full"))
2789 show_advanced = show_avoptions = 1;
2791 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2796 printf("Getting help:\n"
2797 " -h -- print basic options\n"
2798 " -h long -- print more options\n"
2799 " -h full -- print all options (including all format and codec specific options, very long)\n"
2800 " See man %s for detailed description of the options.\n"
2801 "\n", program_name);
2803 show_help_options(options, "Print help / information / capabilities:",
2806 show_help_options(options, "Global options (affect whole program "
2807 "instead of just one file:",
2808 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2810 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2811 per_file | OPT_EXIT, 0);
2813 show_help_options(options, "Per-file main options:", 0,
2814 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2815 OPT_EXIT, per_file);
2817 show_help_options(options, "Advanced per-file options:",
2818 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2820 show_help_options(options, "Video options:",
2821 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2823 show_help_options(options, "Advanced Video options:",
2824 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2826 show_help_options(options, "Audio options:",
2827 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2829 show_help_options(options, "Advanced Audio options:",
2830 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2831 show_help_options(options, "Subtitle options:",
2832 OPT_SUBTITLE, 0, 0);
2835 if (show_avoptions) {
2836 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2837 show_help_children(avcodec_get_class(), flags);
2838 show_help_children(avformat_get_class(), flags);
2840 show_help_children(sws_get_class(), flags);
2842 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2843 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2847 void show_usage(void)
2849 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2850 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2851 av_log(NULL, AV_LOG_INFO, "\n");
2859 static const OptionGroupDef groups[] = {
2860 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2861 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2864 static int open_files(OptionGroupList *l, const char *inout,
2865 int (*open_file)(OptionsContext*, const char*))
2869 for (i = 0; i < l->nb_groups; i++) {
2870 OptionGroup *g = &l->groups[i];
2876 ret = parse_optgroup(&o, g);
2878 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2879 "%s.\n", inout, g->arg);
2883 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2884 ret = open_file(&o, g->arg);
2887 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2891 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2897 int ffmpeg_parse_options(int argc, char **argv)
2899 OptionParseContext octx;
2903 memset(&octx, 0, sizeof(octx));
2905 /* split the commandline into an internal representation */
2906 ret = split_commandline(&octx, argc, argv, options, groups,
2907 FF_ARRAY_ELEMS(groups));
2909 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2913 /* apply global options */
2914 ret = parse_optgroup(NULL, &octx.global_opts);
2916 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2920 /* open input files */
2921 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2923 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2927 /* create the complex filtergraphs */
2928 ret = init_complex_filters();
2930 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2934 /* open output files */
2935 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2937 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2941 /* configure the complex filtergraphs */
2942 ret = configure_complex_filters();
2944 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2949 uninit_parse_context(&octx);
2951 av_strerror(ret, error, sizeof(error));
2952 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2957 static int opt_progress(void *optctx, const char *opt, const char *arg)
2959 AVIOContext *avio = NULL;
2962 if (!strcmp(arg, "-"))
2964 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2966 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2967 arg, av_err2str(ret));
2970 progress_avio = avio;
2974 #define OFFSET(x) offsetof(OptionsContext, x)
2975 const OptionDef options[] = {
2977 #include "cmdutils_common_opts.h"
2978 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2979 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2980 "force format", "fmt" },
2981 { "y", OPT_BOOL, { &file_overwrite },
2982 "overwrite output files" },
2983 { "n", OPT_BOOL, { &no_file_overwrite },
2984 "never overwrite output files" },
2985 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
2986 "Ignore unknown stream types" },
2987 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
2988 "Copy unknown stream types" },
2989 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2990 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2991 "codec name", "codec" },
2992 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2993 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2994 "codec name", "codec" },
2995 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2996 OPT_OUTPUT, { .off = OFFSET(presets) },
2997 "preset name", "preset" },
2998 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2999 OPT_OUTPUT, { .func_arg = opt_map },
3000 "set input stream mapping",
3001 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3002 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3003 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3004 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3005 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3006 "set metadata information of outfile from infile",
3007 "outfile[,metadata]:infile[,metadata]" },
3008 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3009 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3010 "set chapters mapping", "input_file_index" },
3011 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3012 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3013 "record or transcode \"duration\" seconds of audio/video",
3015 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3016 "record or transcode stop time", "time_stop" },
3017 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3018 "set the limit file size in bytes", "limit_size" },
3019 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3020 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3021 "set the start time offset", "time_off" },
3022 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3023 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3024 "enable/disable seeking by timestamp with -ss" },
3025 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3026 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3027 "enable/disable accurate seeking with -ss" },
3028 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3029 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3030 "set the input ts offset", "time_off" },
3031 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3032 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3033 "set the input ts scale", "scale" },
3034 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3035 "set the recording timestamp ('now' to set the current time)", "time" },
3036 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3037 "add metadata", "string=string" },
3038 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3039 OPT_OUTPUT, { .func_arg = opt_data_frames },
3040 "set the number of data frames to output", "number" },
3041 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3042 "add timings for benchmarking" },
3043 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3044 "add timings for each task" },
3045 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3046 "write program-readable progress information", "url" },
3047 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3048 "enable or disable interaction on standard input" },
3049 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3050 "set max runtime in seconds", "limit" },
3051 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3052 "dump each input packet" },
3053 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3054 "when dumping packets, also dump the payload" },
3055 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3056 OPT_INPUT, { .off = OFFSET(rate_emu) },
3057 "read input at native frame rate", "" },
3058 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3059 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
3060 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3061 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
3062 "video sync method", "" },
3063 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3064 "frame drop threshold", "" },
3065 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3066 "audio sync method", "" },
3067 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3068 "audio drift threshold", "threshold" },
3069 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3070 "copy timestamps" },
3071 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3072 "shift input timestamps to start at 0 when using copyts" },
3073 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3074 "copy input stream time base when stream copying", "mode" },
3075 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3076 OPT_OUTPUT, { .off = OFFSET(shortest) },
3077 "finish encoding within shortest input" },
3078 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3079 OPT_OUTPUT, { .off = OFFSET(apad) },
3081 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3082 "timestamp discontinuity delta threshold", "threshold" },
3083 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3084 "timestamp error delta threshold", "threshold" },
3085 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3086 "exit on error", "error" },
3087 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3088 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3089 "copy initial non-keyframes" },
3090 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3091 "copy or discard frames before start time" },
3092 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3093 "set the number of frames to output", "number" },
3094 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3095 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3096 "force codec tag/fourcc", "fourcc/tag" },
3097 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3098 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3099 "use fixed quality scale (VBR)", "q" },
3100 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3101 OPT_OUTPUT, { .func_arg = opt_qscale },
3102 "use fixed quality scale (VBR)", "q" },
3103 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3104 "set profile", "profile" },
3105 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3106 "set stream filtergraph", "filter_graph" },
3107 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3108 "read stream filtergraph description from a file", "filename" },
3109 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3110 "reinit filtergraph on input parameter changes", "" },
3111 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3112 "create a complex filtergraph", "graph_description" },
3113 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3114 "create a complex filtergraph", "graph_description" },
3115 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3116 "read complex filtergraph description from a file", "filename" },
3117 { "stats", OPT_BOOL, { &print_stats },
3118 "print progress report during encoding", },
3119 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3120 OPT_OUTPUT, { .func_arg = opt_attach },
3121 "add an attachment to the output file", "filename" },
3122 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3123 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3124 "extract an attachment into a file", "filename" },
3125 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3126 "print timestamp debugging info" },
3127 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3128 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3129 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3130 OPT_INPUT, { .off = OFFSET(discard) },
3132 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3133 OPT_OUTPUT, { .off = OFFSET(disposition) },
3134 "disposition", "" },
3135 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3136 { .off = OFFSET(thread_queue_size) },
3137 "set the maximum number of queued packets from the demuxer" },
3140 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3141 "set the number of video frames to output", "number" },
3142 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3143 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3144 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3145 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3146 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3147 "set frame size (WxH or abbreviation)", "size" },
3148 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3149 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3150 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3151 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3152 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3153 "set pixel format", "format" },
3154 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3155 "set the number of bits per raw sample", "number" },
3156 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3157 "deprecated use -g 1" },
3158 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3160 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3161 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3162 "rate control override for specific intervals", "override" },
3163 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3164 OPT_OUTPUT, { .func_arg = opt_video_codec },
3165 "force video codec ('copy' to copy stream)", "codec" },
3166 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3168 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3170 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3171 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3172 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3173 "select the pass number (1 to 3)", "n" },
3174 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3175 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3176 "select two pass log file name prefix", "prefix" },
3177 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3178 "this option is deprecated, use the yadif filter instead" },
3179 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3180 "calculate PSNR of compressed frames" },
3181 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3182 "dump video coding statistics to file" },
3183 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3184 "dump video coding statistics to file", "file" },
3185 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3186 "set video filters", "filter_graph" },
3187 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3188 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3189 "specify intra matrix coeffs", "matrix" },
3190 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3191 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3192 "specify inter matrix coeffs", "matrix" },
3193 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3194 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3195 "specify intra matrix coeffs", "matrix" },
3196 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3197 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3198 "top=1/bottom=0/auto=-1 field first", "" },
3199 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3200 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3201 "force video tag/fourcc", "fourcc/tag" },
3202 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3203 "show QP histogram" },
3204 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3205 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3206 "force the selected framerate, disable the best supported framerate selection" },
3207 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3208 OPT_OUTPUT, { .func_arg = opt_streamid },
3209 "set the value of an outfile streamid", "streamIndex:value" },
3210 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3211 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3212 "force key frames at specified timestamps", "timestamps" },
3213 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3214 "audio bitrate (please use -b:a)", "bitrate" },
3215 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3216 "video bitrate (please use -b:v)", "bitrate" },
3217 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3218 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3219 "use HW accelerated decoding", "hwaccel name" },
3220 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3221 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3222 "select a device for HW acceleration" "devicename" },
3224 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3226 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3227 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3228 "automatically insert correct rotate filters" },
3231 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3232 "set the number of audio frames to output", "number" },
3233 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3234 "set audio quality (codec-specific)", "quality", },
3235 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3236 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3237 "set audio sampling rate (in Hz)", "rate" },
3238 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3239 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3240 "set number of audio channels", "channels" },
3241 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3243 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3244 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3245 "force audio codec ('copy' to copy stream)", "codec" },
3246 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3247 OPT_OUTPUT, { .func_arg = opt_old2new },
3248 "force audio tag/fourcc", "fourcc/tag" },
3249 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3250 "change audio volume (256=normal)" , "volume" },
3251 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3252 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3253 "set sample format", "format" },
3254 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3255 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3256 "set channel layout", "layout" },
3257 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3258 "set audio filters", "filter_graph" },
3259 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3260 "set the maximum number of channels to try to guess the channel layout" },
3262 /* subtitle options */
3263 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3264 "disable subtitle" },
3265 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3266 "force subtitle codec ('copy' to copy stream)", "codec" },
3267 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3268 , "force subtitle tag/fourcc", "fourcc/tag" },
3269 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3270 "fix subtitles duration" },
3271 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3272 "set canvas size (WxH or abbreviation)", "size" },
3275 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3276 "deprecated, use -channel", "channel" },
3277 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3278 "deprecated, use -standard", "standard" },
3279 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3282 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3283 "set the maximum demux-decode delay", "seconds" },
3284 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3285 "set the initial demux-decode delay", "seconds" },
3286 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3287 "override the options from ffserver", "" },
3288 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3289 "specify a file in which to print sdp information", "file" },
3291 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3292 "A comma-separated list of bitstream filters", "bitstream_filters" },
3293 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3294 "deprecated", "audio bitstream_filters" },
3295 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3296 "deprecated", "video bitstream_filters" },
3298 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3299 "set the audio options to the indicated preset", "preset" },
3300 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3301 "set the video options to the indicated preset", "preset" },
3302 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3303 "set the subtitle options to the indicated preset", "preset" },
3304 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3305 "set options from indicated preset file", "filename" },
3306 /* data codec support */
3307 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3308 "force data codec ('copy' to copy stream)", "codec" },
3309 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },