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;
124 static int intra_only = 0;
125 static int file_overwrite = 0;
126 static int no_file_overwrite = 0;
127 static int do_psnr = 0;
128 static int input_sync;
129 static int override_ffserver = 0;
130 static int input_stream_potentially_available = 0;
131 static int ignore_unknown_streams = 0;
132 static int copy_unknown_streams = 0;
134 static void uninit_options(OptionsContext *o)
136 const OptionDef *po = options;
139 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
141 void *dst = (uint8_t*)o + po->u.off;
143 if (po->flags & OPT_SPEC) {
144 SpecifierOpt **so = dst;
145 int i, *count = (int*)(so + 1);
146 for (i = 0; i < *count; i++) {
147 av_freep(&(*so)[i].specifier);
148 if (po->flags & OPT_STRING)
149 av_freep(&(*so)[i].u.str);
153 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
158 for (i = 0; i < o->nb_stream_maps; i++)
159 av_freep(&o->stream_maps[i].linklabel);
160 av_freep(&o->stream_maps);
161 av_freep(&o->audio_channel_maps);
162 av_freep(&o->streamid_map);
163 av_freep(&o->attachments);
166 static void init_options(OptionsContext *o)
168 memset(o, 0, sizeof(*o));
170 o->stop_time = INT64_MAX;
171 o->mux_max_delay = 0.7;
172 o->start_time = AV_NOPTS_VALUE;
173 o->start_time_eof = AV_NOPTS_VALUE;
174 o->recording_time = INT64_MAX;
175 o->limit_filesize = UINT64_MAX;
176 o->chapters_input_file = INT_MAX;
177 o->accurate_seek = 1;
180 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
184 printf("Hardware acceleration methods:\n");
185 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
186 printf("%s\n", hwaccels[i].name);
192 /* return a copy of the input with the stream specifiers removed from the keys */
193 static AVDictionary *strip_specifiers(AVDictionary *dict)
195 AVDictionaryEntry *e = NULL;
196 AVDictionary *ret = NULL;
198 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
199 char *p = strchr(e->key, ':');
203 av_dict_set(&ret, e->key, e->value, 0);
210 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
212 static const AVOption opts[] = {
213 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
214 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
217 static const AVClass class = {
219 .item_name = av_default_item_name,
221 .version = LIBAVUTIL_VERSION_INT,
223 const AVClass *pclass = &class;
225 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
228 static int opt_sameq(void *optctx, const char *opt, const char *arg)
230 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
231 "If you are looking for an option to preserve the quality (which is not "
232 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
234 return AVERROR(EINVAL);
237 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
239 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
240 return opt_default(optctx, "channel", arg);
243 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
245 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
246 return opt_default(optctx, "standard", arg);
249 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
251 OptionsContext *o = optctx;
252 return parse_option(o, "codec:a", arg, options);
255 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
257 OptionsContext *o = optctx;
258 return parse_option(o, "codec:v", arg, options);
261 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
263 OptionsContext *o = optctx;
264 return parse_option(o, "codec:s", arg, options);
267 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
269 OptionsContext *o = optctx;
270 return parse_option(o, "codec:d", arg, options);
273 static int opt_map(void *optctx, const char *opt, const char *arg)
275 OptionsContext *o = optctx;
277 int i, negative = 0, file_idx;
278 int sync_file_idx = -1, sync_stream_idx = 0;
287 map = av_strdup(arg);
289 return AVERROR(ENOMEM);
291 /* parse sync stream first, just pick first matching stream */
292 if (sync = strchr(map, ',')) {
294 sync_file_idx = strtol(sync + 1, &sync, 0);
295 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
296 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
301 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
302 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
303 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
307 if (i == input_files[sync_file_idx]->nb_streams) {
308 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
309 "match any streams.\n", arg);
316 /* this mapping refers to lavfi output */
317 const char *c = map + 1;
318 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
319 m = &o->stream_maps[o->nb_stream_maps - 1];
320 m->linklabel = av_get_token(&c, "]");
322 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
326 if (allow_unused = strchr(map, '?'))
328 file_idx = strtol(map, &p, 0);
329 if (file_idx >= nb_input_files || file_idx < 0) {
330 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
334 /* disable some already defined maps */
335 for (i = 0; i < o->nb_stream_maps; i++) {
336 m = &o->stream_maps[i];
337 if (file_idx == m->file_index &&
338 check_stream_specifier(input_files[m->file_index]->ctx,
339 input_files[m->file_index]->ctx->streams[m->stream_index],
340 *p == ':' ? p + 1 : p) > 0)
344 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
345 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
346 *p == ':' ? p + 1 : p) <= 0)
348 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
349 m = &o->stream_maps[o->nb_stream_maps - 1];
351 m->file_index = file_idx;
354 if (sync_file_idx >= 0) {
355 m->sync_file_index = sync_file_idx;
356 m->sync_stream_index = sync_stream_idx;
358 m->sync_file_index = file_idx;
359 m->sync_stream_index = i;
366 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
368 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
369 "To ignore this, add a trailing '?' to the map.\n", arg);
378 static int opt_attach(void *optctx, const char *opt, const char *arg)
380 OptionsContext *o = optctx;
381 GROW_ARRAY(o->attachments, o->nb_attachments);
382 o->attachments[o->nb_attachments - 1] = arg;
386 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
388 OptionsContext *o = optctx;
393 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
394 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
396 /* muted channel syntax */
397 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
398 if ((n == 1 || n == 3) && m->channel_idx == -1) {
399 m->file_idx = m->stream_idx = -1;
401 m->ofile_idx = m->ostream_idx = -1;
406 n = sscanf(arg, "%d.%d.%d:%d.%d",
407 &m->file_idx, &m->stream_idx, &m->channel_idx,
408 &m->ofile_idx, &m->ostream_idx);
410 if (n != 3 && n != 5) {
411 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
412 "[file.stream.channel|-1][:syncfile:syncstream]\n");
416 if (n != 5) // only file.stream.channel specified
417 m->ofile_idx = m->ostream_idx = -1;
420 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
421 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
425 if (m->stream_idx < 0 ||
426 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
427 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
428 m->file_idx, m->stream_idx);
431 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
432 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
433 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
434 m->file_idx, m->stream_idx);
437 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
438 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
439 m->file_idx, m->stream_idx, m->channel_idx);
445 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
447 av_free(sdp_filename);
448 sdp_filename = av_strdup(arg);
453 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
456 err = vaapi_device_init(arg);
464 * Parse a metadata specifier passed as 'arg' parameter.
465 * @param arg metadata string to parse
466 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
467 * @param index for type c/p, chapter/program index is written here
468 * @param stream_spec for type s, the stream specifier is written here
470 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
478 if (*(++arg) && *arg != ':') {
479 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
482 *stream_spec = *arg == ':' ? arg + 1 : "";
487 *index = strtol(++arg, NULL, 0);
490 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
497 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
499 AVDictionary **meta_in = NULL;
500 AVDictionary **meta_out = NULL;
502 char type_in, type_out;
503 const char *istream_spec = NULL, *ostream_spec = NULL;
504 int idx_in = 0, idx_out = 0;
506 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
507 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
510 if (type_out == 'g' || !*outspec)
511 o->metadata_global_manual = 1;
512 if (type_out == 's' || !*outspec)
513 o->metadata_streams_manual = 1;
514 if (type_out == 'c' || !*outspec)
515 o->metadata_chapters_manual = 1;
519 if (type_in == 'g' || type_out == 'g')
520 o->metadata_global_manual = 1;
521 if (type_in == 's' || type_out == 's')
522 o->metadata_streams_manual = 1;
523 if (type_in == 'c' || type_out == 'c')
524 o->metadata_chapters_manual = 1;
526 /* ic is NULL when just disabling automatic mappings */
530 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
531 if ((index) < 0 || (index) >= (nb_elems)) {\
532 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
537 #define SET_DICT(type, meta, context, index)\
540 meta = &context->metadata;\
543 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
544 meta = &context->chapters[index]->metadata;\
547 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
548 meta = &context->programs[index]->metadata;\
551 break; /* handled separately below */ \
552 default: av_assert0(0);\
555 SET_DICT(type_in, meta_in, ic, idx_in);
556 SET_DICT(type_out, meta_out, oc, idx_out);
558 /* for input streams choose first matching stream */
559 if (type_in == 's') {
560 for (i = 0; i < ic->nb_streams; i++) {
561 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
562 meta_in = &ic->streams[i]->metadata;
568 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
573 if (type_out == 's') {
574 for (i = 0; i < oc->nb_streams; i++) {
575 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
576 meta_out = &oc->streams[i]->metadata;
577 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
582 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
587 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
589 OptionsContext *o = optctx;
591 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
592 struct tm time = *gmtime((time_t*)&recording_timestamp);
593 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
595 parse_option(o, "metadata", buf, options);
597 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
598 "tag instead.\n", opt);
602 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
604 const AVCodecDescriptor *desc;
605 const char *codec_string = encoder ? "encoder" : "decoder";
609 avcodec_find_encoder_by_name(name) :
610 avcodec_find_decoder_by_name(name);
612 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
613 codec = encoder ? avcodec_find_encoder(desc->id) :
614 avcodec_find_decoder(desc->id);
616 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
617 codec_string, codec->name, desc->name);
621 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
624 if (codec->type != type) {
625 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
631 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
633 char *codec_name = NULL;
635 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
637 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
638 st->codec->codec_id = codec->id;
641 return avcodec_find_decoder(st->codec->codec_id);
644 /* Add all the streams from the given input file to the global
645 * list of input streams. */
646 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
650 for (i = 0; i < ic->nb_streams; i++) {
651 AVStream *st = ic->streams[i];
652 AVCodecContext *dec = st->codec;
653 InputStream *ist = av_mallocz(sizeof(*ist));
654 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
655 char *hwaccel_output_format = NULL;
656 char *codec_tag = NULL;
658 char *discard_str = NULL;
659 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
664 GROW_ARRAY(input_streams, nb_input_streams);
665 input_streams[nb_input_streams - 1] = ist;
668 ist->file_index = nb_input_files;
670 st->discard = AVDISCARD_ALL;
672 ist->min_pts = INT64_MAX;
673 ist->max_pts = INT64_MIN;
676 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
679 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
681 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
683 uint32_t tag = strtol(codec_tag, &next, 0);
685 tag = AV_RL32(codec_tag);
686 st->codec->codec_tag = tag;
689 ist->dec = choose_decoder(o, ic, st);
690 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
692 ist->reinit_filters = -1;
693 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
695 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
696 ist->user_set_discard = AVDISCARD_NONE;
697 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
698 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
703 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
705 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
707 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
711 ret = avcodec_copy_context(ist->dec_ctx, dec);
713 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
717 switch (dec->codec_type) {
718 case AVMEDIA_TYPE_VIDEO:
720 ist->dec = avcodec_find_decoder(dec->codec_id);
722 if (av_codec_get_lowres(dec)) {
723 dec->flags |= CODEC_FLAG_EMU_EDGE;
727 ist->resample_height = ist->dec_ctx->height;
728 ist->resample_width = ist->dec_ctx->width;
729 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
731 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
732 if (framerate && av_parse_video_rate(&ist->framerate,
734 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
739 ist->top_field_first = -1;
740 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
742 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
744 if (!strcmp(hwaccel, "none"))
745 ist->hwaccel_id = HWACCEL_NONE;
746 else if (!strcmp(hwaccel, "auto"))
747 ist->hwaccel_id = HWACCEL_AUTO;
750 for (i = 0; hwaccels[i].name; i++) {
751 if (!strcmp(hwaccels[i].name, hwaccel)) {
752 ist->hwaccel_id = hwaccels[i].id;
757 if (!ist->hwaccel_id) {
758 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
760 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
761 for (i = 0; hwaccels[i].name; i++)
762 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
763 av_log(NULL, AV_LOG_FATAL, "\n");
769 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
770 if (hwaccel_device) {
771 ist->hwaccel_device = av_strdup(hwaccel_device);
772 if (!ist->hwaccel_device)
776 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
777 hwaccel_output_format, ic, st);
778 if (hwaccel_output_format) {
779 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
780 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
781 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
782 "format: %s", hwaccel_output_format);
785 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
788 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
791 case AVMEDIA_TYPE_AUDIO:
792 ist->guess_layout_max = INT_MAX;
793 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
794 guess_input_channel_layout(ist);
796 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
797 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
798 ist->resample_channels = ist->dec_ctx->channels;
799 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
802 case AVMEDIA_TYPE_DATA:
803 case AVMEDIA_TYPE_SUBTITLE: {
804 char *canvas_size = NULL;
806 ist->dec = avcodec_find_decoder(dec->codec_id);
807 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
808 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
810 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
811 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
816 case AVMEDIA_TYPE_ATTACHMENT:
817 case AVMEDIA_TYPE_UNKNOWN:
825 static void assert_file_overwrite(const char *filename)
827 if (file_overwrite && no_file_overwrite) {
828 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
832 if (!file_overwrite) {
833 const char *proto_name = avio_find_protocol_name(filename);
834 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
835 if (stdin_interaction && !no_file_overwrite) {
836 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
839 signal(SIGINT, SIG_DFL);
841 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
847 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
854 static void dump_attachment(AVStream *st, const char *filename)
857 AVIOContext *out = NULL;
858 AVDictionaryEntry *e;
860 if (!st->codec->extradata_size) {
861 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
862 nb_input_files - 1, st->index);
865 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
868 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
869 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
873 assert_file_overwrite(filename);
875 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
876 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
881 avio_write(out, st->codec->extradata, st->codec->extradata_size);
886 static int open_input_file(OptionsContext *o, const char *filename)
890 AVInputFormat *file_iformat = NULL;
894 AVDictionary *unused_opts = NULL;
895 AVDictionaryEntry *e = NULL;
896 int orig_nb_streams; // number of streams before avformat_find_stream_info
897 char * video_codec_name = NULL;
898 char * audio_codec_name = NULL;
899 char *subtitle_codec_name = NULL;
900 char * data_codec_name = NULL;
901 int scan_all_pmts_set = 0;
904 if (!(file_iformat = av_find_input_format(o->format))) {
905 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
910 if (!strcmp(filename, "-"))
913 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
914 strcmp(filename, "/dev/stdin");
916 /* get default parameters from command line */
917 ic = avformat_alloc_context();
919 print_error(filename, AVERROR(ENOMEM));
922 if (o->nb_audio_sample_rate) {
923 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
925 if (o->nb_audio_channels) {
926 /* because we set audio_channels based on both the "ac" and
927 * "channel_layout" options, we need to check that the specified
928 * demuxer actually has the "channels" option before setting it */
929 if (file_iformat && file_iformat->priv_class &&
930 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
931 AV_OPT_SEARCH_FAKE_OBJ)) {
932 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
935 if (o->nb_frame_rates) {
936 /* set the format-level framerate option;
937 * this is important for video grabbers, e.g. x11 */
938 if (file_iformat && file_iformat->priv_class &&
939 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
940 AV_OPT_SEARCH_FAKE_OBJ)) {
941 av_dict_set(&o->g->format_opts, "framerate",
942 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
945 if (o->nb_frame_sizes) {
946 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
948 if (o->nb_frame_pix_fmts)
949 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
951 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
952 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
953 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
954 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
956 ic->video_codec_id = video_codec_name ?
957 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
958 ic->audio_codec_id = audio_codec_name ?
959 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
960 ic->subtitle_codec_id= subtitle_codec_name ?
961 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
962 ic->data_codec_id = data_codec_name ?
963 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
965 if (video_codec_name)
966 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
967 if (audio_codec_name)
968 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
969 if (subtitle_codec_name)
970 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
972 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
974 ic->flags |= AVFMT_FLAG_NONBLOCK;
975 ic->interrupt_callback = int_cb;
977 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
978 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
979 scan_all_pmts_set = 1;
981 /* open the input file with generic avformat function */
982 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
984 print_error(filename, err);
987 if (scan_all_pmts_set)
988 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
989 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
990 assert_avoptions(o->g->format_opts);
992 /* apply forced codec ids */
993 for (i = 0; i < ic->nb_streams; i++)
994 choose_decoder(o, ic, ic->streams[i]);
996 /* Set AVCodecContext options for avformat_find_stream_info */
997 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
998 orig_nb_streams = ic->nb_streams;
1000 /* If not enough info to get the stream parameters, we decode the
1001 first frames to get it. (used in mpeg case for example) */
1002 ret = avformat_find_stream_info(ic, opts);
1004 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1005 if (ic->nb_streams == 0) {
1006 avformat_close_input(&ic);
1011 if (o->start_time_eof != AV_NOPTS_VALUE) {
1012 if (ic->duration>0) {
1013 o->start_time = o->start_time_eof + ic->duration;
1015 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1017 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1018 /* add the stream start time */
1019 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1020 timestamp += ic->start_time;
1022 /* if seeking requested, we execute it */
1023 if (o->start_time != AV_NOPTS_VALUE) {
1024 int64_t seek_timestamp = timestamp;
1026 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1027 int dts_heuristic = 0;
1028 for (i=0; i<ic->nb_streams; i++) {
1029 AVCodecContext *avctx = ic->streams[i]->codec;
1030 if (avctx->has_b_frames)
1033 if (dts_heuristic) {
1034 seek_timestamp -= 3*AV_TIME_BASE / 23;
1037 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1039 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1040 filename, (double)timestamp / AV_TIME_BASE);
1044 /* update the current parameters so that they match the one of the input stream */
1045 add_input_streams(o, ic);
1047 /* dump the file content */
1048 av_dump_format(ic, nb_input_files, filename, 0);
1050 GROW_ARRAY(input_files, nb_input_files);
1051 f = av_mallocz(sizeof(*f));
1054 input_files[nb_input_files - 1] = f;
1057 f->ist_index = nb_input_streams - ic->nb_streams;
1058 f->start_time = o->start_time;
1059 f->recording_time = o->recording_time;
1060 f->input_ts_offset = o->input_ts_offset;
1061 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1062 f->nb_streams = ic->nb_streams;
1063 f->rate_emu = o->rate_emu;
1064 f->accurate_seek = o->accurate_seek;
1067 f->time_base = (AVRational){ 1, 1 };
1069 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1072 /* check if all codec options have been used */
1073 unused_opts = strip_specifiers(o->g->codec_opts);
1074 for (i = f->ist_index; i < nb_input_streams; i++) {
1076 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1077 AV_DICT_IGNORE_SUFFIX)))
1078 av_dict_set(&unused_opts, e->key, NULL, 0);
1082 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1083 const AVClass *class = avcodec_get_class();
1084 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1085 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1086 const AVClass *fclass = avformat_get_class();
1087 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1088 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1089 if (!option || foption)
1093 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1094 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1095 "input file #%d (%s) is not a decoding option.\n", e->key,
1096 option->help ? option->help : "", nb_input_files - 1,
1101 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1102 "input file #%d (%s) has not been used for any stream. The most "
1103 "likely reason is either wrong type (e.g. a video option with "
1104 "no video streams) or that it is a private option of some decoder "
1105 "which was not actually used for any stream.\n", e->key,
1106 option->help ? option->help : "", nb_input_files - 1, filename);
1108 av_dict_free(&unused_opts);
1110 for (i = 0; i < o->nb_dump_attachment; i++) {
1113 for (j = 0; j < ic->nb_streams; j++) {
1114 AVStream *st = ic->streams[j];
1116 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1117 dump_attachment(st, o->dump_attachment[i].u.str);
1121 for (i = 0; i < orig_nb_streams; i++)
1122 av_dict_free(&opts[i]);
1125 input_stream_potentially_available = 1;
1130 static uint8_t *get_line(AVIOContext *s)
1136 if (avio_open_dyn_buf(&line) < 0) {
1137 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1141 while ((c = avio_r8(s)) && c != '\n')
1144 avio_close_dyn_buf(line, &buf);
1149 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1152 char filename[1000];
1153 const char *base[3] = { getenv("AVCONV_DATADIR"),
1158 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1162 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1163 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1164 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1167 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1168 i != 1 ? "" : "/.avconv", preset_name);
1169 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1175 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1177 enum AVMediaType type = ost->st->codec->codec_type;
1178 char *codec_name = NULL;
1180 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1181 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1183 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1184 NULL, ost->st->codec->codec_type);
1185 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1187 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1188 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1189 "probably disabled. Please choose an encoder manually.\n",
1190 ost->file_index, ost->index, s->oformat->name,
1191 avcodec_get_name(ost->st->codec->codec_id));
1192 return AVERROR_ENCODER_NOT_FOUND;
1194 } else if (!strcmp(codec_name, "copy"))
1195 ost->stream_copy = 1;
1197 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1198 ost->st->codec->codec_id = ost->enc->id;
1200 ost->encoding_needed = !ost->stream_copy;
1202 /* no encoding supported for other media types */
1203 ost->stream_copy = 1;
1204 ost->encoding_needed = 0;
1210 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1213 AVStream *st = avformat_new_stream(oc, NULL);
1214 int idx = oc->nb_streams - 1, ret = 0;
1215 char *bsf = NULL, *next, *codec_tag = NULL;
1216 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1221 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1225 if (oc->nb_streams - 1 < o->nb_streamid_map)
1226 st->id = o->streamid_map[oc->nb_streams - 1];
1228 GROW_ARRAY(output_streams, nb_output_streams);
1229 if (!(ost = av_mallocz(sizeof(*ost))))
1231 output_streams[nb_output_streams - 1] = ost;
1233 ost->file_index = nb_output_files - 1;
1236 st->codec->codec_type = type;
1238 ret = choose_encoder(o, oc, ost);
1240 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1241 "%d:%d\n", ost->file_index, ost->index);
1245 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1246 if (!ost->enc_ctx) {
1247 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1250 ost->enc_ctx->codec_type = type;
1253 AVIOContext *s = NULL;
1254 char *buf = NULL, *arg = NULL, *preset = NULL;
1256 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1258 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1259 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1262 if (!buf[0] || buf[0] == '#') {
1266 if (!(arg = strchr(buf, '='))) {
1267 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1271 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1273 } while (!s->eof_reached);
1277 av_log(NULL, AV_LOG_FATAL,
1278 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1279 preset, ost->file_index, ost->index);
1283 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1286 ost->max_frames = INT64_MAX;
1287 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1288 for (i = 0; i<o->nb_max_frames; i++) {
1289 char *p = o->max_frames[i].specifier;
1290 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1291 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1296 ost->copy_prior_start = -1;
1297 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1299 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1302 if (next = strchr(bsf, ','))
1304 if (arg = strchr(bsf, '='))
1306 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1307 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1311 bsfc_prev->next = bsfc;
1313 ost->bitstream_filters = bsfc;
1315 if (!(bsfc->args = av_strdup(arg))) {
1316 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1324 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1326 uint32_t tag = strtol(codec_tag, &next, 0);
1328 tag = AV_RL32(codec_tag);
1329 ost->st->codec->codec_tag =
1330 ost->enc_ctx->codec_tag = tag;
1333 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1335 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1336 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1339 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1340 ost->disposition = av_strdup(ost->disposition);
1342 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1343 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1345 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1347 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1348 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1349 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1351 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1353 ost->source_index = source_index;
1354 if (source_index >= 0) {
1355 ost->sync_ist = input_streams[source_index];
1356 input_streams[source_index]->discard = 0;
1357 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1359 ost->last_mux_dts = AV_NOPTS_VALUE;
1364 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1367 const char *p = str;
1374 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1381 /* read file contents into a string */
1382 static uint8_t *read_file(const char *filename)
1384 AVIOContext *pb = NULL;
1385 AVIOContext *dyn_buf = NULL;
1386 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1387 uint8_t buf[1024], *str;
1390 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1394 ret = avio_open_dyn_buf(&dyn_buf);
1399 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1400 avio_write(dyn_buf, buf, ret);
1401 avio_w8(dyn_buf, 0);
1404 ret = avio_close_dyn_buf(dyn_buf, &str);
1410 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1413 AVStream *st = ost->st;
1415 if (ost->filters_script && ost->filters) {
1416 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1417 "output stream #%d:%d.\n", nb_output_files, st->index);
1421 if (ost->filters_script)
1422 return read_file(ost->filters_script);
1423 else if (ost->filters)
1424 return av_strdup(ost->filters);
1426 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1430 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1431 const OutputStream *ost, enum AVMediaType type)
1433 if (ost->filters_script || ost->filters) {
1434 av_log(NULL, AV_LOG_ERROR,
1435 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1436 "Filtering and streamcopy cannot be used together.\n",
1437 ost->filters ? "Filtergraph" : "Filtergraph script",
1438 ost->filters ? ost->filters : ost->filters_script,
1439 av_get_media_type_string(type), ost->file_index, ost->index);
1444 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1448 AVCodecContext *video_enc;
1449 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1451 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1453 video_enc = ost->enc_ctx;
1455 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1456 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1457 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1460 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1461 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1463 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1464 if (frame_aspect_ratio) {
1466 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1467 q.num <= 0 || q.den <= 0) {
1468 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1471 ost->frame_aspect_ratio = q;
1474 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1475 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1477 if (!ost->stream_copy) {
1478 const char *p = NULL;
1479 char *frame_size = NULL;
1480 char *frame_pix_fmt = NULL;
1481 char *intra_matrix = NULL, *inter_matrix = NULL;
1482 char *chroma_intra_matrix = NULL;
1486 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1487 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1488 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1492 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1493 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1494 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1495 ost->keep_pix_fmt = 1;
1496 if (!*++frame_pix_fmt)
1497 frame_pix_fmt = NULL;
1499 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1500 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1503 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1506 video_enc->gop_size = 0;
1507 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1509 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1510 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1513 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1515 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1516 if (chroma_intra_matrix) {
1517 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1519 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1522 av_codec_set_chroma_intra_matrix(video_enc, p);
1523 parse_matrix_coeffs(p, chroma_intra_matrix);
1525 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1527 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1528 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1531 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1534 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1535 for (i = 0; p; i++) {
1537 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1539 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1542 video_enc->rc_override =
1543 av_realloc_array(video_enc->rc_override,
1544 i + 1, sizeof(RcOverride));
1545 if (!video_enc->rc_override) {
1546 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1549 video_enc->rc_override[i].start_frame = start;
1550 video_enc->rc_override[i].end_frame = end;
1552 video_enc->rc_override[i].qscale = q;
1553 video_enc->rc_override[i].quality_factor = 1.0;
1556 video_enc->rc_override[i].qscale = 0;
1557 video_enc->rc_override[i].quality_factor = -q/100.0;
1562 video_enc->rc_override_count = i;
1565 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1568 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1571 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1572 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1575 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1576 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1580 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1581 if (ost->logfile_prefix &&
1582 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1586 char logfilename[1024];
1589 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1590 ost->logfile_prefix ? ost->logfile_prefix :
1591 DEFAULT_PASS_LOGFILENAME_PREFIX,
1593 if (!strcmp(ost->enc->name, "libx264")) {
1594 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1596 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1597 char *logbuffer = read_file(logfilename);
1600 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1604 video_enc->stats_in = logbuffer;
1606 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1607 f = av_fopen_utf8(logfilename, "wb");
1609 av_log(NULL, AV_LOG_FATAL,
1610 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1611 logfilename, strerror(errno));
1619 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1620 if (ost->forced_keyframes)
1621 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1623 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1625 ost->top_field_first = -1;
1626 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1629 ost->avfilter = get_ost_filters(o, oc, ost);
1633 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1636 if (ost->stream_copy)
1637 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1642 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1647 AVCodecContext *audio_enc;
1649 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1652 audio_enc = ost->enc_ctx;
1653 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1655 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1656 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1658 if (!ost->stream_copy) {
1659 char *sample_fmt = NULL;
1661 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1663 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1665 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1666 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1670 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1672 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1673 ost->apad = av_strdup(ost->apad);
1675 ost->avfilter = get_ost_filters(o, oc, ost);
1679 /* check for channel mapping for this audio stream */
1680 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1681 AudioChannelMap *map = &o->audio_channel_maps[n];
1682 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1683 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1686 if (map->channel_idx == -1) {
1688 } else if (ost->source_index < 0) {
1689 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1690 ost->file_index, ost->st->index);
1693 ist = input_streams[ost->source_index];
1696 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1697 if (av_reallocp_array(&ost->audio_channels_map,
1698 ost->audio_channels_mapped + 1,
1699 sizeof(*ost->audio_channels_map)
1703 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1709 if (ost->stream_copy)
1710 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1715 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1719 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1720 if (!ost->stream_copy) {
1721 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1728 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1732 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1733 if (!ost->stream_copy) {
1734 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1741 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1743 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1744 ost->stream_copy = 1;
1749 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1753 AVCodecContext *subtitle_enc;
1755 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1757 subtitle_enc = ost->enc_ctx;
1759 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1761 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1763 if (!ost->stream_copy) {
1764 char *frame_size = NULL;
1766 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1767 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1768 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1776 /* arg format is "output-stream-index:streamid-value". */
1777 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1779 OptionsContext *o = optctx;
1784 av_strlcpy(idx_str, arg, sizeof(idx_str));
1785 p = strchr(idx_str, ':');
1787 av_log(NULL, AV_LOG_FATAL,
1788 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1793 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1794 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1795 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1799 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1801 AVFormatContext *is = ifile->ctx;
1802 AVFormatContext *os = ofile->ctx;
1806 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1808 return AVERROR(ENOMEM);
1811 for (i = 0; i < is->nb_chapters; i++) {
1812 AVChapter *in_ch = is->chapters[i], *out_ch;
1813 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1814 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1815 AV_TIME_BASE_Q, in_ch->time_base);
1816 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1817 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1820 if (in_ch->end < ts_off)
1822 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1825 out_ch = av_mallocz(sizeof(AVChapter));
1827 return AVERROR(ENOMEM);
1829 out_ch->id = in_ch->id;
1830 out_ch->time_base = in_ch->time_base;
1831 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1832 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1835 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1837 os->chapters[os->nb_chapters++] = out_ch;
1842 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1845 AVFormatContext *ic = avformat_alloc_context();
1847 ic->interrupt_callback = int_cb;
1848 err = avformat_open_input(&ic, filename, NULL, NULL);
1851 /* copy stream format */
1852 for(i=0;i<ic->nb_streams;i++) {
1856 const char *enc_config;
1858 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1860 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1861 return AVERROR(EINVAL);
1863 if (codec->type == AVMEDIA_TYPE_AUDIO)
1864 opt_audio_codec(o, "c:a", codec->name);
1865 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1866 opt_video_codec(o, "c:v", codec->name);
1867 ost = new_output_stream(o, s, codec->type, -1);
1870 avcodec_get_context_defaults3(st->codec, codec);
1871 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1873 AVDictionary *opts = NULL;
1874 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1875 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1876 av_dict_free(&opts);
1879 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1880 choose_sample_fmt(st, codec);
1881 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1882 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1883 avcodec_copy_context(ost->enc_ctx, st->codec);
1885 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1888 avformat_close_input(&ic);
1892 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1893 AVFormatContext *oc)
1897 switch (ofilter->type) {
1898 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1899 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1901 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1906 ost->source_index = -1;
1907 ost->filter = ofilter;
1911 if (ost->stream_copy) {
1912 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1913 "which is fed from a complex filtergraph. Filtering and streamcopy "
1914 "cannot be used together.\n", ost->file_index, ost->index);
1918 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1919 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1920 av_log(NULL, AV_LOG_ERROR,
1921 "%s '%s' was specified through the %s option "
1922 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1923 "%s and -filter_complex cannot be used together for the same stream.\n",
1924 ost->filters ? "Filtergraph" : "Filtergraph script",
1925 ost->filters ? ost->filters : ost->filters_script,
1926 opt, ost->file_index, ost->index, opt);
1930 avfilter_inout_free(&ofilter->out_tmp);
1933 static int init_complex_filters(void)
1937 for (i = 0; i < nb_filtergraphs; i++) {
1938 ret = init_complex_filtergraph(filtergraphs[i]);
1945 static int configure_complex_filters(void)
1949 for (i = 0; i < nb_filtergraphs; i++)
1950 if (!filtergraph_is_simple(filtergraphs[i]) &&
1951 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1956 static int open_output_file(OptionsContext *o, const char *filename)
1958 AVFormatContext *oc;
1960 AVOutputFormat *file_oformat;
1964 AVDictionary *unused_opts = NULL;
1965 AVDictionaryEntry *e = NULL;
1968 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1969 o->stop_time = INT64_MAX;
1970 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1973 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1974 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1975 if (o->stop_time <= start_time) {
1976 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1979 o->recording_time = o->stop_time - start_time;
1983 GROW_ARRAY(output_files, nb_output_files);
1984 of = av_mallocz(sizeof(*of));
1987 output_files[nb_output_files - 1] = of;
1989 of->ost_index = nb_output_streams;
1990 of->recording_time = o->recording_time;
1991 of->start_time = o->start_time;
1992 of->limit_filesize = o->limit_filesize;
1993 of->shortest = o->shortest;
1994 av_dict_copy(&of->opts, o->g->format_opts, 0);
1996 if (!strcmp(filename, "-"))
1999 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2001 print_error(filename, err);
2006 if (o->recording_time != INT64_MAX)
2007 oc->duration = o->recording_time;
2009 file_oformat= oc->oformat;
2010 oc->interrupt_callback = int_cb;
2012 /* create streams for all unlabeled output pads */
2013 for (i = 0; i < nb_filtergraphs; i++) {
2014 FilterGraph *fg = filtergraphs[i];
2015 for (j = 0; j < fg->nb_outputs; j++) {
2016 OutputFilter *ofilter = fg->outputs[j];
2018 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2021 switch (ofilter->type) {
2022 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2023 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2024 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2026 init_output_filter(ofilter, o, oc);
2030 /* ffserver seeking with date=... needs a date reference */
2031 if (!strcmp(file_oformat->name, "ffm") &&
2032 av_strstart(filename, "http:", NULL)) {
2033 int err = parse_option(o, "metadata", "creation_time=now", options);
2035 print_error(filename, err);
2040 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2041 av_strstart(filename, "http:", NULL)) {
2043 /* special case for files sent to ffserver: we get the stream
2044 parameters from ffserver */
2045 int err = read_ffserver_streams(o, oc, filename);
2047 print_error(filename, err);
2050 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2051 ost = output_streams[j];
2052 for (i = 0; i < nb_input_streams; i++) {
2053 ist = input_streams[i];
2054 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
2056 ost->source_index= i;
2057 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2058 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2060 ist->st->discard = ist->user_set_discard;
2065 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
2069 } else if (!o->nb_stream_maps) {
2070 char *subtitle_codec_name = NULL;
2071 /* pick the "best" stream of each type */
2073 /* video: highest resolution */
2074 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2075 int area = 0, idx = -1;
2076 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2077 for (i = 0; i < nb_input_streams; i++) {
2079 ist = input_streams[i];
2080 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
2081 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2083 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2085 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2092 new_video_stream(o, oc, idx);
2095 /* audio: most channels */
2096 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2097 int best_score = 0, idx = -1;
2098 for (i = 0; i < nb_input_streams; i++) {
2100 ist = input_streams[i];
2101 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2102 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2103 score > best_score) {
2109 new_audio_stream(o, oc, idx);
2112 /* subtitles: pick first */
2113 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2114 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2115 for (i = 0; i < nb_input_streams; i++)
2116 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2117 AVCodecDescriptor const *input_descriptor =
2118 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2119 AVCodecDescriptor const *output_descriptor = NULL;
2120 AVCodec const *output_codec =
2121 avcodec_find_encoder(oc->oformat->subtitle_codec);
2122 int input_props = 0, output_props = 0;
2124 output_descriptor = avcodec_descriptor_get(output_codec->id);
2125 if (input_descriptor)
2126 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2127 if (output_descriptor)
2128 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2129 if (subtitle_codec_name ||
2130 input_props & output_props ||
2131 // Map dvb teletext which has neither property to any output subtitle encoder
2132 input_descriptor && output_descriptor &&
2133 (!input_descriptor->props ||
2134 !output_descriptor->props)) {
2135 new_subtitle_stream(o, oc, i);
2140 /* Data only if codec id match */
2141 if (!o->data_disable ) {
2142 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2143 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2144 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2145 && input_streams[i]->st->codec->codec_id == codec_id )
2146 new_data_stream(o, oc, i);
2150 for (i = 0; i < o->nb_stream_maps; i++) {
2151 StreamMap *map = &o->stream_maps[i];
2156 if (map->linklabel) {
2158 OutputFilter *ofilter = NULL;
2161 for (j = 0; j < nb_filtergraphs; j++) {
2162 fg = filtergraphs[j];
2163 for (k = 0; k < fg->nb_outputs; k++) {
2164 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2165 if (out && !strcmp(out->name, map->linklabel)) {
2166 ofilter = fg->outputs[k];
2173 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2174 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2177 init_output_filter(ofilter, o, oc);
2179 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2181 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2182 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2184 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2186 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2188 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2192 switch (ist->st->codec->codec_type) {
2193 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2194 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2195 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2196 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2197 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2198 case AVMEDIA_TYPE_UNKNOWN:
2199 if (copy_unknown_streams) {
2200 ost = new_unknown_stream (o, oc, src_idx);
2204 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2205 "Cannot map stream #%d:%d - unsupported type.\n",
2206 map->file_index, map->stream_index);
2207 if (!ignore_unknown_streams) {
2208 av_log(NULL, AV_LOG_FATAL,
2209 "If you want unsupported types ignored instead "
2210 "of failing, please use the -ignore_unknown option\n"
2211 "If you want them copied, please use -copy_unknown\n");
2216 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2217 + map->sync_stream_index];
2222 /* handle attached files */
2223 for (i = 0; i < o->nb_attachments; i++) {
2225 uint8_t *attachment;
2229 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2230 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2234 if ((len = avio_size(pb)) <= 0) {
2235 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2239 if (!(attachment = av_malloc(len))) {
2240 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2244 avio_read(pb, attachment, len);
2246 ost = new_attachment_stream(o, oc, -1);
2247 ost->attachment_filename = o->attachments[i];
2248 ost->st->codec->extradata = attachment;
2249 ost->st->codec->extradata_size = len;
2251 p = strrchr(o->attachments[i], '/');
2252 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2256 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2257 AVDictionaryEntry *e;
2258 ost = output_streams[i];
2260 if ((ost->stream_copy || ost->attachment_filename)
2261 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2262 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2263 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2267 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2268 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2269 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2273 /* check if all codec options have been used */
2274 unused_opts = strip_specifiers(o->g->codec_opts);
2275 for (i = of->ost_index; i < nb_output_streams; i++) {
2277 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2278 AV_DICT_IGNORE_SUFFIX)))
2279 av_dict_set(&unused_opts, e->key, NULL, 0);
2283 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2284 const AVClass *class = avcodec_get_class();
2285 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2286 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2287 const AVClass *fclass = avformat_get_class();
2288 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2289 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2290 if (!option || foption)
2294 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2295 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2296 "output file #%d (%s) is not an encoding option.\n", e->key,
2297 option->help ? option->help : "", nb_output_files - 1,
2302 // gop_timecode is injected by generic code but not always used
2303 if (!strcmp(e->key, "gop_timecode"))
2306 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2307 "output file #%d (%s) has not been used for any stream. The most "
2308 "likely reason is either wrong type (e.g. a video option with "
2309 "no video streams) or that it is a private option of some encoder "
2310 "which was not actually used for any stream.\n", e->key,
2311 option->help ? option->help : "", nb_output_files - 1, filename);
2313 av_dict_free(&unused_opts);
2315 /* set the decoding_needed flags and create simple filtergraphs */
2316 for (i = of->ost_index; i < nb_output_streams; i++) {
2317 OutputStream *ost = output_streams[i];
2319 if (ost->encoding_needed && ost->source_index >= 0) {
2320 InputStream *ist = input_streams[ost->source_index];
2321 ist->decoding_needed |= DECODING_FOR_OST;
2323 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2324 ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2325 err = init_simple_filtergraph(ist, ost);
2327 av_log(NULL, AV_LOG_ERROR,
2328 "Error initializing a simple filtergraph between streams "
2329 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2330 nb_output_files - 1, ost->st->index);
2337 /* check filename in case of an image number is expected */
2338 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2339 if (!av_filename_number_test(oc->filename)) {
2340 print_error(oc->filename, AVERROR(EINVAL));
2345 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2346 av_log(NULL, AV_LOG_ERROR,
2347 "No input streams but output needs an input stream\n");
2351 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2352 /* test if it already exists to avoid losing precious files */
2353 assert_file_overwrite(filename);
2356 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2357 &oc->interrupt_callback,
2359 print_error(filename, err);
2362 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2363 assert_file_overwrite(filename);
2365 if (o->mux_preload) {
2366 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2368 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2371 for (i = 0; i < o->nb_metadata_map; i++) {
2373 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2375 if (in_file_index >= nb_input_files) {
2376 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2379 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2380 in_file_index >= 0 ?
2381 input_files[in_file_index]->ctx : NULL, o);
2385 if (o->chapters_input_file >= nb_input_files) {
2386 if (o->chapters_input_file == INT_MAX) {
2387 /* copy chapters from the first input file that has them*/
2388 o->chapters_input_file = -1;
2389 for (i = 0; i < nb_input_files; i++)
2390 if (input_files[i]->ctx->nb_chapters) {
2391 o->chapters_input_file = i;
2395 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2396 o->chapters_input_file);
2400 if (o->chapters_input_file >= 0)
2401 copy_chapters(input_files[o->chapters_input_file], of,
2402 !o->metadata_chapters_manual);
2404 /* copy global metadata by default */
2405 if (!o->metadata_global_manual && nb_input_files){
2406 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2407 AV_DICT_DONT_OVERWRITE);
2408 if(o->recording_time != INT64_MAX)
2409 av_dict_set(&oc->metadata, "duration", NULL, 0);
2410 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2412 if (!o->metadata_streams_manual)
2413 for (i = of->ost_index; i < nb_output_streams; i++) {
2415 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2417 ist = input_streams[output_streams[i]->source_index];
2418 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2419 if (!output_streams[i]->stream_copy) {
2420 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2421 if (ist->autorotate)
2422 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2426 /* process manually set programs */
2427 for (i = 0; i < o->nb_program; i++) {
2428 const char *p = o->program[i].u.str;
2433 const char *p2 = av_get_token(&p, ":");
2434 const char *to_dealloc = p2;
2441 key = av_get_token(&p2, "=");
2443 av_freep(&to_dealloc);
2449 if (!strcmp(key, "program_num"))
2450 progid = strtol(p2, NULL, 0);
2451 av_freep(&to_dealloc);
2455 program = av_new_program(oc, progid);
2457 p = o->program[i].u.str;
2459 const char *p2 = av_get_token(&p, ":");
2460 const char *to_dealloc = p2;
2466 key = av_get_token(&p2, "=");
2468 av_log(NULL, AV_LOG_FATAL,
2469 "No '=' character in program string %s.\n",
2477 if (!strcmp(key, "title")) {
2478 av_dict_set(&program->metadata, "title", p2, 0);
2479 } else if (!strcmp(key, "program_num")) {
2480 } else if (!strcmp(key, "st")) {
2481 int st_num = strtol(p2, NULL, 0);
2482 av_program_add_stream_index(oc, progid, st_num);
2484 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2487 av_freep(&to_dealloc);
2492 /* process manually set metadata */
2493 for (i = 0; i < o->nb_metadata; i++) {
2496 const char *stream_spec;
2497 int index = 0, j, ret = 0;
2499 val = strchr(o->metadata[i].u.str, '=');
2501 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2502 o->metadata[i].u.str);
2507 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2509 for (j = 0; j < oc->nb_streams; j++) {
2510 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2511 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2512 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2513 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2514 ost->rotate_overridden = 1;
2526 if (index < 0 || index >= oc->nb_chapters) {
2527 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2530 m = &oc->chapters[index]->metadata;
2533 if (index < 0 || index >= oc->nb_programs) {
2534 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2537 m = &oc->programs[index]->metadata;
2540 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2543 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2550 static int opt_target(void *optctx, const char *opt, const char *arg)
2552 OptionsContext *o = optctx;
2553 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2554 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2556 if (!strncmp(arg, "pal-", 4)) {
2559 } else if (!strncmp(arg, "ntsc-", 5)) {
2562 } else if (!strncmp(arg, "film-", 5)) {
2566 /* Try to determine PAL/NTSC by peeking in the input files */
2567 if (nb_input_files) {
2569 for (j = 0; j < nb_input_files; j++) {
2570 for (i = 0; i < input_files[j]->nb_streams; i++) {
2571 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2572 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2575 fr = c->time_base.den * 1000 / c->time_base.num;
2579 } else if ((fr == 29970) || (fr == 23976)) {
2584 if (norm != UNKNOWN)
2588 if (norm != UNKNOWN)
2589 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2592 if (norm == UNKNOWN) {
2593 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2594 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2595 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2599 if (!strcmp(arg, "vcd")) {
2600 opt_video_codec(o, "c:v", "mpeg1video");
2601 opt_audio_codec(o, "c:a", "mp2");
2602 parse_option(o, "f", "vcd", options);
2604 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2605 parse_option(o, "r", frame_rates[norm], options);
2606 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2608 opt_default(NULL, "b:v", "1150000");
2609 opt_default(NULL, "maxrate:v", "1150000");
2610 opt_default(NULL, "minrate:v", "1150000");
2611 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2613 opt_default(NULL, "b:a", "224000");
2614 parse_option(o, "ar", "44100", options);
2615 parse_option(o, "ac", "2", options);
2617 opt_default(NULL, "packetsize", "2324");
2618 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2620 /* We have to offset the PTS, so that it is consistent with the SCR.
2621 SCR starts at 36000, but the first two packs contain only padding
2622 and the first pack from the other stream, respectively, may also have
2623 been written before.
2624 So the real data starts at SCR 36000+3*1200. */
2625 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2626 } else if (!strcmp(arg, "svcd")) {
2628 opt_video_codec(o, "c:v", "mpeg2video");
2629 opt_audio_codec(o, "c:a", "mp2");
2630 parse_option(o, "f", "svcd", options);
2632 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2633 parse_option(o, "r", frame_rates[norm], options);
2634 parse_option(o, "pix_fmt", "yuv420p", options);
2635 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2637 opt_default(NULL, "b:v", "2040000");
2638 opt_default(NULL, "maxrate:v", "2516000");
2639 opt_default(NULL, "minrate:v", "0"); // 1145000;
2640 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2641 opt_default(NULL, "scan_offset", "1");
2643 opt_default(NULL, "b:a", "224000");
2644 parse_option(o, "ar", "44100", options);
2646 opt_default(NULL, "packetsize", "2324");
2648 } else if (!strcmp(arg, "dvd")) {
2650 opt_video_codec(o, "c:v", "mpeg2video");
2651 opt_audio_codec(o, "c:a", "ac3");
2652 parse_option(o, "f", "dvd", options);
2654 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2655 parse_option(o, "r", frame_rates[norm], options);
2656 parse_option(o, "pix_fmt", "yuv420p", options);
2657 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2659 opt_default(NULL, "b:v", "6000000");
2660 opt_default(NULL, "maxrate:v", "9000000");
2661 opt_default(NULL, "minrate:v", "0"); // 1500000;
2662 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2664 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2665 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2667 opt_default(NULL, "b:a", "448000");
2668 parse_option(o, "ar", "48000", options);
2670 } else if (!strncmp(arg, "dv", 2)) {
2672 parse_option(o, "f", "dv", options);
2674 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2675 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2676 norm == PAL ? "yuv420p" : "yuv411p", options);
2677 parse_option(o, "r", frame_rates[norm], options);
2679 parse_option(o, "ar", "48000", options);
2680 parse_option(o, "ac", "2", options);
2683 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2684 return AVERROR(EINVAL);
2687 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2688 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2693 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2695 av_free (vstats_filename);
2696 vstats_filename = av_strdup (arg);
2700 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2703 time_t today2 = time(NULL);
2704 struct tm *today = localtime(&today2);
2706 if (!today) { // maybe tomorrow
2707 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2711 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2713 return opt_vstats_file(NULL, opt, filename);
2716 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2718 OptionsContext *o = optctx;
2719 return parse_option(o, "frames:v", arg, options);
2722 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2724 OptionsContext *o = optctx;
2725 return parse_option(o, "frames:a", arg, options);
2728 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2730 OptionsContext *o = optctx;
2731 return parse_option(o, "frames:d", arg, options);
2734 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2737 AVDictionary *cbak = codec_opts;
2738 AVDictionary *fbak = format_opts;
2742 ret = opt_default(NULL, opt, arg);
2744 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2745 av_dict_copy(&o->g->format_opts, format_opts, 0);
2746 av_dict_free(&codec_opts);
2747 av_dict_free(&format_opts);
2754 static int opt_preset(void *optctx, const char *opt, const char *arg)
2756 OptionsContext *o = optctx;
2758 char filename[1000], line[1000], tmp_line[1000];
2759 const char *codec_name = NULL;
2763 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2765 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2766 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2767 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2769 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2773 while (fgets(line, sizeof(line), f)) {
2774 char *key = tmp_line, *value, *endptr;
2776 if (strcspn(line, "#\n\r") == 0)
2778 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2779 if (!av_strtok(key, "=", &value) ||
2780 !av_strtok(value, "\r\n", &endptr)) {
2781 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2784 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2786 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2787 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2788 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2789 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2790 else if (opt_default_new(o, key, value) < 0) {
2791 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2792 filename, line, key, value);
2802 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2804 OptionsContext *o = optctx;
2805 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2806 int ret = parse_option(o, s, arg, options);
2811 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2813 OptionsContext *o = optctx;
2815 if(!strcmp(opt, "ab")){
2816 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2818 } else if(!strcmp(opt, "b")){
2819 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2820 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2823 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2827 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2829 OptionsContext *o = optctx;
2832 if(!strcmp(opt, "qscale")){
2833 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2834 return parse_option(o, "q:v", arg, options);
2836 s = av_asprintf("q%s", opt + 6);
2837 ret = parse_option(o, s, arg, options);
2842 static int opt_profile(void *optctx, const char *opt, const char *arg)
2844 OptionsContext *o = optctx;
2845 if(!strcmp(opt, "profile")){
2846 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2847 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2850 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2854 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2856 OptionsContext *o = optctx;
2857 return parse_option(o, "filter:v", arg, options);
2860 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2862 OptionsContext *o = optctx;
2863 return parse_option(o, "filter:a", arg, options);
2866 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2868 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2869 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2870 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2871 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2873 if (video_sync_method == VSYNC_AUTO)
2874 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2878 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2880 OptionsContext *o = optctx;
2881 char *tcr = av_asprintf("timecode=%s", arg);
2882 int ret = parse_option(o, "metadata:g", tcr, options);
2884 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2889 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2891 OptionsContext *o = optctx;
2892 char layout_str[32];
2895 int ret, channels, ac_str_size;
2898 layout = av_get_channel_layout(arg);
2900 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2901 return AVERROR(EINVAL);
2903 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2904 ret = opt_default_new(o, opt, layout_str);
2908 /* set 'ac' option based on channel layout */
2909 channels = av_get_channel_layout_nb_channels(layout);
2910 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2911 stream_str = strchr(opt, ':');
2912 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2913 ac_str = av_mallocz(ac_str_size);
2915 return AVERROR(ENOMEM);
2916 av_strlcpy(ac_str, "ac", 3);
2918 av_strlcat(ac_str, stream_str, ac_str_size);
2919 ret = parse_option(o, ac_str, layout_str, options);
2925 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2927 OptionsContext *o = optctx;
2928 return parse_option(o, "q:a", arg, options);
2931 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2933 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2934 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2935 return AVERROR(ENOMEM);
2936 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2937 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2938 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2939 return AVERROR(ENOMEM);
2941 input_stream_potentially_available = 1;
2946 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2948 uint8_t *graph_desc = read_file(arg);
2950 return AVERROR(EINVAL);
2952 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2953 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2954 return AVERROR(ENOMEM);
2955 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2956 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2958 input_stream_potentially_available = 1;
2963 void show_help_default(const char *opt, const char *arg)
2965 /* per-file options have at least one of those set */
2966 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2967 int show_advanced = 0, show_avoptions = 0;
2970 if (!strcmp(opt, "long"))
2972 else if (!strcmp(opt, "full"))
2973 show_advanced = show_avoptions = 1;
2975 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2980 printf("Getting help:\n"
2981 " -h -- print basic options\n"
2982 " -h long -- print more options\n"
2983 " -h full -- print all options (including all format and codec specific options, very long)\n"
2984 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2985 " See man %s for detailed description of the options.\n"
2986 "\n", program_name);
2988 show_help_options(options, "Print help / information / capabilities:",
2991 show_help_options(options, "Global options (affect whole program "
2992 "instead of just one file:",
2993 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2995 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2996 per_file | OPT_EXIT, 0);
2998 show_help_options(options, "Per-file main options:", 0,
2999 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3000 OPT_EXIT, per_file);
3002 show_help_options(options, "Advanced per-file options:",
3003 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3005 show_help_options(options, "Video options:",
3006 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3008 show_help_options(options, "Advanced Video options:",
3009 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3011 show_help_options(options, "Audio options:",
3012 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3014 show_help_options(options, "Advanced Audio options:",
3015 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3016 show_help_options(options, "Subtitle options:",
3017 OPT_SUBTITLE, 0, 0);
3020 if (show_avoptions) {
3021 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3022 show_help_children(avcodec_get_class(), flags);
3023 show_help_children(avformat_get_class(), flags);
3025 show_help_children(sws_get_class(), flags);
3027 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3028 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3032 void show_usage(void)
3034 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3035 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3036 av_log(NULL, AV_LOG_INFO, "\n");
3044 static const OptionGroupDef groups[] = {
3045 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
3046 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
3049 static int open_files(OptionGroupList *l, const char *inout,
3050 int (*open_file)(OptionsContext*, const char*))
3054 for (i = 0; i < l->nb_groups; i++) {
3055 OptionGroup *g = &l->groups[i];
3061 ret = parse_optgroup(&o, g);
3063 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3064 "%s.\n", inout, g->arg);
3068 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3069 ret = open_file(&o, g->arg);
3072 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3076 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3082 int ffmpeg_parse_options(int argc, char **argv)
3084 OptionParseContext octx;
3088 memset(&octx, 0, sizeof(octx));
3090 /* split the commandline into an internal representation */
3091 ret = split_commandline(&octx, argc, argv, options, groups,
3092 FF_ARRAY_ELEMS(groups));
3094 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3098 /* apply global options */
3099 ret = parse_optgroup(NULL, &octx.global_opts);
3101 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3105 /* open input files */
3106 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3108 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3112 /* create the complex filtergraphs */
3113 ret = init_complex_filters();
3115 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3119 /* open output files */
3120 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3122 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3126 /* configure the complex filtergraphs */
3127 ret = configure_complex_filters();
3129 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3134 uninit_parse_context(&octx);
3136 av_strerror(ret, error, sizeof(error));
3137 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3142 static int opt_progress(void *optctx, const char *opt, const char *arg)
3144 AVIOContext *avio = NULL;
3147 if (!strcmp(arg, "-"))
3149 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3151 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3152 arg, av_err2str(ret));
3155 progress_avio = avio;
3159 #define OFFSET(x) offsetof(OptionsContext, x)
3160 const OptionDef options[] = {
3162 #include "cmdutils_common_opts.h"
3163 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3164 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3165 "force format", "fmt" },
3166 { "y", OPT_BOOL, { &file_overwrite },
3167 "overwrite output files" },
3168 { "n", OPT_BOOL, { &no_file_overwrite },
3169 "never overwrite output files" },
3170 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3171 "Ignore unknown stream types" },
3172 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3173 "Copy unknown stream types" },
3174 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3175 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3176 "codec name", "codec" },
3177 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3178 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3179 "codec name", "codec" },
3180 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3181 OPT_OUTPUT, { .off = OFFSET(presets) },
3182 "preset name", "preset" },
3183 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3184 OPT_OUTPUT, { .func_arg = opt_map },
3185 "set input stream mapping",
3186 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3187 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3188 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3189 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3190 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3191 "set metadata information of outfile from infile",
3192 "outfile[,metadata]:infile[,metadata]" },
3193 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3194 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3195 "set chapters mapping", "input_file_index" },
3196 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3197 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3198 "record or transcode \"duration\" seconds of audio/video",
3200 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3201 "record or transcode stop time", "time_stop" },
3202 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3203 "set the limit file size in bytes", "limit_size" },
3204 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3205 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3206 "set the start time offset", "time_off" },
3207 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3208 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3209 "set the start time offset relative to EOF", "time_off" },
3210 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3211 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3212 "enable/disable seeking by timestamp with -ss" },
3213 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3214 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3215 "enable/disable accurate seeking with -ss" },
3216 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3217 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3218 "set the input ts offset", "time_off" },
3219 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3220 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3221 "set the input ts scale", "scale" },
3222 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3223 "set the recording timestamp ('now' to set the current time)", "time" },
3224 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3225 "add metadata", "string=string" },
3226 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3227 "add program with specified streams", "title=string:st=number..." },
3228 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3229 OPT_OUTPUT, { .func_arg = opt_data_frames },
3230 "set the number of data frames to output", "number" },
3231 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3232 "add timings for benchmarking" },
3233 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3234 "add timings for each task" },
3235 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3236 "write program-readable progress information", "url" },
3237 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3238 "enable or disable interaction on standard input" },
3239 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3240 "set max runtime in seconds", "limit" },
3241 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3242 "dump each input packet" },
3243 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3244 "when dumping packets, also dump the payload" },
3245 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3246 OPT_INPUT, { .off = OFFSET(rate_emu) },
3247 "read input at native frame rate", "" },
3248 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3249 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3250 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3251 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3252 "video sync method", "" },
3253 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3254 "frame drop threshold", "" },
3255 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3256 "audio sync method", "" },
3257 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3258 "audio drift threshold", "threshold" },
3259 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3260 "copy timestamps" },
3261 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3262 "shift input timestamps to start at 0 when using copyts" },
3263 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3264 "copy input stream time base when stream copying", "mode" },
3265 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3266 OPT_OUTPUT, { .off = OFFSET(shortest) },
3267 "finish encoding within shortest input" },
3268 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3269 OPT_OUTPUT, { .off = OFFSET(apad) },
3271 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3272 "timestamp discontinuity delta threshold", "threshold" },
3273 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3274 "timestamp error delta threshold", "threshold" },
3275 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3276 "exit on error", "error" },
3277 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3278 "abort on the specified condition flags", "flags" },
3279 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3280 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3281 "copy initial non-keyframes" },
3282 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3283 "copy or discard frames before start time" },
3284 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3285 "set the number of frames to output", "number" },
3286 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3287 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3288 "force codec tag/fourcc", "fourcc/tag" },
3289 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3290 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3291 "use fixed quality scale (VBR)", "q" },
3292 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3293 OPT_OUTPUT, { .func_arg = opt_qscale },
3294 "use fixed quality scale (VBR)", "q" },
3295 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3296 "set profile", "profile" },
3297 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3298 "set stream filtergraph", "filter_graph" },
3299 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3300 "read stream filtergraph description from a file", "filename" },
3301 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3302 "reinit filtergraph on input parameter changes", "" },
3303 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3304 "create a complex filtergraph", "graph_description" },
3305 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3306 "create a complex filtergraph", "graph_description" },
3307 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3308 "read complex filtergraph description from a file", "filename" },
3309 { "stats", OPT_BOOL, { &print_stats },
3310 "print progress report during encoding", },
3311 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3312 OPT_OUTPUT, { .func_arg = opt_attach },
3313 "add an attachment to the output file", "filename" },
3314 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3315 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3316 "extract an attachment into a file", "filename" },
3317 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3318 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3319 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3320 "print timestamp debugging info" },
3321 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3322 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3323 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3324 OPT_INPUT, { .off = OFFSET(discard) },
3326 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3327 OPT_OUTPUT, { .off = OFFSET(disposition) },
3328 "disposition", "" },
3329 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3330 { .off = OFFSET(thread_queue_size) },
3331 "set the maximum number of queued packets from the demuxer" },
3334 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3335 "set the number of video frames to output", "number" },
3336 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3337 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3338 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3339 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3340 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3341 "set frame size (WxH or abbreviation)", "size" },
3342 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3343 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3344 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3345 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3346 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3347 "set pixel format", "format" },
3348 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3349 "set the number of bits per raw sample", "number" },
3350 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3351 "deprecated use -g 1" },
3352 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3354 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3355 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3356 "rate control override for specific intervals", "override" },
3357 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3358 OPT_OUTPUT, { .func_arg = opt_video_codec },
3359 "force video codec ('copy' to copy stream)", "codec" },
3360 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3362 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3364 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3365 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3366 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3367 "select the pass number (1 to 3)", "n" },
3368 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3369 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3370 "select two pass log file name prefix", "prefix" },
3371 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3372 "this option is deprecated, use the yadif filter instead" },
3373 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3374 "calculate PSNR of compressed frames" },
3375 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3376 "dump video coding statistics to file" },
3377 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3378 "dump video coding statistics to file", "file" },
3379 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3380 "set video filters", "filter_graph" },
3381 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3382 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3383 "specify intra matrix coeffs", "matrix" },
3384 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3385 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3386 "specify inter matrix coeffs", "matrix" },
3387 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3388 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3389 "specify intra matrix coeffs", "matrix" },
3390 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3391 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3392 "top=1/bottom=0/auto=-1 field first", "" },
3393 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3394 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3395 "force video tag/fourcc", "fourcc/tag" },
3396 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3397 "show QP histogram" },
3398 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3399 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3400 "force the selected framerate, disable the best supported framerate selection" },
3401 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3402 OPT_OUTPUT, { .func_arg = opt_streamid },
3403 "set the value of an outfile streamid", "streamIndex:value" },
3404 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3405 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3406 "force key frames at specified timestamps", "timestamps" },
3407 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3408 "audio bitrate (please use -b:a)", "bitrate" },
3409 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3410 "video bitrate (please use -b:v)", "bitrate" },
3411 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3412 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3413 "use HW accelerated decoding", "hwaccel name" },
3414 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3415 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3416 "select a device for HW acceleration", "devicename" },
3417 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3418 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3419 "select output format used with HW accelerated decoding", "format" },
3420 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3421 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3423 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3424 "show available HW acceleration methods" },
3425 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3426 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3427 "automatically insert correct rotate filters" },
3428 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3429 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3432 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3433 "set the number of audio frames to output", "number" },
3434 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3435 "set audio quality (codec-specific)", "quality", },
3436 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3437 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3438 "set audio sampling rate (in Hz)", "rate" },
3439 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3440 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3441 "set number of audio channels", "channels" },
3442 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3444 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3445 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3446 "force audio codec ('copy' to copy stream)", "codec" },
3447 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3448 OPT_OUTPUT, { .func_arg = opt_old2new },
3449 "force audio tag/fourcc", "fourcc/tag" },
3450 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3451 "change audio volume (256=normal)" , "volume" },
3452 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3453 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3454 "set sample format", "format" },
3455 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3456 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3457 "set channel layout", "layout" },
3458 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3459 "set audio filters", "filter_graph" },
3460 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3461 "set the maximum number of channels to try to guess the channel layout" },
3463 /* subtitle options */
3464 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3465 "disable subtitle" },
3466 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3467 "force subtitle codec ('copy' to copy stream)", "codec" },
3468 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3469 , "force subtitle tag/fourcc", "fourcc/tag" },
3470 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3471 "fix subtitles duration" },
3472 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3473 "set canvas size (WxH or abbreviation)", "size" },
3476 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3477 "deprecated, use -channel", "channel" },
3478 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3479 "deprecated, use -standard", "standard" },
3480 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3483 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3484 "set the maximum demux-decode delay", "seconds" },
3485 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3486 "set the initial demux-decode delay", "seconds" },
3487 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3488 "override the options from ffserver", "" },
3489 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3490 "specify a file in which to print sdp information", "file" },
3492 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3493 "A comma-separated list of bitstream filters", "bitstream_filters" },
3494 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3495 "deprecated", "audio bitstream_filters" },
3496 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3497 "deprecated", "video bitstream_filters" },
3499 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3500 "set the audio options to the indicated preset", "preset" },
3501 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3502 "set the video options to the indicated preset", "preset" },
3503 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3504 "set the subtitle options to the indicated preset", "preset" },
3505 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3506 "set options from indicated preset file", "filename" },
3507 /* data codec support */
3508 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3509 "force data codec ('copy' to copy stream)", "codec" },
3510 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3514 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3515 "set VAAPI hardware device (DRM path or X11 display name)", "device" },