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", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 #if CONFIG_VIDEOTOOLBOX
80 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
85 char *vstats_filename;
88 float audio_drift_threshold = 0.1;
89 float dts_delta_threshold = 10;
90 float dts_error_threshold = 3600*30;
92 int audio_volume = 256;
93 int audio_sync_method = 0;
94 int video_sync_method = VSYNC_AUTO;
95 float frame_drop_threshold = 0;
96 int do_deinterlace = 0;
98 int do_benchmark_all = 0;
102 int start_at_zero = 0;
105 int exit_on_error = 0;
106 int print_stats = -1;
108 int stdin_interaction = 1;
109 int frame_bits_per_raw_sample = 0;
110 float max_error_rate = 2.0/3;
113 static int intra_only = 0;
114 static int file_overwrite = 0;
115 static int no_file_overwrite = 0;
116 static int do_psnr = 0;
117 static int input_sync;
118 static int override_ffserver = 0;
119 static int input_stream_potentially_available = 0;
120 static int ignore_unknown_streams = 0;
121 static int copy_unknown_streams = 0;
123 static void uninit_options(OptionsContext *o)
125 const OptionDef *po = options;
128 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
130 void *dst = (uint8_t*)o + po->u.off;
132 if (po->flags & OPT_SPEC) {
133 SpecifierOpt **so = dst;
134 int i, *count = (int*)(so + 1);
135 for (i = 0; i < *count; i++) {
136 av_freep(&(*so)[i].specifier);
137 if (po->flags & OPT_STRING)
138 av_freep(&(*so)[i].u.str);
142 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
147 for (i = 0; i < o->nb_stream_maps; i++)
148 av_freep(&o->stream_maps[i].linklabel);
149 av_freep(&o->stream_maps);
150 av_freep(&o->audio_channel_maps);
151 av_freep(&o->streamid_map);
152 av_freep(&o->attachments);
155 static void init_options(OptionsContext *o)
157 memset(o, 0, sizeof(*o));
159 o->stop_time = INT64_MAX;
160 o->mux_max_delay = 0.7;
161 o->start_time = AV_NOPTS_VALUE;
162 o->start_time_eof = AV_NOPTS_VALUE;
163 o->recording_time = INT64_MAX;
164 o->limit_filesize = UINT64_MAX;
165 o->chapters_input_file = INT_MAX;
166 o->accurate_seek = 1;
169 /* return a copy of the input with the stream specifiers removed from the keys */
170 static AVDictionary *strip_specifiers(AVDictionary *dict)
172 AVDictionaryEntry *e = NULL;
173 AVDictionary *ret = NULL;
175 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
176 char *p = strchr(e->key, ':');
180 av_dict_set(&ret, e->key, e->value, 0);
187 static int opt_sameq(void *optctx, const char *opt, const char *arg)
189 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
190 "If you are looking for an option to preserve the quality (which is not "
191 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
193 return AVERROR(EINVAL);
196 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
198 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
199 return opt_default(optctx, "channel", arg);
202 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
204 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
205 return opt_default(optctx, "standard", arg);
208 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
210 OptionsContext *o = optctx;
211 return parse_option(o, "codec:a", arg, options);
214 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
216 OptionsContext *o = optctx;
217 return parse_option(o, "codec:v", arg, options);
220 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
222 OptionsContext *o = optctx;
223 return parse_option(o, "codec:s", arg, options);
226 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
228 OptionsContext *o = optctx;
229 return parse_option(o, "codec:d", arg, options);
232 static int opt_map(void *optctx, const char *opt, const char *arg)
234 OptionsContext *o = optctx;
236 int i, negative = 0, file_idx;
237 int sync_file_idx = -1, sync_stream_idx = 0;
246 map = av_strdup(arg);
248 return AVERROR(ENOMEM);
250 /* parse sync stream first, just pick first matching stream */
251 if (sync = strchr(map, ',')) {
253 sync_file_idx = strtol(sync + 1, &sync, 0);
254 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
255 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
260 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
261 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
262 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
266 if (i == input_files[sync_file_idx]->nb_streams) {
267 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
268 "match any streams.\n", arg);
275 /* this mapping refers to lavfi output */
276 const char *c = map + 1;
277 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
278 m = &o->stream_maps[o->nb_stream_maps - 1];
279 m->linklabel = av_get_token(&c, "]");
281 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
285 if (allow_unused = strchr(map, '?'))
287 file_idx = strtol(map, &p, 0);
288 if (file_idx >= nb_input_files || file_idx < 0) {
289 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
293 /* disable some already defined maps */
294 for (i = 0; i < o->nb_stream_maps; i++) {
295 m = &o->stream_maps[i];
296 if (file_idx == m->file_index &&
297 check_stream_specifier(input_files[m->file_index]->ctx,
298 input_files[m->file_index]->ctx->streams[m->stream_index],
299 *p == ':' ? p + 1 : p) > 0)
303 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
304 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
305 *p == ':' ? p + 1 : p) <= 0)
307 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
308 m = &o->stream_maps[o->nb_stream_maps - 1];
310 m->file_index = file_idx;
313 if (sync_file_idx >= 0) {
314 m->sync_file_index = sync_file_idx;
315 m->sync_stream_index = sync_stream_idx;
317 m->sync_file_index = file_idx;
318 m->sync_stream_index = i;
325 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
327 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
328 "To ignore this, add a trailing '?' to the map.\n", arg);
337 static int opt_attach(void *optctx, const char *opt, const char *arg)
339 OptionsContext *o = optctx;
340 GROW_ARRAY(o->attachments, o->nb_attachments);
341 o->attachments[o->nb_attachments - 1] = arg;
345 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
347 OptionsContext *o = optctx;
352 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
353 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
355 /* muted channel syntax */
356 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
357 if ((n == 1 || n == 3) && m->channel_idx == -1) {
358 m->file_idx = m->stream_idx = -1;
360 m->ofile_idx = m->ostream_idx = -1;
365 n = sscanf(arg, "%d.%d.%d:%d.%d",
366 &m->file_idx, &m->stream_idx, &m->channel_idx,
367 &m->ofile_idx, &m->ostream_idx);
369 if (n != 3 && n != 5) {
370 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
371 "[file.stream.channel|-1][:syncfile:syncstream]\n");
375 if (n != 5) // only file.stream.channel specified
376 m->ofile_idx = m->ostream_idx = -1;
379 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
380 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
384 if (m->stream_idx < 0 ||
385 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
386 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
387 m->file_idx, m->stream_idx);
390 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
391 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
392 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
393 m->file_idx, m->stream_idx);
396 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
397 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
398 m->file_idx, m->stream_idx, m->channel_idx);
404 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
406 av_free(sdp_filename);
407 sdp_filename = av_strdup(arg);
412 * Parse a metadata specifier passed as 'arg' parameter.
413 * @param arg metadata string to parse
414 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
415 * @param index for type c/p, chapter/program index is written here
416 * @param stream_spec for type s, the stream specifier is written here
418 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
426 if (*(++arg) && *arg != ':') {
427 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
430 *stream_spec = *arg == ':' ? arg + 1 : "";
435 *index = strtol(++arg, NULL, 0);
438 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
445 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
447 AVDictionary **meta_in = NULL;
448 AVDictionary **meta_out = NULL;
450 char type_in, type_out;
451 const char *istream_spec = NULL, *ostream_spec = NULL;
452 int idx_in = 0, idx_out = 0;
454 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
455 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
458 if (type_out == 'g' || !*outspec)
459 o->metadata_global_manual = 1;
460 if (type_out == 's' || !*outspec)
461 o->metadata_streams_manual = 1;
462 if (type_out == 'c' || !*outspec)
463 o->metadata_chapters_manual = 1;
467 if (type_in == 'g' || type_out == 'g')
468 o->metadata_global_manual = 1;
469 if (type_in == 's' || type_out == 's')
470 o->metadata_streams_manual = 1;
471 if (type_in == 'c' || type_out == 'c')
472 o->metadata_chapters_manual = 1;
474 /* ic is NULL when just disabling automatic mappings */
478 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
479 if ((index) < 0 || (index) >= (nb_elems)) {\
480 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
485 #define SET_DICT(type, meta, context, index)\
488 meta = &context->metadata;\
491 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
492 meta = &context->chapters[index]->metadata;\
495 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
496 meta = &context->programs[index]->metadata;\
499 break; /* handled separately below */ \
500 default: av_assert0(0);\
503 SET_DICT(type_in, meta_in, ic, idx_in);
504 SET_DICT(type_out, meta_out, oc, idx_out);
506 /* for input streams choose first matching stream */
507 if (type_in == 's') {
508 for (i = 0; i < ic->nb_streams; i++) {
509 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
510 meta_in = &ic->streams[i]->metadata;
516 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
521 if (type_out == 's') {
522 for (i = 0; i < oc->nb_streams; i++) {
523 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
524 meta_out = &oc->streams[i]->metadata;
525 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
530 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
535 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
537 OptionsContext *o = optctx;
539 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
540 struct tm time = *gmtime((time_t*)&recording_timestamp);
541 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
543 parse_option(o, "metadata", buf, options);
545 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
546 "tag instead.\n", opt);
550 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
552 const AVCodecDescriptor *desc;
553 const char *codec_string = encoder ? "encoder" : "decoder";
557 avcodec_find_encoder_by_name(name) :
558 avcodec_find_decoder_by_name(name);
560 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
561 codec = encoder ? avcodec_find_encoder(desc->id) :
562 avcodec_find_decoder(desc->id);
564 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
565 codec_string, codec->name, desc->name);
569 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
572 if (codec->type != type) {
573 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
579 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
581 char *codec_name = NULL;
583 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
585 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
586 st->codec->codec_id = codec->id;
589 return avcodec_find_decoder(st->codec->codec_id);
592 /* Add all the streams from the given input file to the global
593 * list of input streams. */
594 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
598 for (i = 0; i < ic->nb_streams; i++) {
599 AVStream *st = ic->streams[i];
600 AVCodecContext *dec = st->codec;
601 InputStream *ist = av_mallocz(sizeof(*ist));
602 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
603 char *codec_tag = NULL;
605 char *discard_str = NULL;
606 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
611 GROW_ARRAY(input_streams, nb_input_streams);
612 input_streams[nb_input_streams - 1] = ist;
615 ist->file_index = nb_input_files;
617 st->discard = AVDISCARD_ALL;
620 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
623 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
625 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
627 uint32_t tag = strtol(codec_tag, &next, 0);
629 tag = AV_RL32(codec_tag);
630 st->codec->codec_tag = tag;
633 ist->dec = choose_decoder(o, ic, st);
634 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
636 ist->reinit_filters = -1;
637 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
639 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
640 ist->user_set_discard = AVDISCARD_NONE;
641 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
642 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
647 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
649 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
651 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
655 ret = avcodec_copy_context(ist->dec_ctx, dec);
657 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
661 switch (dec->codec_type) {
662 case AVMEDIA_TYPE_VIDEO:
664 ist->dec = avcodec_find_decoder(dec->codec_id);
665 if (av_codec_get_lowres(dec)) {
666 dec->flags |= CODEC_FLAG_EMU_EDGE;
669 ist->resample_height = ist->dec_ctx->height;
670 ist->resample_width = ist->dec_ctx->width;
671 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
673 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
674 if (framerate && av_parse_video_rate(&ist->framerate,
676 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
681 ist->top_field_first = -1;
682 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
684 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
686 if (!strcmp(hwaccel, "none"))
687 ist->hwaccel_id = HWACCEL_NONE;
688 else if (!strcmp(hwaccel, "auto"))
689 ist->hwaccel_id = HWACCEL_AUTO;
692 for (i = 0; hwaccels[i].name; i++) {
693 if (!strcmp(hwaccels[i].name, hwaccel)) {
694 ist->hwaccel_id = hwaccels[i].id;
699 if (!ist->hwaccel_id) {
700 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
702 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
703 for (i = 0; hwaccels[i].name; i++)
704 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
705 av_log(NULL, AV_LOG_FATAL, "\n");
711 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
712 if (hwaccel_device) {
713 ist->hwaccel_device = av_strdup(hwaccel_device);
714 if (!ist->hwaccel_device)
717 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
720 case AVMEDIA_TYPE_AUDIO:
721 ist->guess_layout_max = INT_MAX;
722 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
723 guess_input_channel_layout(ist);
725 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
726 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
727 ist->resample_channels = ist->dec_ctx->channels;
728 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
731 case AVMEDIA_TYPE_DATA:
732 case AVMEDIA_TYPE_SUBTITLE: {
733 char *canvas_size = NULL;
735 ist->dec = avcodec_find_decoder(dec->codec_id);
736 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
737 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
739 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
740 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
745 case AVMEDIA_TYPE_ATTACHMENT:
746 case AVMEDIA_TYPE_UNKNOWN:
754 static void assert_file_overwrite(const char *filename)
756 if (file_overwrite && no_file_overwrite) {
757 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
761 if (!file_overwrite) {
762 const char *proto_name = avio_find_protocol_name(filename);
763 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
764 if (stdin_interaction && !no_file_overwrite) {
765 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
768 signal(SIGINT, SIG_DFL);
770 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
776 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
783 static void dump_attachment(AVStream *st, const char *filename)
786 AVIOContext *out = NULL;
787 AVDictionaryEntry *e;
789 if (!st->codec->extradata_size) {
790 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
791 nb_input_files - 1, st->index);
794 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
797 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
798 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
802 assert_file_overwrite(filename);
804 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
805 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
810 avio_write(out, st->codec->extradata, st->codec->extradata_size);
815 static int open_input_file(OptionsContext *o, const char *filename)
819 AVInputFormat *file_iformat = NULL;
823 AVDictionary *unused_opts = NULL;
824 AVDictionaryEntry *e = NULL;
825 int orig_nb_streams; // number of streams before avformat_find_stream_info
826 char * video_codec_name = NULL;
827 char * audio_codec_name = NULL;
828 char *subtitle_codec_name = NULL;
829 char * data_codec_name = NULL;
830 int scan_all_pmts_set = 0;
833 if (!(file_iformat = av_find_input_format(o->format))) {
834 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
839 if (!strcmp(filename, "-"))
842 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
843 strcmp(filename, "/dev/stdin");
845 /* get default parameters from command line */
846 ic = avformat_alloc_context();
848 print_error(filename, AVERROR(ENOMEM));
851 if (o->nb_audio_sample_rate) {
852 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
854 if (o->nb_audio_channels) {
855 /* because we set audio_channels based on both the "ac" and
856 * "channel_layout" options, we need to check that the specified
857 * demuxer actually has the "channels" option before setting it */
858 if (file_iformat && file_iformat->priv_class &&
859 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
860 AV_OPT_SEARCH_FAKE_OBJ)) {
861 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
864 if (o->nb_frame_rates) {
865 /* set the format-level framerate option;
866 * this is important for video grabbers, e.g. x11 */
867 if (file_iformat && file_iformat->priv_class &&
868 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
869 AV_OPT_SEARCH_FAKE_OBJ)) {
870 av_dict_set(&o->g->format_opts, "framerate",
871 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
874 if (o->nb_frame_sizes) {
875 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
877 if (o->nb_frame_pix_fmts)
878 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
880 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
881 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
882 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
883 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
885 ic->video_codec_id = video_codec_name ?
886 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
887 ic->audio_codec_id = audio_codec_name ?
888 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
889 ic->subtitle_codec_id= subtitle_codec_name ?
890 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
891 ic->data_codec_id = data_codec_name ?
892 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
894 if (video_codec_name)
895 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
896 if (audio_codec_name)
897 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
898 if (subtitle_codec_name)
899 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
901 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
903 ic->flags |= AVFMT_FLAG_NONBLOCK;
904 ic->interrupt_callback = int_cb;
906 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
907 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
908 scan_all_pmts_set = 1;
910 /* open the input file with generic avformat function */
911 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
913 print_error(filename, err);
916 if (scan_all_pmts_set)
917 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
918 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
919 assert_avoptions(o->g->format_opts);
921 /* apply forced codec ids */
922 for (i = 0; i < ic->nb_streams; i++)
923 choose_decoder(o, ic, ic->streams[i]);
925 /* Set AVCodecContext options for avformat_find_stream_info */
926 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
927 orig_nb_streams = ic->nb_streams;
929 /* If not enough info to get the stream parameters, we decode the
930 first frames to get it. (used in mpeg case for example) */
931 ret = avformat_find_stream_info(ic, opts);
933 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
934 if (ic->nb_streams == 0) {
935 avformat_close_input(&ic);
940 if (o->start_time_eof != AV_NOPTS_VALUE) {
941 if (ic->duration>0) {
942 o->start_time = o->start_time_eof + ic->duration;
944 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
946 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
947 /* add the stream start time */
948 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
949 timestamp += ic->start_time;
951 /* if seeking requested, we execute it */
952 if (o->start_time != AV_NOPTS_VALUE) {
953 int64_t seek_timestamp = timestamp;
955 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
956 int dts_heuristic = 0;
957 for (i=0; i<ic->nb_streams; i++) {
958 AVCodecContext *avctx = ic->streams[i]->codec;
959 if (avctx->has_b_frames)
963 seek_timestamp -= 3*AV_TIME_BASE / 23;
966 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
968 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
969 filename, (double)timestamp / AV_TIME_BASE);
973 /* update the current parameters so that they match the one of the input stream */
974 add_input_streams(o, ic);
976 /* dump the file content */
977 av_dump_format(ic, nb_input_files, filename, 0);
979 GROW_ARRAY(input_files, nb_input_files);
980 f = av_mallocz(sizeof(*f));
983 input_files[nb_input_files - 1] = f;
986 f->ist_index = nb_input_streams - ic->nb_streams;
987 f->start_time = o->start_time;
988 f->recording_time = o->recording_time;
989 f->input_ts_offset = o->input_ts_offset;
990 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
991 f->nb_streams = ic->nb_streams;
992 f->rate_emu = o->rate_emu;
993 f->accurate_seek = o->accurate_seek;
995 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
998 /* check if all codec options have been used */
999 unused_opts = strip_specifiers(o->g->codec_opts);
1000 for (i = f->ist_index; i < nb_input_streams; i++) {
1002 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1003 AV_DICT_IGNORE_SUFFIX)))
1004 av_dict_set(&unused_opts, e->key, NULL, 0);
1008 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1009 const AVClass *class = avcodec_get_class();
1010 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1011 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1012 const AVClass *fclass = avformat_get_class();
1013 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1014 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1015 if (!option || foption)
1019 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1020 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1021 "input file #%d (%s) is not a decoding option.\n", e->key,
1022 option->help ? option->help : "", nb_input_files - 1,
1027 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1028 "input file #%d (%s) has not been used for any stream. The most "
1029 "likely reason is either wrong type (e.g. a video option with "
1030 "no video streams) or that it is a private option of some decoder "
1031 "which was not actually used for any stream.\n", e->key,
1032 option->help ? option->help : "", nb_input_files - 1, filename);
1034 av_dict_free(&unused_opts);
1036 for (i = 0; i < o->nb_dump_attachment; i++) {
1039 for (j = 0; j < ic->nb_streams; j++) {
1040 AVStream *st = ic->streams[j];
1042 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1043 dump_attachment(st, o->dump_attachment[i].u.str);
1047 for (i = 0; i < orig_nb_streams; i++)
1048 av_dict_free(&opts[i]);
1051 input_stream_potentially_available = 1;
1056 static uint8_t *get_line(AVIOContext *s)
1062 if (avio_open_dyn_buf(&line) < 0) {
1063 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1067 while ((c = avio_r8(s)) && c != '\n')
1070 avio_close_dyn_buf(line, &buf);
1075 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1078 char filename[1000];
1079 const char *base[3] = { getenv("AVCONV_DATADIR"),
1084 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1088 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1089 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1090 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1093 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1094 i != 1 ? "" : "/.avconv", preset_name);
1095 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1101 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1103 char *codec_name = NULL;
1105 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1107 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1108 NULL, ost->st->codec->codec_type);
1109 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1110 } else if (!strcmp(codec_name, "copy"))
1111 ost->stream_copy = 1;
1113 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1114 ost->st->codec->codec_id = ost->enc->id;
1118 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1121 AVStream *st = avformat_new_stream(oc, NULL);
1122 int idx = oc->nb_streams - 1, ret = 0;
1123 char *bsf = NULL, *next, *codec_tag = NULL;
1124 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1129 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1133 if (oc->nb_streams - 1 < o->nb_streamid_map)
1134 st->id = o->streamid_map[oc->nb_streams - 1];
1136 GROW_ARRAY(output_streams, nb_output_streams);
1137 if (!(ost = av_mallocz(sizeof(*ost))))
1139 output_streams[nb_output_streams - 1] = ost;
1141 ost->file_index = nb_output_files - 1;
1144 st->codec->codec_type = type;
1145 choose_encoder(o, oc, ost);
1147 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1148 if (!ost->enc_ctx) {
1149 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1152 ost->enc_ctx->codec_type = type;
1155 AVIOContext *s = NULL;
1156 char *buf = NULL, *arg = NULL, *preset = NULL;
1158 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1160 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1161 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1164 if (!buf[0] || buf[0] == '#') {
1168 if (!(arg = strchr(buf, '='))) {
1169 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1173 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1175 } while (!s->eof_reached);
1179 av_log(NULL, AV_LOG_FATAL,
1180 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1181 preset, ost->file_index, ost->index);
1185 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1188 ost->max_frames = INT64_MAX;
1189 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1190 for (i = 0; i<o->nb_max_frames; i++) {
1191 char *p = o->max_frames[i].specifier;
1192 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1193 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1198 ost->copy_prior_start = -1;
1199 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1201 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1204 if (next = strchr(bsf, ','))
1206 if (arg = strchr(bsf, '='))
1208 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1209 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1213 bsfc_prev->next = bsfc;
1215 ost->bitstream_filters = bsfc;
1216 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1222 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1224 uint32_t tag = strtol(codec_tag, &next, 0);
1226 tag = AV_RL32(codec_tag);
1227 ost->st->codec->codec_tag =
1228 ost->enc_ctx->codec_tag = tag;
1231 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1233 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1234 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1237 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1238 ost->disposition = av_strdup(ost->disposition);
1240 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1241 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1243 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1245 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1246 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1247 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1249 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1251 ost->source_index = source_index;
1252 if (source_index >= 0) {
1253 ost->sync_ist = input_streams[source_index];
1254 input_streams[source_index]->discard = 0;
1255 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1257 ost->last_mux_dts = AV_NOPTS_VALUE;
1262 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1265 const char *p = str;
1272 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1279 /* read file contents into a string */
1280 static uint8_t *read_file(const char *filename)
1282 AVIOContext *pb = NULL;
1283 AVIOContext *dyn_buf = NULL;
1284 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1285 uint8_t buf[1024], *str;
1288 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1292 ret = avio_open_dyn_buf(&dyn_buf);
1297 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1298 avio_write(dyn_buf, buf, ret);
1299 avio_w8(dyn_buf, 0);
1302 ret = avio_close_dyn_buf(dyn_buf, &str);
1308 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1311 AVStream *st = ost->st;
1313 if (ost->filters_script && ost->filters) {
1314 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1315 "output stream #%d:%d.\n", nb_output_files, st->index);
1319 if (ost->filters_script)
1320 return read_file(ost->filters_script);
1321 else if (ost->filters)
1322 return av_strdup(ost->filters);
1324 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1328 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1329 const OutputStream *ost, enum AVMediaType type)
1331 if (ost->filters_script || ost->filters) {
1332 av_log(NULL, AV_LOG_ERROR,
1333 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1334 "Filtering and streamcopy cannot be used together.\n",
1335 ost->filters ? "Filtergraph" : "Filtergraph script",
1336 ost->filters ? ost->filters : ost->filters_script,
1337 av_get_media_type_string(type), ost->file_index, ost->index);
1342 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1346 AVCodecContext *video_enc;
1347 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1349 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1351 video_enc = ost->enc_ctx;
1353 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1354 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1355 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1358 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1359 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1361 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1362 if (frame_aspect_ratio) {
1364 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1365 q.num <= 0 || q.den <= 0) {
1366 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1369 ost->frame_aspect_ratio = q;
1372 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1373 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1375 if (!ost->stream_copy) {
1376 const char *p = NULL;
1377 char *frame_size = NULL;
1378 char *frame_pix_fmt = NULL;
1379 char *intra_matrix = NULL, *inter_matrix = NULL;
1380 char *chroma_intra_matrix = NULL;
1384 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1385 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1386 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1390 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1391 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1392 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1393 ost->keep_pix_fmt = 1;
1394 if (!*++frame_pix_fmt)
1395 frame_pix_fmt = NULL;
1397 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1398 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1401 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1404 video_enc->gop_size = 0;
1405 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1407 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1408 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1411 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1413 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1414 if (chroma_intra_matrix) {
1415 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1417 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1420 av_codec_set_chroma_intra_matrix(video_enc, p);
1421 parse_matrix_coeffs(p, chroma_intra_matrix);
1423 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1425 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1426 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1429 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1432 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1433 for (i = 0; p; i++) {
1435 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1437 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1440 video_enc->rc_override =
1441 av_realloc_array(video_enc->rc_override,
1442 i + 1, sizeof(RcOverride));
1443 if (!video_enc->rc_override) {
1444 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1447 video_enc->rc_override[i].start_frame = start;
1448 video_enc->rc_override[i].end_frame = end;
1450 video_enc->rc_override[i].qscale = q;
1451 video_enc->rc_override[i].quality_factor = 1.0;
1454 video_enc->rc_override[i].qscale = 0;
1455 video_enc->rc_override[i].quality_factor = -q/100.0;
1460 video_enc->rc_override_count = i;
1463 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1466 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1469 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1470 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1473 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1474 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1478 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1479 if (ost->logfile_prefix &&
1480 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1484 char logfilename[1024];
1487 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1488 ost->logfile_prefix ? ost->logfile_prefix :
1489 DEFAULT_PASS_LOGFILENAME_PREFIX,
1491 if (!strcmp(ost->enc->name, "libx264")) {
1492 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1494 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1495 char *logbuffer = read_file(logfilename);
1498 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1502 video_enc->stats_in = logbuffer;
1504 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1505 f = av_fopen_utf8(logfilename, "wb");
1507 av_log(NULL, AV_LOG_FATAL,
1508 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1509 logfilename, strerror(errno));
1517 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1518 if (ost->forced_keyframes)
1519 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1521 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1523 ost->top_field_first = -1;
1524 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1527 ost->avfilter = get_ost_filters(o, oc, ost);
1531 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1534 if (ost->stream_copy)
1535 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1540 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1545 AVCodecContext *audio_enc;
1547 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1550 audio_enc = ost->enc_ctx;
1551 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1553 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1554 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1556 if (!ost->stream_copy) {
1557 char *sample_fmt = NULL;
1559 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1561 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1563 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1564 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1568 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1570 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1571 ost->apad = av_strdup(ost->apad);
1573 ost->avfilter = get_ost_filters(o, oc, ost);
1577 /* check for channel mapping for this audio stream */
1578 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1579 AudioChannelMap *map = &o->audio_channel_maps[n];
1580 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1581 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1584 if (map->channel_idx == -1) {
1586 } else if (ost->source_index < 0) {
1587 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1588 ost->file_index, ost->st->index);
1591 ist = input_streams[ost->source_index];
1594 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1595 if (av_reallocp_array(&ost->audio_channels_map,
1596 ost->audio_channels_mapped + 1,
1597 sizeof(*ost->audio_channels_map)
1601 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1607 if (ost->stream_copy)
1608 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1613 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1617 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1618 if (!ost->stream_copy) {
1619 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1626 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1630 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1631 if (!ost->stream_copy) {
1632 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1639 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1641 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1642 ost->stream_copy = 1;
1647 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1651 AVCodecContext *subtitle_enc;
1653 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1655 subtitle_enc = ost->enc_ctx;
1657 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1659 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1661 if (!ost->stream_copy) {
1662 char *frame_size = NULL;
1664 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1665 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1666 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1674 /* arg format is "output-stream-index:streamid-value". */
1675 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1677 OptionsContext *o = optctx;
1682 av_strlcpy(idx_str, arg, sizeof(idx_str));
1683 p = strchr(idx_str, ':');
1685 av_log(NULL, AV_LOG_FATAL,
1686 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1691 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1692 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1693 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1697 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1699 AVFormatContext *is = ifile->ctx;
1700 AVFormatContext *os = ofile->ctx;
1704 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1706 return AVERROR(ENOMEM);
1709 for (i = 0; i < is->nb_chapters; i++) {
1710 AVChapter *in_ch = is->chapters[i], *out_ch;
1711 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1712 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1713 AV_TIME_BASE_Q, in_ch->time_base);
1714 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1715 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1718 if (in_ch->end < ts_off)
1720 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1723 out_ch = av_mallocz(sizeof(AVChapter));
1725 return AVERROR(ENOMEM);
1727 out_ch->id = in_ch->id;
1728 out_ch->time_base = in_ch->time_base;
1729 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1730 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1733 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1735 os->chapters[os->nb_chapters++] = out_ch;
1740 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1743 AVFormatContext *ic = avformat_alloc_context();
1745 ic->interrupt_callback = int_cb;
1746 err = avformat_open_input(&ic, filename, NULL, NULL);
1749 /* copy stream format */
1750 for(i=0;i<ic->nb_streams;i++) {
1754 const char *enc_config;
1756 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1758 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1759 return AVERROR(EINVAL);
1761 if (codec->type == AVMEDIA_TYPE_AUDIO)
1762 opt_audio_codec(o, "c:a", codec->name);
1763 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1764 opt_video_codec(o, "c:v", codec->name);
1765 ost = new_output_stream(o, s, codec->type, -1);
1768 avcodec_get_context_defaults3(st->codec, codec);
1769 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1771 AVDictionary *opts = NULL;
1772 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1773 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1774 av_dict_free(&opts);
1777 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1778 choose_sample_fmt(st, codec);
1779 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1780 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1781 avcodec_copy_context(ost->enc_ctx, st->codec);
1783 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1786 avformat_close_input(&ic);
1790 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1791 AVFormatContext *oc)
1795 switch (ofilter->type) {
1796 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1797 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1799 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1804 ost->source_index = -1;
1805 ost->filter = ofilter;
1809 if (ost->stream_copy) {
1810 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1811 "which is fed from a complex filtergraph. Filtering and streamcopy "
1812 "cannot be used together.\n", ost->file_index, ost->index);
1816 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1817 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1818 av_log(NULL, AV_LOG_ERROR,
1819 "%s '%s' was specified through the %s option "
1820 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1821 "%s and -filter_complex cannot be used together for the same stream.\n",
1822 ost->filters ? "Filtergraph" : "Filtergraph script",
1823 ost->filters ? ost->filters : ost->filters_script,
1824 opt, ost->file_index, ost->index, opt);
1828 avfilter_inout_free(&ofilter->out_tmp);
1831 static int init_complex_filters(void)
1835 for (i = 0; i < nb_filtergraphs; i++) {
1836 ret = init_complex_filtergraph(filtergraphs[i]);
1843 static int configure_complex_filters(void)
1847 for (i = 0; i < nb_filtergraphs; i++)
1848 if (!filtergraphs[i]->graph &&
1849 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1854 static int open_output_file(OptionsContext *o, const char *filename)
1856 AVFormatContext *oc;
1858 AVOutputFormat *file_oformat;
1862 AVDictionary *unused_opts = NULL;
1863 AVDictionaryEntry *e = NULL;
1866 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1867 o->stop_time = INT64_MAX;
1868 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1871 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1872 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1873 if (o->stop_time <= start_time) {
1874 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1877 o->recording_time = o->stop_time - start_time;
1881 GROW_ARRAY(output_files, nb_output_files);
1882 of = av_mallocz(sizeof(*of));
1885 output_files[nb_output_files - 1] = of;
1887 of->ost_index = nb_output_streams;
1888 of->recording_time = o->recording_time;
1889 of->start_time = o->start_time;
1890 of->limit_filesize = o->limit_filesize;
1891 of->shortest = o->shortest;
1892 av_dict_copy(&of->opts, o->g->format_opts, 0);
1894 if (!strcmp(filename, "-"))
1897 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1899 print_error(filename, err);
1904 if (o->recording_time != INT64_MAX)
1905 oc->duration = o->recording_time;
1907 file_oformat= oc->oformat;
1908 oc->interrupt_callback = int_cb;
1910 /* create streams for all unlabeled output pads */
1911 for (i = 0; i < nb_filtergraphs; i++) {
1912 FilterGraph *fg = filtergraphs[i];
1913 for (j = 0; j < fg->nb_outputs; j++) {
1914 OutputFilter *ofilter = fg->outputs[j];
1916 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1919 switch (ofilter->type) {
1920 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1921 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1922 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1924 init_output_filter(ofilter, o, oc);
1928 /* ffserver seeking with date=... needs a date reference */
1929 if (!strcmp(file_oformat->name, "ffm") &&
1930 av_strstart(filename, "http:", NULL)) {
1931 int err = parse_option(o, "metadata", "creation_time=now", options);
1933 print_error(filename, err);
1938 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1939 av_strstart(filename, "http:", NULL)) {
1941 /* special case for files sent to ffserver: we get the stream
1942 parameters from ffserver */
1943 int err = read_ffserver_streams(o, oc, filename);
1945 print_error(filename, err);
1948 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1949 ost = output_streams[j];
1950 for (i = 0; i < nb_input_streams; i++) {
1951 ist = input_streams[i];
1952 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1954 ost->source_index= i;
1955 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1956 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1958 ist->st->discard = ist->user_set_discard;
1963 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));
1967 } else if (!o->nb_stream_maps) {
1968 char *subtitle_codec_name = NULL;
1969 /* pick the "best" stream of each type */
1971 /* video: highest resolution */
1972 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1973 int area = 0, idx = -1;
1974 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1975 for (i = 0; i < nb_input_streams; i++) {
1977 ist = input_streams[i];
1978 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
1979 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1981 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1983 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1990 new_video_stream(o, oc, idx);
1993 /* audio: most channels */
1994 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1995 int best_score = 0, idx = -1;
1996 for (i = 0; i < nb_input_streams; i++) {
1998 ist = input_streams[i];
1999 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2000 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2001 score > best_score) {
2007 new_audio_stream(o, oc, idx);
2010 /* subtitles: pick first */
2011 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2012 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2013 for (i = 0; i < nb_input_streams; i++)
2014 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2015 AVCodecDescriptor const *input_descriptor =
2016 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2017 AVCodecDescriptor const *output_descriptor = NULL;
2018 AVCodec const *output_codec =
2019 avcodec_find_encoder(oc->oformat->subtitle_codec);
2020 int input_props = 0, output_props = 0;
2022 output_descriptor = avcodec_descriptor_get(output_codec->id);
2023 if (input_descriptor)
2024 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2025 if (output_descriptor)
2026 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2027 if (subtitle_codec_name ||
2028 input_props & output_props ||
2029 // Map dvb teletext which has neither property to any output subtitle encoder
2030 input_descriptor && output_descriptor &&
2031 (!input_descriptor->props ||
2032 !output_descriptor->props)) {
2033 new_subtitle_stream(o, oc, i);
2038 /* Data only if codec id match */
2039 if (!o->data_disable ) {
2040 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2041 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2042 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2043 && input_streams[i]->st->codec->codec_id == codec_id )
2044 new_data_stream(o, oc, i);
2048 for (i = 0; i < o->nb_stream_maps; i++) {
2049 StreamMap *map = &o->stream_maps[i];
2054 if (map->linklabel) {
2056 OutputFilter *ofilter = NULL;
2059 for (j = 0; j < nb_filtergraphs; j++) {
2060 fg = filtergraphs[j];
2061 for (k = 0; k < fg->nb_outputs; k++) {
2062 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2063 if (out && !strcmp(out->name, map->linklabel)) {
2064 ofilter = fg->outputs[k];
2071 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2072 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2075 init_output_filter(ofilter, o, oc);
2077 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2079 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2080 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2082 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2084 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2086 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2090 switch (ist->st->codec->codec_type) {
2091 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2092 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2093 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2094 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2095 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2096 case AVMEDIA_TYPE_UNKNOWN:
2097 if (copy_unknown_streams) {
2098 ost = new_unknown_stream (o, oc, src_idx);
2102 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2103 "Cannot map stream #%d:%d - unsupported type.\n",
2104 map->file_index, map->stream_index);
2105 if (!ignore_unknown_streams) {
2106 av_log(NULL, AV_LOG_FATAL,
2107 "If you want unsupported types ignored instead "
2108 "of failing, please use the -ignore_unknown option\n"
2109 "If you want them copied, please use -copy_unknown\n");
2114 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2115 + map->sync_stream_index];
2120 /* handle attached files */
2121 for (i = 0; i < o->nb_attachments; i++) {
2123 uint8_t *attachment;
2127 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2128 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2132 if ((len = avio_size(pb)) <= 0) {
2133 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2137 if (!(attachment = av_malloc(len))) {
2138 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2142 avio_read(pb, attachment, len);
2144 ost = new_attachment_stream(o, oc, -1);
2145 ost->stream_copy = 1;
2146 ost->attachment_filename = o->attachments[i];
2148 ost->st->codec->extradata = attachment;
2149 ost->st->codec->extradata_size = len;
2151 p = strrchr(o->attachments[i], '/');
2152 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2156 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2157 AVDictionaryEntry *e;
2158 ost = output_streams[i];
2160 if ((ost->stream_copy || ost->attachment_filename)
2161 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2162 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2163 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2167 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2168 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2169 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2173 /* check if all codec options have been used */
2174 unused_opts = strip_specifiers(o->g->codec_opts);
2175 for (i = of->ost_index; i < nb_output_streams; i++) {
2177 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2178 AV_DICT_IGNORE_SUFFIX)))
2179 av_dict_set(&unused_opts, e->key, NULL, 0);
2183 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2184 const AVClass *class = avcodec_get_class();
2185 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2186 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2187 const AVClass *fclass = avformat_get_class();
2188 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2189 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2190 if (!option || foption)
2194 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2195 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2196 "output file #%d (%s) is not an encoding option.\n", e->key,
2197 option->help ? option->help : "", nb_output_files - 1,
2202 // gop_timecode is injected by generic code but not always used
2203 if (!strcmp(e->key, "gop_timecode"))
2206 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2207 "output file #%d (%s) has not been used for any stream. The most "
2208 "likely reason is either wrong type (e.g. a video option with "
2209 "no video streams) or that it is a private option of some encoder "
2210 "which was not actually used for any stream.\n", e->key,
2211 option->help ? option->help : "", nb_output_files - 1, filename);
2213 av_dict_free(&unused_opts);
2215 /* set the encoding/decoding_needed flags */
2216 for (i = of->ost_index; i < nb_output_streams; i++) {
2217 OutputStream *ost = output_streams[i];
2219 ost->encoding_needed = !ost->stream_copy;
2220 if (ost->encoding_needed && ost->source_index >= 0) {
2221 InputStream *ist = input_streams[ost->source_index];
2222 ist->decoding_needed |= DECODING_FOR_OST;
2226 /* check filename in case of an image number is expected */
2227 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2228 if (!av_filename_number_test(oc->filename)) {
2229 print_error(oc->filename, AVERROR(EINVAL));
2234 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2235 av_log(NULL, AV_LOG_ERROR,
2236 "No input streams but output needs an input stream\n");
2240 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2241 /* test if it already exists to avoid losing precious files */
2242 assert_file_overwrite(filename);
2245 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2246 &oc->interrupt_callback,
2248 print_error(filename, err);
2251 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2252 assert_file_overwrite(filename);
2254 if (o->mux_preload) {
2255 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2257 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2260 for (i = 0; i < o->nb_metadata_map; i++) {
2262 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2264 if (in_file_index >= nb_input_files) {
2265 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2268 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2269 in_file_index >= 0 ?
2270 input_files[in_file_index]->ctx : NULL, o);
2274 if (o->chapters_input_file >= nb_input_files) {
2275 if (o->chapters_input_file == INT_MAX) {
2276 /* copy chapters from the first input file that has them*/
2277 o->chapters_input_file = -1;
2278 for (i = 0; i < nb_input_files; i++)
2279 if (input_files[i]->ctx->nb_chapters) {
2280 o->chapters_input_file = i;
2284 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2285 o->chapters_input_file);
2289 if (o->chapters_input_file >= 0)
2290 copy_chapters(input_files[o->chapters_input_file], of,
2291 !o->metadata_chapters_manual);
2293 /* copy global metadata by default */
2294 if (!o->metadata_global_manual && nb_input_files){
2295 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2296 AV_DICT_DONT_OVERWRITE);
2297 if(o->recording_time != INT64_MAX)
2298 av_dict_set(&oc->metadata, "duration", NULL, 0);
2299 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2301 if (!o->metadata_streams_manual)
2302 for (i = of->ost_index; i < nb_output_streams; i++) {
2304 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2306 ist = input_streams[output_streams[i]->source_index];
2307 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2308 if (!output_streams[i]->stream_copy) {
2309 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2310 if (ist->autorotate)
2311 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2315 /* process manually set metadata */
2316 for (i = 0; i < o->nb_metadata; i++) {
2319 const char *stream_spec;
2320 int index = 0, j, ret = 0;
2323 val = strchr(o->metadata[i].u.str, '=');
2325 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2326 o->metadata[i].u.str);
2331 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2332 !strcmp(val, "now")) {
2333 time_t now = time(0);
2334 struct tm *ptm, tmbuf;
2335 ptm = localtime_r(&now, &tmbuf);
2337 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2342 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2344 for (j = 0; j < oc->nb_streams; j++) {
2345 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2346 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2347 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2348 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2349 ost->rotate_overridden = 1;
2361 if (index < 0 || index >= oc->nb_chapters) {
2362 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2365 m = &oc->chapters[index]->metadata;
2368 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2371 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2378 static int opt_target(void *optctx, const char *opt, const char *arg)
2380 OptionsContext *o = optctx;
2381 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2382 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2384 if (!strncmp(arg, "pal-", 4)) {
2387 } else if (!strncmp(arg, "ntsc-", 5)) {
2390 } else if (!strncmp(arg, "film-", 5)) {
2394 /* Try to determine PAL/NTSC by peeking in the input files */
2395 if (nb_input_files) {
2397 for (j = 0; j < nb_input_files; j++) {
2398 for (i = 0; i < input_files[j]->nb_streams; i++) {
2399 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2400 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2403 fr = c->time_base.den * 1000 / c->time_base.num;
2407 } else if ((fr == 29970) || (fr == 23976)) {
2412 if (norm != UNKNOWN)
2416 if (norm != UNKNOWN)
2417 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2420 if (norm == UNKNOWN) {
2421 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2422 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2423 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2427 if (!strcmp(arg, "vcd")) {
2428 opt_video_codec(o, "c:v", "mpeg1video");
2429 opt_audio_codec(o, "c:a", "mp2");
2430 parse_option(o, "f", "vcd", options);
2432 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2433 parse_option(o, "r", frame_rates[norm], options);
2434 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2436 opt_default(NULL, "b:v", "1150000");
2437 opt_default(NULL, "maxrate:v", "1150000");
2438 opt_default(NULL, "minrate:v", "1150000");
2439 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2441 opt_default(NULL, "b:a", "224000");
2442 parse_option(o, "ar", "44100", options);
2443 parse_option(o, "ac", "2", options);
2445 opt_default(NULL, "packetsize", "2324");
2446 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2448 /* We have to offset the PTS, so that it is consistent with the SCR.
2449 SCR starts at 36000, but the first two packs contain only padding
2450 and the first pack from the other stream, respectively, may also have
2451 been written before.
2452 So the real data starts at SCR 36000+3*1200. */
2453 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2454 } else if (!strcmp(arg, "svcd")) {
2456 opt_video_codec(o, "c:v", "mpeg2video");
2457 opt_audio_codec(o, "c:a", "mp2");
2458 parse_option(o, "f", "svcd", options);
2460 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2461 parse_option(o, "r", frame_rates[norm], options);
2462 parse_option(o, "pix_fmt", "yuv420p", options);
2463 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2465 opt_default(NULL, "b:v", "2040000");
2466 opt_default(NULL, "maxrate:v", "2516000");
2467 opt_default(NULL, "minrate:v", "0"); // 1145000;
2468 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2469 opt_default(NULL, "scan_offset", "1");
2471 opt_default(NULL, "b:a", "224000");
2472 parse_option(o, "ar", "44100", options);
2474 opt_default(NULL, "packetsize", "2324");
2476 } else if (!strcmp(arg, "dvd")) {
2478 opt_video_codec(o, "c:v", "mpeg2video");
2479 opt_audio_codec(o, "c:a", "ac3");
2480 parse_option(o, "f", "dvd", options);
2482 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2483 parse_option(o, "r", frame_rates[norm], options);
2484 parse_option(o, "pix_fmt", "yuv420p", options);
2485 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2487 opt_default(NULL, "b:v", "6000000");
2488 opt_default(NULL, "maxrate:v", "9000000");
2489 opt_default(NULL, "minrate:v", "0"); // 1500000;
2490 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2492 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2493 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2495 opt_default(NULL, "b:a", "448000");
2496 parse_option(o, "ar", "48000", options);
2498 } else if (!strncmp(arg, "dv", 2)) {
2500 parse_option(o, "f", "dv", options);
2502 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2503 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2504 norm == PAL ? "yuv420p" : "yuv411p", options);
2505 parse_option(o, "r", frame_rates[norm], options);
2507 parse_option(o, "ar", "48000", options);
2508 parse_option(o, "ac", "2", options);
2511 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2512 return AVERROR(EINVAL);
2515 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2516 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2521 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2523 av_free (vstats_filename);
2524 vstats_filename = av_strdup (arg);
2528 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2531 time_t today2 = time(NULL);
2532 struct tm *today = localtime(&today2);
2534 if (!today) { // maybe tomorrow
2535 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2539 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2541 return opt_vstats_file(NULL, opt, filename);
2544 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2546 OptionsContext *o = optctx;
2547 return parse_option(o, "frames:v", arg, options);
2550 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2552 OptionsContext *o = optctx;
2553 return parse_option(o, "frames:a", arg, options);
2556 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2558 OptionsContext *o = optctx;
2559 return parse_option(o, "frames:d", arg, options);
2562 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2565 AVDictionary *cbak = codec_opts;
2566 AVDictionary *fbak = format_opts;
2570 ret = opt_default(NULL, opt, arg);
2572 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2573 av_dict_copy(&o->g->format_opts, format_opts, 0);
2574 av_dict_free(&codec_opts);
2575 av_dict_free(&format_opts);
2582 static int opt_preset(void *optctx, const char *opt, const char *arg)
2584 OptionsContext *o = optctx;
2586 char filename[1000], line[1000], tmp_line[1000];
2587 const char *codec_name = NULL;
2591 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2593 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2594 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2595 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2597 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2601 while (fgets(line, sizeof(line), f)) {
2602 char *key = tmp_line, *value, *endptr;
2604 if (strcspn(line, "#\n\r") == 0)
2606 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2607 if (!av_strtok(key, "=", &value) ||
2608 !av_strtok(value, "\r\n", &endptr)) {
2609 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2612 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2614 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2615 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2616 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2617 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2618 else if (opt_default_new(o, key, value) < 0) {
2619 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2620 filename, line, key, value);
2630 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2632 OptionsContext *o = optctx;
2633 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2634 int ret = parse_option(o, s, arg, options);
2639 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2641 OptionsContext *o = optctx;
2643 if(!strcmp(opt, "ab")){
2644 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2646 } else if(!strcmp(opt, "b")){
2647 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2648 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2651 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2655 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2657 OptionsContext *o = optctx;
2660 if(!strcmp(opt, "qscale")){
2661 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2662 return parse_option(o, "q:v", arg, options);
2664 s = av_asprintf("q%s", opt + 6);
2665 ret = parse_option(o, s, arg, options);
2670 static int opt_profile(void *optctx, const char *opt, const char *arg)
2672 OptionsContext *o = optctx;
2673 if(!strcmp(opt, "profile")){
2674 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2675 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2678 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2682 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2684 OptionsContext *o = optctx;
2685 return parse_option(o, "filter:v", arg, options);
2688 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2690 OptionsContext *o = optctx;
2691 return parse_option(o, "filter:a", arg, options);
2694 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2696 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2697 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2698 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2699 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2701 if (video_sync_method == VSYNC_AUTO)
2702 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2706 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2708 OptionsContext *o = optctx;
2709 char *tcr = av_asprintf("timecode=%s", arg);
2710 int ret = parse_option(o, "metadata:g", tcr, options);
2712 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2717 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2719 OptionsContext *o = optctx;
2720 char layout_str[32];
2723 int ret, channels, ac_str_size;
2726 layout = av_get_channel_layout(arg);
2728 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2729 return AVERROR(EINVAL);
2731 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2732 ret = opt_default_new(o, opt, layout_str);
2736 /* set 'ac' option based on channel layout */
2737 channels = av_get_channel_layout_nb_channels(layout);
2738 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2739 stream_str = strchr(opt, ':');
2740 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2741 ac_str = av_mallocz(ac_str_size);
2743 return AVERROR(ENOMEM);
2744 av_strlcpy(ac_str, "ac", 3);
2746 av_strlcat(ac_str, stream_str, ac_str_size);
2747 ret = parse_option(o, ac_str, layout_str, options);
2753 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2755 OptionsContext *o = optctx;
2756 return parse_option(o, "q:a", arg, options);
2759 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2761 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2762 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2763 return AVERROR(ENOMEM);
2764 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2765 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2766 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2767 return AVERROR(ENOMEM);
2769 input_stream_potentially_available = 1;
2774 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2776 uint8_t *graph_desc = read_file(arg);
2778 return AVERROR(EINVAL);
2780 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2781 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2782 return AVERROR(ENOMEM);
2783 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2784 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2786 input_stream_potentially_available = 1;
2791 void show_help_default(const char *opt, const char *arg)
2793 /* per-file options have at least one of those set */
2794 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2795 int show_advanced = 0, show_avoptions = 0;
2798 if (!strcmp(opt, "long"))
2800 else if (!strcmp(opt, "full"))
2801 show_advanced = show_avoptions = 1;
2803 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2808 printf("Getting help:\n"
2809 " -h -- print basic options\n"
2810 " -h long -- print more options\n"
2811 " -h full -- print all options (including all format and codec specific options, very long)\n"
2812 " See man %s for detailed description of the options.\n"
2813 "\n", program_name);
2815 show_help_options(options, "Print help / information / capabilities:",
2818 show_help_options(options, "Global options (affect whole program "
2819 "instead of just one file:",
2820 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2822 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2823 per_file | OPT_EXIT, 0);
2825 show_help_options(options, "Per-file main options:", 0,
2826 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2827 OPT_EXIT, per_file);
2829 show_help_options(options, "Advanced per-file options:",
2830 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2832 show_help_options(options, "Video options:",
2833 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2835 show_help_options(options, "Advanced Video options:",
2836 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2838 show_help_options(options, "Audio options:",
2839 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2841 show_help_options(options, "Advanced Audio options:",
2842 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2843 show_help_options(options, "Subtitle options:",
2844 OPT_SUBTITLE, 0, 0);
2847 if (show_avoptions) {
2848 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2849 show_help_children(avcodec_get_class(), flags);
2850 show_help_children(avformat_get_class(), flags);
2852 show_help_children(sws_get_class(), flags);
2854 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2855 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2859 void show_usage(void)
2861 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2862 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2863 av_log(NULL, AV_LOG_INFO, "\n");
2871 static const OptionGroupDef groups[] = {
2872 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2873 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2876 static int open_files(OptionGroupList *l, const char *inout,
2877 int (*open_file)(OptionsContext*, const char*))
2881 for (i = 0; i < l->nb_groups; i++) {
2882 OptionGroup *g = &l->groups[i];
2888 ret = parse_optgroup(&o, g);
2890 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2891 "%s.\n", inout, g->arg);
2895 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2896 ret = open_file(&o, g->arg);
2899 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2903 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2909 int ffmpeg_parse_options(int argc, char **argv)
2911 OptionParseContext octx;
2915 memset(&octx, 0, sizeof(octx));
2917 /* split the commandline into an internal representation */
2918 ret = split_commandline(&octx, argc, argv, options, groups,
2919 FF_ARRAY_ELEMS(groups));
2921 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2925 /* apply global options */
2926 ret = parse_optgroup(NULL, &octx.global_opts);
2928 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2932 /* open input files */
2933 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2935 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2939 /* create the complex filtergraphs */
2940 ret = init_complex_filters();
2942 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2946 /* open output files */
2947 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2949 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2953 /* configure the complex filtergraphs */
2954 ret = configure_complex_filters();
2956 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2961 uninit_parse_context(&octx);
2963 av_strerror(ret, error, sizeof(error));
2964 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2969 static int opt_progress(void *optctx, const char *opt, const char *arg)
2971 AVIOContext *avio = NULL;
2974 if (!strcmp(arg, "-"))
2976 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2978 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2979 arg, av_err2str(ret));
2982 progress_avio = avio;
2986 #define OFFSET(x) offsetof(OptionsContext, x)
2987 const OptionDef options[] = {
2989 #include "cmdutils_common_opts.h"
2990 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2991 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2992 "force format", "fmt" },
2993 { "y", OPT_BOOL, { &file_overwrite },
2994 "overwrite output files" },
2995 { "n", OPT_BOOL, { &no_file_overwrite },
2996 "never overwrite output files" },
2997 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
2998 "Ignore unknown stream types" },
2999 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3000 "Copy unknown stream types" },
3001 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3002 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3003 "codec name", "codec" },
3004 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3005 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3006 "codec name", "codec" },
3007 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3008 OPT_OUTPUT, { .off = OFFSET(presets) },
3009 "preset name", "preset" },
3010 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3011 OPT_OUTPUT, { .func_arg = opt_map },
3012 "set input stream mapping",
3013 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3014 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3015 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3016 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3017 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3018 "set metadata information of outfile from infile",
3019 "outfile[,metadata]:infile[,metadata]" },
3020 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3021 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3022 "set chapters mapping", "input_file_index" },
3023 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3024 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3025 "record or transcode \"duration\" seconds of audio/video",
3027 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3028 "record or transcode stop time", "time_stop" },
3029 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3030 "set the limit file size in bytes", "limit_size" },
3031 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3032 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3033 "set the start time offset", "time_off" },
3034 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3035 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3036 "set the start time offset relative to EOF", "time_off" },
3037 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3038 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3039 "enable/disable seeking by timestamp with -ss" },
3040 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3041 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3042 "enable/disable accurate seeking with -ss" },
3043 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3044 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3045 "set the input ts offset", "time_off" },
3046 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3047 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3048 "set the input ts scale", "scale" },
3049 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3050 "set the recording timestamp ('now' to set the current time)", "time" },
3051 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3052 "add metadata", "string=string" },
3053 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3054 OPT_OUTPUT, { .func_arg = opt_data_frames },
3055 "set the number of data frames to output", "number" },
3056 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3057 "add timings for benchmarking" },
3058 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3059 "add timings for each task" },
3060 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3061 "write program-readable progress information", "url" },
3062 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3063 "enable or disable interaction on standard input" },
3064 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3065 "set max runtime in seconds", "limit" },
3066 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3067 "dump each input packet" },
3068 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3069 "when dumping packets, also dump the payload" },
3070 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3071 OPT_INPUT, { .off = OFFSET(rate_emu) },
3072 "read input at native frame rate", "" },
3073 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3074 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
3075 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3076 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
3077 "video sync method", "" },
3078 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3079 "frame drop threshold", "" },
3080 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3081 "audio sync method", "" },
3082 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3083 "audio drift threshold", "threshold" },
3084 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3085 "copy timestamps" },
3086 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3087 "shift input timestamps to start at 0 when using copyts" },
3088 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3089 "copy input stream time base when stream copying", "mode" },
3090 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3091 OPT_OUTPUT, { .off = OFFSET(shortest) },
3092 "finish encoding within shortest input" },
3093 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3094 OPT_OUTPUT, { .off = OFFSET(apad) },
3096 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3097 "timestamp discontinuity delta threshold", "threshold" },
3098 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3099 "timestamp error delta threshold", "threshold" },
3100 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3101 "exit on error", "error" },
3102 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3103 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3104 "copy initial non-keyframes" },
3105 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3106 "copy or discard frames before start time" },
3107 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3108 "set the number of frames to output", "number" },
3109 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3110 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3111 "force codec tag/fourcc", "fourcc/tag" },
3112 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3113 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3114 "use fixed quality scale (VBR)", "q" },
3115 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3116 OPT_OUTPUT, { .func_arg = opt_qscale },
3117 "use fixed quality scale (VBR)", "q" },
3118 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3119 "set profile", "profile" },
3120 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3121 "set stream filtergraph", "filter_graph" },
3122 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3123 "read stream filtergraph description from a file", "filename" },
3124 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3125 "reinit filtergraph on input parameter changes", "" },
3126 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3127 "create a complex filtergraph", "graph_description" },
3128 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3129 "create a complex filtergraph", "graph_description" },
3130 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3131 "read complex filtergraph description from a file", "filename" },
3132 { "stats", OPT_BOOL, { &print_stats },
3133 "print progress report during encoding", },
3134 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3135 OPT_OUTPUT, { .func_arg = opt_attach },
3136 "add an attachment to the output file", "filename" },
3137 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3138 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3139 "extract an attachment into a file", "filename" },
3140 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3141 "print timestamp debugging info" },
3142 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3143 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3144 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3145 OPT_INPUT, { .off = OFFSET(discard) },
3147 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3148 OPT_OUTPUT, { .off = OFFSET(disposition) },
3149 "disposition", "" },
3150 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3151 { .off = OFFSET(thread_queue_size) },
3152 "set the maximum number of queued packets from the demuxer" },
3155 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3156 "set the number of video frames to output", "number" },
3157 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3158 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3159 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3160 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3161 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3162 "set frame size (WxH or abbreviation)", "size" },
3163 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3164 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3165 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3166 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3167 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3168 "set pixel format", "format" },
3169 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3170 "set the number of bits per raw sample", "number" },
3171 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3172 "deprecated use -g 1" },
3173 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3175 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3176 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3177 "rate control override for specific intervals", "override" },
3178 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3179 OPT_OUTPUT, { .func_arg = opt_video_codec },
3180 "force video codec ('copy' to copy stream)", "codec" },
3181 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3183 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3185 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3186 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3187 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3188 "select the pass number (1 to 3)", "n" },
3189 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3190 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3191 "select two pass log file name prefix", "prefix" },
3192 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3193 "this option is deprecated, use the yadif filter instead" },
3194 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3195 "calculate PSNR of compressed frames" },
3196 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3197 "dump video coding statistics to file" },
3198 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3199 "dump video coding statistics to file", "file" },
3200 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3201 "set video filters", "filter_graph" },
3202 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3203 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3204 "specify intra matrix coeffs", "matrix" },
3205 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3206 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3207 "specify inter matrix coeffs", "matrix" },
3208 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3209 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3210 "specify intra matrix coeffs", "matrix" },
3211 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3212 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3213 "top=1/bottom=0/auto=-1 field first", "" },
3214 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3215 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3216 "force video tag/fourcc", "fourcc/tag" },
3217 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3218 "show QP histogram" },
3219 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3220 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3221 "force the selected framerate, disable the best supported framerate selection" },
3222 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3223 OPT_OUTPUT, { .func_arg = opt_streamid },
3224 "set the value of an outfile streamid", "streamIndex:value" },
3225 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3226 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3227 "force key frames at specified timestamps", "timestamps" },
3228 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3229 "audio bitrate (please use -b:a)", "bitrate" },
3230 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3231 "video bitrate (please use -b:v)", "bitrate" },
3232 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3233 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3234 "use HW accelerated decoding", "hwaccel name" },
3235 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3236 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3237 "select a device for HW acceleration" "devicename" },
3239 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3241 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3242 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3244 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3245 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3246 "automatically insert correct rotate filters" },
3249 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3250 "set the number of audio frames to output", "number" },
3251 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3252 "set audio quality (codec-specific)", "quality", },
3253 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3254 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3255 "set audio sampling rate (in Hz)", "rate" },
3256 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3257 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3258 "set number of audio channels", "channels" },
3259 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3261 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3262 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3263 "force audio codec ('copy' to copy stream)", "codec" },
3264 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3265 OPT_OUTPUT, { .func_arg = opt_old2new },
3266 "force audio tag/fourcc", "fourcc/tag" },
3267 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3268 "change audio volume (256=normal)" , "volume" },
3269 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3270 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3271 "set sample format", "format" },
3272 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3273 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3274 "set channel layout", "layout" },
3275 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3276 "set audio filters", "filter_graph" },
3277 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3278 "set the maximum number of channels to try to guess the channel layout" },
3280 /* subtitle options */
3281 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3282 "disable subtitle" },
3283 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3284 "force subtitle codec ('copy' to copy stream)", "codec" },
3285 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3286 , "force subtitle tag/fourcc", "fourcc/tag" },
3287 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3288 "fix subtitles duration" },
3289 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3290 "set canvas size (WxH or abbreviation)", "size" },
3293 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3294 "deprecated, use -channel", "channel" },
3295 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3296 "deprecated, use -standard", "standard" },
3297 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3300 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3301 "set the maximum demux-decode delay", "seconds" },
3302 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3303 "set the initial demux-decode delay", "seconds" },
3304 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3305 "override the options from ffserver", "" },
3306 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3307 "specify a file in which to print sdp information", "file" },
3309 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3310 "A comma-separated list of bitstream filters", "bitstream_filters" },
3311 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3312 "deprecated", "audio bitstream_filters" },
3313 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3314 "deprecated", "video bitstream_filters" },
3316 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3317 "set the audio options to the indicated preset", "preset" },
3318 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3319 "set the video options to the indicated preset", "preset" },
3320 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3321 "set the subtitle options to the indicated preset", "preset" },
3322 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3323 "set options from indicated preset file", "filename" },
3324 /* data codec support */
3325 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3326 "force data codec ('copy' to copy stream)", "codec" },
3327 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },