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->codecpar->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->codecpar->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->codecpar->codec_type, 0);
638 st->codecpar->codec_id = codec->id;
641 return avcodec_find_decoder(st->codecpar->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 AVCodecParameters *par = st->codecpar;
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 AVClass *cc = avcodec_get_class();
660 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
665 GROW_ARRAY(input_streams, nb_input_streams);
666 input_streams[nb_input_streams - 1] = ist;
669 ist->file_index = nb_input_files;
671 st->discard = AVDISCARD_ALL;
673 ist->min_pts = INT64_MAX;
674 ist->max_pts = INT64_MIN;
677 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
680 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
682 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
684 uint32_t tag = strtol(codec_tag, &next, 0);
686 tag = AV_RL32(codec_tag);
687 st->codecpar->codec_tag = tag;
690 ist->dec = choose_decoder(o, ic, st);
691 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
693 ist->reinit_filters = -1;
694 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
696 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
697 ist->user_set_discard = AVDISCARD_NONE;
698 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
699 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
704 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
706 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
708 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
712 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
714 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
718 switch (par->codec_type) {
719 case AVMEDIA_TYPE_VIDEO:
721 ist->dec = avcodec_find_decoder(par->codec_id);
723 if (av_codec_get_lowres(st->codec)) {
724 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
725 ist->dec_ctx->width = st->codec->width;
726 ist->dec_ctx->height = st->codec->height;
727 ist->dec_ctx->coded_width = st->codec->coded_width;
728 ist->dec_ctx->coded_height = st->codec->coded_height;
729 ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
733 // avformat_find_stream_info() doesn't set this for us anymore.
734 ist->dec_ctx->framerate = st->avg_frame_rate;
736 ist->resample_height = ist->dec_ctx->height;
737 ist->resample_width = ist->dec_ctx->width;
738 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
740 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
741 if (framerate && av_parse_video_rate(&ist->framerate,
743 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
748 ist->top_field_first = -1;
749 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
751 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
753 if (!strcmp(hwaccel, "none"))
754 ist->hwaccel_id = HWACCEL_NONE;
755 else if (!strcmp(hwaccel, "auto"))
756 ist->hwaccel_id = HWACCEL_AUTO;
759 for (i = 0; hwaccels[i].name; i++) {
760 if (!strcmp(hwaccels[i].name, hwaccel)) {
761 ist->hwaccel_id = hwaccels[i].id;
766 if (!ist->hwaccel_id) {
767 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
769 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
770 for (i = 0; hwaccels[i].name; i++)
771 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
772 av_log(NULL, AV_LOG_FATAL, "\n");
778 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
779 if (hwaccel_device) {
780 ist->hwaccel_device = av_strdup(hwaccel_device);
781 if (!ist->hwaccel_device)
785 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
786 hwaccel_output_format, ic, st);
787 if (hwaccel_output_format) {
788 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
789 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
790 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
791 "format: %s", hwaccel_output_format);
794 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
797 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
800 case AVMEDIA_TYPE_AUDIO:
801 ist->guess_layout_max = INT_MAX;
802 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
803 guess_input_channel_layout(ist);
805 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
806 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
807 ist->resample_channels = ist->dec_ctx->channels;
808 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
811 case AVMEDIA_TYPE_DATA:
812 case AVMEDIA_TYPE_SUBTITLE: {
813 char *canvas_size = NULL;
815 ist->dec = avcodec_find_decoder(par->codec_id);
816 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
817 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
819 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
820 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
825 case AVMEDIA_TYPE_ATTACHMENT:
826 case AVMEDIA_TYPE_UNKNOWN:
832 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
834 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
840 static void assert_file_overwrite(const char *filename)
842 if (file_overwrite && no_file_overwrite) {
843 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
847 if (!file_overwrite) {
848 const char *proto_name = avio_find_protocol_name(filename);
849 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
850 if (stdin_interaction && !no_file_overwrite) {
851 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
854 signal(SIGINT, SIG_DFL);
856 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
862 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
869 static void dump_attachment(AVStream *st, const char *filename)
872 AVIOContext *out = NULL;
873 AVDictionaryEntry *e;
875 if (!st->codecpar->extradata_size) {
876 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
877 nb_input_files - 1, st->index);
880 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
883 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
884 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
888 assert_file_overwrite(filename);
890 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
891 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
896 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
901 static int open_input_file(OptionsContext *o, const char *filename)
905 AVInputFormat *file_iformat = NULL;
909 AVDictionary *unused_opts = NULL;
910 AVDictionaryEntry *e = NULL;
911 int orig_nb_streams; // number of streams before avformat_find_stream_info
912 char * video_codec_name = NULL;
913 char * audio_codec_name = NULL;
914 char *subtitle_codec_name = NULL;
915 char * data_codec_name = NULL;
916 int scan_all_pmts_set = 0;
919 if (!(file_iformat = av_find_input_format(o->format))) {
920 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
925 if (!strcmp(filename, "-"))
928 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
929 strcmp(filename, "/dev/stdin");
931 /* get default parameters from command line */
932 ic = avformat_alloc_context();
934 print_error(filename, AVERROR(ENOMEM));
937 if (o->nb_audio_sample_rate) {
938 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
940 if (o->nb_audio_channels) {
941 /* because we set audio_channels based on both the "ac" and
942 * "channel_layout" options, we need to check that the specified
943 * demuxer actually has the "channels" option before setting it */
944 if (file_iformat && file_iformat->priv_class &&
945 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
946 AV_OPT_SEARCH_FAKE_OBJ)) {
947 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
950 if (o->nb_frame_rates) {
951 /* set the format-level framerate option;
952 * this is important for video grabbers, e.g. x11 */
953 if (file_iformat && file_iformat->priv_class &&
954 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
955 AV_OPT_SEARCH_FAKE_OBJ)) {
956 av_dict_set(&o->g->format_opts, "framerate",
957 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
960 if (o->nb_frame_sizes) {
961 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
963 if (o->nb_frame_pix_fmts)
964 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
966 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
967 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
968 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
969 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
971 ic->video_codec_id = video_codec_name ?
972 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
973 ic->audio_codec_id = audio_codec_name ?
974 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
975 ic->subtitle_codec_id= subtitle_codec_name ?
976 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
977 ic->data_codec_id = data_codec_name ?
978 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
980 if (video_codec_name)
981 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
982 if (audio_codec_name)
983 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
984 if (subtitle_codec_name)
985 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
987 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
989 ic->flags |= AVFMT_FLAG_NONBLOCK;
990 ic->interrupt_callback = int_cb;
992 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
993 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
994 scan_all_pmts_set = 1;
996 /* open the input file with generic avformat function */
997 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
999 print_error(filename, err);
1000 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1001 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1004 if (scan_all_pmts_set)
1005 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1006 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1007 assert_avoptions(o->g->format_opts);
1009 /* apply forced codec ids */
1010 for (i = 0; i < ic->nb_streams; i++)
1011 choose_decoder(o, ic, ic->streams[i]);
1013 /* Set AVCodecContext options for avformat_find_stream_info */
1014 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1015 orig_nb_streams = ic->nb_streams;
1017 /* If not enough info to get the stream parameters, we decode the
1018 first frames to get it. (used in mpeg case for example) */
1019 ret = avformat_find_stream_info(ic, opts);
1021 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1022 if (ic->nb_streams == 0) {
1023 avformat_close_input(&ic);
1028 if (o->start_time_eof != AV_NOPTS_VALUE) {
1029 if (ic->duration>0) {
1030 o->start_time = o->start_time_eof + ic->duration;
1032 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1034 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1035 /* add the stream start time */
1036 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1037 timestamp += ic->start_time;
1039 /* if seeking requested, we execute it */
1040 if (o->start_time != AV_NOPTS_VALUE) {
1041 int64_t seek_timestamp = timestamp;
1043 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1044 int dts_heuristic = 0;
1045 for (i=0; i<ic->nb_streams; i++) {
1046 const AVCodecParameters *par = ic->streams[i]->codecpar;
1047 if (par->video_delay)
1050 if (dts_heuristic) {
1051 seek_timestamp -= 3*AV_TIME_BASE / 23;
1054 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1056 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1057 filename, (double)timestamp / AV_TIME_BASE);
1061 /* update the current parameters so that they match the one of the input stream */
1062 add_input_streams(o, ic);
1064 /* dump the file content */
1065 av_dump_format(ic, nb_input_files, filename, 0);
1067 GROW_ARRAY(input_files, nb_input_files);
1068 f = av_mallocz(sizeof(*f));
1071 input_files[nb_input_files - 1] = f;
1074 f->ist_index = nb_input_streams - ic->nb_streams;
1075 f->start_time = o->start_time;
1076 f->recording_time = o->recording_time;
1077 f->input_ts_offset = o->input_ts_offset;
1078 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1079 f->nb_streams = ic->nb_streams;
1080 f->rate_emu = o->rate_emu;
1081 f->accurate_seek = o->accurate_seek;
1084 f->time_base = (AVRational){ 1, 1 };
1086 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1089 /* check if all codec options have been used */
1090 unused_opts = strip_specifiers(o->g->codec_opts);
1091 for (i = f->ist_index; i < nb_input_streams; i++) {
1093 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1094 AV_DICT_IGNORE_SUFFIX)))
1095 av_dict_set(&unused_opts, e->key, NULL, 0);
1099 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1100 const AVClass *class = avcodec_get_class();
1101 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1102 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1103 const AVClass *fclass = avformat_get_class();
1104 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1105 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1106 if (!option || foption)
1110 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1111 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1112 "input file #%d (%s) is not a decoding option.\n", e->key,
1113 option->help ? option->help : "", nb_input_files - 1,
1118 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1119 "input file #%d (%s) has not been used for any stream. The most "
1120 "likely reason is either wrong type (e.g. a video option with "
1121 "no video streams) or that it is a private option of some decoder "
1122 "which was not actually used for any stream.\n", e->key,
1123 option->help ? option->help : "", nb_input_files - 1, filename);
1125 av_dict_free(&unused_opts);
1127 for (i = 0; i < o->nb_dump_attachment; i++) {
1130 for (j = 0; j < ic->nb_streams; j++) {
1131 AVStream *st = ic->streams[j];
1133 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1134 dump_attachment(st, o->dump_attachment[i].u.str);
1138 for (i = 0; i < orig_nb_streams; i++)
1139 av_dict_free(&opts[i]);
1142 input_stream_potentially_available = 1;
1147 static uint8_t *get_line(AVIOContext *s)
1153 if (avio_open_dyn_buf(&line) < 0) {
1154 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1158 while ((c = avio_r8(s)) && c != '\n')
1161 avio_close_dyn_buf(line, &buf);
1166 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1169 char filename[1000];
1170 const char *base[3] = { getenv("AVCONV_DATADIR"),
1175 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1179 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1180 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1181 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1184 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1185 i != 1 ? "" : "/.avconv", preset_name);
1186 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1192 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1194 enum AVMediaType type = ost->st->codecpar->codec_type;
1195 char *codec_name = NULL;
1197 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1198 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1200 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1201 NULL, ost->st->codecpar->codec_type);
1202 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1204 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1205 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1206 "probably disabled. Please choose an encoder manually.\n",
1207 ost->file_index, ost->index, s->oformat->name,
1208 avcodec_get_name(ost->st->codecpar->codec_id));
1209 return AVERROR_ENCODER_NOT_FOUND;
1211 } else if (!strcmp(codec_name, "copy"))
1212 ost->stream_copy = 1;
1214 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1215 ost->st->codecpar->codec_id = ost->enc->id;
1217 ost->encoding_needed = !ost->stream_copy;
1219 /* no encoding supported for other media types */
1220 ost->stream_copy = 1;
1221 ost->encoding_needed = 0;
1227 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1230 AVStream *st = avformat_new_stream(oc, NULL);
1231 int idx = oc->nb_streams - 1, ret = 0;
1232 const char *bsfs = NULL;
1233 char *next, *codec_tag = NULL;
1238 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1242 if (oc->nb_streams - 1 < o->nb_streamid_map)
1243 st->id = o->streamid_map[oc->nb_streams - 1];
1245 GROW_ARRAY(output_streams, nb_output_streams);
1246 if (!(ost = av_mallocz(sizeof(*ost))))
1248 output_streams[nb_output_streams - 1] = ost;
1250 ost->file_index = nb_output_files - 1;
1253 st->codecpar->codec_type = type;
1255 ret = choose_encoder(o, oc, ost);
1257 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1258 "%d:%d\n", ost->file_index, ost->index);
1262 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1263 if (!ost->enc_ctx) {
1264 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1267 ost->enc_ctx->codec_type = type;
1269 ost->ref_par = avcodec_parameters_alloc();
1270 if (!ost->ref_par) {
1271 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1276 AVIOContext *s = NULL;
1277 char *buf = NULL, *arg = NULL, *preset = NULL;
1279 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1281 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1282 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1285 if (!buf[0] || buf[0] == '#') {
1289 if (!(arg = strchr(buf, '='))) {
1290 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1294 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1296 } while (!s->eof_reached);
1300 av_log(NULL, AV_LOG_FATAL,
1301 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1302 preset, ost->file_index, ost->index);
1306 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1309 ost->max_frames = INT64_MAX;
1310 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1311 for (i = 0; i<o->nb_max_frames; i++) {
1312 char *p = o->max_frames[i].specifier;
1313 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1314 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1319 ost->copy_prior_start = -1;
1320 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1322 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1323 while (bsfs && *bsfs) {
1324 const AVBitStreamFilter *filter;
1325 char *bsf, *bsf_options_str, *bsf_name;
1327 bsf = av_get_token(&bsfs, ",");
1330 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1334 filter = av_bsf_get_by_name(bsf_name);
1336 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1340 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1341 ost->nb_bitstream_filters + 1,
1342 sizeof(*ost->bsf_ctx));
1346 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1348 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1352 ost->nb_bitstream_filters++;
1354 if (bsf_options_str && filter->priv_class) {
1355 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1356 const char * shorthand[2] = {NULL};
1359 shorthand[0] = opt->name;
1361 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1363 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1372 if (ost->nb_bitstream_filters) {
1373 ost->bsf_extradata_updated = av_mallocz_array(ost->nb_bitstream_filters, sizeof(*ost->bsf_extradata_updated));
1374 if (!ost->bsf_extradata_updated) {
1375 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1380 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1382 uint32_t tag = strtol(codec_tag, &next, 0);
1384 tag = AV_RL32(codec_tag);
1385 ost->st->codecpar->codec_tag =
1386 ost->enc_ctx->codec_tag = tag;
1389 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1391 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1392 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1395 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1396 ost->disposition = av_strdup(ost->disposition);
1398 ost->max_muxing_queue_size = 128;
1399 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1400 ost->max_muxing_queue_size *= sizeof(AVPacket);
1402 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1403 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1405 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1407 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1408 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1409 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1411 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1413 ost->source_index = source_index;
1414 if (source_index >= 0) {
1415 ost->sync_ist = input_streams[source_index];
1416 input_streams[source_index]->discard = 0;
1417 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1419 ost->last_mux_dts = AV_NOPTS_VALUE;
1421 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1422 if (!ost->muxing_queue)
1428 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1431 const char *p = str;
1438 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1445 /* read file contents into a string */
1446 static uint8_t *read_file(const char *filename)
1448 AVIOContext *pb = NULL;
1449 AVIOContext *dyn_buf = NULL;
1450 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1451 uint8_t buf[1024], *str;
1454 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1458 ret = avio_open_dyn_buf(&dyn_buf);
1463 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1464 avio_write(dyn_buf, buf, ret);
1465 avio_w8(dyn_buf, 0);
1468 ret = avio_close_dyn_buf(dyn_buf, &str);
1474 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1477 AVStream *st = ost->st;
1479 if (ost->filters_script && ost->filters) {
1480 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1481 "output stream #%d:%d.\n", nb_output_files, st->index);
1485 if (ost->filters_script)
1486 return read_file(ost->filters_script);
1487 else if (ost->filters)
1488 return av_strdup(ost->filters);
1490 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1494 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1495 const OutputStream *ost, enum AVMediaType type)
1497 if (ost->filters_script || ost->filters) {
1498 av_log(NULL, AV_LOG_ERROR,
1499 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1500 "Filtering and streamcopy cannot be used together.\n",
1501 ost->filters ? "Filtergraph" : "Filtergraph script",
1502 ost->filters ? ost->filters : ost->filters_script,
1503 av_get_media_type_string(type), ost->file_index, ost->index);
1508 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1512 AVCodecContext *video_enc;
1513 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1515 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1517 video_enc = ost->enc_ctx;
1519 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1520 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1521 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1524 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1525 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1527 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1528 if (frame_aspect_ratio) {
1530 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1531 q.num <= 0 || q.den <= 0) {
1532 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1535 ost->frame_aspect_ratio = q;
1538 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1539 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1541 if (!ost->stream_copy) {
1542 const char *p = NULL;
1543 char *frame_size = NULL;
1544 char *frame_pix_fmt = NULL;
1545 char *intra_matrix = NULL, *inter_matrix = NULL;
1546 char *chroma_intra_matrix = NULL;
1550 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1551 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1552 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1556 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1557 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1558 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1559 ost->keep_pix_fmt = 1;
1560 if (!*++frame_pix_fmt)
1561 frame_pix_fmt = NULL;
1563 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1564 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1567 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1570 video_enc->gop_size = 0;
1571 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1573 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1574 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1577 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1579 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1580 if (chroma_intra_matrix) {
1581 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1583 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1586 av_codec_set_chroma_intra_matrix(video_enc, p);
1587 parse_matrix_coeffs(p, chroma_intra_matrix);
1589 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1591 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1592 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1595 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1598 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1599 for (i = 0; p; i++) {
1601 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1603 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1606 video_enc->rc_override =
1607 av_realloc_array(video_enc->rc_override,
1608 i + 1, sizeof(RcOverride));
1609 if (!video_enc->rc_override) {
1610 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1613 video_enc->rc_override[i].start_frame = start;
1614 video_enc->rc_override[i].end_frame = end;
1616 video_enc->rc_override[i].qscale = q;
1617 video_enc->rc_override[i].quality_factor = 1.0;
1620 video_enc->rc_override[i].qscale = 0;
1621 video_enc->rc_override[i].quality_factor = -q/100.0;
1626 video_enc->rc_override_count = i;
1629 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1632 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1635 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1636 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1639 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1640 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1644 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1645 if (ost->logfile_prefix &&
1646 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1650 char logfilename[1024];
1653 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1654 ost->logfile_prefix ? ost->logfile_prefix :
1655 DEFAULT_PASS_LOGFILENAME_PREFIX,
1657 if (!strcmp(ost->enc->name, "libx264")) {
1658 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1660 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1661 char *logbuffer = read_file(logfilename);
1664 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1668 video_enc->stats_in = logbuffer;
1670 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1671 f = av_fopen_utf8(logfilename, "wb");
1673 av_log(NULL, AV_LOG_FATAL,
1674 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1675 logfilename, strerror(errno));
1683 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1684 if (ost->forced_keyframes)
1685 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1687 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1689 ost->top_field_first = -1;
1690 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1693 ost->avfilter = get_ost_filters(o, oc, ost);
1697 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1700 if (ost->stream_copy)
1701 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1706 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1711 AVCodecContext *audio_enc;
1713 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1716 audio_enc = ost->enc_ctx;
1717 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1719 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1720 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1722 if (!ost->stream_copy) {
1723 char *sample_fmt = NULL;
1725 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1727 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1729 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1730 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1734 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1736 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1737 ost->apad = av_strdup(ost->apad);
1739 ost->avfilter = get_ost_filters(o, oc, ost);
1743 /* check for channel mapping for this audio stream */
1744 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1745 AudioChannelMap *map = &o->audio_channel_maps[n];
1746 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1747 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1750 if (map->channel_idx == -1) {
1752 } else if (ost->source_index < 0) {
1753 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1754 ost->file_index, ost->st->index);
1757 ist = input_streams[ost->source_index];
1760 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1761 if (av_reallocp_array(&ost->audio_channels_map,
1762 ost->audio_channels_mapped + 1,
1763 sizeof(*ost->audio_channels_map)
1767 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1773 if (ost->stream_copy)
1774 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1779 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1783 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1784 if (!ost->stream_copy) {
1785 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1792 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1796 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1797 if (!ost->stream_copy) {
1798 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1805 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1807 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1808 ost->stream_copy = 1;
1813 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1817 AVCodecContext *subtitle_enc;
1819 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1821 subtitle_enc = ost->enc_ctx;
1823 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1825 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1827 if (!ost->stream_copy) {
1828 char *frame_size = NULL;
1830 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1831 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1832 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1840 /* arg format is "output-stream-index:streamid-value". */
1841 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1843 OptionsContext *o = optctx;
1848 av_strlcpy(idx_str, arg, sizeof(idx_str));
1849 p = strchr(idx_str, ':');
1851 av_log(NULL, AV_LOG_FATAL,
1852 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1857 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1858 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1859 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1863 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1865 AVFormatContext *is = ifile->ctx;
1866 AVFormatContext *os = ofile->ctx;
1870 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1872 return AVERROR(ENOMEM);
1875 for (i = 0; i < is->nb_chapters; i++) {
1876 AVChapter *in_ch = is->chapters[i], *out_ch;
1877 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1878 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1879 AV_TIME_BASE_Q, in_ch->time_base);
1880 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1881 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1884 if (in_ch->end < ts_off)
1886 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1889 out_ch = av_mallocz(sizeof(AVChapter));
1891 return AVERROR(ENOMEM);
1893 out_ch->id = in_ch->id;
1894 out_ch->time_base = in_ch->time_base;
1895 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1896 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1899 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1901 os->chapters[os->nb_chapters++] = out_ch;
1906 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1909 AVFormatContext *ic = avformat_alloc_context();
1911 ic->interrupt_callback = int_cb;
1912 err = avformat_open_input(&ic, filename, NULL, NULL);
1915 /* copy stream format */
1916 for(i=0;i<ic->nb_streams;i++) {
1920 const char *enc_config;
1922 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1924 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1925 return AVERROR(EINVAL);
1927 if (codec->type == AVMEDIA_TYPE_AUDIO)
1928 opt_audio_codec(o, "c:a", codec->name);
1929 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1930 opt_video_codec(o, "c:v", codec->name);
1931 ost = new_output_stream(o, s, codec->type, -1);
1934 avcodec_get_context_defaults3(st->codec, codec);
1935 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1937 AVDictionary *opts = NULL;
1938 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1939 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1940 av_dict_free(&opts);
1943 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1944 choose_sample_fmt(st, codec);
1945 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1946 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1947 avcodec_copy_context(ost->enc_ctx, st->codec);
1949 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1952 avformat_close_input(&ic);
1956 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1957 AVFormatContext *oc)
1961 switch (ofilter->type) {
1962 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1963 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1965 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1970 ost->source_index = -1;
1971 ost->filter = ofilter;
1974 ofilter->format = -1;
1976 if (ost->stream_copy) {
1977 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1978 "which is fed from a complex filtergraph. Filtering and streamcopy "
1979 "cannot be used together.\n", ost->file_index, ost->index);
1983 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1984 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1985 av_log(NULL, AV_LOG_ERROR,
1986 "%s '%s' was specified through the %s option "
1987 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1988 "%s and -filter_complex cannot be used together for the same stream.\n",
1989 ost->filters ? "Filtergraph" : "Filtergraph script",
1990 ost->filters ? ost->filters : ost->filters_script,
1991 opt, ost->file_index, ost->index, opt);
1995 avfilter_inout_free(&ofilter->out_tmp);
1998 static int init_complex_filters(void)
2002 for (i = 0; i < nb_filtergraphs; i++) {
2003 ret = init_complex_filtergraph(filtergraphs[i]);
2010 static int configure_complex_filters(void)
2014 for (i = 0; i < nb_filtergraphs; i++) {
2015 FilterGraph *fg = filtergraphs[i];
2017 if (filtergraph_is_simple(fg))
2020 for (j = 0; j < fg->nb_inputs; j++) {
2021 ret = ifilter_parameters_from_decoder(fg->inputs[j],
2022 fg->inputs[j]->ist->dec_ctx);
2024 av_log(NULL, AV_LOG_ERROR,
2025 "Error initializing filtergraph %d input %d\n", i, j);
2030 ret = configure_filtergraph(filtergraphs[i]);
2037 static int open_output_file(OptionsContext *o, const char *filename)
2039 AVFormatContext *oc;
2041 AVOutputFormat *file_oformat;
2045 AVDictionary *unused_opts = NULL;
2046 AVDictionaryEntry *e = NULL;
2049 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2050 o->stop_time = INT64_MAX;
2051 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2054 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2055 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2056 if (o->stop_time <= start_time) {
2057 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2060 o->recording_time = o->stop_time - start_time;
2064 GROW_ARRAY(output_files, nb_output_files);
2065 of = av_mallocz(sizeof(*of));
2068 output_files[nb_output_files - 1] = of;
2070 of->ost_index = nb_output_streams;
2071 of->recording_time = o->recording_time;
2072 of->start_time = o->start_time;
2073 of->limit_filesize = o->limit_filesize;
2074 of->shortest = o->shortest;
2075 av_dict_copy(&of->opts, o->g->format_opts, 0);
2077 if (!strcmp(filename, "-"))
2080 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2082 print_error(filename, err);
2087 if (o->recording_time != INT64_MAX)
2088 oc->duration = o->recording_time;
2090 file_oformat= oc->oformat;
2091 oc->interrupt_callback = int_cb;
2093 /* create streams for all unlabeled output pads */
2094 for (i = 0; i < nb_filtergraphs; i++) {
2095 FilterGraph *fg = filtergraphs[i];
2096 for (j = 0; j < fg->nb_outputs; j++) {
2097 OutputFilter *ofilter = fg->outputs[j];
2099 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2102 switch (ofilter->type) {
2103 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2104 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2105 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2107 init_output_filter(ofilter, o, oc);
2111 /* ffserver seeking with date=... needs a date reference */
2112 if (!strcmp(file_oformat->name, "ffm") &&
2113 av_strstart(filename, "http:", NULL)) {
2114 int err = parse_option(o, "metadata", "creation_time=now", options);
2116 print_error(filename, err);
2121 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2122 av_strstart(filename, "http:", NULL)) {
2124 /* special case for files sent to ffserver: we get the stream
2125 parameters from ffserver */
2126 int err = read_ffserver_streams(o, oc, filename);
2128 print_error(filename, err);
2131 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2132 ost = output_streams[j];
2133 for (i = 0; i < nb_input_streams; i++) {
2134 ist = input_streams[i];
2135 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2137 ost->source_index= i;
2138 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2139 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2141 ist->st->discard = ist->user_set_discard;
2146 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
2150 } else if (!o->nb_stream_maps) {
2151 char *subtitle_codec_name = NULL;
2152 /* pick the "best" stream of each type */
2154 /* video: highest resolution */
2155 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2156 int area = 0, idx = -1;
2157 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2158 for (i = 0; i < nb_input_streams; i++) {
2160 ist = input_streams[i];
2161 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2162 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2164 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2166 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2173 new_video_stream(o, oc, idx);
2176 /* audio: most channels */
2177 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2178 int best_score = 0, idx = -1;
2179 for (i = 0; i < nb_input_streams; i++) {
2181 ist = input_streams[i];
2182 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2183 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2184 score > best_score) {
2190 new_audio_stream(o, oc, idx);
2193 /* subtitles: pick first */
2194 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2195 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2196 for (i = 0; i < nb_input_streams; i++)
2197 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2198 AVCodecDescriptor const *input_descriptor =
2199 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2200 AVCodecDescriptor const *output_descriptor = NULL;
2201 AVCodec const *output_codec =
2202 avcodec_find_encoder(oc->oformat->subtitle_codec);
2203 int input_props = 0, output_props = 0;
2205 output_descriptor = avcodec_descriptor_get(output_codec->id);
2206 if (input_descriptor)
2207 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2208 if (output_descriptor)
2209 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2210 if (subtitle_codec_name ||
2211 input_props & output_props ||
2212 // Map dvb teletext which has neither property to any output subtitle encoder
2213 input_descriptor && output_descriptor &&
2214 (!input_descriptor->props ||
2215 !output_descriptor->props)) {
2216 new_subtitle_stream(o, oc, i);
2221 /* Data only if codec id match */
2222 if (!o->data_disable ) {
2223 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2224 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2225 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2226 && input_streams[i]->st->codecpar->codec_id == codec_id )
2227 new_data_stream(o, oc, i);
2231 for (i = 0; i < o->nb_stream_maps; i++) {
2232 StreamMap *map = &o->stream_maps[i];
2237 if (map->linklabel) {
2239 OutputFilter *ofilter = NULL;
2242 for (j = 0; j < nb_filtergraphs; j++) {
2243 fg = filtergraphs[j];
2244 for (k = 0; k < fg->nb_outputs; k++) {
2245 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2246 if (out && !strcmp(out->name, map->linklabel)) {
2247 ofilter = fg->outputs[k];
2254 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2255 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2258 init_output_filter(ofilter, o, oc);
2260 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2262 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2263 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2265 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2267 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2269 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2273 switch (ist->st->codecpar->codec_type) {
2274 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2275 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2276 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2277 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2278 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2279 case AVMEDIA_TYPE_UNKNOWN:
2280 if (copy_unknown_streams) {
2281 ost = new_unknown_stream (o, oc, src_idx);
2285 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2286 "Cannot map stream #%d:%d - unsupported type.\n",
2287 map->file_index, map->stream_index);
2288 if (!ignore_unknown_streams) {
2289 av_log(NULL, AV_LOG_FATAL,
2290 "If you want unsupported types ignored instead "
2291 "of failing, please use the -ignore_unknown option\n"
2292 "If you want them copied, please use -copy_unknown\n");
2297 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2298 + map->sync_stream_index];
2303 /* handle attached files */
2304 for (i = 0; i < o->nb_attachments; i++) {
2306 uint8_t *attachment;
2310 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2311 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2315 if ((len = avio_size(pb)) <= 0) {
2316 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2320 if (!(attachment = av_malloc(len))) {
2321 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2325 avio_read(pb, attachment, len);
2327 ost = new_attachment_stream(o, oc, -1);
2328 ost->stream_copy = 0;
2329 ost->attachment_filename = o->attachments[i];
2330 ost->st->codecpar->extradata = attachment;
2331 ost->st->codecpar->extradata_size = len;
2333 p = strrchr(o->attachments[i], '/');
2334 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2338 #if FF_API_LAVF_AVCTX
2339 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2340 AVDictionaryEntry *e;
2341 ost = output_streams[i];
2343 if ((ost->stream_copy || ost->attachment_filename)
2344 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2345 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2346 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2351 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2352 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2353 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2357 /* check if all codec options have been used */
2358 unused_opts = strip_specifiers(o->g->codec_opts);
2359 for (i = of->ost_index; i < nb_output_streams; i++) {
2361 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2362 AV_DICT_IGNORE_SUFFIX)))
2363 av_dict_set(&unused_opts, e->key, NULL, 0);
2367 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2368 const AVClass *class = avcodec_get_class();
2369 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2370 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2371 const AVClass *fclass = avformat_get_class();
2372 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2373 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2374 if (!option || foption)
2378 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2379 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2380 "output file #%d (%s) is not an encoding option.\n", e->key,
2381 option->help ? option->help : "", nb_output_files - 1,
2386 // gop_timecode is injected by generic code but not always used
2387 if (!strcmp(e->key, "gop_timecode"))
2390 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2391 "output file #%d (%s) has not been used for any stream. The most "
2392 "likely reason is either wrong type (e.g. a video option with "
2393 "no video streams) or that it is a private option of some encoder "
2394 "which was not actually used for any stream.\n", e->key,
2395 option->help ? option->help : "", nb_output_files - 1, filename);
2397 av_dict_free(&unused_opts);
2399 /* set the decoding_needed flags and create simple filtergraphs */
2400 for (i = of->ost_index; i < nb_output_streams; i++) {
2401 OutputStream *ost = output_streams[i];
2403 if (ost->encoding_needed && ost->source_index >= 0) {
2404 InputStream *ist = input_streams[ost->source_index];
2405 ist->decoding_needed |= DECODING_FOR_OST;
2407 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2408 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2409 err = init_simple_filtergraph(ist, ost);
2411 av_log(NULL, AV_LOG_ERROR,
2412 "Error initializing a simple filtergraph between streams "
2413 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2414 nb_output_files - 1, ost->st->index);
2420 /* set the filter output constraints */
2422 OutputFilter *f = ost->filter;
2424 switch (ost->enc_ctx->codec_type) {
2425 case AVMEDIA_TYPE_VIDEO:
2426 f->frame_rate = ost->frame_rate;
2427 f->width = ost->enc_ctx->width;
2428 f->height = ost->enc_ctx->height;
2429 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2430 f->format = ost->enc_ctx->pix_fmt;
2431 } else if (ost->enc->pix_fmts) {
2433 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2435 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2438 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2441 case AVMEDIA_TYPE_AUDIO:
2442 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2443 f->format = ost->enc_ctx->sample_fmt;
2444 } else if (ost->enc->sample_fmts) {
2446 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2448 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2451 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2453 if (ost->enc_ctx->sample_rate) {
2454 f->sample_rate = ost->enc_ctx->sample_rate;
2455 } else if (ost->enc->supported_samplerates) {
2457 while (ost->enc->supported_samplerates[count])
2459 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2460 if (!f->sample_rates)
2462 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2463 (count + 1) * sizeof(*f->sample_rates));
2465 if (ost->enc_ctx->channels) {
2466 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2467 } else if (ost->enc->channel_layouts) {
2469 while (ost->enc->channel_layouts[count])
2471 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2472 if (!f->channel_layouts)
2474 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2475 (count + 1) * sizeof(*f->channel_layouts));
2482 /* check filename in case of an image number is expected */
2483 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2484 if (!av_filename_number_test(oc->filename)) {
2485 print_error(oc->filename, AVERROR(EINVAL));
2490 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2491 av_log(NULL, AV_LOG_ERROR,
2492 "No input streams but output needs an input stream\n");
2496 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2497 /* test if it already exists to avoid losing precious files */
2498 assert_file_overwrite(filename);
2501 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2502 &oc->interrupt_callback,
2504 print_error(filename, err);
2507 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2508 assert_file_overwrite(filename);
2510 if (o->mux_preload) {
2511 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2513 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2516 for (i = 0; i < o->nb_metadata_map; i++) {
2518 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2520 if (in_file_index >= nb_input_files) {
2521 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2524 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2525 in_file_index >= 0 ?
2526 input_files[in_file_index]->ctx : NULL, o);
2530 if (o->chapters_input_file >= nb_input_files) {
2531 if (o->chapters_input_file == INT_MAX) {
2532 /* copy chapters from the first input file that has them*/
2533 o->chapters_input_file = -1;
2534 for (i = 0; i < nb_input_files; i++)
2535 if (input_files[i]->ctx->nb_chapters) {
2536 o->chapters_input_file = i;
2540 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2541 o->chapters_input_file);
2545 if (o->chapters_input_file >= 0)
2546 copy_chapters(input_files[o->chapters_input_file], of,
2547 !o->metadata_chapters_manual);
2549 /* copy global metadata by default */
2550 if (!o->metadata_global_manual && nb_input_files){
2551 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2552 AV_DICT_DONT_OVERWRITE);
2553 if(o->recording_time != INT64_MAX)
2554 av_dict_set(&oc->metadata, "duration", NULL, 0);
2555 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2557 if (!o->metadata_streams_manual)
2558 for (i = of->ost_index; i < nb_output_streams; i++) {
2560 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2562 ist = input_streams[output_streams[i]->source_index];
2563 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2564 if (!output_streams[i]->stream_copy) {
2565 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2566 if (ist->autorotate)
2567 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2571 /* process manually set programs */
2572 for (i = 0; i < o->nb_program; i++) {
2573 const char *p = o->program[i].u.str;
2578 const char *p2 = av_get_token(&p, ":");
2579 const char *to_dealloc = p2;
2586 key = av_get_token(&p2, "=");
2588 av_freep(&to_dealloc);
2594 if (!strcmp(key, "program_num"))
2595 progid = strtol(p2, NULL, 0);
2596 av_freep(&to_dealloc);
2600 program = av_new_program(oc, progid);
2602 p = o->program[i].u.str;
2604 const char *p2 = av_get_token(&p, ":");
2605 const char *to_dealloc = p2;
2611 key = av_get_token(&p2, "=");
2613 av_log(NULL, AV_LOG_FATAL,
2614 "No '=' character in program string %s.\n",
2622 if (!strcmp(key, "title")) {
2623 av_dict_set(&program->metadata, "title", p2, 0);
2624 } else if (!strcmp(key, "program_num")) {
2625 } else if (!strcmp(key, "st")) {
2626 int st_num = strtol(p2, NULL, 0);
2627 av_program_add_stream_index(oc, progid, st_num);
2629 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2632 av_freep(&to_dealloc);
2637 /* process manually set metadata */
2638 for (i = 0; i < o->nb_metadata; i++) {
2641 const char *stream_spec;
2642 int index = 0, j, ret = 0;
2644 val = strchr(o->metadata[i].u.str, '=');
2646 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2647 o->metadata[i].u.str);
2652 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2654 for (j = 0; j < oc->nb_streams; j++) {
2655 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2656 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2657 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2658 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2659 ost->rotate_overridden = 1;
2671 if (index < 0 || index >= oc->nb_chapters) {
2672 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2675 m = &oc->chapters[index]->metadata;
2678 if (index < 0 || index >= oc->nb_programs) {
2679 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2682 m = &oc->programs[index]->metadata;
2685 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2688 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2695 static int opt_target(void *optctx, const char *opt, const char *arg)
2697 OptionsContext *o = optctx;
2698 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2699 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2701 if (!strncmp(arg, "pal-", 4)) {
2704 } else if (!strncmp(arg, "ntsc-", 5)) {
2707 } else if (!strncmp(arg, "film-", 5)) {
2711 /* Try to determine PAL/NTSC by peeking in the input files */
2712 if (nb_input_files) {
2714 for (j = 0; j < nb_input_files; j++) {
2715 for (i = 0; i < input_files[j]->nb_streams; i++) {
2716 AVStream *st = input_files[j]->ctx->streams[i];
2717 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2719 fr = st->time_base.den * 1000 / st->time_base.num;
2723 } else if ((fr == 29970) || (fr == 23976)) {
2728 if (norm != UNKNOWN)
2732 if (norm != UNKNOWN)
2733 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2736 if (norm == UNKNOWN) {
2737 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2738 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2739 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2743 if (!strcmp(arg, "vcd")) {
2744 opt_video_codec(o, "c:v", "mpeg1video");
2745 opt_audio_codec(o, "c:a", "mp2");
2746 parse_option(o, "f", "vcd", options);
2748 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2749 parse_option(o, "r", frame_rates[norm], options);
2750 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2752 opt_default(NULL, "b:v", "1150000");
2753 opt_default(NULL, "maxrate:v", "1150000");
2754 opt_default(NULL, "minrate:v", "1150000");
2755 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2757 opt_default(NULL, "b:a", "224000");
2758 parse_option(o, "ar", "44100", options);
2759 parse_option(o, "ac", "2", options);
2761 opt_default(NULL, "packetsize", "2324");
2762 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2764 /* We have to offset the PTS, so that it is consistent with the SCR.
2765 SCR starts at 36000, but the first two packs contain only padding
2766 and the first pack from the other stream, respectively, may also have
2767 been written before.
2768 So the real data starts at SCR 36000+3*1200. */
2769 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2770 } else if (!strcmp(arg, "svcd")) {
2772 opt_video_codec(o, "c:v", "mpeg2video");
2773 opt_audio_codec(o, "c:a", "mp2");
2774 parse_option(o, "f", "svcd", options);
2776 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2777 parse_option(o, "r", frame_rates[norm], options);
2778 parse_option(o, "pix_fmt", "yuv420p", options);
2779 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2781 opt_default(NULL, "b:v", "2040000");
2782 opt_default(NULL, "maxrate:v", "2516000");
2783 opt_default(NULL, "minrate:v", "0"); // 1145000;
2784 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2785 opt_default(NULL, "scan_offset", "1");
2787 opt_default(NULL, "b:a", "224000");
2788 parse_option(o, "ar", "44100", options);
2790 opt_default(NULL, "packetsize", "2324");
2792 } else if (!strcmp(arg, "dvd")) {
2794 opt_video_codec(o, "c:v", "mpeg2video");
2795 opt_audio_codec(o, "c:a", "ac3");
2796 parse_option(o, "f", "dvd", options);
2798 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2799 parse_option(o, "r", frame_rates[norm], options);
2800 parse_option(o, "pix_fmt", "yuv420p", options);
2801 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2803 opt_default(NULL, "b:v", "6000000");
2804 opt_default(NULL, "maxrate:v", "9000000");
2805 opt_default(NULL, "minrate:v", "0"); // 1500000;
2806 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2808 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2809 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2811 opt_default(NULL, "b:a", "448000");
2812 parse_option(o, "ar", "48000", options);
2814 } else if (!strncmp(arg, "dv", 2)) {
2816 parse_option(o, "f", "dv", options);
2818 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2819 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2820 norm == PAL ? "yuv420p" : "yuv411p", options);
2821 parse_option(o, "r", frame_rates[norm], options);
2823 parse_option(o, "ar", "48000", options);
2824 parse_option(o, "ac", "2", options);
2827 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2828 return AVERROR(EINVAL);
2831 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2832 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2837 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2839 av_free (vstats_filename);
2840 vstats_filename = av_strdup (arg);
2844 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2847 time_t today2 = time(NULL);
2848 struct tm *today = localtime(&today2);
2850 if (!today) { // maybe tomorrow
2851 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2855 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2857 return opt_vstats_file(NULL, opt, filename);
2860 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2862 OptionsContext *o = optctx;
2863 return parse_option(o, "frames:v", arg, options);
2866 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2868 OptionsContext *o = optctx;
2869 return parse_option(o, "frames:a", arg, options);
2872 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2874 OptionsContext *o = optctx;
2875 return parse_option(o, "frames:d", arg, options);
2878 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2881 AVDictionary *cbak = codec_opts;
2882 AVDictionary *fbak = format_opts;
2886 ret = opt_default(NULL, opt, arg);
2888 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2889 av_dict_copy(&o->g->format_opts, format_opts, 0);
2890 av_dict_free(&codec_opts);
2891 av_dict_free(&format_opts);
2898 static int opt_preset(void *optctx, const char *opt, const char *arg)
2900 OptionsContext *o = optctx;
2902 char filename[1000], line[1000], tmp_line[1000];
2903 const char *codec_name = NULL;
2907 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2909 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2910 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2911 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2913 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2917 while (fgets(line, sizeof(line), f)) {
2918 char *key = tmp_line, *value, *endptr;
2920 if (strcspn(line, "#\n\r") == 0)
2922 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2923 if (!av_strtok(key, "=", &value) ||
2924 !av_strtok(value, "\r\n", &endptr)) {
2925 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2928 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2930 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2931 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2932 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2933 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2934 else if (opt_default_new(o, key, value) < 0) {
2935 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2936 filename, line, key, value);
2946 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2948 OptionsContext *o = optctx;
2949 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2950 int ret = parse_option(o, s, arg, options);
2955 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2957 OptionsContext *o = optctx;
2959 if(!strcmp(opt, "ab")){
2960 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2962 } else if(!strcmp(opt, "b")){
2963 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2964 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2967 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2971 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2973 OptionsContext *o = optctx;
2976 if(!strcmp(opt, "qscale")){
2977 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2978 return parse_option(o, "q:v", arg, options);
2980 s = av_asprintf("q%s", opt + 6);
2981 ret = parse_option(o, s, arg, options);
2986 static int opt_profile(void *optctx, const char *opt, const char *arg)
2988 OptionsContext *o = optctx;
2989 if(!strcmp(opt, "profile")){
2990 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2991 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2994 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2998 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3000 OptionsContext *o = optctx;
3001 return parse_option(o, "filter:v", arg, options);
3004 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3006 OptionsContext *o = optctx;
3007 return parse_option(o, "filter:a", arg, options);
3010 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3012 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3013 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3014 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3015 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3017 if (video_sync_method == VSYNC_AUTO)
3018 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3022 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3024 OptionsContext *o = optctx;
3025 char *tcr = av_asprintf("timecode=%s", arg);
3026 int ret = parse_option(o, "metadata:g", tcr, options);
3028 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3033 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3035 OptionsContext *o = optctx;
3036 char layout_str[32];
3039 int ret, channels, ac_str_size;
3042 layout = av_get_channel_layout(arg);
3044 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3045 return AVERROR(EINVAL);
3047 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3048 ret = opt_default_new(o, opt, layout_str);
3052 /* set 'ac' option based on channel layout */
3053 channels = av_get_channel_layout_nb_channels(layout);
3054 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3055 stream_str = strchr(opt, ':');
3056 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3057 ac_str = av_mallocz(ac_str_size);
3059 return AVERROR(ENOMEM);
3060 av_strlcpy(ac_str, "ac", 3);
3062 av_strlcat(ac_str, stream_str, ac_str_size);
3063 ret = parse_option(o, ac_str, layout_str, options);
3069 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3071 OptionsContext *o = optctx;
3072 return parse_option(o, "q:a", arg, options);
3075 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3077 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3078 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3079 return AVERROR(ENOMEM);
3080 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3081 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3082 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3083 return AVERROR(ENOMEM);
3085 input_stream_potentially_available = 1;
3090 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3092 uint8_t *graph_desc = read_file(arg);
3094 return AVERROR(EINVAL);
3096 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3097 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3098 return AVERROR(ENOMEM);
3099 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3100 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3102 input_stream_potentially_available = 1;
3107 void show_help_default(const char *opt, const char *arg)
3109 /* per-file options have at least one of those set */
3110 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3111 int show_advanced = 0, show_avoptions = 0;
3114 if (!strcmp(opt, "long"))
3116 else if (!strcmp(opt, "full"))
3117 show_advanced = show_avoptions = 1;
3119 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3124 printf("Getting help:\n"
3125 " -h -- print basic options\n"
3126 " -h long -- print more options\n"
3127 " -h full -- print all options (including all format and codec specific options, very long)\n"
3128 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3129 " See man %s for detailed description of the options.\n"
3130 "\n", program_name);
3132 show_help_options(options, "Print help / information / capabilities:",
3135 show_help_options(options, "Global options (affect whole program "
3136 "instead of just one file:",
3137 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3139 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3140 per_file | OPT_EXIT, 0);
3142 show_help_options(options, "Per-file main options:", 0,
3143 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3144 OPT_EXIT, per_file);
3146 show_help_options(options, "Advanced per-file options:",
3147 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3149 show_help_options(options, "Video options:",
3150 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3152 show_help_options(options, "Advanced Video options:",
3153 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3155 show_help_options(options, "Audio options:",
3156 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3158 show_help_options(options, "Advanced Audio options:",
3159 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3160 show_help_options(options, "Subtitle options:",
3161 OPT_SUBTITLE, 0, 0);
3164 if (show_avoptions) {
3165 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3166 show_help_children(avcodec_get_class(), flags);
3167 show_help_children(avformat_get_class(), flags);
3169 show_help_children(sws_get_class(), flags);
3171 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3172 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3176 void show_usage(void)
3178 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3179 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3180 av_log(NULL, AV_LOG_INFO, "\n");
3188 static const OptionGroupDef groups[] = {
3189 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
3190 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
3193 static int open_files(OptionGroupList *l, const char *inout,
3194 int (*open_file)(OptionsContext*, const char*))
3198 for (i = 0; i < l->nb_groups; i++) {
3199 OptionGroup *g = &l->groups[i];
3205 ret = parse_optgroup(&o, g);
3207 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3208 "%s.\n", inout, g->arg);
3212 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3213 ret = open_file(&o, g->arg);
3216 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3220 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3226 int ffmpeg_parse_options(int argc, char **argv)
3228 OptionParseContext octx;
3232 memset(&octx, 0, sizeof(octx));
3234 /* split the commandline into an internal representation */
3235 ret = split_commandline(&octx, argc, argv, options, groups,
3236 FF_ARRAY_ELEMS(groups));
3238 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3242 /* apply global options */
3243 ret = parse_optgroup(NULL, &octx.global_opts);
3245 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3249 /* configure terminal and setup signal handlers */
3252 /* open input files */
3253 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3255 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3259 /* create the complex filtergraphs */
3260 ret = init_complex_filters();
3262 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3266 /* open output files */
3267 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3269 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3273 /* configure the complex filtergraphs */
3274 ret = configure_complex_filters();
3276 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3281 uninit_parse_context(&octx);
3283 av_strerror(ret, error, sizeof(error));
3284 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3289 static int opt_progress(void *optctx, const char *opt, const char *arg)
3291 AVIOContext *avio = NULL;
3294 if (!strcmp(arg, "-"))
3296 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3298 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3299 arg, av_err2str(ret));
3302 progress_avio = avio;
3306 #define OFFSET(x) offsetof(OptionsContext, x)
3307 const OptionDef options[] = {
3309 #include "cmdutils_common_opts.h"
3310 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3311 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3312 "force format", "fmt" },
3313 { "y", OPT_BOOL, { &file_overwrite },
3314 "overwrite output files" },
3315 { "n", OPT_BOOL, { &no_file_overwrite },
3316 "never overwrite output files" },
3317 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3318 "Ignore unknown stream types" },
3319 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3320 "Copy unknown stream types" },
3321 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3322 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3323 "codec name", "codec" },
3324 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3325 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3326 "codec name", "codec" },
3327 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3328 OPT_OUTPUT, { .off = OFFSET(presets) },
3329 "preset name", "preset" },
3330 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3331 OPT_OUTPUT, { .func_arg = opt_map },
3332 "set input stream mapping",
3333 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3334 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3335 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3336 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3337 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3338 "set metadata information of outfile from infile",
3339 "outfile[,metadata]:infile[,metadata]" },
3340 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3341 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3342 "set chapters mapping", "input_file_index" },
3343 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3344 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3345 "record or transcode \"duration\" seconds of audio/video",
3347 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3348 "record or transcode stop time", "time_stop" },
3349 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3350 "set the limit file size in bytes", "limit_size" },
3351 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3352 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3353 "set the start time offset", "time_off" },
3354 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3355 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3356 "set the start time offset relative to EOF", "time_off" },
3357 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3358 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3359 "enable/disable seeking by timestamp with -ss" },
3360 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3361 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3362 "enable/disable accurate seeking with -ss" },
3363 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3364 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3365 "set the input ts offset", "time_off" },
3366 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3367 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3368 "set the input ts scale", "scale" },
3369 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3370 "set the recording timestamp ('now' to set the current time)", "time" },
3371 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3372 "add metadata", "string=string" },
3373 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3374 "add program with specified streams", "title=string:st=number..." },
3375 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3376 OPT_OUTPUT, { .func_arg = opt_data_frames },
3377 "set the number of data frames to output", "number" },
3378 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3379 "add timings for benchmarking" },
3380 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3381 "add timings for each task" },
3382 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3383 "write program-readable progress information", "url" },
3384 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3385 "enable or disable interaction on standard input" },
3386 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3387 "set max runtime in seconds", "limit" },
3388 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3389 "dump each input packet" },
3390 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3391 "when dumping packets, also dump the payload" },
3392 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3393 OPT_INPUT, { .off = OFFSET(rate_emu) },
3394 "read input at native frame rate", "" },
3395 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3396 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3397 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3398 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3399 "video sync method", "" },
3400 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3401 "frame drop threshold", "" },
3402 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3403 "audio sync method", "" },
3404 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3405 "audio drift threshold", "threshold" },
3406 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3407 "copy timestamps" },
3408 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3409 "shift input timestamps to start at 0 when using copyts" },
3410 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3411 "copy input stream time base when stream copying", "mode" },
3412 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3413 OPT_OUTPUT, { .off = OFFSET(shortest) },
3414 "finish encoding within shortest input" },
3415 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3416 OPT_OUTPUT, { .off = OFFSET(apad) },
3418 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3419 "timestamp discontinuity delta threshold", "threshold" },
3420 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3421 "timestamp error delta threshold", "threshold" },
3422 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3423 "exit on error", "error" },
3424 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3425 "abort on the specified condition flags", "flags" },
3426 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3427 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3428 "copy initial non-keyframes" },
3429 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3430 "copy or discard frames before start time" },
3431 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3432 "set the number of frames to output", "number" },
3433 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3434 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3435 "force codec tag/fourcc", "fourcc/tag" },
3436 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3437 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3438 "use fixed quality scale (VBR)", "q" },
3439 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3440 OPT_OUTPUT, { .func_arg = opt_qscale },
3441 "use fixed quality scale (VBR)", "q" },
3442 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3443 "set profile", "profile" },
3444 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3445 "set stream filtergraph", "filter_graph" },
3446 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3447 "number of non-complex filter threads" },
3448 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3449 "read stream filtergraph description from a file", "filename" },
3450 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3451 "reinit filtergraph on input parameter changes", "" },
3452 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3453 "create a complex filtergraph", "graph_description" },
3454 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3455 "number of threads for -filter_complex" },
3456 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3457 "create a complex filtergraph", "graph_description" },
3458 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3459 "read complex filtergraph description from a file", "filename" },
3460 { "stats", OPT_BOOL, { &print_stats },
3461 "print progress report during encoding", },
3462 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3463 OPT_OUTPUT, { .func_arg = opt_attach },
3464 "add an attachment to the output file", "filename" },
3465 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3466 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3467 "extract an attachment into a file", "filename" },
3468 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3469 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3470 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3471 "print timestamp debugging info" },
3472 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3473 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3474 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3475 OPT_INPUT, { .off = OFFSET(discard) },
3477 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3478 OPT_OUTPUT, { .off = OFFSET(disposition) },
3479 "disposition", "" },
3480 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3481 { .off = OFFSET(thread_queue_size) },
3482 "set the maximum number of queued packets from the demuxer" },
3485 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3486 "set the number of video frames to output", "number" },
3487 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3488 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3489 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3490 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3491 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3492 "set frame size (WxH or abbreviation)", "size" },
3493 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3494 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3495 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3496 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3497 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3498 "set pixel format", "format" },
3499 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3500 "set the number of bits per raw sample", "number" },
3501 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3502 "deprecated use -g 1" },
3503 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3505 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3506 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3507 "rate control override for specific intervals", "override" },
3508 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3509 OPT_OUTPUT, { .func_arg = opt_video_codec },
3510 "force video codec ('copy' to copy stream)", "codec" },
3511 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3513 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3515 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3516 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3517 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3518 "select the pass number (1 to 3)", "n" },
3519 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3520 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3521 "select two pass log file name prefix", "prefix" },
3522 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3523 "this option is deprecated, use the yadif filter instead" },
3524 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3525 "calculate PSNR of compressed frames" },
3526 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3527 "dump video coding statistics to file" },
3528 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3529 "dump video coding statistics to file", "file" },
3530 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3531 "set video filters", "filter_graph" },
3532 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3533 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3534 "specify intra matrix coeffs", "matrix" },
3535 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3536 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3537 "specify inter matrix coeffs", "matrix" },
3538 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3539 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3540 "specify intra matrix coeffs", "matrix" },
3541 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3542 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3543 "top=1/bottom=0/auto=-1 field first", "" },
3544 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3545 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3546 "force video tag/fourcc", "fourcc/tag" },
3547 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3548 "show QP histogram" },
3549 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3550 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3551 "force the selected framerate, disable the best supported framerate selection" },
3552 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3553 OPT_OUTPUT, { .func_arg = opt_streamid },
3554 "set the value of an outfile streamid", "streamIndex:value" },
3555 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3556 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3557 "force key frames at specified timestamps", "timestamps" },
3558 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3559 "audio bitrate (please use -b:a)", "bitrate" },
3560 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3561 "video bitrate (please use -b:v)", "bitrate" },
3562 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3563 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3564 "use HW accelerated decoding", "hwaccel name" },
3565 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3566 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3567 "select a device for HW acceleration", "devicename" },
3568 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3569 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3570 "select output format used with HW accelerated decoding", "format" },
3571 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3572 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3574 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3575 "show available HW acceleration methods" },
3576 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3577 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3578 "automatically insert correct rotate filters" },
3579 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3580 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3583 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3584 "set the number of audio frames to output", "number" },
3585 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3586 "set audio quality (codec-specific)", "quality", },
3587 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3588 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3589 "set audio sampling rate (in Hz)", "rate" },
3590 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3591 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3592 "set number of audio channels", "channels" },
3593 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3595 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3596 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3597 "force audio codec ('copy' to copy stream)", "codec" },
3598 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3599 OPT_OUTPUT, { .func_arg = opt_old2new },
3600 "force audio tag/fourcc", "fourcc/tag" },
3601 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3602 "change audio volume (256=normal)" , "volume" },
3603 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3604 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3605 "set sample format", "format" },
3606 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3607 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3608 "set channel layout", "layout" },
3609 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3610 "set audio filters", "filter_graph" },
3611 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3612 "set the maximum number of channels to try to guess the channel layout" },
3614 /* subtitle options */
3615 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3616 "disable subtitle" },
3617 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3618 "force subtitle codec ('copy' to copy stream)", "codec" },
3619 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3620 , "force subtitle tag/fourcc", "fourcc/tag" },
3621 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3622 "fix subtitles duration" },
3623 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3624 "set canvas size (WxH or abbreviation)", "size" },
3627 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3628 "deprecated, use -channel", "channel" },
3629 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3630 "deprecated, use -standard", "standard" },
3631 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3634 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3635 "set the maximum demux-decode delay", "seconds" },
3636 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3637 "set the initial demux-decode delay", "seconds" },
3638 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3639 "override the options from ffserver", "" },
3640 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3641 "specify a file in which to print sdp information", "file" },
3643 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3644 "A comma-separated list of bitstream filters", "bitstream_filters" },
3645 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3646 "deprecated", "audio bitstream_filters" },
3647 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3648 "deprecated", "video bitstream_filters" },
3650 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3651 "set the audio options to the indicated preset", "preset" },
3652 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3653 "set the video options to the indicated preset", "preset" },
3654 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3655 "set the subtitle options to the indicated preset", "preset" },
3656 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3657 "set options from indicated preset file", "filename" },
3659 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3660 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3662 /* data codec support */
3663 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3664 "force data codec ('copy' to copy stream)", "codec" },
3665 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3669 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3670 "set VAAPI hardware device (DRM path or X11 display name)", "device" },