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->start_time_eof = AV_NOPTS_VALUE;
160 o->recording_time = INT64_MAX;
161 o->limit_filesize = UINT64_MAX;
162 o->chapters_input_file = INT_MAX;
163 o->accurate_seek = 1;
166 /* return a copy of the input with the stream specifiers removed from the keys */
167 static AVDictionary *strip_specifiers(AVDictionary *dict)
169 AVDictionaryEntry *e = NULL;
170 AVDictionary *ret = NULL;
172 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
173 char *p = strchr(e->key, ':');
177 av_dict_set(&ret, e->key, e->value, 0);
184 static int opt_sameq(void *optctx, const char *opt, const char *arg)
186 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
187 "If you are looking for an option to preserve the quality (which is not "
188 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
190 return AVERROR(EINVAL);
193 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
195 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
196 return opt_default(optctx, "channel", arg);
199 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
201 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
202 return opt_default(optctx, "standard", arg);
205 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
207 OptionsContext *o = optctx;
208 return parse_option(o, "codec:a", arg, options);
211 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
213 OptionsContext *o = optctx;
214 return parse_option(o, "codec:v", arg, options);
217 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
219 OptionsContext *o = optctx;
220 return parse_option(o, "codec:s", arg, options);
223 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
225 OptionsContext *o = optctx;
226 return parse_option(o, "codec:d", arg, options);
229 static int opt_map(void *optctx, const char *opt, const char *arg)
231 OptionsContext *o = optctx;
233 int i, negative = 0, file_idx;
234 int sync_file_idx = -1, sync_stream_idx = 0;
243 map = av_strdup(arg);
245 return AVERROR(ENOMEM);
247 /* parse sync stream first, just pick first matching stream */
248 if (sync = strchr(map, ',')) {
250 sync_file_idx = strtol(sync + 1, &sync, 0);
251 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
252 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
257 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
258 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
259 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
263 if (i == input_files[sync_file_idx]->nb_streams) {
264 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
265 "match any streams.\n", arg);
272 /* this mapping refers to lavfi output */
273 const char *c = map + 1;
274 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
275 m = &o->stream_maps[o->nb_stream_maps - 1];
276 m->linklabel = av_get_token(&c, "]");
278 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
282 if (allow_unused = strchr(map, '?'))
284 file_idx = strtol(map, &p, 0);
285 if (file_idx >= nb_input_files || file_idx < 0) {
286 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
290 /* disable some already defined maps */
291 for (i = 0; i < o->nb_stream_maps; i++) {
292 m = &o->stream_maps[i];
293 if (file_idx == m->file_index &&
294 check_stream_specifier(input_files[m->file_index]->ctx,
295 input_files[m->file_index]->ctx->streams[m->stream_index],
296 *p == ':' ? p + 1 : p) > 0)
300 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
301 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
302 *p == ':' ? p + 1 : p) <= 0)
304 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
305 m = &o->stream_maps[o->nb_stream_maps - 1];
307 m->file_index = file_idx;
310 if (sync_file_idx >= 0) {
311 m->sync_file_index = sync_file_idx;
312 m->sync_stream_index = sync_stream_idx;
314 m->sync_file_index = file_idx;
315 m->sync_stream_index = i;
322 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
324 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
325 "To ignore this, add a trailing '?' to the map.\n", arg);
334 static int opt_attach(void *optctx, const char *opt, const char *arg)
336 OptionsContext *o = optctx;
337 GROW_ARRAY(o->attachments, o->nb_attachments);
338 o->attachments[o->nb_attachments - 1] = arg;
342 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
344 OptionsContext *o = optctx;
349 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
350 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
352 /* muted channel syntax */
353 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
354 if ((n == 1 || n == 3) && m->channel_idx == -1) {
355 m->file_idx = m->stream_idx = -1;
357 m->ofile_idx = m->ostream_idx = -1;
362 n = sscanf(arg, "%d.%d.%d:%d.%d",
363 &m->file_idx, &m->stream_idx, &m->channel_idx,
364 &m->ofile_idx, &m->ostream_idx);
366 if (n != 3 && n != 5) {
367 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
368 "[file.stream.channel|-1][:syncfile:syncstream]\n");
372 if (n != 5) // only file.stream.channel specified
373 m->ofile_idx = m->ostream_idx = -1;
376 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
377 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
381 if (m->stream_idx < 0 ||
382 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
383 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
384 m->file_idx, m->stream_idx);
387 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
388 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
389 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
390 m->file_idx, m->stream_idx);
393 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
394 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
395 m->file_idx, m->stream_idx, m->channel_idx);
401 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
403 av_free(sdp_filename);
404 sdp_filename = av_strdup(arg);
409 * Parse a metadata specifier passed as 'arg' parameter.
410 * @param arg metadata string to parse
411 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
412 * @param index for type c/p, chapter/program index is written here
413 * @param stream_spec for type s, the stream specifier is written here
415 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
423 if (*(++arg) && *arg != ':') {
424 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
427 *stream_spec = *arg == ':' ? arg + 1 : "";
432 *index = strtol(++arg, NULL, 0);
435 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
442 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
444 AVDictionary **meta_in = NULL;
445 AVDictionary **meta_out = NULL;
447 char type_in, type_out;
448 const char *istream_spec = NULL, *ostream_spec = NULL;
449 int idx_in = 0, idx_out = 0;
451 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
452 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
455 if (type_out == 'g' || !*outspec)
456 o->metadata_global_manual = 1;
457 if (type_out == 's' || !*outspec)
458 o->metadata_streams_manual = 1;
459 if (type_out == 'c' || !*outspec)
460 o->metadata_chapters_manual = 1;
464 if (type_in == 'g' || type_out == 'g')
465 o->metadata_global_manual = 1;
466 if (type_in == 's' || type_out == 's')
467 o->metadata_streams_manual = 1;
468 if (type_in == 'c' || type_out == 'c')
469 o->metadata_chapters_manual = 1;
471 /* ic is NULL when just disabling automatic mappings */
475 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
476 if ((index) < 0 || (index) >= (nb_elems)) {\
477 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
482 #define SET_DICT(type, meta, context, index)\
485 meta = &context->metadata;\
488 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
489 meta = &context->chapters[index]->metadata;\
492 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
493 meta = &context->programs[index]->metadata;\
496 break; /* handled separately below */ \
497 default: av_assert0(0);\
500 SET_DICT(type_in, meta_in, ic, idx_in);
501 SET_DICT(type_out, meta_out, oc, idx_out);
503 /* for input streams choose first matching stream */
504 if (type_in == 's') {
505 for (i = 0; i < ic->nb_streams; i++) {
506 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
507 meta_in = &ic->streams[i]->metadata;
513 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
518 if (type_out == 's') {
519 for (i = 0; i < oc->nb_streams; i++) {
520 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
521 meta_out = &oc->streams[i]->metadata;
522 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
527 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
532 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
534 OptionsContext *o = optctx;
536 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
537 struct tm time = *gmtime((time_t*)&recording_timestamp);
538 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
540 parse_option(o, "metadata", buf, options);
542 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
543 "tag instead.\n", opt);
547 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
549 const AVCodecDescriptor *desc;
550 const char *codec_string = encoder ? "encoder" : "decoder";
554 avcodec_find_encoder_by_name(name) :
555 avcodec_find_decoder_by_name(name);
557 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
558 codec = encoder ? avcodec_find_encoder(desc->id) :
559 avcodec_find_decoder(desc->id);
561 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
562 codec_string, codec->name, desc->name);
566 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
569 if (codec->type != type) {
570 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
576 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
578 char *codec_name = NULL;
580 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
582 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
583 st->codec->codec_id = codec->id;
586 return avcodec_find_decoder(st->codec->codec_id);
589 /* Add all the streams from the given input file to the global
590 * list of input streams. */
591 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
595 for (i = 0; i < ic->nb_streams; i++) {
596 AVStream *st = ic->streams[i];
597 AVCodecContext *dec = st->codec;
598 InputStream *ist = av_mallocz(sizeof(*ist));
599 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
600 char *codec_tag = NULL;
602 char *discard_str = NULL;
603 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
608 GROW_ARRAY(input_streams, nb_input_streams);
609 input_streams[nb_input_streams - 1] = ist;
612 ist->file_index = nb_input_files;
614 st->discard = AVDISCARD_ALL;
617 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
620 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
622 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
624 uint32_t tag = strtol(codec_tag, &next, 0);
626 tag = AV_RL32(codec_tag);
627 st->codec->codec_tag = tag;
630 ist->dec = choose_decoder(o, ic, st);
631 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
633 ist->reinit_filters = -1;
634 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
636 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
637 ist->user_set_discard = AVDISCARD_NONE;
638 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
639 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
644 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
646 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
648 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
652 ret = avcodec_copy_context(ist->dec_ctx, dec);
654 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
658 switch (dec->codec_type) {
659 case AVMEDIA_TYPE_VIDEO:
661 ist->dec = avcodec_find_decoder(dec->codec_id);
662 if (av_codec_get_lowres(dec)) {
663 dec->flags |= CODEC_FLAG_EMU_EDGE;
666 ist->resample_height = ist->dec_ctx->height;
667 ist->resample_width = ist->dec_ctx->width;
668 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
670 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
671 if (framerate && av_parse_video_rate(&ist->framerate,
673 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
678 ist->top_field_first = -1;
679 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
681 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
683 if (!strcmp(hwaccel, "none"))
684 ist->hwaccel_id = HWACCEL_NONE;
685 else if (!strcmp(hwaccel, "auto"))
686 ist->hwaccel_id = HWACCEL_AUTO;
689 for (i = 0; hwaccels[i].name; i++) {
690 if (!strcmp(hwaccels[i].name, hwaccel)) {
691 ist->hwaccel_id = hwaccels[i].id;
696 if (!ist->hwaccel_id) {
697 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
699 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
700 for (i = 0; hwaccels[i].name; i++)
701 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
702 av_log(NULL, AV_LOG_FATAL, "\n");
708 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
709 if (hwaccel_device) {
710 ist->hwaccel_device = av_strdup(hwaccel_device);
711 if (!ist->hwaccel_device)
714 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
717 case AVMEDIA_TYPE_AUDIO:
718 ist->guess_layout_max = INT_MAX;
719 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
720 guess_input_channel_layout(ist);
722 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
723 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
724 ist->resample_channels = ist->dec_ctx->channels;
725 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
728 case AVMEDIA_TYPE_DATA:
729 case AVMEDIA_TYPE_SUBTITLE: {
730 char *canvas_size = NULL;
732 ist->dec = avcodec_find_decoder(dec->codec_id);
733 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
734 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
736 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
737 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
742 case AVMEDIA_TYPE_ATTACHMENT:
743 case AVMEDIA_TYPE_UNKNOWN:
751 static void assert_file_overwrite(const char *filename)
753 if (file_overwrite && no_file_overwrite) {
754 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
758 if (!file_overwrite) {
759 const char *proto_name = avio_find_protocol_name(filename);
760 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
761 if (stdin_interaction && !no_file_overwrite) {
762 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
765 signal(SIGINT, SIG_DFL);
767 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
773 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
780 static void dump_attachment(AVStream *st, const char *filename)
783 AVIOContext *out = NULL;
784 AVDictionaryEntry *e;
786 if (!st->codec->extradata_size) {
787 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
788 nb_input_files - 1, st->index);
791 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
794 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
795 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
799 assert_file_overwrite(filename);
801 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
802 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
807 avio_write(out, st->codec->extradata, st->codec->extradata_size);
812 static int open_input_file(OptionsContext *o, const char *filename)
816 AVInputFormat *file_iformat = NULL;
820 AVDictionary *unused_opts = NULL;
821 AVDictionaryEntry *e = NULL;
822 int orig_nb_streams; // number of streams before avformat_find_stream_info
823 char * video_codec_name = NULL;
824 char * audio_codec_name = NULL;
825 char *subtitle_codec_name = NULL;
826 char * data_codec_name = NULL;
827 int scan_all_pmts_set = 0;
830 if (!(file_iformat = av_find_input_format(o->format))) {
831 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
836 if (!strcmp(filename, "-"))
839 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
840 strcmp(filename, "/dev/stdin");
842 /* get default parameters from command line */
843 ic = avformat_alloc_context();
845 print_error(filename, AVERROR(ENOMEM));
848 if (o->nb_audio_sample_rate) {
849 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
851 if (o->nb_audio_channels) {
852 /* because we set audio_channels based on both the "ac" and
853 * "channel_layout" options, we need to check that the specified
854 * demuxer actually has the "channels" option before setting it */
855 if (file_iformat && file_iformat->priv_class &&
856 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
857 AV_OPT_SEARCH_FAKE_OBJ)) {
858 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
861 if (o->nb_frame_rates) {
862 /* set the format-level framerate option;
863 * this is important for video grabbers, e.g. x11 */
864 if (file_iformat && file_iformat->priv_class &&
865 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
866 AV_OPT_SEARCH_FAKE_OBJ)) {
867 av_dict_set(&o->g->format_opts, "framerate",
868 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
871 if (o->nb_frame_sizes) {
872 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
874 if (o->nb_frame_pix_fmts)
875 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
877 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
878 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
879 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
880 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
882 ic->video_codec_id = video_codec_name ?
883 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
884 ic->audio_codec_id = audio_codec_name ?
885 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
886 ic->subtitle_codec_id= subtitle_codec_name ?
887 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
888 ic->data_codec_id = data_codec_name ?
889 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
891 if (video_codec_name)
892 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
893 if (audio_codec_name)
894 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
895 if (subtitle_codec_name)
896 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
898 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
900 ic->flags |= AVFMT_FLAG_NONBLOCK;
901 ic->interrupt_callback = int_cb;
903 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
904 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
905 scan_all_pmts_set = 1;
907 /* open the input file with generic avformat function */
908 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
910 print_error(filename, err);
913 if (scan_all_pmts_set)
914 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
915 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
916 assert_avoptions(o->g->format_opts);
918 /* apply forced codec ids */
919 for (i = 0; i < ic->nb_streams; i++)
920 choose_decoder(o, ic, ic->streams[i]);
922 /* Set AVCodecContext options for avformat_find_stream_info */
923 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
924 orig_nb_streams = ic->nb_streams;
926 /* If not enough info to get the stream parameters, we decode the
927 first frames to get it. (used in mpeg case for example) */
928 ret = avformat_find_stream_info(ic, opts);
930 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
931 if (ic->nb_streams == 0) {
932 avformat_close_input(&ic);
937 if (o->start_time_eof != AV_NOPTS_VALUE) {
938 if (ic->duration>0) {
939 o->start_time = o->start_time_eof + ic->duration;
941 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
943 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
944 /* add the stream start time */
945 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
946 timestamp += ic->start_time;
948 /* if seeking requested, we execute it */
949 if (o->start_time != AV_NOPTS_VALUE) {
950 int64_t seek_timestamp = timestamp;
952 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
953 int dts_heuristic = 0;
954 for (i=0; i<ic->nb_streams; i++) {
955 AVCodecContext *avctx = ic->streams[i]->codec;
956 if (avctx->has_b_frames)
960 seek_timestamp -= 3*AV_TIME_BASE / 23;
963 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
965 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
966 filename, (double)timestamp / AV_TIME_BASE);
970 /* update the current parameters so that they match the one of the input stream */
971 add_input_streams(o, ic);
973 /* dump the file content */
974 av_dump_format(ic, nb_input_files, filename, 0);
976 GROW_ARRAY(input_files, nb_input_files);
977 f = av_mallocz(sizeof(*f));
980 input_files[nb_input_files - 1] = f;
983 f->ist_index = nb_input_streams - ic->nb_streams;
984 f->start_time = o->start_time;
985 f->recording_time = o->recording_time;
986 f->input_ts_offset = o->input_ts_offset;
987 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
988 f->nb_streams = ic->nb_streams;
989 f->rate_emu = o->rate_emu;
990 f->accurate_seek = o->accurate_seek;
992 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
995 /* check if all codec options have been used */
996 unused_opts = strip_specifiers(o->g->codec_opts);
997 for (i = f->ist_index; i < nb_input_streams; i++) {
999 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1000 AV_DICT_IGNORE_SUFFIX)))
1001 av_dict_set(&unused_opts, e->key, NULL, 0);
1005 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1006 const AVClass *class = avcodec_get_class();
1007 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1008 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1009 const AVClass *fclass = avformat_get_class();
1010 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1011 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1012 if (!option || foption)
1016 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1017 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1018 "input file #%d (%s) is not a decoding option.\n", e->key,
1019 option->help ? option->help : "", nb_input_files - 1,
1024 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1025 "input file #%d (%s) has not been used for any stream. The most "
1026 "likely reason is either wrong type (e.g. a video option with "
1027 "no video streams) or that it is a private option of some decoder "
1028 "which was not actually used for any stream.\n", e->key,
1029 option->help ? option->help : "", nb_input_files - 1, filename);
1031 av_dict_free(&unused_opts);
1033 for (i = 0; i < o->nb_dump_attachment; i++) {
1036 for (j = 0; j < ic->nb_streams; j++) {
1037 AVStream *st = ic->streams[j];
1039 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1040 dump_attachment(st, o->dump_attachment[i].u.str);
1044 for (i = 0; i < orig_nb_streams; i++)
1045 av_dict_free(&opts[i]);
1048 input_stream_potentially_available = 1;
1053 static uint8_t *get_line(AVIOContext *s)
1059 if (avio_open_dyn_buf(&line) < 0) {
1060 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1064 while ((c = avio_r8(s)) && c != '\n')
1067 avio_close_dyn_buf(line, &buf);
1072 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1075 char filename[1000];
1076 const char *base[3] = { getenv("AVCONV_DATADIR"),
1081 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1085 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1086 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1087 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1090 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1091 i != 1 ? "" : "/.avconv", preset_name);
1092 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1098 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1100 char *codec_name = NULL;
1102 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1104 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1105 NULL, ost->st->codec->codec_type);
1106 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1107 } else if (!strcmp(codec_name, "copy"))
1108 ost->stream_copy = 1;
1110 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1111 ost->st->codec->codec_id = ost->enc->id;
1115 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1118 AVStream *st = avformat_new_stream(oc, NULL);
1119 int idx = oc->nb_streams - 1, ret = 0;
1120 char *bsf = NULL, *next, *codec_tag = NULL;
1121 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1126 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1130 if (oc->nb_streams - 1 < o->nb_streamid_map)
1131 st->id = o->streamid_map[oc->nb_streams - 1];
1133 GROW_ARRAY(output_streams, nb_output_streams);
1134 if (!(ost = av_mallocz(sizeof(*ost))))
1136 output_streams[nb_output_streams - 1] = ost;
1138 ost->file_index = nb_output_files - 1;
1141 st->codec->codec_type = type;
1142 choose_encoder(o, oc, ost);
1144 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1145 if (!ost->enc_ctx) {
1146 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1149 ost->enc_ctx->codec_type = type;
1152 AVIOContext *s = NULL;
1153 char *buf = NULL, *arg = NULL, *preset = NULL;
1155 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1157 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1158 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1161 if (!buf[0] || buf[0] == '#') {
1165 if (!(arg = strchr(buf, '='))) {
1166 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1170 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1172 } while (!s->eof_reached);
1176 av_log(NULL, AV_LOG_FATAL,
1177 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1178 preset, ost->file_index, ost->index);
1182 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1185 ost->max_frames = INT64_MAX;
1186 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1187 for (i = 0; i<o->nb_max_frames; i++) {
1188 char *p = o->max_frames[i].specifier;
1189 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1190 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1195 ost->copy_prior_start = -1;
1196 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1198 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1201 if (next = strchr(bsf, ','))
1203 if (arg = strchr(bsf, '='))
1205 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1206 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1210 bsfc_prev->next = bsfc;
1212 ost->bitstream_filters = bsfc;
1213 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1219 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1221 uint32_t tag = strtol(codec_tag, &next, 0);
1223 tag = AV_RL32(codec_tag);
1224 ost->st->codec->codec_tag =
1225 ost->enc_ctx->codec_tag = tag;
1228 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1230 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1231 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1234 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1235 ost->disposition = av_strdup(ost->disposition);
1237 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1238 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1240 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1242 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1243 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1244 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1246 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1248 ost->source_index = source_index;
1249 if (source_index >= 0) {
1250 ost->sync_ist = input_streams[source_index];
1251 input_streams[source_index]->discard = 0;
1252 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1254 ost->last_mux_dts = AV_NOPTS_VALUE;
1259 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1262 const char *p = str;
1269 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1276 /* read file contents into a string */
1277 static uint8_t *read_file(const char *filename)
1279 AVIOContext *pb = NULL;
1280 AVIOContext *dyn_buf = NULL;
1281 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1282 uint8_t buf[1024], *str;
1285 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1289 ret = avio_open_dyn_buf(&dyn_buf);
1294 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1295 avio_write(dyn_buf, buf, ret);
1296 avio_w8(dyn_buf, 0);
1299 ret = avio_close_dyn_buf(dyn_buf, &str);
1305 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1308 AVStream *st = ost->st;
1310 if (ost->filters_script && ost->filters) {
1311 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1312 "output stream #%d:%d.\n", nb_output_files, st->index);
1316 if (ost->filters_script)
1317 return read_file(ost->filters_script);
1318 else if (ost->filters)
1319 return av_strdup(ost->filters);
1321 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1325 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1326 const OutputStream *ost, enum AVMediaType type)
1328 if (ost->filters_script || ost->filters) {
1329 av_log(NULL, AV_LOG_ERROR,
1330 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1331 "Filtering and streamcopy cannot be used together.\n",
1332 ost->filters ? "Filtergraph" : "Filtergraph script",
1333 ost->filters ? ost->filters : ost->filters_script,
1334 av_get_media_type_string(type), ost->file_index, ost->index);
1339 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1343 AVCodecContext *video_enc;
1344 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1346 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1348 video_enc = ost->enc_ctx;
1350 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1351 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1352 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1355 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1356 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1358 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1359 if (frame_aspect_ratio) {
1361 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1362 q.num <= 0 || q.den <= 0) {
1363 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1366 ost->frame_aspect_ratio = q;
1369 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1370 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1372 if (!ost->stream_copy) {
1373 const char *p = NULL;
1374 char *frame_size = NULL;
1375 char *frame_pix_fmt = NULL;
1376 char *intra_matrix = NULL, *inter_matrix = NULL;
1377 char *chroma_intra_matrix = NULL;
1381 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1382 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1383 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1387 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1388 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1389 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1390 ost->keep_pix_fmt = 1;
1391 if (!*++frame_pix_fmt)
1392 frame_pix_fmt = NULL;
1394 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1395 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1398 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1401 video_enc->gop_size = 0;
1402 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1404 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1405 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1408 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1410 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1411 if (chroma_intra_matrix) {
1412 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1414 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1417 av_codec_set_chroma_intra_matrix(video_enc, p);
1418 parse_matrix_coeffs(p, chroma_intra_matrix);
1420 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1422 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1423 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1426 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1429 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1430 for (i = 0; p; i++) {
1432 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1434 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1437 video_enc->rc_override =
1438 av_realloc_array(video_enc->rc_override,
1439 i + 1, sizeof(RcOverride));
1440 if (!video_enc->rc_override) {
1441 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1444 video_enc->rc_override[i].start_frame = start;
1445 video_enc->rc_override[i].end_frame = end;
1447 video_enc->rc_override[i].qscale = q;
1448 video_enc->rc_override[i].quality_factor = 1.0;
1451 video_enc->rc_override[i].qscale = 0;
1452 video_enc->rc_override[i].quality_factor = -q/100.0;
1457 video_enc->rc_override_count = i;
1460 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1463 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1466 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1467 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1470 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1471 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1475 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1476 if (ost->logfile_prefix &&
1477 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1481 char logfilename[1024];
1484 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1485 ost->logfile_prefix ? ost->logfile_prefix :
1486 DEFAULT_PASS_LOGFILENAME_PREFIX,
1488 if (!strcmp(ost->enc->name, "libx264")) {
1489 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1491 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1492 char *logbuffer = read_file(logfilename);
1495 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1499 video_enc->stats_in = logbuffer;
1501 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1502 f = av_fopen_utf8(logfilename, "wb");
1504 av_log(NULL, AV_LOG_FATAL,
1505 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1506 logfilename, strerror(errno));
1514 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1515 if (ost->forced_keyframes)
1516 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1518 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1520 ost->top_field_first = -1;
1521 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1524 ost->avfilter = get_ost_filters(o, oc, ost);
1528 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1531 if (ost->stream_copy)
1532 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1537 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1542 AVCodecContext *audio_enc;
1544 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1547 audio_enc = ost->enc_ctx;
1548 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1550 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1551 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1553 if (!ost->stream_copy) {
1554 char *sample_fmt = NULL;
1556 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1558 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1560 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1561 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1565 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1567 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1568 ost->apad = av_strdup(ost->apad);
1570 ost->avfilter = get_ost_filters(o, oc, ost);
1574 /* check for channel mapping for this audio stream */
1575 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1576 AudioChannelMap *map = &o->audio_channel_maps[n];
1577 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1578 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1581 if (map->channel_idx == -1) {
1583 } else if (ost->source_index < 0) {
1584 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1585 ost->file_index, ost->st->index);
1588 ist = input_streams[ost->source_index];
1591 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1592 if (av_reallocp_array(&ost->audio_channels_map,
1593 ost->audio_channels_mapped + 1,
1594 sizeof(*ost->audio_channels_map)
1598 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1604 if (ost->stream_copy)
1605 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1610 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1614 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1615 if (!ost->stream_copy) {
1616 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1623 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1627 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1628 if (!ost->stream_copy) {
1629 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1636 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1638 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1639 ost->stream_copy = 1;
1644 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1648 AVCodecContext *subtitle_enc;
1650 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1652 subtitle_enc = ost->enc_ctx;
1654 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1656 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1658 if (!ost->stream_copy) {
1659 char *frame_size = NULL;
1661 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1662 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1663 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1671 /* arg format is "output-stream-index:streamid-value". */
1672 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1674 OptionsContext *o = optctx;
1679 av_strlcpy(idx_str, arg, sizeof(idx_str));
1680 p = strchr(idx_str, ':');
1682 av_log(NULL, AV_LOG_FATAL,
1683 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1688 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1689 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1690 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1694 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1696 AVFormatContext *is = ifile->ctx;
1697 AVFormatContext *os = ofile->ctx;
1701 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1703 return AVERROR(ENOMEM);
1706 for (i = 0; i < is->nb_chapters; i++) {
1707 AVChapter *in_ch = is->chapters[i], *out_ch;
1708 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1709 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1710 AV_TIME_BASE_Q, in_ch->time_base);
1711 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1712 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1715 if (in_ch->end < ts_off)
1717 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1720 out_ch = av_mallocz(sizeof(AVChapter));
1722 return AVERROR(ENOMEM);
1724 out_ch->id = in_ch->id;
1725 out_ch->time_base = in_ch->time_base;
1726 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1727 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1730 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1732 os->chapters[os->nb_chapters++] = out_ch;
1737 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1740 AVFormatContext *ic = avformat_alloc_context();
1742 ic->interrupt_callback = int_cb;
1743 err = avformat_open_input(&ic, filename, NULL, NULL);
1746 /* copy stream format */
1747 for(i=0;i<ic->nb_streams;i++) {
1751 const char *enc_config;
1753 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1755 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1756 return AVERROR(EINVAL);
1758 if (codec->type == AVMEDIA_TYPE_AUDIO)
1759 opt_audio_codec(o, "c:a", codec->name);
1760 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1761 opt_video_codec(o, "c:v", codec->name);
1762 ost = new_output_stream(o, s, codec->type, -1);
1765 avcodec_get_context_defaults3(st->codec, codec);
1766 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1768 AVDictionary *opts = NULL;
1769 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1770 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1771 av_dict_free(&opts);
1774 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1775 choose_sample_fmt(st, codec);
1776 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1777 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1778 avcodec_copy_context(ost->enc_ctx, st->codec);
1780 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1783 avformat_close_input(&ic);
1787 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1788 AVFormatContext *oc)
1792 switch (ofilter->type) {
1793 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1794 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1796 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1801 ost->source_index = -1;
1802 ost->filter = ofilter;
1806 if (ost->stream_copy) {
1807 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1808 "which is fed from a complex filtergraph. Filtering and streamcopy "
1809 "cannot be used together.\n", ost->file_index, ost->index);
1813 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1814 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1815 av_log(NULL, AV_LOG_ERROR,
1816 "%s '%s' was specified through the %s option "
1817 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1818 "%s and -filter_complex cannot be used together for the same stream.\n",
1819 ost->filters ? "Filtergraph" : "Filtergraph script",
1820 ost->filters ? ost->filters : ost->filters_script,
1821 opt, ost->file_index, ost->index, opt);
1825 avfilter_inout_free(&ofilter->out_tmp);
1828 static int init_complex_filters(void)
1832 for (i = 0; i < nb_filtergraphs; i++) {
1833 ret = init_complex_filtergraph(filtergraphs[i]);
1840 static int configure_complex_filters(void)
1844 for (i = 0; i < nb_filtergraphs; i++)
1845 if (!filtergraphs[i]->graph &&
1846 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1851 static int open_output_file(OptionsContext *o, const char *filename)
1853 AVFormatContext *oc;
1855 AVOutputFormat *file_oformat;
1859 AVDictionary *unused_opts = NULL;
1860 AVDictionaryEntry *e = NULL;
1863 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1864 o->stop_time = INT64_MAX;
1865 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1868 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1869 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1870 if (o->stop_time <= start_time) {
1871 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1874 o->recording_time = o->stop_time - start_time;
1878 GROW_ARRAY(output_files, nb_output_files);
1879 of = av_mallocz(sizeof(*of));
1882 output_files[nb_output_files - 1] = of;
1884 of->ost_index = nb_output_streams;
1885 of->recording_time = o->recording_time;
1886 of->start_time = o->start_time;
1887 of->limit_filesize = o->limit_filesize;
1888 of->shortest = o->shortest;
1889 av_dict_copy(&of->opts, o->g->format_opts, 0);
1891 if (!strcmp(filename, "-"))
1894 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1896 print_error(filename, err);
1901 if (o->recording_time != INT64_MAX)
1902 oc->duration = o->recording_time;
1904 file_oformat= oc->oformat;
1905 oc->interrupt_callback = int_cb;
1907 /* create streams for all unlabeled output pads */
1908 for (i = 0; i < nb_filtergraphs; i++) {
1909 FilterGraph *fg = filtergraphs[i];
1910 for (j = 0; j < fg->nb_outputs; j++) {
1911 OutputFilter *ofilter = fg->outputs[j];
1913 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1916 switch (ofilter->type) {
1917 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1918 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1919 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1921 init_output_filter(ofilter, o, oc);
1925 /* ffserver seeking with date=... needs a date reference */
1926 if (!strcmp(file_oformat->name, "ffm") &&
1927 av_strstart(filename, "http:", NULL)) {
1928 int err = parse_option(o, "metadata", "creation_time=now", options);
1930 print_error(filename, err);
1935 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1936 av_strstart(filename, "http:", NULL)) {
1938 /* special case for files sent to ffserver: we get the stream
1939 parameters from ffserver */
1940 int err = read_ffserver_streams(o, oc, filename);
1942 print_error(filename, err);
1945 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1946 ost = output_streams[j];
1947 for (i = 0; i < nb_input_streams; i++) {
1948 ist = input_streams[i];
1949 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1951 ost->source_index= i;
1952 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1953 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1955 ist->st->discard = ist->user_set_discard;
1960 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));
1964 } else if (!o->nb_stream_maps) {
1965 char *subtitle_codec_name = NULL;
1966 /* pick the "best" stream of each type */
1968 /* video: highest resolution */
1969 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1970 int area = 0, idx = -1;
1971 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1972 for (i = 0; i < nb_input_streams; i++) {
1974 ist = input_streams[i];
1975 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
1976 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1978 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1980 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1987 new_video_stream(o, oc, idx);
1990 /* audio: most channels */
1991 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1992 int channels = 0, idx = -1;
1993 for (i = 0; i < nb_input_streams; i++) {
1994 ist = input_streams[i];
1995 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1996 ist->st->codec->channels > channels) {
1997 channels = ist->st->codec->channels;
2002 new_audio_stream(o, oc, idx);
2005 /* subtitles: pick first */
2006 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2007 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2008 for (i = 0; i < nb_input_streams; i++)
2009 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2010 AVCodecDescriptor const *input_descriptor =
2011 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2012 AVCodecDescriptor const *output_descriptor = NULL;
2013 AVCodec const *output_codec =
2014 avcodec_find_encoder(oc->oformat->subtitle_codec);
2015 int input_props = 0, output_props = 0;
2017 output_descriptor = avcodec_descriptor_get(output_codec->id);
2018 if (input_descriptor)
2019 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2020 if (output_descriptor)
2021 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2022 if (subtitle_codec_name ||
2023 input_props & output_props ||
2024 // Map dvb teletext which has neither property to any output subtitle encoder
2025 input_descriptor && output_descriptor &&
2026 (!input_descriptor->props ||
2027 !output_descriptor->props)) {
2028 new_subtitle_stream(o, oc, i);
2033 /* Data only if codec id match */
2034 if (!o->data_disable ) {
2035 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2036 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2037 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2038 && input_streams[i]->st->codec->codec_id == codec_id )
2039 new_data_stream(o, oc, i);
2043 for (i = 0; i < o->nb_stream_maps; i++) {
2044 StreamMap *map = &o->stream_maps[i];
2049 if (map->linklabel) {
2051 OutputFilter *ofilter = NULL;
2054 for (j = 0; j < nb_filtergraphs; j++) {
2055 fg = filtergraphs[j];
2056 for (k = 0; k < fg->nb_outputs; k++) {
2057 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2058 if (out && !strcmp(out->name, map->linklabel)) {
2059 ofilter = fg->outputs[k];
2066 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2067 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2070 init_output_filter(ofilter, o, oc);
2072 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2074 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2075 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2077 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2079 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2081 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2085 switch (ist->st->codec->codec_type) {
2086 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2087 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2088 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2089 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2090 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2091 case AVMEDIA_TYPE_UNKNOWN:
2092 if (copy_unknown_streams) {
2093 ost = new_unknown_stream (o, oc, src_idx);
2097 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2098 "Cannot map stream #%d:%d - unsupported type.\n",
2099 map->file_index, map->stream_index);
2100 if (!ignore_unknown_streams) {
2101 av_log(NULL, AV_LOG_FATAL,
2102 "If you want unsupported types ignored instead "
2103 "of failing, please use the -ignore_unknown option\n"
2104 "If you want them copied, please use -copy_unknown\n");
2109 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2110 + map->sync_stream_index];
2115 /* handle attached files */
2116 for (i = 0; i < o->nb_attachments; i++) {
2118 uint8_t *attachment;
2122 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2123 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2127 if ((len = avio_size(pb)) <= 0) {
2128 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2132 if (!(attachment = av_malloc(len))) {
2133 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2137 avio_read(pb, attachment, len);
2139 ost = new_attachment_stream(o, oc, -1);
2140 ost->stream_copy = 1;
2141 ost->attachment_filename = o->attachments[i];
2143 ost->st->codec->extradata = attachment;
2144 ost->st->codec->extradata_size = len;
2146 p = strrchr(o->attachments[i], '/');
2147 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2151 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2152 AVDictionaryEntry *e;
2153 ost = output_streams[i];
2155 if ((ost->stream_copy || ost->attachment_filename)
2156 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2157 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2158 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2162 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2163 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2164 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2168 /* check if all codec options have been used */
2169 unused_opts = strip_specifiers(o->g->codec_opts);
2170 for (i = of->ost_index; i < nb_output_streams; i++) {
2172 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2173 AV_DICT_IGNORE_SUFFIX)))
2174 av_dict_set(&unused_opts, e->key, NULL, 0);
2178 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2179 const AVClass *class = avcodec_get_class();
2180 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2181 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2182 const AVClass *fclass = avformat_get_class();
2183 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2184 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2185 if (!option || foption)
2189 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2190 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2191 "output file #%d (%s) is not an encoding option.\n", e->key,
2192 option->help ? option->help : "", nb_output_files - 1,
2197 // gop_timecode is injected by generic code but not always used
2198 if (!strcmp(e->key, "gop_timecode"))
2201 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2202 "output file #%d (%s) has not been used for any stream. The most "
2203 "likely reason is either wrong type (e.g. a video option with "
2204 "no video streams) or that it is a private option of some encoder "
2205 "which was not actually used for any stream.\n", e->key,
2206 option->help ? option->help : "", nb_output_files - 1, filename);
2208 av_dict_free(&unused_opts);
2210 /* set the encoding/decoding_needed flags */
2211 for (i = of->ost_index; i < nb_output_streams; i++) {
2212 OutputStream *ost = output_streams[i];
2214 ost->encoding_needed = !ost->stream_copy;
2215 if (ost->encoding_needed && ost->source_index >= 0) {
2216 InputStream *ist = input_streams[ost->source_index];
2217 ist->decoding_needed |= DECODING_FOR_OST;
2221 /* check filename in case of an image number is expected */
2222 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2223 if (!av_filename_number_test(oc->filename)) {
2224 print_error(oc->filename, AVERROR(EINVAL));
2229 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2230 av_log(NULL, AV_LOG_ERROR,
2231 "No input streams but output needs an input stream\n");
2235 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2236 /* test if it already exists to avoid losing precious files */
2237 assert_file_overwrite(filename);
2240 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2241 &oc->interrupt_callback,
2243 print_error(filename, err);
2246 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2247 assert_file_overwrite(filename);
2249 if (o->mux_preload) {
2250 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2252 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2255 for (i = 0; i < o->nb_metadata_map; i++) {
2257 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2259 if (in_file_index >= nb_input_files) {
2260 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2263 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2264 in_file_index >= 0 ?
2265 input_files[in_file_index]->ctx : NULL, o);
2269 if (o->chapters_input_file >= nb_input_files) {
2270 if (o->chapters_input_file == INT_MAX) {
2271 /* copy chapters from the first input file that has them*/
2272 o->chapters_input_file = -1;
2273 for (i = 0; i < nb_input_files; i++)
2274 if (input_files[i]->ctx->nb_chapters) {
2275 o->chapters_input_file = i;
2279 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2280 o->chapters_input_file);
2284 if (o->chapters_input_file >= 0)
2285 copy_chapters(input_files[o->chapters_input_file], of,
2286 !o->metadata_chapters_manual);
2288 /* copy global metadata by default */
2289 if (!o->metadata_global_manual && nb_input_files){
2290 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2291 AV_DICT_DONT_OVERWRITE);
2292 if(o->recording_time != INT64_MAX)
2293 av_dict_set(&oc->metadata, "duration", NULL, 0);
2294 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2296 if (!o->metadata_streams_manual)
2297 for (i = of->ost_index; i < nb_output_streams; i++) {
2299 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2301 ist = input_streams[output_streams[i]->source_index];
2302 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2303 if (!output_streams[i]->stream_copy) {
2304 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2305 if (ist->autorotate)
2306 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2310 /* process manually set metadata */
2311 for (i = 0; i < o->nb_metadata; i++) {
2314 const char *stream_spec;
2315 int index = 0, j, ret = 0;
2318 val = strchr(o->metadata[i].u.str, '=');
2320 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2321 o->metadata[i].u.str);
2326 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2327 !strcmp(val, "now")) {
2328 time_t now = time(0);
2329 struct tm *ptm, tmbuf;
2330 ptm = localtime_r(&now, &tmbuf);
2332 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2337 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2339 for (j = 0; j < oc->nb_streams; j++) {
2340 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2341 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2342 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2343 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2344 ost->rotate_overridden = 1;
2356 if (index < 0 || index >= oc->nb_chapters) {
2357 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2360 m = &oc->chapters[index]->metadata;
2363 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2366 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2373 static int opt_target(void *optctx, const char *opt, const char *arg)
2375 OptionsContext *o = optctx;
2376 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2377 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2379 if (!strncmp(arg, "pal-", 4)) {
2382 } else if (!strncmp(arg, "ntsc-", 5)) {
2385 } else if (!strncmp(arg, "film-", 5)) {
2389 /* Try to determine PAL/NTSC by peeking in the input files */
2390 if (nb_input_files) {
2392 for (j = 0; j < nb_input_files; j++) {
2393 for (i = 0; i < input_files[j]->nb_streams; i++) {
2394 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2395 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2398 fr = c->time_base.den * 1000 / c->time_base.num;
2402 } else if ((fr == 29970) || (fr == 23976)) {
2407 if (norm != UNKNOWN)
2411 if (norm != UNKNOWN)
2412 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2415 if (norm == UNKNOWN) {
2416 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2417 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2418 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2422 if (!strcmp(arg, "vcd")) {
2423 opt_video_codec(o, "c:v", "mpeg1video");
2424 opt_audio_codec(o, "c:a", "mp2");
2425 parse_option(o, "f", "vcd", options);
2427 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2428 parse_option(o, "r", frame_rates[norm], options);
2429 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2431 opt_default(NULL, "b:v", "1150000");
2432 opt_default(NULL, "maxrate:v", "1150000");
2433 opt_default(NULL, "minrate:v", "1150000");
2434 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2436 opt_default(NULL, "b:a", "224000");
2437 parse_option(o, "ar", "44100", options);
2438 parse_option(o, "ac", "2", options);
2440 opt_default(NULL, "packetsize", "2324");
2441 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2443 /* We have to offset the PTS, so that it is consistent with the SCR.
2444 SCR starts at 36000, but the first two packs contain only padding
2445 and the first pack from the other stream, respectively, may also have
2446 been written before.
2447 So the real data starts at SCR 36000+3*1200. */
2448 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2449 } else if (!strcmp(arg, "svcd")) {
2451 opt_video_codec(o, "c:v", "mpeg2video");
2452 opt_audio_codec(o, "c:a", "mp2");
2453 parse_option(o, "f", "svcd", options);
2455 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2456 parse_option(o, "r", frame_rates[norm], options);
2457 parse_option(o, "pix_fmt", "yuv420p", options);
2458 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2460 opt_default(NULL, "b:v", "2040000");
2461 opt_default(NULL, "maxrate:v", "2516000");
2462 opt_default(NULL, "minrate:v", "0"); // 1145000;
2463 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2464 opt_default(NULL, "scan_offset", "1");
2466 opt_default(NULL, "b:a", "224000");
2467 parse_option(o, "ar", "44100", options);
2469 opt_default(NULL, "packetsize", "2324");
2471 } else if (!strcmp(arg, "dvd")) {
2473 opt_video_codec(o, "c:v", "mpeg2video");
2474 opt_audio_codec(o, "c:a", "ac3");
2475 parse_option(o, "f", "dvd", options);
2477 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2478 parse_option(o, "r", frame_rates[norm], options);
2479 parse_option(o, "pix_fmt", "yuv420p", options);
2480 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2482 opt_default(NULL, "b:v", "6000000");
2483 opt_default(NULL, "maxrate:v", "9000000");
2484 opt_default(NULL, "minrate:v", "0"); // 1500000;
2485 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2487 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2488 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2490 opt_default(NULL, "b:a", "448000");
2491 parse_option(o, "ar", "48000", options);
2493 } else if (!strncmp(arg, "dv", 2)) {
2495 parse_option(o, "f", "dv", options);
2497 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2498 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2499 norm == PAL ? "yuv420p" : "yuv411p", options);
2500 parse_option(o, "r", frame_rates[norm], options);
2502 parse_option(o, "ar", "48000", options);
2503 parse_option(o, "ac", "2", options);
2506 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2507 return AVERROR(EINVAL);
2510 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2511 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2516 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2518 av_free (vstats_filename);
2519 vstats_filename = av_strdup (arg);
2523 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2526 time_t today2 = time(NULL);
2527 struct tm *today = localtime(&today2);
2529 if (!today) { // maybe tomorrow
2530 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2534 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2536 return opt_vstats_file(NULL, opt, filename);
2539 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2541 OptionsContext *o = optctx;
2542 return parse_option(o, "frames:v", arg, options);
2545 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2547 OptionsContext *o = optctx;
2548 return parse_option(o, "frames:a", arg, options);
2551 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2553 OptionsContext *o = optctx;
2554 return parse_option(o, "frames:d", arg, options);
2557 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2560 AVDictionary *cbak = codec_opts;
2561 AVDictionary *fbak = format_opts;
2565 ret = opt_default(NULL, opt, arg);
2567 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2568 av_dict_copy(&o->g->format_opts, format_opts, 0);
2569 av_dict_free(&codec_opts);
2570 av_dict_free(&format_opts);
2577 static int opt_preset(void *optctx, const char *opt, const char *arg)
2579 OptionsContext *o = optctx;
2581 char filename[1000], line[1000], tmp_line[1000];
2582 const char *codec_name = NULL;
2586 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2588 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2589 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2590 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2592 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2596 while (fgets(line, sizeof(line), f)) {
2597 char *key = tmp_line, *value, *endptr;
2599 if (strcspn(line, "#\n\r") == 0)
2601 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2602 if (!av_strtok(key, "=", &value) ||
2603 !av_strtok(value, "\r\n", &endptr)) {
2604 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2607 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2609 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2610 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2611 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2612 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2613 else if (opt_default_new(o, key, value) < 0) {
2614 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2615 filename, line, key, value);
2625 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2627 OptionsContext *o = optctx;
2628 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2629 int ret = parse_option(o, s, arg, options);
2634 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2636 OptionsContext *o = optctx;
2638 if(!strcmp(opt, "ab")){
2639 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2641 } else if(!strcmp(opt, "b")){
2642 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2643 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2646 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2650 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2652 OptionsContext *o = optctx;
2655 if(!strcmp(opt, "qscale")){
2656 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2657 return parse_option(o, "q:v", arg, options);
2659 s = av_asprintf("q%s", opt + 6);
2660 ret = parse_option(o, s, arg, options);
2665 static int opt_profile(void *optctx, const char *opt, const char *arg)
2667 OptionsContext *o = optctx;
2668 if(!strcmp(opt, "profile")){
2669 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2670 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2673 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2677 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2679 OptionsContext *o = optctx;
2680 return parse_option(o, "filter:v", arg, options);
2683 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2685 OptionsContext *o = optctx;
2686 return parse_option(o, "filter:a", arg, options);
2689 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2691 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2692 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2693 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2694 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2696 if (video_sync_method == VSYNC_AUTO)
2697 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2701 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2703 OptionsContext *o = optctx;
2704 char *tcr = av_asprintf("timecode=%s", arg);
2705 int ret = parse_option(o, "metadata:g", tcr, options);
2707 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2712 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2714 OptionsContext *o = optctx;
2715 char layout_str[32];
2718 int ret, channels, ac_str_size;
2721 layout = av_get_channel_layout(arg);
2723 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2724 return AVERROR(EINVAL);
2726 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2727 ret = opt_default_new(o, opt, layout_str);
2731 /* set 'ac' option based on channel layout */
2732 channels = av_get_channel_layout_nb_channels(layout);
2733 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2734 stream_str = strchr(opt, ':');
2735 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2736 ac_str = av_mallocz(ac_str_size);
2738 return AVERROR(ENOMEM);
2739 av_strlcpy(ac_str, "ac", 3);
2741 av_strlcat(ac_str, stream_str, ac_str_size);
2742 ret = parse_option(o, ac_str, layout_str, options);
2748 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2750 OptionsContext *o = optctx;
2751 return parse_option(o, "q:a", arg, options);
2754 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2756 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2757 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2758 return AVERROR(ENOMEM);
2759 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2760 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2761 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2762 return AVERROR(ENOMEM);
2764 input_stream_potentially_available = 1;
2769 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2771 uint8_t *graph_desc = read_file(arg);
2773 return AVERROR(EINVAL);
2775 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2776 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2777 return AVERROR(ENOMEM);
2778 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2779 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2781 input_stream_potentially_available = 1;
2786 void show_help_default(const char *opt, const char *arg)
2788 /* per-file options have at least one of those set */
2789 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2790 int show_advanced = 0, show_avoptions = 0;
2793 if (!strcmp(opt, "long"))
2795 else if (!strcmp(opt, "full"))
2796 show_advanced = show_avoptions = 1;
2798 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2803 printf("Getting help:\n"
2804 " -h -- print basic options\n"
2805 " -h long -- print more options\n"
2806 " -h full -- print all options (including all format and codec specific options, very long)\n"
2807 " See man %s for detailed description of the options.\n"
2808 "\n", program_name);
2810 show_help_options(options, "Print help / information / capabilities:",
2813 show_help_options(options, "Global options (affect whole program "
2814 "instead of just one file:",
2815 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2817 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2818 per_file | OPT_EXIT, 0);
2820 show_help_options(options, "Per-file main options:", 0,
2821 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2822 OPT_EXIT, per_file);
2824 show_help_options(options, "Advanced per-file options:",
2825 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2827 show_help_options(options, "Video options:",
2828 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2830 show_help_options(options, "Advanced Video options:",
2831 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2833 show_help_options(options, "Audio options:",
2834 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2836 show_help_options(options, "Advanced Audio options:",
2837 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2838 show_help_options(options, "Subtitle options:",
2839 OPT_SUBTITLE, 0, 0);
2842 if (show_avoptions) {
2843 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2844 show_help_children(avcodec_get_class(), flags);
2845 show_help_children(avformat_get_class(), flags);
2847 show_help_children(sws_get_class(), flags);
2849 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2850 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2854 void show_usage(void)
2856 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2857 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2858 av_log(NULL, AV_LOG_INFO, "\n");
2866 static const OptionGroupDef groups[] = {
2867 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2868 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2871 static int open_files(OptionGroupList *l, const char *inout,
2872 int (*open_file)(OptionsContext*, const char*))
2876 for (i = 0; i < l->nb_groups; i++) {
2877 OptionGroup *g = &l->groups[i];
2883 ret = parse_optgroup(&o, g);
2885 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2886 "%s.\n", inout, g->arg);
2890 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2891 ret = open_file(&o, g->arg);
2894 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2898 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2904 int ffmpeg_parse_options(int argc, char **argv)
2906 OptionParseContext octx;
2910 memset(&octx, 0, sizeof(octx));
2912 /* split the commandline into an internal representation */
2913 ret = split_commandline(&octx, argc, argv, options, groups,
2914 FF_ARRAY_ELEMS(groups));
2916 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2920 /* apply global options */
2921 ret = parse_optgroup(NULL, &octx.global_opts);
2923 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2927 /* open input files */
2928 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2930 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2934 /* create the complex filtergraphs */
2935 ret = init_complex_filters();
2937 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2941 /* open output files */
2942 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2944 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2948 /* configure the complex filtergraphs */
2949 ret = configure_complex_filters();
2951 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2956 uninit_parse_context(&octx);
2958 av_strerror(ret, error, sizeof(error));
2959 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2964 static int opt_progress(void *optctx, const char *opt, const char *arg)
2966 AVIOContext *avio = NULL;
2969 if (!strcmp(arg, "-"))
2971 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2973 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2974 arg, av_err2str(ret));
2977 progress_avio = avio;
2981 #define OFFSET(x) offsetof(OptionsContext, x)
2982 const OptionDef options[] = {
2984 #include "cmdutils_common_opts.h"
2985 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2986 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2987 "force format", "fmt" },
2988 { "y", OPT_BOOL, { &file_overwrite },
2989 "overwrite output files" },
2990 { "n", OPT_BOOL, { &no_file_overwrite },
2991 "never overwrite output files" },
2992 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
2993 "Ignore unknown stream types" },
2994 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
2995 "Copy unknown stream types" },
2996 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2997 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2998 "codec name", "codec" },
2999 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3000 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3001 "codec name", "codec" },
3002 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3003 OPT_OUTPUT, { .off = OFFSET(presets) },
3004 "preset name", "preset" },
3005 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3006 OPT_OUTPUT, { .func_arg = opt_map },
3007 "set input stream mapping",
3008 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3009 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3010 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3011 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3012 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3013 "set metadata information of outfile from infile",
3014 "outfile[,metadata]:infile[,metadata]" },
3015 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3016 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3017 "set chapters mapping", "input_file_index" },
3018 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3019 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3020 "record or transcode \"duration\" seconds of audio/video",
3022 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3023 "record or transcode stop time", "time_stop" },
3024 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3025 "set the limit file size in bytes", "limit_size" },
3026 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3027 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3028 "set the start time offset", "time_off" },
3029 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3030 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3031 "set the start time offset relative to EOF", "time_off" },
3032 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3033 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3034 "enable/disable seeking by timestamp with -ss" },
3035 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3036 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3037 "enable/disable accurate seeking with -ss" },
3038 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3039 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3040 "set the input ts offset", "time_off" },
3041 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3042 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3043 "set the input ts scale", "scale" },
3044 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3045 "set the recording timestamp ('now' to set the current time)", "time" },
3046 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3047 "add metadata", "string=string" },
3048 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3049 OPT_OUTPUT, { .func_arg = opt_data_frames },
3050 "set the number of data frames to output", "number" },
3051 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3052 "add timings for benchmarking" },
3053 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3054 "add timings for each task" },
3055 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3056 "write program-readable progress information", "url" },
3057 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3058 "enable or disable interaction on standard input" },
3059 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3060 "set max runtime in seconds", "limit" },
3061 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3062 "dump each input packet" },
3063 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3064 "when dumping packets, also dump the payload" },
3065 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3066 OPT_INPUT, { .off = OFFSET(rate_emu) },
3067 "read input at native frame rate", "" },
3068 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3069 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
3070 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3071 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
3072 "video sync method", "" },
3073 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3074 "frame drop threshold", "" },
3075 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3076 "audio sync method", "" },
3077 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3078 "audio drift threshold", "threshold" },
3079 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3080 "copy timestamps" },
3081 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3082 "shift input timestamps to start at 0 when using copyts" },
3083 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3084 "copy input stream time base when stream copying", "mode" },
3085 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3086 OPT_OUTPUT, { .off = OFFSET(shortest) },
3087 "finish encoding within shortest input" },
3088 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3089 OPT_OUTPUT, { .off = OFFSET(apad) },
3091 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3092 "timestamp discontinuity delta threshold", "threshold" },
3093 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3094 "timestamp error delta threshold", "threshold" },
3095 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3096 "exit on error", "error" },
3097 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3098 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3099 "copy initial non-keyframes" },
3100 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3101 "copy or discard frames before start time" },
3102 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3103 "set the number of frames to output", "number" },
3104 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3105 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3106 "force codec tag/fourcc", "fourcc/tag" },
3107 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3108 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3109 "use fixed quality scale (VBR)", "q" },
3110 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3111 OPT_OUTPUT, { .func_arg = opt_qscale },
3112 "use fixed quality scale (VBR)", "q" },
3113 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3114 "set profile", "profile" },
3115 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3116 "set stream filtergraph", "filter_graph" },
3117 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3118 "read stream filtergraph description from a file", "filename" },
3119 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3120 "reinit filtergraph on input parameter changes", "" },
3121 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3122 "create a complex filtergraph", "graph_description" },
3123 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3124 "create a complex filtergraph", "graph_description" },
3125 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3126 "read complex filtergraph description from a file", "filename" },
3127 { "stats", OPT_BOOL, { &print_stats },
3128 "print progress report during encoding", },
3129 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3130 OPT_OUTPUT, { .func_arg = opt_attach },
3131 "add an attachment to the output file", "filename" },
3132 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3133 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3134 "extract an attachment into a file", "filename" },
3135 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3136 "print timestamp debugging info" },
3137 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3138 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3139 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3140 OPT_INPUT, { .off = OFFSET(discard) },
3142 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3143 OPT_OUTPUT, { .off = OFFSET(disposition) },
3144 "disposition", "" },
3145 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3146 { .off = OFFSET(thread_queue_size) },
3147 "set the maximum number of queued packets from the demuxer" },
3150 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3151 "set the number of video frames to output", "number" },
3152 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3153 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3154 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3155 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3156 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3157 "set frame size (WxH or abbreviation)", "size" },
3158 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3159 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3160 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3161 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3162 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3163 "set pixel format", "format" },
3164 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3165 "set the number of bits per raw sample", "number" },
3166 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3167 "deprecated use -g 1" },
3168 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3170 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3171 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3172 "rate control override for specific intervals", "override" },
3173 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3174 OPT_OUTPUT, { .func_arg = opt_video_codec },
3175 "force video codec ('copy' to copy stream)", "codec" },
3176 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3178 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3180 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3181 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3182 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3183 "select the pass number (1 to 3)", "n" },
3184 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3185 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3186 "select two pass log file name prefix", "prefix" },
3187 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3188 "this option is deprecated, use the yadif filter instead" },
3189 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3190 "calculate PSNR of compressed frames" },
3191 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3192 "dump video coding statistics to file" },
3193 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3194 "dump video coding statistics to file", "file" },
3195 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3196 "set video filters", "filter_graph" },
3197 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3198 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3199 "specify intra matrix coeffs", "matrix" },
3200 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3201 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3202 "specify inter matrix coeffs", "matrix" },
3203 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3204 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3205 "specify intra matrix coeffs", "matrix" },
3206 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3207 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3208 "top=1/bottom=0/auto=-1 field first", "" },
3209 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3210 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3211 "force video tag/fourcc", "fourcc/tag" },
3212 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3213 "show QP histogram" },
3214 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3215 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3216 "force the selected framerate, disable the best supported framerate selection" },
3217 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3218 OPT_OUTPUT, { .func_arg = opt_streamid },
3219 "set the value of an outfile streamid", "streamIndex:value" },
3220 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3221 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3222 "force key frames at specified timestamps", "timestamps" },
3223 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3224 "audio bitrate (please use -b:a)", "bitrate" },
3225 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3226 "video bitrate (please use -b:v)", "bitrate" },
3227 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3228 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3229 "use HW accelerated decoding", "hwaccel name" },
3230 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3231 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3232 "select a device for HW acceleration" "devicename" },
3234 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3236 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3237 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3238 "automatically insert correct rotate filters" },
3241 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3242 "set the number of audio frames to output", "number" },
3243 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3244 "set audio quality (codec-specific)", "quality", },
3245 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3246 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3247 "set audio sampling rate (in Hz)", "rate" },
3248 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3249 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3250 "set number of audio channels", "channels" },
3251 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3253 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3254 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3255 "force audio codec ('copy' to copy stream)", "codec" },
3256 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3257 OPT_OUTPUT, { .func_arg = opt_old2new },
3258 "force audio tag/fourcc", "fourcc/tag" },
3259 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3260 "change audio volume (256=normal)" , "volume" },
3261 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3262 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3263 "set sample format", "format" },
3264 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3265 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3266 "set channel layout", "layout" },
3267 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3268 "set audio filters", "filter_graph" },
3269 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3270 "set the maximum number of channels to try to guess the channel layout" },
3272 /* subtitle options */
3273 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3274 "disable subtitle" },
3275 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3276 "force subtitle codec ('copy' to copy stream)", "codec" },
3277 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3278 , "force subtitle tag/fourcc", "fourcc/tag" },
3279 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3280 "fix subtitles duration" },
3281 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3282 "set canvas size (WxH or abbreviation)", "size" },
3285 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3286 "deprecated, use -channel", "channel" },
3287 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3288 "deprecated, use -standard", "standard" },
3289 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3292 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3293 "set the maximum demux-decode delay", "seconds" },
3294 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3295 "set the initial demux-decode delay", "seconds" },
3296 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3297 "override the options from ffserver", "" },
3298 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3299 "specify a file in which to print sdp information", "file" },
3301 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3302 "A comma-separated list of bitstream filters", "bitstream_filters" },
3303 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3304 "deprecated", "audio bitstream_filters" },
3305 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3306 "deprecated", "video bitstream_filters" },
3308 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3309 "set the audio options to the indicated preset", "preset" },
3310 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3311 "set the video options to the indicated preset", "preset" },
3312 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3313 "set the subtitle options to the indicated preset", "preset" },
3314 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3315 "set options from indicated preset file", "filename" },
3316 /* data codec support */
3317 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3318 "force data codec ('copy' to copy stream)", "codec" },
3319 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },