2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
70 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
73 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
76 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
78 #if CONFIG_VIDEOTOOLBOX
79 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
82 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
85 { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
88 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
92 int hwaccel_lax_profile_check = 0;
93 AVBufferRef *hw_device_ctx;
95 char *vstats_filename;
98 float audio_drift_threshold = 0.1;
99 float dts_delta_threshold = 10;
100 float dts_error_threshold = 3600*30;
102 int audio_volume = 256;
103 int audio_sync_method = 0;
104 int video_sync_method = VSYNC_AUTO;
105 float frame_drop_threshold = 0;
106 int do_deinterlace = 0;
107 int do_benchmark = 0;
108 int do_benchmark_all = 0;
112 int start_at_zero = 0;
115 int exit_on_error = 0;
116 int abort_on_flags = 0;
117 int print_stats = -1;
119 int stdin_interaction = 1;
120 int frame_bits_per_raw_sample = 0;
121 float max_error_rate = 2.0/3;
122 int filter_nbthreads = 0;
123 int filter_complex_nbthreads = 0;
124 int vstats_version = 2;
127 static int intra_only = 0;
128 static int file_overwrite = 0;
129 static int no_file_overwrite = 0;
130 static int do_psnr = 0;
131 static int input_sync;
132 static int override_ffserver = 0;
133 static int input_stream_potentially_available = 0;
134 static int ignore_unknown_streams = 0;
135 static int copy_unknown_streams = 0;
137 static void uninit_options(OptionsContext *o)
139 const OptionDef *po = options;
142 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
144 void *dst = (uint8_t*)o + po->u.off;
146 if (po->flags & OPT_SPEC) {
147 SpecifierOpt **so = dst;
148 int i, *count = (int*)(so + 1);
149 for (i = 0; i < *count; i++) {
150 av_freep(&(*so)[i].specifier);
151 if (po->flags & OPT_STRING)
152 av_freep(&(*so)[i].u.str);
156 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
161 for (i = 0; i < o->nb_stream_maps; i++)
162 av_freep(&o->stream_maps[i].linklabel);
163 av_freep(&o->stream_maps);
164 av_freep(&o->audio_channel_maps);
165 av_freep(&o->streamid_map);
166 av_freep(&o->attachments);
169 static void init_options(OptionsContext *o)
171 memset(o, 0, sizeof(*o));
173 o->stop_time = INT64_MAX;
174 o->mux_max_delay = 0.7;
175 o->start_time = AV_NOPTS_VALUE;
176 o->start_time_eof = AV_NOPTS_VALUE;
177 o->recording_time = INT64_MAX;
178 o->limit_filesize = UINT64_MAX;
179 o->chapters_input_file = INT_MAX;
180 o->accurate_seek = 1;
183 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
187 printf("Hardware acceleration methods:\n");
188 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
189 printf("%s\n", hwaccels[i].name);
195 /* return a copy of the input with the stream specifiers removed from the keys */
196 static AVDictionary *strip_specifiers(AVDictionary *dict)
198 AVDictionaryEntry *e = NULL;
199 AVDictionary *ret = NULL;
201 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
202 char *p = strchr(e->key, ':');
206 av_dict_set(&ret, e->key, e->value, 0);
213 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
215 static const AVOption opts[] = {
216 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
217 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
220 static const AVClass class = {
222 .item_name = av_default_item_name,
224 .version = LIBAVUTIL_VERSION_INT,
226 const AVClass *pclass = &class;
228 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
231 static int opt_sameq(void *optctx, const char *opt, const char *arg)
233 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
234 "If you are looking for an option to preserve the quality (which is not "
235 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
237 return AVERROR(EINVAL);
240 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
242 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
243 return opt_default(optctx, "channel", arg);
246 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
248 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
249 return opt_default(optctx, "standard", arg);
252 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
254 OptionsContext *o = optctx;
255 return parse_option(o, "codec:a", arg, options);
258 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
260 OptionsContext *o = optctx;
261 return parse_option(o, "codec:v", arg, options);
264 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
266 OptionsContext *o = optctx;
267 return parse_option(o, "codec:s", arg, options);
270 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
272 OptionsContext *o = optctx;
273 return parse_option(o, "codec:d", arg, options);
276 static int opt_map(void *optctx, const char *opt, const char *arg)
278 OptionsContext *o = optctx;
280 int i, negative = 0, file_idx;
281 int sync_file_idx = -1, sync_stream_idx = 0;
290 map = av_strdup(arg);
292 return AVERROR(ENOMEM);
294 /* parse sync stream first, just pick first matching stream */
295 if (sync = strchr(map, ',')) {
297 sync_file_idx = strtol(sync + 1, &sync, 0);
298 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
299 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
304 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
305 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
306 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
310 if (i == input_files[sync_file_idx]->nb_streams) {
311 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
312 "match any streams.\n", arg);
319 /* this mapping refers to lavfi output */
320 const char *c = map + 1;
321 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
322 m = &o->stream_maps[o->nb_stream_maps - 1];
323 m->linklabel = av_get_token(&c, "]");
325 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
329 if (allow_unused = strchr(map, '?'))
331 file_idx = strtol(map, &p, 0);
332 if (file_idx >= nb_input_files || file_idx < 0) {
333 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
337 /* disable some already defined maps */
338 for (i = 0; i < o->nb_stream_maps; i++) {
339 m = &o->stream_maps[i];
340 if (file_idx == m->file_index &&
341 check_stream_specifier(input_files[m->file_index]->ctx,
342 input_files[m->file_index]->ctx->streams[m->stream_index],
343 *p == ':' ? p + 1 : p) > 0)
347 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
348 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
349 *p == ':' ? p + 1 : p) <= 0)
351 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
352 m = &o->stream_maps[o->nb_stream_maps - 1];
354 m->file_index = file_idx;
357 if (sync_file_idx >= 0) {
358 m->sync_file_index = sync_file_idx;
359 m->sync_stream_index = sync_stream_idx;
361 m->sync_file_index = file_idx;
362 m->sync_stream_index = i;
369 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
371 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
372 "To ignore this, add a trailing '?' to the map.\n", arg);
381 static int opt_attach(void *optctx, const char *opt, const char *arg)
383 OptionsContext *o = optctx;
384 GROW_ARRAY(o->attachments, o->nb_attachments);
385 o->attachments[o->nb_attachments - 1] = arg;
389 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
391 OptionsContext *o = optctx;
396 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
397 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
399 /* muted channel syntax */
400 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
401 if ((n == 1 || n == 3) && m->channel_idx == -1) {
402 m->file_idx = m->stream_idx = -1;
404 m->ofile_idx = m->ostream_idx = -1;
409 n = sscanf(arg, "%d.%d.%d:%d.%d",
410 &m->file_idx, &m->stream_idx, &m->channel_idx,
411 &m->ofile_idx, &m->ostream_idx);
413 if (n != 3 && n != 5) {
414 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
415 "[file.stream.channel|-1][:syncfile:syncstream]\n");
419 if (n != 5) // only file.stream.channel specified
420 m->ofile_idx = m->ostream_idx = -1;
423 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
424 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
428 if (m->stream_idx < 0 ||
429 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
430 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
431 m->file_idx, m->stream_idx);
434 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
435 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
436 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
437 m->file_idx, m->stream_idx);
440 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
441 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
442 m->file_idx, m->stream_idx, m->channel_idx);
448 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
450 av_free(sdp_filename);
451 sdp_filename = av_strdup(arg);
456 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
459 err = vaapi_device_init(arg);
467 * Parse a metadata specifier passed as 'arg' parameter.
468 * @param arg metadata string to parse
469 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
470 * @param index for type c/p, chapter/program index is written here
471 * @param stream_spec for type s, the stream specifier is written here
473 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
481 if (*(++arg) && *arg != ':') {
482 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
485 *stream_spec = *arg == ':' ? arg + 1 : "";
490 *index = strtol(++arg, NULL, 0);
493 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
500 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
502 AVDictionary **meta_in = NULL;
503 AVDictionary **meta_out = NULL;
505 char type_in, type_out;
506 const char *istream_spec = NULL, *ostream_spec = NULL;
507 int idx_in = 0, idx_out = 0;
509 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
510 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
513 if (type_out == 'g' || !*outspec)
514 o->metadata_global_manual = 1;
515 if (type_out == 's' || !*outspec)
516 o->metadata_streams_manual = 1;
517 if (type_out == 'c' || !*outspec)
518 o->metadata_chapters_manual = 1;
522 if (type_in == 'g' || type_out == 'g')
523 o->metadata_global_manual = 1;
524 if (type_in == 's' || type_out == 's')
525 o->metadata_streams_manual = 1;
526 if (type_in == 'c' || type_out == 'c')
527 o->metadata_chapters_manual = 1;
529 /* ic is NULL when just disabling automatic mappings */
533 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
534 if ((index) < 0 || (index) >= (nb_elems)) {\
535 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
540 #define SET_DICT(type, meta, context, index)\
543 meta = &context->metadata;\
546 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
547 meta = &context->chapters[index]->metadata;\
550 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
551 meta = &context->programs[index]->metadata;\
554 break; /* handled separately below */ \
555 default: av_assert0(0);\
558 SET_DICT(type_in, meta_in, ic, idx_in);
559 SET_DICT(type_out, meta_out, oc, idx_out);
561 /* for input streams choose first matching stream */
562 if (type_in == 's') {
563 for (i = 0; i < ic->nb_streams; i++) {
564 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
565 meta_in = &ic->streams[i]->metadata;
571 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
576 if (type_out == 's') {
577 for (i = 0; i < oc->nb_streams; i++) {
578 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
579 meta_out = &oc->streams[i]->metadata;
580 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
585 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
590 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
592 OptionsContext *o = optctx;
594 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
595 struct tm time = *gmtime((time_t*)&recording_timestamp);
596 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
598 parse_option(o, "metadata", buf, options);
600 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
601 "tag instead.\n", opt);
605 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
607 const AVCodecDescriptor *desc;
608 const char *codec_string = encoder ? "encoder" : "decoder";
612 avcodec_find_encoder_by_name(name) :
613 avcodec_find_decoder_by_name(name);
615 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
616 codec = encoder ? avcodec_find_encoder(desc->id) :
617 avcodec_find_decoder(desc->id);
619 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
620 codec_string, codec->name, desc->name);
624 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
627 if (codec->type != type) {
628 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
634 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
636 char *codec_name = NULL;
638 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
640 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
641 st->codecpar->codec_id = codec->id;
644 return avcodec_find_decoder(st->codecpar->codec_id);
647 /* Add all the streams from the given input file to the global
648 * list of input streams. */
649 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
653 for (i = 0; i < ic->nb_streams; i++) {
654 AVStream *st = ic->streams[i];
655 AVCodecParameters *par = st->codecpar;
656 InputStream *ist = av_mallocz(sizeof(*ist));
657 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
658 char *hwaccel_output_format = NULL;
659 char *codec_tag = NULL;
661 char *discard_str = NULL;
662 const AVClass *cc = avcodec_get_class();
663 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
668 GROW_ARRAY(input_streams, nb_input_streams);
669 input_streams[nb_input_streams - 1] = ist;
672 ist->file_index = nb_input_files;
674 st->discard = AVDISCARD_ALL;
676 ist->min_pts = INT64_MAX;
677 ist->max_pts = INT64_MIN;
680 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
683 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
685 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
687 uint32_t tag = strtol(codec_tag, &next, 0);
689 tag = AV_RL32(codec_tag);
690 st->codecpar->codec_tag = tag;
693 ist->dec = choose_decoder(o, ic, st);
694 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
696 ist->reinit_filters = -1;
697 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
699 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
700 ist->user_set_discard = AVDISCARD_NONE;
701 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
702 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
707 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
709 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
711 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
715 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
717 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
721 switch (par->codec_type) {
722 case AVMEDIA_TYPE_VIDEO:
724 ist->dec = avcodec_find_decoder(par->codec_id);
726 if (av_codec_get_lowres(st->codec)) {
727 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
728 ist->dec_ctx->width = st->codec->width;
729 ist->dec_ctx->height = st->codec->height;
730 ist->dec_ctx->coded_width = st->codec->coded_width;
731 ist->dec_ctx->coded_height = st->codec->coded_height;
732 ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
736 // avformat_find_stream_info() doesn't set this for us anymore.
737 ist->dec_ctx->framerate = st->avg_frame_rate;
739 ist->resample_height = ist->dec_ctx->height;
740 ist->resample_width = ist->dec_ctx->width;
741 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
743 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
744 if (framerate && av_parse_video_rate(&ist->framerate,
746 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
751 ist->top_field_first = -1;
752 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
754 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
756 if (!strcmp(hwaccel, "none"))
757 ist->hwaccel_id = HWACCEL_NONE;
758 else if (!strcmp(hwaccel, "auto"))
759 ist->hwaccel_id = HWACCEL_AUTO;
762 for (i = 0; hwaccels[i].name; i++) {
763 if (!strcmp(hwaccels[i].name, hwaccel)) {
764 ist->hwaccel_id = hwaccels[i].id;
769 if (!ist->hwaccel_id) {
770 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
772 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
773 for (i = 0; hwaccels[i].name; i++)
774 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
775 av_log(NULL, AV_LOG_FATAL, "\n");
781 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
782 if (hwaccel_device) {
783 ist->hwaccel_device = av_strdup(hwaccel_device);
784 if (!ist->hwaccel_device)
788 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
789 hwaccel_output_format, ic, st);
790 if (hwaccel_output_format) {
791 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
792 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
793 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
794 "format: %s", hwaccel_output_format);
797 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
800 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
803 case AVMEDIA_TYPE_AUDIO:
804 ist->guess_layout_max = INT_MAX;
805 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
806 guess_input_channel_layout(ist);
808 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
809 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
810 ist->resample_channels = ist->dec_ctx->channels;
811 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
814 case AVMEDIA_TYPE_DATA:
815 case AVMEDIA_TYPE_SUBTITLE: {
816 char *canvas_size = NULL;
818 ist->dec = avcodec_find_decoder(par->codec_id);
819 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
820 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
822 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
823 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
828 case AVMEDIA_TYPE_ATTACHMENT:
829 case AVMEDIA_TYPE_UNKNOWN:
835 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
837 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
843 static void assert_file_overwrite(const char *filename)
845 if (file_overwrite && no_file_overwrite) {
846 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
850 if (!file_overwrite) {
851 const char *proto_name = avio_find_protocol_name(filename);
852 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
853 if (stdin_interaction && !no_file_overwrite) {
854 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
857 signal(SIGINT, SIG_DFL);
859 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
865 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
872 static void dump_attachment(AVStream *st, const char *filename)
875 AVIOContext *out = NULL;
876 AVDictionaryEntry *e;
878 if (!st->codecpar->extradata_size) {
879 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
880 nb_input_files - 1, st->index);
883 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
886 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
887 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
891 assert_file_overwrite(filename);
893 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
894 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
899 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
904 static int open_input_file(OptionsContext *o, const char *filename)
908 AVInputFormat *file_iformat = NULL;
912 AVDictionary *unused_opts = NULL;
913 AVDictionaryEntry *e = NULL;
914 int orig_nb_streams; // number of streams before avformat_find_stream_info
915 char * video_codec_name = NULL;
916 char * audio_codec_name = NULL;
917 char *subtitle_codec_name = NULL;
918 char * data_codec_name = NULL;
919 int scan_all_pmts_set = 0;
922 if (!(file_iformat = av_find_input_format(o->format))) {
923 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
928 if (!strcmp(filename, "-"))
931 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
932 strcmp(filename, "/dev/stdin");
934 /* get default parameters from command line */
935 ic = avformat_alloc_context();
937 print_error(filename, AVERROR(ENOMEM));
940 if (o->nb_audio_sample_rate) {
941 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
943 if (o->nb_audio_channels) {
944 /* because we set audio_channels based on both the "ac" and
945 * "channel_layout" options, we need to check that the specified
946 * demuxer actually has the "channels" option before setting it */
947 if (file_iformat && file_iformat->priv_class &&
948 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
949 AV_OPT_SEARCH_FAKE_OBJ)) {
950 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
953 if (o->nb_frame_rates) {
954 /* set the format-level framerate option;
955 * this is important for video grabbers, e.g. x11 */
956 if (file_iformat && file_iformat->priv_class &&
957 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
958 AV_OPT_SEARCH_FAKE_OBJ)) {
959 av_dict_set(&o->g->format_opts, "framerate",
960 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
963 if (o->nb_frame_sizes) {
964 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
966 if (o->nb_frame_pix_fmts)
967 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
969 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
970 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
971 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
972 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
974 ic->video_codec_id = video_codec_name ?
975 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
976 ic->audio_codec_id = audio_codec_name ?
977 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
978 ic->subtitle_codec_id= subtitle_codec_name ?
979 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
980 ic->data_codec_id = data_codec_name ?
981 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
983 if (video_codec_name)
984 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
985 if (audio_codec_name)
986 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
987 if (subtitle_codec_name)
988 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
990 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
992 ic->flags |= AVFMT_FLAG_NONBLOCK;
993 ic->interrupt_callback = int_cb;
995 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
996 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
997 scan_all_pmts_set = 1;
999 /* open the input file with generic avformat function */
1000 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1002 print_error(filename, err);
1003 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1004 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1007 if (scan_all_pmts_set)
1008 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1009 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1010 assert_avoptions(o->g->format_opts);
1012 /* apply forced codec ids */
1013 for (i = 0; i < ic->nb_streams; i++)
1014 choose_decoder(o, ic, ic->streams[i]);
1016 /* Set AVCodecContext options for avformat_find_stream_info */
1017 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1018 orig_nb_streams = ic->nb_streams;
1020 /* If not enough info to get the stream parameters, we decode the
1021 first frames to get it. (used in mpeg case for example) */
1022 ret = avformat_find_stream_info(ic, opts);
1024 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1025 if (ic->nb_streams == 0) {
1026 avformat_close_input(&ic);
1031 if (o->start_time_eof != AV_NOPTS_VALUE) {
1032 if (ic->duration>0) {
1033 o->start_time = o->start_time_eof + ic->duration;
1035 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1037 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1038 /* add the stream start time */
1039 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1040 timestamp += ic->start_time;
1042 /* if seeking requested, we execute it */
1043 if (o->start_time != AV_NOPTS_VALUE) {
1044 int64_t seek_timestamp = timestamp;
1046 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1047 int dts_heuristic = 0;
1048 for (i=0; i<ic->nb_streams; i++) {
1049 const AVCodecParameters *par = ic->streams[i]->codecpar;
1050 if (par->video_delay)
1053 if (dts_heuristic) {
1054 seek_timestamp -= 3*AV_TIME_BASE / 23;
1057 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1059 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1060 filename, (double)timestamp / AV_TIME_BASE);
1064 /* update the current parameters so that they match the one of the input stream */
1065 add_input_streams(o, ic);
1067 /* dump the file content */
1068 av_dump_format(ic, nb_input_files, filename, 0);
1070 GROW_ARRAY(input_files, nb_input_files);
1071 f = av_mallocz(sizeof(*f));
1074 input_files[nb_input_files - 1] = f;
1077 f->ist_index = nb_input_streams - ic->nb_streams;
1078 f->start_time = o->start_time;
1079 f->recording_time = o->recording_time;
1080 f->input_ts_offset = o->input_ts_offset;
1081 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1082 f->nb_streams = ic->nb_streams;
1083 f->rate_emu = o->rate_emu;
1084 f->accurate_seek = o->accurate_seek;
1087 f->time_base = (AVRational){ 1, 1 };
1089 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1092 /* check if all codec options have been used */
1093 unused_opts = strip_specifiers(o->g->codec_opts);
1094 for (i = f->ist_index; i < nb_input_streams; i++) {
1096 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1097 AV_DICT_IGNORE_SUFFIX)))
1098 av_dict_set(&unused_opts, e->key, NULL, 0);
1102 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1103 const AVClass *class = avcodec_get_class();
1104 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1105 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1106 const AVClass *fclass = avformat_get_class();
1107 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1108 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1109 if (!option || foption)
1113 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1114 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1115 "input file #%d (%s) is not a decoding option.\n", e->key,
1116 option->help ? option->help : "", nb_input_files - 1,
1121 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1122 "input file #%d (%s) has not been used for any stream. The most "
1123 "likely reason is either wrong type (e.g. a video option with "
1124 "no video streams) or that it is a private option of some decoder "
1125 "which was not actually used for any stream.\n", e->key,
1126 option->help ? option->help : "", nb_input_files - 1, filename);
1128 av_dict_free(&unused_opts);
1130 for (i = 0; i < o->nb_dump_attachment; i++) {
1133 for (j = 0; j < ic->nb_streams; j++) {
1134 AVStream *st = ic->streams[j];
1136 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1137 dump_attachment(st, o->dump_attachment[i].u.str);
1141 for (i = 0; i < orig_nb_streams; i++)
1142 av_dict_free(&opts[i]);
1145 input_stream_potentially_available = 1;
1150 static uint8_t *get_line(AVIOContext *s)
1156 if (avio_open_dyn_buf(&line) < 0) {
1157 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1161 while ((c = avio_r8(s)) && c != '\n')
1164 avio_close_dyn_buf(line, &buf);
1169 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1172 char filename[1000];
1173 const char *base[3] = { getenv("AVCONV_DATADIR"),
1178 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1182 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1183 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1184 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1187 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1188 i != 1 ? "" : "/.avconv", preset_name);
1189 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1195 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1197 enum AVMediaType type = ost->st->codecpar->codec_type;
1198 char *codec_name = NULL;
1200 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1201 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1203 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1204 NULL, ost->st->codecpar->codec_type);
1205 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1207 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1208 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1209 "probably disabled. Please choose an encoder manually.\n",
1210 ost->file_index, ost->index, s->oformat->name,
1211 avcodec_get_name(ost->st->codecpar->codec_id));
1212 return AVERROR_ENCODER_NOT_FOUND;
1214 } else if (!strcmp(codec_name, "copy"))
1215 ost->stream_copy = 1;
1217 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1218 ost->st->codecpar->codec_id = ost->enc->id;
1220 ost->encoding_needed = !ost->stream_copy;
1222 /* no encoding supported for other media types */
1223 ost->stream_copy = 1;
1224 ost->encoding_needed = 0;
1230 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1233 AVStream *st = avformat_new_stream(oc, NULL);
1234 int idx = oc->nb_streams - 1, ret = 0;
1235 const char *bsfs = NULL, *time_base = NULL;
1236 char *next, *codec_tag = NULL;
1241 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1245 if (oc->nb_streams - 1 < o->nb_streamid_map)
1246 st->id = o->streamid_map[oc->nb_streams - 1];
1248 GROW_ARRAY(output_streams, nb_output_streams);
1249 if (!(ost = av_mallocz(sizeof(*ost))))
1251 output_streams[nb_output_streams - 1] = ost;
1253 ost->file_index = nb_output_files - 1;
1256 st->codecpar->codec_type = type;
1258 ret = choose_encoder(o, oc, ost);
1260 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1261 "%d:%d\n", ost->file_index, ost->index);
1265 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1266 if (!ost->enc_ctx) {
1267 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1270 ost->enc_ctx->codec_type = type;
1272 ost->ref_par = avcodec_parameters_alloc();
1273 if (!ost->ref_par) {
1274 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1279 AVIOContext *s = NULL;
1280 char *buf = NULL, *arg = NULL, *preset = NULL;
1282 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1284 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1285 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1288 if (!buf[0] || buf[0] == '#') {
1292 if (!(arg = strchr(buf, '='))) {
1293 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1297 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1299 } while (!s->eof_reached);
1303 av_log(NULL, AV_LOG_FATAL,
1304 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1305 preset, ost->file_index, ost->index);
1309 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1312 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1315 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1316 q.num <= 0 || q.den <= 0) {
1317 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1323 ost->max_frames = INT64_MAX;
1324 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1325 for (i = 0; i<o->nb_max_frames; i++) {
1326 char *p = o->max_frames[i].specifier;
1327 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1328 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1333 ost->copy_prior_start = -1;
1334 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1336 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1337 while (bsfs && *bsfs) {
1338 const AVBitStreamFilter *filter;
1339 char *bsf, *bsf_options_str, *bsf_name;
1341 bsf = av_get_token(&bsfs, ",");
1344 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1348 filter = av_bsf_get_by_name(bsf_name);
1350 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1354 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1355 ost->nb_bitstream_filters + 1,
1356 sizeof(*ost->bsf_ctx));
1360 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1362 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1366 ost->nb_bitstream_filters++;
1368 if (bsf_options_str && filter->priv_class) {
1369 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1370 const char * shorthand[2] = {NULL};
1373 shorthand[0] = opt->name;
1375 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1377 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1386 if (ost->nb_bitstream_filters) {
1387 ost->bsf_extradata_updated = av_mallocz_array(ost->nb_bitstream_filters, sizeof(*ost->bsf_extradata_updated));
1388 if (!ost->bsf_extradata_updated) {
1389 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1394 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1396 uint32_t tag = strtol(codec_tag, &next, 0);
1398 tag = AV_RL32(codec_tag);
1399 ost->st->codecpar->codec_tag =
1400 ost->enc_ctx->codec_tag = tag;
1403 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1405 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1406 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1409 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1410 ost->disposition = av_strdup(ost->disposition);
1412 ost->max_muxing_queue_size = 128;
1413 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1414 ost->max_muxing_queue_size *= sizeof(AVPacket);
1416 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1417 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1419 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1421 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1422 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1423 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1425 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1427 ost->source_index = source_index;
1428 if (source_index >= 0) {
1429 ost->sync_ist = input_streams[source_index];
1430 input_streams[source_index]->discard = 0;
1431 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1433 ost->last_mux_dts = AV_NOPTS_VALUE;
1435 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1436 if (!ost->muxing_queue)
1442 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1445 const char *p = str;
1452 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1459 /* read file contents into a string */
1460 static uint8_t *read_file(const char *filename)
1462 AVIOContext *pb = NULL;
1463 AVIOContext *dyn_buf = NULL;
1464 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1465 uint8_t buf[1024], *str;
1468 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1472 ret = avio_open_dyn_buf(&dyn_buf);
1477 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1478 avio_write(dyn_buf, buf, ret);
1479 avio_w8(dyn_buf, 0);
1482 ret = avio_close_dyn_buf(dyn_buf, &str);
1488 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1491 AVStream *st = ost->st;
1493 if (ost->filters_script && ost->filters) {
1494 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1495 "output stream #%d:%d.\n", nb_output_files, st->index);
1499 if (ost->filters_script)
1500 return read_file(ost->filters_script);
1501 else if (ost->filters)
1502 return av_strdup(ost->filters);
1504 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1508 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1509 const OutputStream *ost, enum AVMediaType type)
1511 if (ost->filters_script || ost->filters) {
1512 av_log(NULL, AV_LOG_ERROR,
1513 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1514 "Filtering and streamcopy cannot be used together.\n",
1515 ost->filters ? "Filtergraph" : "Filtergraph script",
1516 ost->filters ? ost->filters : ost->filters_script,
1517 av_get_media_type_string(type), ost->file_index, ost->index);
1522 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1526 AVCodecContext *video_enc;
1527 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1529 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1531 video_enc = ost->enc_ctx;
1533 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1534 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1535 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1538 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1539 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1541 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1542 if (frame_aspect_ratio) {
1544 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1545 q.num <= 0 || q.den <= 0) {
1546 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1549 ost->frame_aspect_ratio = q;
1552 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1553 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1555 if (!ost->stream_copy) {
1556 const char *p = NULL;
1557 char *frame_size = NULL;
1558 char *frame_pix_fmt = NULL;
1559 char *intra_matrix = NULL, *inter_matrix = NULL;
1560 char *chroma_intra_matrix = NULL;
1564 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1565 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1566 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1570 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1571 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1572 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1573 ost->keep_pix_fmt = 1;
1574 if (!*++frame_pix_fmt)
1575 frame_pix_fmt = NULL;
1577 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1578 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1581 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1584 video_enc->gop_size = 0;
1585 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1587 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1588 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1591 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1593 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1594 if (chroma_intra_matrix) {
1595 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1597 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1600 av_codec_set_chroma_intra_matrix(video_enc, p);
1601 parse_matrix_coeffs(p, chroma_intra_matrix);
1603 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1605 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1606 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1609 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1612 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1613 for (i = 0; p; i++) {
1615 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1617 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1620 video_enc->rc_override =
1621 av_realloc_array(video_enc->rc_override,
1622 i + 1, sizeof(RcOverride));
1623 if (!video_enc->rc_override) {
1624 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1627 video_enc->rc_override[i].start_frame = start;
1628 video_enc->rc_override[i].end_frame = end;
1630 video_enc->rc_override[i].qscale = q;
1631 video_enc->rc_override[i].quality_factor = 1.0;
1634 video_enc->rc_override[i].qscale = 0;
1635 video_enc->rc_override[i].quality_factor = -q/100.0;
1640 video_enc->rc_override_count = i;
1643 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1646 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1649 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1650 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1653 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1654 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1658 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1659 if (ost->logfile_prefix &&
1660 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1664 char logfilename[1024];
1667 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1668 ost->logfile_prefix ? ost->logfile_prefix :
1669 DEFAULT_PASS_LOGFILENAME_PREFIX,
1671 if (!strcmp(ost->enc->name, "libx264")) {
1672 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1674 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1675 char *logbuffer = read_file(logfilename);
1678 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1682 video_enc->stats_in = logbuffer;
1684 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1685 f = av_fopen_utf8(logfilename, "wb");
1687 av_log(NULL, AV_LOG_FATAL,
1688 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1689 logfilename, strerror(errno));
1697 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1698 if (ost->forced_keyframes)
1699 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1701 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1703 ost->top_field_first = -1;
1704 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1707 ost->avfilter = get_ost_filters(o, oc, ost);
1711 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1714 if (ost->stream_copy)
1715 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1720 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1725 AVCodecContext *audio_enc;
1727 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1730 audio_enc = ost->enc_ctx;
1731 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1733 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1734 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1736 if (!ost->stream_copy) {
1737 char *sample_fmt = NULL;
1739 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1741 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1743 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1744 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1748 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1750 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1751 ost->apad = av_strdup(ost->apad);
1753 ost->avfilter = get_ost_filters(o, oc, ost);
1757 /* check for channel mapping for this audio stream */
1758 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1759 AudioChannelMap *map = &o->audio_channel_maps[n];
1760 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1761 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1764 if (map->channel_idx == -1) {
1766 } else if (ost->source_index < 0) {
1767 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1768 ost->file_index, ost->st->index);
1771 ist = input_streams[ost->source_index];
1774 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1775 if (av_reallocp_array(&ost->audio_channels_map,
1776 ost->audio_channels_mapped + 1,
1777 sizeof(*ost->audio_channels_map)
1781 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1787 if (ost->stream_copy)
1788 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1793 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1797 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1798 if (!ost->stream_copy) {
1799 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1806 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1810 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1811 if (!ost->stream_copy) {
1812 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1819 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1821 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1822 ost->stream_copy = 1;
1827 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1831 AVCodecContext *subtitle_enc;
1833 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1835 subtitle_enc = ost->enc_ctx;
1837 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1839 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1841 if (!ost->stream_copy) {
1842 char *frame_size = NULL;
1844 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1845 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1846 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1854 /* arg format is "output-stream-index:streamid-value". */
1855 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1857 OptionsContext *o = optctx;
1862 av_strlcpy(idx_str, arg, sizeof(idx_str));
1863 p = strchr(idx_str, ':');
1865 av_log(NULL, AV_LOG_FATAL,
1866 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1871 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1872 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1873 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1877 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1879 AVFormatContext *is = ifile->ctx;
1880 AVFormatContext *os = ofile->ctx;
1884 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1886 return AVERROR(ENOMEM);
1889 for (i = 0; i < is->nb_chapters; i++) {
1890 AVChapter *in_ch = is->chapters[i], *out_ch;
1891 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1892 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1893 AV_TIME_BASE_Q, in_ch->time_base);
1894 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1895 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1898 if (in_ch->end < ts_off)
1900 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1903 out_ch = av_mallocz(sizeof(AVChapter));
1905 return AVERROR(ENOMEM);
1907 out_ch->id = in_ch->id;
1908 out_ch->time_base = in_ch->time_base;
1909 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1910 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1913 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1915 os->chapters[os->nb_chapters++] = out_ch;
1920 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1923 AVFormatContext *ic = avformat_alloc_context();
1925 ic->interrupt_callback = int_cb;
1926 err = avformat_open_input(&ic, filename, NULL, NULL);
1929 /* copy stream format */
1930 for(i=0;i<ic->nb_streams;i++) {
1934 const char *enc_config;
1936 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1938 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1939 return AVERROR(EINVAL);
1941 if (codec->type == AVMEDIA_TYPE_AUDIO)
1942 opt_audio_codec(o, "c:a", codec->name);
1943 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1944 opt_video_codec(o, "c:v", codec->name);
1945 ost = new_output_stream(o, s, codec->type, -1);
1948 avcodec_get_context_defaults3(st->codec, codec);
1949 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1951 AVDictionary *opts = NULL;
1952 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1953 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1954 av_dict_free(&opts);
1957 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1958 choose_sample_fmt(st, codec);
1959 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1960 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1961 avcodec_copy_context(ost->enc_ctx, st->codec);
1963 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1966 avformat_close_input(&ic);
1970 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1971 AVFormatContext *oc)
1975 switch (ofilter->type) {
1976 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1977 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1979 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1984 ost->source_index = -1;
1985 ost->filter = ofilter;
1988 ofilter->format = -1;
1990 if (ost->stream_copy) {
1991 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1992 "which is fed from a complex filtergraph. Filtering and streamcopy "
1993 "cannot be used together.\n", ost->file_index, ost->index);
1997 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1998 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1999 av_log(NULL, AV_LOG_ERROR,
2000 "%s '%s' was specified through the %s option "
2001 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2002 "%s and -filter_complex cannot be used together for the same stream.\n",
2003 ost->filters ? "Filtergraph" : "Filtergraph script",
2004 ost->filters ? ost->filters : ost->filters_script,
2005 opt, ost->file_index, ost->index, opt);
2009 avfilter_inout_free(&ofilter->out_tmp);
2012 static int init_complex_filters(void)
2016 for (i = 0; i < nb_filtergraphs; i++) {
2017 ret = init_complex_filtergraph(filtergraphs[i]);
2024 static int configure_complex_filters(void)
2028 for (i = 0; i < nb_filtergraphs; i++) {
2029 FilterGraph *fg = filtergraphs[i];
2031 if (filtergraph_is_simple(fg))
2034 for (j = 0; j < fg->nb_inputs; j++) {
2035 ret = ifilter_parameters_from_decoder(fg->inputs[j],
2036 fg->inputs[j]->ist->dec_ctx);
2038 av_log(NULL, AV_LOG_ERROR,
2039 "Error initializing filtergraph %d input %d\n", i, j);
2044 ret = configure_filtergraph(filtergraphs[i]);
2051 static int open_output_file(OptionsContext *o, const char *filename)
2053 AVFormatContext *oc;
2055 AVOutputFormat *file_oformat;
2059 AVDictionary *unused_opts = NULL;
2060 AVDictionaryEntry *e = NULL;
2061 int format_flags = 0;
2063 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2064 o->stop_time = INT64_MAX;
2065 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2068 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2069 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2070 if (o->stop_time <= start_time) {
2071 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2074 o->recording_time = o->stop_time - start_time;
2078 GROW_ARRAY(output_files, nb_output_files);
2079 of = av_mallocz(sizeof(*of));
2082 output_files[nb_output_files - 1] = of;
2084 of->ost_index = nb_output_streams;
2085 of->recording_time = o->recording_time;
2086 of->start_time = o->start_time;
2087 of->limit_filesize = o->limit_filesize;
2088 of->shortest = o->shortest;
2089 av_dict_copy(&of->opts, o->g->format_opts, 0);
2091 if (!strcmp(filename, "-"))
2094 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2096 print_error(filename, err);
2101 if (o->recording_time != INT64_MAX)
2102 oc->duration = o->recording_time;
2104 file_oformat= oc->oformat;
2105 oc->interrupt_callback = int_cb;
2107 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2109 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2110 av_opt_eval_flags(oc, o, e->value, &format_flags);
2113 /* create streams for all unlabeled output pads */
2114 for (i = 0; i < nb_filtergraphs; i++) {
2115 FilterGraph *fg = filtergraphs[i];
2116 for (j = 0; j < fg->nb_outputs; j++) {
2117 OutputFilter *ofilter = fg->outputs[j];
2119 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2122 switch (ofilter->type) {
2123 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2124 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2125 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2127 init_output_filter(ofilter, o, oc);
2131 /* ffserver seeking with date=... needs a date reference */
2132 if (!strcmp(file_oformat->name, "ffm") &&
2133 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2134 av_strstart(filename, "http:", NULL)) {
2135 int err = parse_option(o, "metadata", "creation_time=now", options);
2137 print_error(filename, err);
2142 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2143 av_strstart(filename, "http:", NULL)) {
2145 /* special case for files sent to ffserver: we get the stream
2146 parameters from ffserver */
2147 int err = read_ffserver_streams(o, oc, filename);
2149 print_error(filename, err);
2152 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2153 ost = output_streams[j];
2154 for (i = 0; i < nb_input_streams; i++) {
2155 ist = input_streams[i];
2156 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2158 ost->source_index= i;
2159 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2160 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2162 ist->st->discard = ist->user_set_discard;
2167 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
2171 } else if (!o->nb_stream_maps) {
2172 char *subtitle_codec_name = NULL;
2173 /* pick the "best" stream of each type */
2175 /* video: highest resolution */
2176 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2177 int area = 0, idx = -1;
2178 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2179 for (i = 0; i < nb_input_streams; i++) {
2181 ist = input_streams[i];
2182 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2183 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2185 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2187 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2194 new_video_stream(o, oc, idx);
2197 /* audio: most channels */
2198 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2199 int best_score = 0, idx = -1;
2200 for (i = 0; i < nb_input_streams; i++) {
2202 ist = input_streams[i];
2203 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2204 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2205 score > best_score) {
2211 new_audio_stream(o, oc, idx);
2214 /* subtitles: pick first */
2215 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2216 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2217 for (i = 0; i < nb_input_streams; i++)
2218 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2219 AVCodecDescriptor const *input_descriptor =
2220 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2221 AVCodecDescriptor const *output_descriptor = NULL;
2222 AVCodec const *output_codec =
2223 avcodec_find_encoder(oc->oformat->subtitle_codec);
2224 int input_props = 0, output_props = 0;
2226 output_descriptor = avcodec_descriptor_get(output_codec->id);
2227 if (input_descriptor)
2228 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2229 if (output_descriptor)
2230 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2231 if (subtitle_codec_name ||
2232 input_props & output_props ||
2233 // Map dvb teletext which has neither property to any output subtitle encoder
2234 input_descriptor && output_descriptor &&
2235 (!input_descriptor->props ||
2236 !output_descriptor->props)) {
2237 new_subtitle_stream(o, oc, i);
2242 /* Data only if codec id match */
2243 if (!o->data_disable ) {
2244 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2245 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2246 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2247 && input_streams[i]->st->codecpar->codec_id == codec_id )
2248 new_data_stream(o, oc, i);
2252 for (i = 0; i < o->nb_stream_maps; i++) {
2253 StreamMap *map = &o->stream_maps[i];
2258 if (map->linklabel) {
2260 OutputFilter *ofilter = NULL;
2263 for (j = 0; j < nb_filtergraphs; j++) {
2264 fg = filtergraphs[j];
2265 for (k = 0; k < fg->nb_outputs; k++) {
2266 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2267 if (out && !strcmp(out->name, map->linklabel)) {
2268 ofilter = fg->outputs[k];
2275 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2276 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2279 init_output_filter(ofilter, o, oc);
2281 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2283 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2284 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2286 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2288 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2290 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2294 switch (ist->st->codecpar->codec_type) {
2295 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2296 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2297 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2298 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2299 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2300 case AVMEDIA_TYPE_UNKNOWN:
2301 if (copy_unknown_streams) {
2302 ost = new_unknown_stream (o, oc, src_idx);
2306 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2307 "Cannot map stream #%d:%d - unsupported type.\n",
2308 map->file_index, map->stream_index);
2309 if (!ignore_unknown_streams) {
2310 av_log(NULL, AV_LOG_FATAL,
2311 "If you want unsupported types ignored instead "
2312 "of failing, please use the -ignore_unknown option\n"
2313 "If you want them copied, please use -copy_unknown\n");
2318 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2319 + map->sync_stream_index];
2324 /* handle attached files */
2325 for (i = 0; i < o->nb_attachments; i++) {
2327 uint8_t *attachment;
2331 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2332 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2336 if ((len = avio_size(pb)) <= 0) {
2337 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2341 if (!(attachment = av_malloc(len))) {
2342 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2346 avio_read(pb, attachment, len);
2348 ost = new_attachment_stream(o, oc, -1);
2349 ost->stream_copy = 0;
2350 ost->attachment_filename = o->attachments[i];
2351 ost->st->codecpar->extradata = attachment;
2352 ost->st->codecpar->extradata_size = len;
2354 p = strrchr(o->attachments[i], '/');
2355 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2359 #if FF_API_LAVF_AVCTX
2360 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2361 AVDictionaryEntry *e;
2362 ost = output_streams[i];
2364 if ((ost->stream_copy || ost->attachment_filename)
2365 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2366 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2367 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2372 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2373 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2374 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2378 /* check if all codec options have been used */
2379 unused_opts = strip_specifiers(o->g->codec_opts);
2380 for (i = of->ost_index; i < nb_output_streams; i++) {
2382 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2383 AV_DICT_IGNORE_SUFFIX)))
2384 av_dict_set(&unused_opts, e->key, NULL, 0);
2388 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2389 const AVClass *class = avcodec_get_class();
2390 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2391 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2392 const AVClass *fclass = avformat_get_class();
2393 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2394 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2395 if (!option || foption)
2399 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2400 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2401 "output file #%d (%s) is not an encoding option.\n", e->key,
2402 option->help ? option->help : "", nb_output_files - 1,
2407 // gop_timecode is injected by generic code but not always used
2408 if (!strcmp(e->key, "gop_timecode"))
2411 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2412 "output file #%d (%s) has not been used for any stream. The most "
2413 "likely reason is either wrong type (e.g. a video option with "
2414 "no video streams) or that it is a private option of some encoder "
2415 "which was not actually used for any stream.\n", e->key,
2416 option->help ? option->help : "", nb_output_files - 1, filename);
2418 av_dict_free(&unused_opts);
2420 /* set the decoding_needed flags and create simple filtergraphs */
2421 for (i = of->ost_index; i < nb_output_streams; i++) {
2422 OutputStream *ost = output_streams[i];
2424 if (ost->encoding_needed && ost->source_index >= 0) {
2425 InputStream *ist = input_streams[ost->source_index];
2426 ist->decoding_needed |= DECODING_FOR_OST;
2428 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2429 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2430 err = init_simple_filtergraph(ist, ost);
2432 av_log(NULL, AV_LOG_ERROR,
2433 "Error initializing a simple filtergraph between streams "
2434 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2435 nb_output_files - 1, ost->st->index);
2441 /* set the filter output constraints */
2443 OutputFilter *f = ost->filter;
2445 switch (ost->enc_ctx->codec_type) {
2446 case AVMEDIA_TYPE_VIDEO:
2447 f->frame_rate = ost->frame_rate;
2448 f->width = ost->enc_ctx->width;
2449 f->height = ost->enc_ctx->height;
2450 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2451 f->format = ost->enc_ctx->pix_fmt;
2452 } else if (ost->enc->pix_fmts) {
2454 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2456 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2459 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2462 case AVMEDIA_TYPE_AUDIO:
2463 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2464 f->format = ost->enc_ctx->sample_fmt;
2465 } else if (ost->enc->sample_fmts) {
2467 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2469 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2472 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2474 if (ost->enc_ctx->sample_rate) {
2475 f->sample_rate = ost->enc_ctx->sample_rate;
2476 } else if (ost->enc->supported_samplerates) {
2478 while (ost->enc->supported_samplerates[count])
2480 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2481 if (!f->sample_rates)
2483 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2484 (count + 1) * sizeof(*f->sample_rates));
2486 if (ost->enc_ctx->channels) {
2487 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2488 } else if (ost->enc->channel_layouts) {
2490 while (ost->enc->channel_layouts[count])
2492 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2493 if (!f->channel_layouts)
2495 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2496 (count + 1) * sizeof(*f->channel_layouts));
2503 /* check filename in case of an image number is expected */
2504 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2505 if (!av_filename_number_test(oc->filename)) {
2506 print_error(oc->filename, AVERROR(EINVAL));
2511 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2512 av_log(NULL, AV_LOG_ERROR,
2513 "No input streams but output needs an input stream\n");
2517 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2518 /* test if it already exists to avoid losing precious files */
2519 assert_file_overwrite(filename);
2522 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2523 &oc->interrupt_callback,
2525 print_error(filename, err);
2528 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2529 assert_file_overwrite(filename);
2531 if (o->mux_preload) {
2532 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2534 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2537 for (i = 0; i < o->nb_metadata_map; i++) {
2539 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2541 if (in_file_index >= nb_input_files) {
2542 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2545 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2546 in_file_index >= 0 ?
2547 input_files[in_file_index]->ctx : NULL, o);
2551 if (o->chapters_input_file >= nb_input_files) {
2552 if (o->chapters_input_file == INT_MAX) {
2553 /* copy chapters from the first input file that has them*/
2554 o->chapters_input_file = -1;
2555 for (i = 0; i < nb_input_files; i++)
2556 if (input_files[i]->ctx->nb_chapters) {
2557 o->chapters_input_file = i;
2561 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2562 o->chapters_input_file);
2566 if (o->chapters_input_file >= 0)
2567 copy_chapters(input_files[o->chapters_input_file], of,
2568 !o->metadata_chapters_manual);
2570 /* copy global metadata by default */
2571 if (!o->metadata_global_manual && nb_input_files){
2572 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2573 AV_DICT_DONT_OVERWRITE);
2574 if(o->recording_time != INT64_MAX)
2575 av_dict_set(&oc->metadata, "duration", NULL, 0);
2576 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2578 if (!o->metadata_streams_manual)
2579 for (i = of->ost_index; i < nb_output_streams; i++) {
2581 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2583 ist = input_streams[output_streams[i]->source_index];
2584 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2585 if (!output_streams[i]->stream_copy) {
2586 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2587 if (ist->autorotate)
2588 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2592 /* process manually set programs */
2593 for (i = 0; i < o->nb_program; i++) {
2594 const char *p = o->program[i].u.str;
2599 const char *p2 = av_get_token(&p, ":");
2600 const char *to_dealloc = p2;
2607 key = av_get_token(&p2, "=");
2609 av_freep(&to_dealloc);
2615 if (!strcmp(key, "program_num"))
2616 progid = strtol(p2, NULL, 0);
2617 av_freep(&to_dealloc);
2621 program = av_new_program(oc, progid);
2623 p = o->program[i].u.str;
2625 const char *p2 = av_get_token(&p, ":");
2626 const char *to_dealloc = p2;
2632 key = av_get_token(&p2, "=");
2634 av_log(NULL, AV_LOG_FATAL,
2635 "No '=' character in program string %s.\n",
2643 if (!strcmp(key, "title")) {
2644 av_dict_set(&program->metadata, "title", p2, 0);
2645 } else if (!strcmp(key, "program_num")) {
2646 } else if (!strcmp(key, "st")) {
2647 int st_num = strtol(p2, NULL, 0);
2648 av_program_add_stream_index(oc, progid, st_num);
2650 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2653 av_freep(&to_dealloc);
2658 /* process manually set metadata */
2659 for (i = 0; i < o->nb_metadata; i++) {
2662 const char *stream_spec;
2663 int index = 0, j, ret = 0;
2665 val = strchr(o->metadata[i].u.str, '=');
2667 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2668 o->metadata[i].u.str);
2673 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2675 for (j = 0; j < oc->nb_streams; j++) {
2676 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2677 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2678 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2679 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2680 ost->rotate_overridden = 1;
2692 if (index < 0 || index >= oc->nb_chapters) {
2693 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2696 m = &oc->chapters[index]->metadata;
2699 if (index < 0 || index >= oc->nb_programs) {
2700 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2703 m = &oc->programs[index]->metadata;
2706 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2709 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2716 static int opt_target(void *optctx, const char *opt, const char *arg)
2718 OptionsContext *o = optctx;
2719 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2720 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2722 if (!strncmp(arg, "pal-", 4)) {
2725 } else if (!strncmp(arg, "ntsc-", 5)) {
2728 } else if (!strncmp(arg, "film-", 5)) {
2732 /* Try to determine PAL/NTSC by peeking in the input files */
2733 if (nb_input_files) {
2735 for (j = 0; j < nb_input_files; j++) {
2736 for (i = 0; i < input_files[j]->nb_streams; i++) {
2737 AVStream *st = input_files[j]->ctx->streams[i];
2738 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2740 fr = st->time_base.den * 1000 / st->time_base.num;
2744 } else if ((fr == 29970) || (fr == 23976)) {
2749 if (norm != UNKNOWN)
2753 if (norm != UNKNOWN)
2754 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2757 if (norm == UNKNOWN) {
2758 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2759 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2760 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2764 if (!strcmp(arg, "vcd")) {
2765 opt_video_codec(o, "c:v", "mpeg1video");
2766 opt_audio_codec(o, "c:a", "mp2");
2767 parse_option(o, "f", "vcd", options);
2769 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2770 parse_option(o, "r", frame_rates[norm], options);
2771 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2773 opt_default(NULL, "b:v", "1150000");
2774 opt_default(NULL, "maxrate:v", "1150000");
2775 opt_default(NULL, "minrate:v", "1150000");
2776 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2778 opt_default(NULL, "b:a", "224000");
2779 parse_option(o, "ar", "44100", options);
2780 parse_option(o, "ac", "2", options);
2782 opt_default(NULL, "packetsize", "2324");
2783 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2785 /* We have to offset the PTS, so that it is consistent with the SCR.
2786 SCR starts at 36000, but the first two packs contain only padding
2787 and the first pack from the other stream, respectively, may also have
2788 been written before.
2789 So the real data starts at SCR 36000+3*1200. */
2790 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2791 } else if (!strcmp(arg, "svcd")) {
2793 opt_video_codec(o, "c:v", "mpeg2video");
2794 opt_audio_codec(o, "c:a", "mp2");
2795 parse_option(o, "f", "svcd", options);
2797 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2798 parse_option(o, "r", frame_rates[norm], options);
2799 parse_option(o, "pix_fmt", "yuv420p", options);
2800 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2802 opt_default(NULL, "b:v", "2040000");
2803 opt_default(NULL, "maxrate:v", "2516000");
2804 opt_default(NULL, "minrate:v", "0"); // 1145000;
2805 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2806 opt_default(NULL, "scan_offset", "1");
2808 opt_default(NULL, "b:a", "224000");
2809 parse_option(o, "ar", "44100", options);
2811 opt_default(NULL, "packetsize", "2324");
2813 } else if (!strcmp(arg, "dvd")) {
2815 opt_video_codec(o, "c:v", "mpeg2video");
2816 opt_audio_codec(o, "c:a", "ac3");
2817 parse_option(o, "f", "dvd", options);
2819 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2820 parse_option(o, "r", frame_rates[norm], options);
2821 parse_option(o, "pix_fmt", "yuv420p", options);
2822 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2824 opt_default(NULL, "b:v", "6000000");
2825 opt_default(NULL, "maxrate:v", "9000000");
2826 opt_default(NULL, "minrate:v", "0"); // 1500000;
2827 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2829 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2830 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2832 opt_default(NULL, "b:a", "448000");
2833 parse_option(o, "ar", "48000", options);
2835 } else if (!strncmp(arg, "dv", 2)) {
2837 parse_option(o, "f", "dv", options);
2839 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2840 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2841 norm == PAL ? "yuv420p" : "yuv411p", options);
2842 parse_option(o, "r", frame_rates[norm], options);
2844 parse_option(o, "ar", "48000", options);
2845 parse_option(o, "ac", "2", options);
2848 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2849 return AVERROR(EINVAL);
2852 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2853 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2858 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2860 av_free (vstats_filename);
2861 vstats_filename = av_strdup (arg);
2865 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2868 time_t today2 = time(NULL);
2869 struct tm *today = localtime(&today2);
2871 if (!today) { // maybe tomorrow
2872 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2876 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2878 return opt_vstats_file(NULL, opt, filename);
2881 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2883 OptionsContext *o = optctx;
2884 return parse_option(o, "frames:v", arg, options);
2887 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2889 OptionsContext *o = optctx;
2890 return parse_option(o, "frames:a", arg, options);
2893 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2895 OptionsContext *o = optctx;
2896 return parse_option(o, "frames:d", arg, options);
2899 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2902 AVDictionary *cbak = codec_opts;
2903 AVDictionary *fbak = format_opts;
2907 ret = opt_default(NULL, opt, arg);
2909 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2910 av_dict_copy(&o->g->format_opts, format_opts, 0);
2911 av_dict_free(&codec_opts);
2912 av_dict_free(&format_opts);
2919 static int opt_preset(void *optctx, const char *opt, const char *arg)
2921 OptionsContext *o = optctx;
2923 char filename[1000], line[1000], tmp_line[1000];
2924 const char *codec_name = NULL;
2928 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2930 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2931 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2932 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2934 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2938 while (fgets(line, sizeof(line), f)) {
2939 char *key = tmp_line, *value, *endptr;
2941 if (strcspn(line, "#\n\r") == 0)
2943 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2944 if (!av_strtok(key, "=", &value) ||
2945 !av_strtok(value, "\r\n", &endptr)) {
2946 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2949 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2951 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2952 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2953 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2954 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2955 else if (opt_default_new(o, key, value) < 0) {
2956 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2957 filename, line, key, value);
2967 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2969 OptionsContext *o = optctx;
2970 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2971 int ret = parse_option(o, s, arg, options);
2976 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2978 OptionsContext *o = optctx;
2980 if(!strcmp(opt, "ab")){
2981 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2983 } else if(!strcmp(opt, "b")){
2984 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2985 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2988 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2992 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2994 OptionsContext *o = optctx;
2997 if(!strcmp(opt, "qscale")){
2998 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2999 return parse_option(o, "q:v", arg, options);
3001 s = av_asprintf("q%s", opt + 6);
3002 ret = parse_option(o, s, arg, options);
3007 static int opt_profile(void *optctx, const char *opt, const char *arg)
3009 OptionsContext *o = optctx;
3010 if(!strcmp(opt, "profile")){
3011 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3012 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3015 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3019 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3021 OptionsContext *o = optctx;
3022 return parse_option(o, "filter:v", arg, options);
3025 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3027 OptionsContext *o = optctx;
3028 return parse_option(o, "filter:a", arg, options);
3031 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3033 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3034 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3035 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3036 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3038 if (video_sync_method == VSYNC_AUTO)
3039 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3043 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3045 OptionsContext *o = optctx;
3046 char *tcr = av_asprintf("timecode=%s", arg);
3047 int ret = parse_option(o, "metadata:g", tcr, options);
3049 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3054 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3056 OptionsContext *o = optctx;
3057 char layout_str[32];
3060 int ret, channels, ac_str_size;
3063 layout = av_get_channel_layout(arg);
3065 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3066 return AVERROR(EINVAL);
3068 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3069 ret = opt_default_new(o, opt, layout_str);
3073 /* set 'ac' option based on channel layout */
3074 channels = av_get_channel_layout_nb_channels(layout);
3075 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3076 stream_str = strchr(opt, ':');
3077 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3078 ac_str = av_mallocz(ac_str_size);
3080 return AVERROR(ENOMEM);
3081 av_strlcpy(ac_str, "ac", 3);
3083 av_strlcat(ac_str, stream_str, ac_str_size);
3084 ret = parse_option(o, ac_str, layout_str, options);
3090 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3092 OptionsContext *o = optctx;
3093 return parse_option(o, "q:a", arg, options);
3096 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3098 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3099 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3100 return AVERROR(ENOMEM);
3101 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3102 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3103 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3104 return AVERROR(ENOMEM);
3106 input_stream_potentially_available = 1;
3111 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3113 uint8_t *graph_desc = read_file(arg);
3115 return AVERROR(EINVAL);
3117 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3118 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3119 return AVERROR(ENOMEM);
3120 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3121 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3123 input_stream_potentially_available = 1;
3128 void show_help_default(const char *opt, const char *arg)
3130 /* per-file options have at least one of those set */
3131 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3132 int show_advanced = 0, show_avoptions = 0;
3135 if (!strcmp(opt, "long"))
3137 else if (!strcmp(opt, "full"))
3138 show_advanced = show_avoptions = 1;
3140 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3145 printf("Getting help:\n"
3146 " -h -- print basic options\n"
3147 " -h long -- print more options\n"
3148 " -h full -- print all options (including all format and codec specific options, very long)\n"
3149 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3150 " See man %s for detailed description of the options.\n"
3151 "\n", program_name);
3153 show_help_options(options, "Print help / information / capabilities:",
3156 show_help_options(options, "Global options (affect whole program "
3157 "instead of just one file:",
3158 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3160 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3161 per_file | OPT_EXIT, 0);
3163 show_help_options(options, "Per-file main options:", 0,
3164 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3165 OPT_EXIT, per_file);
3167 show_help_options(options, "Advanced per-file options:",
3168 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3170 show_help_options(options, "Video options:",
3171 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3173 show_help_options(options, "Advanced Video options:",
3174 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3176 show_help_options(options, "Audio options:",
3177 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3179 show_help_options(options, "Advanced Audio options:",
3180 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3181 show_help_options(options, "Subtitle options:",
3182 OPT_SUBTITLE, 0, 0);
3185 if (show_avoptions) {
3186 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3187 show_help_children(avcodec_get_class(), flags);
3188 show_help_children(avformat_get_class(), flags);
3190 show_help_children(sws_get_class(), flags);
3192 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3193 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3197 void show_usage(void)
3199 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3200 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3201 av_log(NULL, AV_LOG_INFO, "\n");
3209 static const OptionGroupDef groups[] = {
3210 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3211 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3214 static int open_files(OptionGroupList *l, const char *inout,
3215 int (*open_file)(OptionsContext*, const char*))
3219 for (i = 0; i < l->nb_groups; i++) {
3220 OptionGroup *g = &l->groups[i];
3226 ret = parse_optgroup(&o, g);
3228 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3229 "%s.\n", inout, g->arg);
3233 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3234 ret = open_file(&o, g->arg);
3237 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3241 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3247 int ffmpeg_parse_options(int argc, char **argv)
3249 OptionParseContext octx;
3253 memset(&octx, 0, sizeof(octx));
3255 /* split the commandline into an internal representation */
3256 ret = split_commandline(&octx, argc, argv, options, groups,
3257 FF_ARRAY_ELEMS(groups));
3259 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3263 /* apply global options */
3264 ret = parse_optgroup(NULL, &octx.global_opts);
3266 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3270 /* configure terminal and setup signal handlers */
3273 /* open input files */
3274 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3276 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3280 /* create the complex filtergraphs */
3281 ret = init_complex_filters();
3283 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3287 /* open output files */
3288 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3290 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3294 /* configure the complex filtergraphs */
3295 ret = configure_complex_filters();
3297 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3302 uninit_parse_context(&octx);
3304 av_strerror(ret, error, sizeof(error));
3305 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3310 static int opt_progress(void *optctx, const char *opt, const char *arg)
3312 AVIOContext *avio = NULL;
3315 if (!strcmp(arg, "-"))
3317 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3319 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3320 arg, av_err2str(ret));
3323 progress_avio = avio;
3327 #define OFFSET(x) offsetof(OptionsContext, x)
3328 const OptionDef options[] = {
3330 #include "cmdutils_common_opts.h"
3331 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3332 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3333 "force format", "fmt" },
3334 { "y", OPT_BOOL, { &file_overwrite },
3335 "overwrite output files" },
3336 { "n", OPT_BOOL, { &no_file_overwrite },
3337 "never overwrite output files" },
3338 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3339 "Ignore unknown stream types" },
3340 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3341 "Copy unknown stream types" },
3342 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3343 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3344 "codec name", "codec" },
3345 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3346 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3347 "codec name", "codec" },
3348 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3349 OPT_OUTPUT, { .off = OFFSET(presets) },
3350 "preset name", "preset" },
3351 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3352 OPT_OUTPUT, { .func_arg = opt_map },
3353 "set input stream mapping",
3354 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3355 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3356 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3357 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3358 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3359 "set metadata information of outfile from infile",
3360 "outfile[,metadata]:infile[,metadata]" },
3361 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3362 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3363 "set chapters mapping", "input_file_index" },
3364 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3365 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3366 "record or transcode \"duration\" seconds of audio/video",
3368 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3369 "record or transcode stop time", "time_stop" },
3370 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3371 "set the limit file size in bytes", "limit_size" },
3372 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3373 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3374 "set the start time offset", "time_off" },
3375 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3376 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3377 "set the start time offset relative to EOF", "time_off" },
3378 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3379 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3380 "enable/disable seeking by timestamp with -ss" },
3381 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3382 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3383 "enable/disable accurate seeking with -ss" },
3384 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3385 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3386 "set the input ts offset", "time_off" },
3387 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3388 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3389 "set the input ts scale", "scale" },
3390 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3391 "set the recording timestamp ('now' to set the current time)", "time" },
3392 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3393 "add metadata", "string=string" },
3394 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3395 "add program with specified streams", "title=string:st=number..." },
3396 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3397 OPT_OUTPUT, { .func_arg = opt_data_frames },
3398 "set the number of data frames to output", "number" },
3399 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3400 "add timings for benchmarking" },
3401 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3402 "add timings for each task" },
3403 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3404 "write program-readable progress information", "url" },
3405 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3406 "enable or disable interaction on standard input" },
3407 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3408 "set max runtime in seconds", "limit" },
3409 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3410 "dump each input packet" },
3411 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3412 "when dumping packets, also dump the payload" },
3413 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3414 OPT_INPUT, { .off = OFFSET(rate_emu) },
3415 "read input at native frame rate", "" },
3416 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3417 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3418 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3419 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3420 "video sync method", "" },
3421 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3422 "frame drop threshold", "" },
3423 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3424 "audio sync method", "" },
3425 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3426 "audio drift threshold", "threshold" },
3427 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3428 "copy timestamps" },
3429 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3430 "shift input timestamps to start at 0 when using copyts" },
3431 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3432 "copy input stream time base when stream copying", "mode" },
3433 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3434 OPT_OUTPUT, { .off = OFFSET(shortest) },
3435 "finish encoding within shortest input" },
3436 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3437 OPT_OUTPUT, { .off = OFFSET(apad) },
3439 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3440 "timestamp discontinuity delta threshold", "threshold" },
3441 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3442 "timestamp error delta threshold", "threshold" },
3443 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3444 "exit on error", "error" },
3445 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3446 "abort on the specified condition flags", "flags" },
3447 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3448 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3449 "copy initial non-keyframes" },
3450 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3451 "copy or discard frames before start time" },
3452 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3453 "set the number of frames to output", "number" },
3454 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3455 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3456 "force codec tag/fourcc", "fourcc/tag" },
3457 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3458 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3459 "use fixed quality scale (VBR)", "q" },
3460 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3461 OPT_OUTPUT, { .func_arg = opt_qscale },
3462 "use fixed quality scale (VBR)", "q" },
3463 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3464 "set profile", "profile" },
3465 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3466 "set stream filtergraph", "filter_graph" },
3467 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3468 "number of non-complex filter threads" },
3469 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3470 "read stream filtergraph description from a file", "filename" },
3471 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3472 "reinit filtergraph on input parameter changes", "" },
3473 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3474 "create a complex filtergraph", "graph_description" },
3475 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3476 "number of threads for -filter_complex" },
3477 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3478 "create a complex filtergraph", "graph_description" },
3479 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3480 "read complex filtergraph description from a file", "filename" },
3481 { "stats", OPT_BOOL, { &print_stats },
3482 "print progress report during encoding", },
3483 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3484 OPT_OUTPUT, { .func_arg = opt_attach },
3485 "add an attachment to the output file", "filename" },
3486 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3487 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3488 "extract an attachment into a file", "filename" },
3489 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3490 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3491 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3492 "print timestamp debugging info" },
3493 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3494 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3495 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3496 OPT_INPUT, { .off = OFFSET(discard) },
3498 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3499 OPT_OUTPUT, { .off = OFFSET(disposition) },
3500 "disposition", "" },
3501 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3502 { .off = OFFSET(thread_queue_size) },
3503 "set the maximum number of queued packets from the demuxer" },
3506 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3507 "set the number of video frames to output", "number" },
3508 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3509 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3510 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3511 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3512 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3513 "set frame size (WxH or abbreviation)", "size" },
3514 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3515 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3516 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3517 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3518 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3519 "set pixel format", "format" },
3520 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3521 "set the number of bits per raw sample", "number" },
3522 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3523 "deprecated use -g 1" },
3524 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3526 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3527 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3528 "rate control override for specific intervals", "override" },
3529 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3530 OPT_OUTPUT, { .func_arg = opt_video_codec },
3531 "force video codec ('copy' to copy stream)", "codec" },
3532 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3534 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3536 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3537 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3538 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3539 "select the pass number (1 to 3)", "n" },
3540 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3541 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3542 "select two pass log file name prefix", "prefix" },
3543 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3544 "this option is deprecated, use the yadif filter instead" },
3545 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3546 "calculate PSNR of compressed frames" },
3547 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3548 "dump video coding statistics to file" },
3549 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3550 "dump video coding statistics to file", "file" },
3551 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3552 "Version of the vstats format to use."},
3553 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3554 "set video filters", "filter_graph" },
3555 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3556 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3557 "specify intra matrix coeffs", "matrix" },
3558 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3559 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3560 "specify inter matrix coeffs", "matrix" },
3561 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3562 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3563 "specify intra matrix coeffs", "matrix" },
3564 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3565 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3566 "top=1/bottom=0/auto=-1 field first", "" },
3567 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3568 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3569 "force video tag/fourcc", "fourcc/tag" },
3570 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3571 "show QP histogram" },
3572 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3573 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3574 "force the selected framerate, disable the best supported framerate selection" },
3575 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3576 OPT_OUTPUT, { .func_arg = opt_streamid },
3577 "set the value of an outfile streamid", "streamIndex:value" },
3578 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3579 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3580 "force key frames at specified timestamps", "timestamps" },
3581 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3582 "audio bitrate (please use -b:a)", "bitrate" },
3583 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3584 "video bitrate (please use -b:v)", "bitrate" },
3585 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3586 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3587 "use HW accelerated decoding", "hwaccel name" },
3588 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3589 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3590 "select a device for HW acceleration", "devicename" },
3591 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3592 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3593 "select output format used with HW accelerated decoding", "format" },
3594 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3595 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3597 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3598 "show available HW acceleration methods" },
3599 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3600 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3601 "automatically insert correct rotate filters" },
3602 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3603 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3606 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3607 "set the number of audio frames to output", "number" },
3608 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3609 "set audio quality (codec-specific)", "quality", },
3610 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3611 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3612 "set audio sampling rate (in Hz)", "rate" },
3613 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3614 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3615 "set number of audio channels", "channels" },
3616 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3618 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3619 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3620 "force audio codec ('copy' to copy stream)", "codec" },
3621 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3622 OPT_OUTPUT, { .func_arg = opt_old2new },
3623 "force audio tag/fourcc", "fourcc/tag" },
3624 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3625 "change audio volume (256=normal)" , "volume" },
3626 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3627 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3628 "set sample format", "format" },
3629 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3630 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3631 "set channel layout", "layout" },
3632 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3633 "set audio filters", "filter_graph" },
3634 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3635 "set the maximum number of channels to try to guess the channel layout" },
3637 /* subtitle options */
3638 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3639 "disable subtitle" },
3640 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3641 "force subtitle codec ('copy' to copy stream)", "codec" },
3642 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3643 , "force subtitle tag/fourcc", "fourcc/tag" },
3644 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3645 "fix subtitles duration" },
3646 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3647 "set canvas size (WxH or abbreviation)", "size" },
3650 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3651 "deprecated, use -channel", "channel" },
3652 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3653 "deprecated, use -standard", "standard" },
3654 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3657 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3658 "set the maximum demux-decode delay", "seconds" },
3659 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3660 "set the initial demux-decode delay", "seconds" },
3661 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3662 "override the options from ffserver", "" },
3663 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3664 "specify a file in which to print sdp information", "file" },
3666 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3667 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3669 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3670 "A comma-separated list of bitstream filters", "bitstream_filters" },
3671 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3672 "deprecated", "audio bitstream_filters" },
3673 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3674 "deprecated", "video bitstream_filters" },
3676 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3677 "set the audio options to the indicated preset", "preset" },
3678 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3679 "set the video options to the indicated preset", "preset" },
3680 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3681 "set the subtitle options to the indicated preset", "preset" },
3682 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3683 "set options from indicated preset file", "filename" },
3685 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3686 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3688 /* data codec support */
3689 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3690 "force data codec ('copy' to copy stream)", "codec" },
3691 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3695 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3696 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3700 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3701 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},