2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
70 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
73 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
76 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
78 #if CONFIG_VIDEOTOOLBOX
79 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
82 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
85 { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
88 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
92 int hwaccel_lax_profile_check = 0;
93 AVBufferRef *hw_device_ctx;
95 char *vstats_filename;
98 float audio_drift_threshold = 0.1;
99 float dts_delta_threshold = 10;
100 float dts_error_threshold = 3600*30;
102 int audio_volume = 256;
103 int audio_sync_method = 0;
104 int video_sync_method = VSYNC_AUTO;
105 float frame_drop_threshold = 0;
106 int do_deinterlace = 0;
107 int do_benchmark = 0;
108 int do_benchmark_all = 0;
112 int start_at_zero = 0;
115 int exit_on_error = 0;
116 int abort_on_flags = 0;
117 int print_stats = -1;
119 int stdin_interaction = 1;
120 int frame_bits_per_raw_sample = 0;
121 float max_error_rate = 2.0/3;
124 static int intra_only = 0;
125 static int file_overwrite = 0;
126 static int no_file_overwrite = 0;
127 static int do_psnr = 0;
128 static int input_sync;
129 static int override_ffserver = 0;
130 static int input_stream_potentially_available = 0;
131 static int ignore_unknown_streams = 0;
132 static int copy_unknown_streams = 0;
134 static void uninit_options(OptionsContext *o)
136 const OptionDef *po = options;
139 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
141 void *dst = (uint8_t*)o + po->u.off;
143 if (po->flags & OPT_SPEC) {
144 SpecifierOpt **so = dst;
145 int i, *count = (int*)(so + 1);
146 for (i = 0; i < *count; i++) {
147 av_freep(&(*so)[i].specifier);
148 if (po->flags & OPT_STRING)
149 av_freep(&(*so)[i].u.str);
153 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
158 for (i = 0; i < o->nb_stream_maps; i++)
159 av_freep(&o->stream_maps[i].linklabel);
160 av_freep(&o->stream_maps);
161 av_freep(&o->audio_channel_maps);
162 av_freep(&o->streamid_map);
163 av_freep(&o->attachments);
166 static void init_options(OptionsContext *o)
168 memset(o, 0, sizeof(*o));
170 o->stop_time = INT64_MAX;
171 o->mux_max_delay = 0.7;
172 o->start_time = AV_NOPTS_VALUE;
173 o->start_time_eof = AV_NOPTS_VALUE;
174 o->recording_time = INT64_MAX;
175 o->limit_filesize = UINT64_MAX;
176 o->chapters_input_file = INT_MAX;
177 o->accurate_seek = 1;
180 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
184 printf("Hardware acceleration methods:\n");
185 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
186 printf("%s\n", hwaccels[i].name);
192 /* return a copy of the input with the stream specifiers removed from the keys */
193 static AVDictionary *strip_specifiers(AVDictionary *dict)
195 AVDictionaryEntry *e = NULL;
196 AVDictionary *ret = NULL;
198 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
199 char *p = strchr(e->key, ':');
203 av_dict_set(&ret, e->key, e->value, 0);
210 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
212 static const AVOption opts[] = {
213 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
214 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
217 static const AVClass class = {
219 .item_name = av_default_item_name,
221 .version = LIBAVUTIL_VERSION_INT,
223 const AVClass *pclass = &class;
225 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
228 static int opt_sameq(void *optctx, const char *opt, const char *arg)
230 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
231 "If you are looking for an option to preserve the quality (which is not "
232 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
234 return AVERROR(EINVAL);
237 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
239 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
240 return opt_default(optctx, "channel", arg);
243 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
245 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
246 return opt_default(optctx, "standard", arg);
249 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
251 OptionsContext *o = optctx;
252 return parse_option(o, "codec:a", arg, options);
255 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
257 OptionsContext *o = optctx;
258 return parse_option(o, "codec:v", arg, options);
261 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
263 OptionsContext *o = optctx;
264 return parse_option(o, "codec:s", arg, options);
267 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
269 OptionsContext *o = optctx;
270 return parse_option(o, "codec:d", arg, options);
273 static int opt_map(void *optctx, const char *opt, const char *arg)
275 OptionsContext *o = optctx;
277 int i, negative = 0, file_idx;
278 int sync_file_idx = -1, sync_stream_idx = 0;
287 map = av_strdup(arg);
289 return AVERROR(ENOMEM);
291 /* parse sync stream first, just pick first matching stream */
292 if (sync = strchr(map, ',')) {
294 sync_file_idx = strtol(sync + 1, &sync, 0);
295 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
296 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
301 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
302 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
303 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
307 if (i == input_files[sync_file_idx]->nb_streams) {
308 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
309 "match any streams.\n", arg);
316 /* this mapping refers to lavfi output */
317 const char *c = map + 1;
318 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
319 m = &o->stream_maps[o->nb_stream_maps - 1];
320 m->linklabel = av_get_token(&c, "]");
322 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
326 if (allow_unused = strchr(map, '?'))
328 file_idx = strtol(map, &p, 0);
329 if (file_idx >= nb_input_files || file_idx < 0) {
330 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
334 /* disable some already defined maps */
335 for (i = 0; i < o->nb_stream_maps; i++) {
336 m = &o->stream_maps[i];
337 if (file_idx == m->file_index &&
338 check_stream_specifier(input_files[m->file_index]->ctx,
339 input_files[m->file_index]->ctx->streams[m->stream_index],
340 *p == ':' ? p + 1 : p) > 0)
344 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
345 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
346 *p == ':' ? p + 1 : p) <= 0)
348 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
349 m = &o->stream_maps[o->nb_stream_maps - 1];
351 m->file_index = file_idx;
354 if (sync_file_idx >= 0) {
355 m->sync_file_index = sync_file_idx;
356 m->sync_stream_index = sync_stream_idx;
358 m->sync_file_index = file_idx;
359 m->sync_stream_index = i;
366 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
368 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
369 "To ignore this, add a trailing '?' to the map.\n", arg);
378 static int opt_attach(void *optctx, const char *opt, const char *arg)
380 OptionsContext *o = optctx;
381 GROW_ARRAY(o->attachments, o->nb_attachments);
382 o->attachments[o->nb_attachments - 1] = arg;
386 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
388 OptionsContext *o = optctx;
393 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
394 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
396 /* muted channel syntax */
397 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
398 if ((n == 1 || n == 3) && m->channel_idx == -1) {
399 m->file_idx = m->stream_idx = -1;
401 m->ofile_idx = m->ostream_idx = -1;
406 n = sscanf(arg, "%d.%d.%d:%d.%d",
407 &m->file_idx, &m->stream_idx, &m->channel_idx,
408 &m->ofile_idx, &m->ostream_idx);
410 if (n != 3 && n != 5) {
411 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
412 "[file.stream.channel|-1][:syncfile:syncstream]\n");
416 if (n != 5) // only file.stream.channel specified
417 m->ofile_idx = m->ostream_idx = -1;
420 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
421 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
425 if (m->stream_idx < 0 ||
426 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
427 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
428 m->file_idx, m->stream_idx);
431 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
432 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
433 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
434 m->file_idx, m->stream_idx);
437 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
438 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
439 m->file_idx, m->stream_idx, m->channel_idx);
445 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
447 av_free(sdp_filename);
448 sdp_filename = av_strdup(arg);
453 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
456 err = vaapi_device_init(arg);
464 * Parse a metadata specifier passed as 'arg' parameter.
465 * @param arg metadata string to parse
466 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
467 * @param index for type c/p, chapter/program index is written here
468 * @param stream_spec for type s, the stream specifier is written here
470 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
478 if (*(++arg) && *arg != ':') {
479 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
482 *stream_spec = *arg == ':' ? arg + 1 : "";
487 *index = strtol(++arg, NULL, 0);
490 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
497 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
499 AVDictionary **meta_in = NULL;
500 AVDictionary **meta_out = NULL;
502 char type_in, type_out;
503 const char *istream_spec = NULL, *ostream_spec = NULL;
504 int idx_in = 0, idx_out = 0;
506 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
507 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
510 if (type_out == 'g' || !*outspec)
511 o->metadata_global_manual = 1;
512 if (type_out == 's' || !*outspec)
513 o->metadata_streams_manual = 1;
514 if (type_out == 'c' || !*outspec)
515 o->metadata_chapters_manual = 1;
519 if (type_in == 'g' || type_out == 'g')
520 o->metadata_global_manual = 1;
521 if (type_in == 's' || type_out == 's')
522 o->metadata_streams_manual = 1;
523 if (type_in == 'c' || type_out == 'c')
524 o->metadata_chapters_manual = 1;
526 /* ic is NULL when just disabling automatic mappings */
530 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
531 if ((index) < 0 || (index) >= (nb_elems)) {\
532 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
537 #define SET_DICT(type, meta, context, index)\
540 meta = &context->metadata;\
543 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
544 meta = &context->chapters[index]->metadata;\
547 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
548 meta = &context->programs[index]->metadata;\
551 break; /* handled separately below */ \
552 default: av_assert0(0);\
555 SET_DICT(type_in, meta_in, ic, idx_in);
556 SET_DICT(type_out, meta_out, oc, idx_out);
558 /* for input streams choose first matching stream */
559 if (type_in == 's') {
560 for (i = 0; i < ic->nb_streams; i++) {
561 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
562 meta_in = &ic->streams[i]->metadata;
568 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
573 if (type_out == 's') {
574 for (i = 0; i < oc->nb_streams; i++) {
575 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
576 meta_out = &oc->streams[i]->metadata;
577 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
582 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
587 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
589 OptionsContext *o = optctx;
591 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
592 struct tm time = *gmtime((time_t*)&recording_timestamp);
593 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
595 parse_option(o, "metadata", buf, options);
597 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
598 "tag instead.\n", opt);
602 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
604 const AVCodecDescriptor *desc;
605 const char *codec_string = encoder ? "encoder" : "decoder";
609 avcodec_find_encoder_by_name(name) :
610 avcodec_find_decoder_by_name(name);
612 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
613 codec = encoder ? avcodec_find_encoder(desc->id) :
614 avcodec_find_decoder(desc->id);
616 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
617 codec_string, codec->name, desc->name);
621 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
624 if (codec->type != type) {
625 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
631 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
633 char *codec_name = NULL;
635 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
637 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
638 st->codec->codec_id = codec->id;
641 return avcodec_find_decoder(st->codec->codec_id);
644 /* Add all the streams from the given input file to the global
645 * list of input streams. */
646 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
650 for (i = 0; i < ic->nb_streams; i++) {
651 AVStream *st = ic->streams[i];
652 AVCodecContext *dec = st->codec;
653 InputStream *ist = av_mallocz(sizeof(*ist));
654 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
655 char *hwaccel_output_format = NULL;
656 char *codec_tag = NULL;
658 char *discard_str = NULL;
659 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
664 GROW_ARRAY(input_streams, nb_input_streams);
665 input_streams[nb_input_streams - 1] = ist;
668 ist->file_index = nb_input_files;
670 st->discard = AVDISCARD_ALL;
672 ist->min_pts = INT64_MAX;
673 ist->max_pts = INT64_MIN;
676 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
679 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
681 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
683 uint32_t tag = strtol(codec_tag, &next, 0);
685 tag = AV_RL32(codec_tag);
686 st->codec->codec_tag = tag;
689 ist->dec = choose_decoder(o, ic, st);
690 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
692 ist->reinit_filters = -1;
693 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
695 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
696 ist->user_set_discard = AVDISCARD_NONE;
697 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
698 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
703 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
705 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
707 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
711 ret = avcodec_copy_context(ist->dec_ctx, dec);
713 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
717 switch (dec->codec_type) {
718 case AVMEDIA_TYPE_VIDEO:
720 ist->dec = avcodec_find_decoder(dec->codec_id);
722 if (av_codec_get_lowres(dec)) {
723 dec->flags |= CODEC_FLAG_EMU_EDGE;
727 ist->resample_height = ist->dec_ctx->height;
728 ist->resample_width = ist->dec_ctx->width;
729 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
731 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
732 if (framerate && av_parse_video_rate(&ist->framerate,
734 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
739 ist->top_field_first = -1;
740 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
742 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
744 if (!strcmp(hwaccel, "none"))
745 ist->hwaccel_id = HWACCEL_NONE;
746 else if (!strcmp(hwaccel, "auto"))
747 ist->hwaccel_id = HWACCEL_AUTO;
750 for (i = 0; hwaccels[i].name; i++) {
751 if (!strcmp(hwaccels[i].name, hwaccel)) {
752 ist->hwaccel_id = hwaccels[i].id;
757 if (!ist->hwaccel_id) {
758 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
760 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
761 for (i = 0; hwaccels[i].name; i++)
762 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
763 av_log(NULL, AV_LOG_FATAL, "\n");
769 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
770 if (hwaccel_device) {
771 ist->hwaccel_device = av_strdup(hwaccel_device);
772 if (!ist->hwaccel_device)
776 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
777 hwaccel_output_format, ic, st);
778 if (hwaccel_output_format) {
779 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
780 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
781 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
782 "format: %s", hwaccel_output_format);
785 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
788 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
791 case AVMEDIA_TYPE_AUDIO:
792 ist->guess_layout_max = INT_MAX;
793 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
794 guess_input_channel_layout(ist);
796 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
797 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
798 ist->resample_channels = ist->dec_ctx->channels;
799 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
802 case AVMEDIA_TYPE_DATA:
803 case AVMEDIA_TYPE_SUBTITLE: {
804 char *canvas_size = NULL;
806 ist->dec = avcodec_find_decoder(dec->codec_id);
807 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
808 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
810 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
811 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
816 case AVMEDIA_TYPE_ATTACHMENT:
817 case AVMEDIA_TYPE_UNKNOWN:
825 static void assert_file_overwrite(const char *filename)
827 if (file_overwrite && no_file_overwrite) {
828 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
832 if (!file_overwrite) {
833 const char *proto_name = avio_find_protocol_name(filename);
834 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
835 if (stdin_interaction && !no_file_overwrite) {
836 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
839 signal(SIGINT, SIG_DFL);
841 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
847 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
854 static void dump_attachment(AVStream *st, const char *filename)
857 AVIOContext *out = NULL;
858 AVDictionaryEntry *e;
860 if (!st->codec->extradata_size) {
861 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
862 nb_input_files - 1, st->index);
865 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
868 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
869 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
873 assert_file_overwrite(filename);
875 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
876 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
881 avio_write(out, st->codec->extradata, st->codec->extradata_size);
886 static int open_input_file(OptionsContext *o, const char *filename)
890 AVInputFormat *file_iformat = NULL;
894 AVDictionary *unused_opts = NULL;
895 AVDictionaryEntry *e = NULL;
896 int orig_nb_streams; // number of streams before avformat_find_stream_info
897 char * video_codec_name = NULL;
898 char * audio_codec_name = NULL;
899 char *subtitle_codec_name = NULL;
900 char * data_codec_name = NULL;
901 int scan_all_pmts_set = 0;
904 if (!(file_iformat = av_find_input_format(o->format))) {
905 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
910 if (!strcmp(filename, "-"))
913 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
914 strcmp(filename, "/dev/stdin");
916 /* get default parameters from command line */
917 ic = avformat_alloc_context();
919 print_error(filename, AVERROR(ENOMEM));
922 if (o->nb_audio_sample_rate) {
923 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
925 if (o->nb_audio_channels) {
926 /* because we set audio_channels based on both the "ac" and
927 * "channel_layout" options, we need to check that the specified
928 * demuxer actually has the "channels" option before setting it */
929 if (file_iformat && file_iformat->priv_class &&
930 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
931 AV_OPT_SEARCH_FAKE_OBJ)) {
932 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
935 if (o->nb_frame_rates) {
936 /* set the format-level framerate option;
937 * this is important for video grabbers, e.g. x11 */
938 if (file_iformat && file_iformat->priv_class &&
939 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
940 AV_OPT_SEARCH_FAKE_OBJ)) {
941 av_dict_set(&o->g->format_opts, "framerate",
942 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
945 if (o->nb_frame_sizes) {
946 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
948 if (o->nb_frame_pix_fmts)
949 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
951 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
952 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
953 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
954 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
956 ic->video_codec_id = video_codec_name ?
957 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
958 ic->audio_codec_id = audio_codec_name ?
959 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
960 ic->subtitle_codec_id= subtitle_codec_name ?
961 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
962 ic->data_codec_id = data_codec_name ?
963 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
965 if (video_codec_name)
966 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
967 if (audio_codec_name)
968 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
969 if (subtitle_codec_name)
970 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
972 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
974 ic->flags |= AVFMT_FLAG_NONBLOCK;
975 ic->interrupt_callback = int_cb;
977 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
978 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
979 scan_all_pmts_set = 1;
981 /* open the input file with generic avformat function */
982 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
984 print_error(filename, err);
985 if (err == AVERROR_PROTOCOL_NOT_FOUND)
986 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
989 if (scan_all_pmts_set)
990 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
991 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
992 assert_avoptions(o->g->format_opts);
994 /* apply forced codec ids */
995 for (i = 0; i < ic->nb_streams; i++)
996 choose_decoder(o, ic, ic->streams[i]);
998 /* Set AVCodecContext options for avformat_find_stream_info */
999 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1000 orig_nb_streams = ic->nb_streams;
1002 /* If not enough info to get the stream parameters, we decode the
1003 first frames to get it. (used in mpeg case for example) */
1004 ret = avformat_find_stream_info(ic, opts);
1006 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1007 if (ic->nb_streams == 0) {
1008 avformat_close_input(&ic);
1013 if (o->start_time_eof != AV_NOPTS_VALUE) {
1014 if (ic->duration>0) {
1015 o->start_time = o->start_time_eof + ic->duration;
1017 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1019 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1020 /* add the stream start time */
1021 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1022 timestamp += ic->start_time;
1024 /* if seeking requested, we execute it */
1025 if (o->start_time != AV_NOPTS_VALUE) {
1026 int64_t seek_timestamp = timestamp;
1028 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1029 int dts_heuristic = 0;
1030 for (i=0; i<ic->nb_streams; i++) {
1031 AVCodecContext *avctx = ic->streams[i]->codec;
1032 if (avctx->has_b_frames)
1035 if (dts_heuristic) {
1036 seek_timestamp -= 3*AV_TIME_BASE / 23;
1039 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1041 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1042 filename, (double)timestamp / AV_TIME_BASE);
1046 /* update the current parameters so that they match the one of the input stream */
1047 add_input_streams(o, ic);
1049 /* dump the file content */
1050 av_dump_format(ic, nb_input_files, filename, 0);
1052 GROW_ARRAY(input_files, nb_input_files);
1053 f = av_mallocz(sizeof(*f));
1056 input_files[nb_input_files - 1] = f;
1059 f->ist_index = nb_input_streams - ic->nb_streams;
1060 f->start_time = o->start_time;
1061 f->recording_time = o->recording_time;
1062 f->input_ts_offset = o->input_ts_offset;
1063 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1064 f->nb_streams = ic->nb_streams;
1065 f->rate_emu = o->rate_emu;
1066 f->accurate_seek = o->accurate_seek;
1069 f->time_base = (AVRational){ 1, 1 };
1071 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1074 /* check if all codec options have been used */
1075 unused_opts = strip_specifiers(o->g->codec_opts);
1076 for (i = f->ist_index; i < nb_input_streams; i++) {
1078 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1079 AV_DICT_IGNORE_SUFFIX)))
1080 av_dict_set(&unused_opts, e->key, NULL, 0);
1084 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1085 const AVClass *class = avcodec_get_class();
1086 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1087 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1088 const AVClass *fclass = avformat_get_class();
1089 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1090 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1091 if (!option || foption)
1095 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1096 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1097 "input file #%d (%s) is not a decoding option.\n", e->key,
1098 option->help ? option->help : "", nb_input_files - 1,
1103 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1104 "input file #%d (%s) has not been used for any stream. The most "
1105 "likely reason is either wrong type (e.g. a video option with "
1106 "no video streams) or that it is a private option of some decoder "
1107 "which was not actually used for any stream.\n", e->key,
1108 option->help ? option->help : "", nb_input_files - 1, filename);
1110 av_dict_free(&unused_opts);
1112 for (i = 0; i < o->nb_dump_attachment; i++) {
1115 for (j = 0; j < ic->nb_streams; j++) {
1116 AVStream *st = ic->streams[j];
1118 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1119 dump_attachment(st, o->dump_attachment[i].u.str);
1123 for (i = 0; i < orig_nb_streams; i++)
1124 av_dict_free(&opts[i]);
1127 input_stream_potentially_available = 1;
1132 static uint8_t *get_line(AVIOContext *s)
1138 if (avio_open_dyn_buf(&line) < 0) {
1139 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1143 while ((c = avio_r8(s)) && c != '\n')
1146 avio_close_dyn_buf(line, &buf);
1151 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1154 char filename[1000];
1155 const char *base[3] = { getenv("AVCONV_DATADIR"),
1160 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1164 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1165 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1166 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1169 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1170 i != 1 ? "" : "/.avconv", preset_name);
1171 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1177 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1179 enum AVMediaType type = ost->st->codec->codec_type;
1180 char *codec_name = NULL;
1182 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1183 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1185 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1186 NULL, ost->st->codec->codec_type);
1187 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1189 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1190 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1191 "probably disabled. Please choose an encoder manually.\n",
1192 ost->file_index, ost->index, s->oformat->name,
1193 avcodec_get_name(ost->st->codec->codec_id));
1194 return AVERROR_ENCODER_NOT_FOUND;
1196 } else if (!strcmp(codec_name, "copy"))
1197 ost->stream_copy = 1;
1199 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1200 ost->st->codec->codec_id = ost->enc->id;
1202 ost->encoding_needed = !ost->stream_copy;
1204 /* no encoding supported for other media types */
1205 ost->stream_copy = 1;
1206 ost->encoding_needed = 0;
1212 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1215 AVStream *st = avformat_new_stream(oc, NULL);
1216 int idx = oc->nb_streams - 1, ret = 0;
1217 char *bsf = NULL, *next, *codec_tag = NULL;
1218 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1223 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1227 if (oc->nb_streams - 1 < o->nb_streamid_map)
1228 st->id = o->streamid_map[oc->nb_streams - 1];
1230 GROW_ARRAY(output_streams, nb_output_streams);
1231 if (!(ost = av_mallocz(sizeof(*ost))))
1233 output_streams[nb_output_streams - 1] = ost;
1235 ost->file_index = nb_output_files - 1;
1238 st->codec->codec_type = type;
1240 ret = choose_encoder(o, oc, ost);
1242 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1243 "%d:%d\n", ost->file_index, ost->index);
1247 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1248 if (!ost->enc_ctx) {
1249 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1252 ost->enc_ctx->codec_type = type;
1255 AVIOContext *s = NULL;
1256 char *buf = NULL, *arg = NULL, *preset = NULL;
1258 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1260 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1261 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1264 if (!buf[0] || buf[0] == '#') {
1268 if (!(arg = strchr(buf, '='))) {
1269 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1273 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1275 } while (!s->eof_reached);
1279 av_log(NULL, AV_LOG_FATAL,
1280 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1281 preset, ost->file_index, ost->index);
1285 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1288 ost->max_frames = INT64_MAX;
1289 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1290 for (i = 0; i<o->nb_max_frames; i++) {
1291 char *p = o->max_frames[i].specifier;
1292 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1293 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1298 ost->copy_prior_start = -1;
1299 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1301 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1304 if (next = strchr(bsf, ','))
1306 if (arg = strchr(bsf, '='))
1308 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1309 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1313 bsfc_prev->next = bsfc;
1315 ost->bitstream_filters = bsfc;
1317 if (!(bsfc->args = av_strdup(arg))) {
1318 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1326 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1328 uint32_t tag = strtol(codec_tag, &next, 0);
1330 tag = AV_RL32(codec_tag);
1331 ost->st->codec->codec_tag =
1332 ost->enc_ctx->codec_tag = tag;
1335 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1337 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1338 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1341 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1342 ost->disposition = av_strdup(ost->disposition);
1344 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1345 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1347 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1349 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1350 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1351 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1353 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1355 ost->source_index = source_index;
1356 if (source_index >= 0) {
1357 ost->sync_ist = input_streams[source_index];
1358 input_streams[source_index]->discard = 0;
1359 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1361 ost->last_mux_dts = AV_NOPTS_VALUE;
1366 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1369 const char *p = str;
1376 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1383 /* read file contents into a string */
1384 static uint8_t *read_file(const char *filename)
1386 AVIOContext *pb = NULL;
1387 AVIOContext *dyn_buf = NULL;
1388 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1389 uint8_t buf[1024], *str;
1392 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1396 ret = avio_open_dyn_buf(&dyn_buf);
1401 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1402 avio_write(dyn_buf, buf, ret);
1403 avio_w8(dyn_buf, 0);
1406 ret = avio_close_dyn_buf(dyn_buf, &str);
1412 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1415 AVStream *st = ost->st;
1417 if (ost->filters_script && ost->filters) {
1418 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1419 "output stream #%d:%d.\n", nb_output_files, st->index);
1423 if (ost->filters_script)
1424 return read_file(ost->filters_script);
1425 else if (ost->filters)
1426 return av_strdup(ost->filters);
1428 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1432 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1433 const OutputStream *ost, enum AVMediaType type)
1435 if (ost->filters_script || ost->filters) {
1436 av_log(NULL, AV_LOG_ERROR,
1437 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1438 "Filtering and streamcopy cannot be used together.\n",
1439 ost->filters ? "Filtergraph" : "Filtergraph script",
1440 ost->filters ? ost->filters : ost->filters_script,
1441 av_get_media_type_string(type), ost->file_index, ost->index);
1446 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1450 AVCodecContext *video_enc;
1451 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1453 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1455 video_enc = ost->enc_ctx;
1457 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1458 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1459 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1462 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1463 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1465 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1466 if (frame_aspect_ratio) {
1468 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1469 q.num <= 0 || q.den <= 0) {
1470 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1473 ost->frame_aspect_ratio = q;
1476 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1477 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1479 if (!ost->stream_copy) {
1480 const char *p = NULL;
1481 char *frame_size = NULL;
1482 char *frame_pix_fmt = NULL;
1483 char *intra_matrix = NULL, *inter_matrix = NULL;
1484 char *chroma_intra_matrix = NULL;
1488 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1489 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1490 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1494 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1495 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1496 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1497 ost->keep_pix_fmt = 1;
1498 if (!*++frame_pix_fmt)
1499 frame_pix_fmt = NULL;
1501 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1502 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1505 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1508 video_enc->gop_size = 0;
1509 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1511 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1512 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1515 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1517 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1518 if (chroma_intra_matrix) {
1519 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1521 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1524 av_codec_set_chroma_intra_matrix(video_enc, p);
1525 parse_matrix_coeffs(p, chroma_intra_matrix);
1527 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1529 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1530 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1533 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1536 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1537 for (i = 0; p; i++) {
1539 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1541 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1544 video_enc->rc_override =
1545 av_realloc_array(video_enc->rc_override,
1546 i + 1, sizeof(RcOverride));
1547 if (!video_enc->rc_override) {
1548 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1551 video_enc->rc_override[i].start_frame = start;
1552 video_enc->rc_override[i].end_frame = end;
1554 video_enc->rc_override[i].qscale = q;
1555 video_enc->rc_override[i].quality_factor = 1.0;
1558 video_enc->rc_override[i].qscale = 0;
1559 video_enc->rc_override[i].quality_factor = -q/100.0;
1564 video_enc->rc_override_count = i;
1567 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1570 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1573 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1574 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1577 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1578 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1582 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1583 if (ost->logfile_prefix &&
1584 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1588 char logfilename[1024];
1591 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1592 ost->logfile_prefix ? ost->logfile_prefix :
1593 DEFAULT_PASS_LOGFILENAME_PREFIX,
1595 if (!strcmp(ost->enc->name, "libx264")) {
1596 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1598 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1599 char *logbuffer = read_file(logfilename);
1602 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1606 video_enc->stats_in = logbuffer;
1608 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1609 f = av_fopen_utf8(logfilename, "wb");
1611 av_log(NULL, AV_LOG_FATAL,
1612 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1613 logfilename, strerror(errno));
1621 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1622 if (ost->forced_keyframes)
1623 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1625 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1627 ost->top_field_first = -1;
1628 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1631 ost->avfilter = get_ost_filters(o, oc, ost);
1635 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1638 if (ost->stream_copy)
1639 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1644 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1649 AVCodecContext *audio_enc;
1651 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1654 audio_enc = ost->enc_ctx;
1655 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1657 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1658 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1660 if (!ost->stream_copy) {
1661 char *sample_fmt = NULL;
1663 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1665 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1667 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1668 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1672 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1674 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1675 ost->apad = av_strdup(ost->apad);
1677 ost->avfilter = get_ost_filters(o, oc, ost);
1681 /* check for channel mapping for this audio stream */
1682 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1683 AudioChannelMap *map = &o->audio_channel_maps[n];
1684 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1685 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1688 if (map->channel_idx == -1) {
1690 } else if (ost->source_index < 0) {
1691 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1692 ost->file_index, ost->st->index);
1695 ist = input_streams[ost->source_index];
1698 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1699 if (av_reallocp_array(&ost->audio_channels_map,
1700 ost->audio_channels_mapped + 1,
1701 sizeof(*ost->audio_channels_map)
1705 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1711 if (ost->stream_copy)
1712 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1717 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1721 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1722 if (!ost->stream_copy) {
1723 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1730 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1734 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1735 if (!ost->stream_copy) {
1736 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1743 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1745 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1746 ost->stream_copy = 1;
1751 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1755 AVCodecContext *subtitle_enc;
1757 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1759 subtitle_enc = ost->enc_ctx;
1761 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1763 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1765 if (!ost->stream_copy) {
1766 char *frame_size = NULL;
1768 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1769 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1770 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1778 /* arg format is "output-stream-index:streamid-value". */
1779 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1781 OptionsContext *o = optctx;
1786 av_strlcpy(idx_str, arg, sizeof(idx_str));
1787 p = strchr(idx_str, ':');
1789 av_log(NULL, AV_LOG_FATAL,
1790 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1795 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1796 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1797 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1801 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1803 AVFormatContext *is = ifile->ctx;
1804 AVFormatContext *os = ofile->ctx;
1808 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1810 return AVERROR(ENOMEM);
1813 for (i = 0; i < is->nb_chapters; i++) {
1814 AVChapter *in_ch = is->chapters[i], *out_ch;
1815 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1816 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1817 AV_TIME_BASE_Q, in_ch->time_base);
1818 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1819 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1822 if (in_ch->end < ts_off)
1824 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1827 out_ch = av_mallocz(sizeof(AVChapter));
1829 return AVERROR(ENOMEM);
1831 out_ch->id = in_ch->id;
1832 out_ch->time_base = in_ch->time_base;
1833 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1834 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1837 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1839 os->chapters[os->nb_chapters++] = out_ch;
1844 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1847 AVFormatContext *ic = avformat_alloc_context();
1849 ic->interrupt_callback = int_cb;
1850 err = avformat_open_input(&ic, filename, NULL, NULL);
1853 /* copy stream format */
1854 for(i=0;i<ic->nb_streams;i++) {
1858 const char *enc_config;
1860 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1862 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1863 return AVERROR(EINVAL);
1865 if (codec->type == AVMEDIA_TYPE_AUDIO)
1866 opt_audio_codec(o, "c:a", codec->name);
1867 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1868 opt_video_codec(o, "c:v", codec->name);
1869 ost = new_output_stream(o, s, codec->type, -1);
1872 avcodec_get_context_defaults3(st->codec, codec);
1873 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1875 AVDictionary *opts = NULL;
1876 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1877 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1878 av_dict_free(&opts);
1881 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1882 choose_sample_fmt(st, codec);
1883 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1884 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1885 avcodec_copy_context(ost->enc_ctx, st->codec);
1887 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1890 avformat_close_input(&ic);
1894 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1895 AVFormatContext *oc)
1899 switch (ofilter->type) {
1900 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1901 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1903 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1908 ost->source_index = -1;
1909 ost->filter = ofilter;
1913 if (ost->stream_copy) {
1914 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1915 "which is fed from a complex filtergraph. Filtering and streamcopy "
1916 "cannot be used together.\n", ost->file_index, ost->index);
1920 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1921 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1922 av_log(NULL, AV_LOG_ERROR,
1923 "%s '%s' was specified through the %s option "
1924 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1925 "%s and -filter_complex cannot be used together for the same stream.\n",
1926 ost->filters ? "Filtergraph" : "Filtergraph script",
1927 ost->filters ? ost->filters : ost->filters_script,
1928 opt, ost->file_index, ost->index, opt);
1932 avfilter_inout_free(&ofilter->out_tmp);
1935 static int init_complex_filters(void)
1939 for (i = 0; i < nb_filtergraphs; i++) {
1940 ret = init_complex_filtergraph(filtergraphs[i]);
1947 static int configure_complex_filters(void)
1951 for (i = 0; i < nb_filtergraphs; i++)
1952 if (!filtergraph_is_simple(filtergraphs[i]) &&
1953 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1958 static int open_output_file(OptionsContext *o, const char *filename)
1960 AVFormatContext *oc;
1962 AVOutputFormat *file_oformat;
1966 AVDictionary *unused_opts = NULL;
1967 AVDictionaryEntry *e = NULL;
1970 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1971 o->stop_time = INT64_MAX;
1972 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1975 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1976 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1977 if (o->stop_time <= start_time) {
1978 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1981 o->recording_time = o->stop_time - start_time;
1985 GROW_ARRAY(output_files, nb_output_files);
1986 of = av_mallocz(sizeof(*of));
1989 output_files[nb_output_files - 1] = of;
1991 of->ost_index = nb_output_streams;
1992 of->recording_time = o->recording_time;
1993 of->start_time = o->start_time;
1994 of->limit_filesize = o->limit_filesize;
1995 of->shortest = o->shortest;
1996 av_dict_copy(&of->opts, o->g->format_opts, 0);
1998 if (!strcmp(filename, "-"))
2001 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2003 print_error(filename, err);
2008 if (o->recording_time != INT64_MAX)
2009 oc->duration = o->recording_time;
2011 file_oformat= oc->oformat;
2012 oc->interrupt_callback = int_cb;
2014 /* create streams for all unlabeled output pads */
2015 for (i = 0; i < nb_filtergraphs; i++) {
2016 FilterGraph *fg = filtergraphs[i];
2017 for (j = 0; j < fg->nb_outputs; j++) {
2018 OutputFilter *ofilter = fg->outputs[j];
2020 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2023 switch (ofilter->type) {
2024 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2025 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2026 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2028 init_output_filter(ofilter, o, oc);
2032 /* ffserver seeking with date=... needs a date reference */
2033 if (!strcmp(file_oformat->name, "ffm") &&
2034 av_strstart(filename, "http:", NULL)) {
2035 int err = parse_option(o, "metadata", "creation_time=now", options);
2037 print_error(filename, err);
2042 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2043 av_strstart(filename, "http:", NULL)) {
2045 /* special case for files sent to ffserver: we get the stream
2046 parameters from ffserver */
2047 int err = read_ffserver_streams(o, oc, filename);
2049 print_error(filename, err);
2052 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2053 ost = output_streams[j];
2054 for (i = 0; i < nb_input_streams; i++) {
2055 ist = input_streams[i];
2056 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
2058 ost->source_index= i;
2059 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2060 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2062 ist->st->discard = ist->user_set_discard;
2067 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
2071 } else if (!o->nb_stream_maps) {
2072 char *subtitle_codec_name = NULL;
2073 /* pick the "best" stream of each type */
2075 /* video: highest resolution */
2076 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2077 int area = 0, idx = -1;
2078 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2079 for (i = 0; i < nb_input_streams; i++) {
2081 ist = input_streams[i];
2082 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
2083 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2085 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2087 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2094 new_video_stream(o, oc, idx);
2097 /* audio: most channels */
2098 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2099 int best_score = 0, idx = -1;
2100 for (i = 0; i < nb_input_streams; i++) {
2102 ist = input_streams[i];
2103 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2104 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2105 score > best_score) {
2111 new_audio_stream(o, oc, idx);
2114 /* subtitles: pick first */
2115 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2116 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2117 for (i = 0; i < nb_input_streams; i++)
2118 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2119 AVCodecDescriptor const *input_descriptor =
2120 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2121 AVCodecDescriptor const *output_descriptor = NULL;
2122 AVCodec const *output_codec =
2123 avcodec_find_encoder(oc->oformat->subtitle_codec);
2124 int input_props = 0, output_props = 0;
2126 output_descriptor = avcodec_descriptor_get(output_codec->id);
2127 if (input_descriptor)
2128 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2129 if (output_descriptor)
2130 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2131 if (subtitle_codec_name ||
2132 input_props & output_props ||
2133 // Map dvb teletext which has neither property to any output subtitle encoder
2134 input_descriptor && output_descriptor &&
2135 (!input_descriptor->props ||
2136 !output_descriptor->props)) {
2137 new_subtitle_stream(o, oc, i);
2142 /* Data only if codec id match */
2143 if (!o->data_disable ) {
2144 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2145 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2146 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2147 && input_streams[i]->st->codec->codec_id == codec_id )
2148 new_data_stream(o, oc, i);
2152 for (i = 0; i < o->nb_stream_maps; i++) {
2153 StreamMap *map = &o->stream_maps[i];
2158 if (map->linklabel) {
2160 OutputFilter *ofilter = NULL;
2163 for (j = 0; j < nb_filtergraphs; j++) {
2164 fg = filtergraphs[j];
2165 for (k = 0; k < fg->nb_outputs; k++) {
2166 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2167 if (out && !strcmp(out->name, map->linklabel)) {
2168 ofilter = fg->outputs[k];
2175 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2176 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2179 init_output_filter(ofilter, o, oc);
2181 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2183 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2184 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2186 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2188 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2190 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2194 switch (ist->st->codec->codec_type) {
2195 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2196 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2197 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2198 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2199 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2200 case AVMEDIA_TYPE_UNKNOWN:
2201 if (copy_unknown_streams) {
2202 ost = new_unknown_stream (o, oc, src_idx);
2206 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2207 "Cannot map stream #%d:%d - unsupported type.\n",
2208 map->file_index, map->stream_index);
2209 if (!ignore_unknown_streams) {
2210 av_log(NULL, AV_LOG_FATAL,
2211 "If you want unsupported types ignored instead "
2212 "of failing, please use the -ignore_unknown option\n"
2213 "If you want them copied, please use -copy_unknown\n");
2218 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2219 + map->sync_stream_index];
2224 /* handle attached files */
2225 for (i = 0; i < o->nb_attachments; i++) {
2227 uint8_t *attachment;
2231 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2232 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2236 if ((len = avio_size(pb)) <= 0) {
2237 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2241 if (!(attachment = av_malloc(len))) {
2242 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2246 avio_read(pb, attachment, len);
2248 ost = new_attachment_stream(o, oc, -1);
2249 ost->attachment_filename = o->attachments[i];
2250 ost->st->codec->extradata = attachment;
2251 ost->st->codec->extradata_size = len;
2253 p = strrchr(o->attachments[i], '/');
2254 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2258 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2259 AVDictionaryEntry *e;
2260 ost = output_streams[i];
2262 if ((ost->stream_copy || ost->attachment_filename)
2263 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2264 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2265 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2269 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2270 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2271 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2275 /* check if all codec options have been used */
2276 unused_opts = strip_specifiers(o->g->codec_opts);
2277 for (i = of->ost_index; i < nb_output_streams; i++) {
2279 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2280 AV_DICT_IGNORE_SUFFIX)))
2281 av_dict_set(&unused_opts, e->key, NULL, 0);
2285 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2286 const AVClass *class = avcodec_get_class();
2287 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2288 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2289 const AVClass *fclass = avformat_get_class();
2290 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2291 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2292 if (!option || foption)
2296 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2297 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2298 "output file #%d (%s) is not an encoding option.\n", e->key,
2299 option->help ? option->help : "", nb_output_files - 1,
2304 // gop_timecode is injected by generic code but not always used
2305 if (!strcmp(e->key, "gop_timecode"))
2308 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2309 "output file #%d (%s) has not been used for any stream. The most "
2310 "likely reason is either wrong type (e.g. a video option with "
2311 "no video streams) or that it is a private option of some encoder "
2312 "which was not actually used for any stream.\n", e->key,
2313 option->help ? option->help : "", nb_output_files - 1, filename);
2315 av_dict_free(&unused_opts);
2317 /* set the decoding_needed flags and create simple filtergraphs */
2318 for (i = of->ost_index; i < nb_output_streams; i++) {
2319 OutputStream *ost = output_streams[i];
2321 if (ost->encoding_needed && ost->source_index >= 0) {
2322 InputStream *ist = input_streams[ost->source_index];
2323 ist->decoding_needed |= DECODING_FOR_OST;
2325 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2326 ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2327 err = init_simple_filtergraph(ist, ost);
2329 av_log(NULL, AV_LOG_ERROR,
2330 "Error initializing a simple filtergraph between streams "
2331 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2332 nb_output_files - 1, ost->st->index);
2339 /* check filename in case of an image number is expected */
2340 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2341 if (!av_filename_number_test(oc->filename)) {
2342 print_error(oc->filename, AVERROR(EINVAL));
2347 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2348 av_log(NULL, AV_LOG_ERROR,
2349 "No input streams but output needs an input stream\n");
2353 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2354 /* test if it already exists to avoid losing precious files */
2355 assert_file_overwrite(filename);
2358 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2359 &oc->interrupt_callback,
2361 print_error(filename, err);
2364 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2365 assert_file_overwrite(filename);
2367 if (o->mux_preload) {
2368 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2370 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2373 for (i = 0; i < o->nb_metadata_map; i++) {
2375 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2377 if (in_file_index >= nb_input_files) {
2378 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2381 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2382 in_file_index >= 0 ?
2383 input_files[in_file_index]->ctx : NULL, o);
2387 if (o->chapters_input_file >= nb_input_files) {
2388 if (o->chapters_input_file == INT_MAX) {
2389 /* copy chapters from the first input file that has them*/
2390 o->chapters_input_file = -1;
2391 for (i = 0; i < nb_input_files; i++)
2392 if (input_files[i]->ctx->nb_chapters) {
2393 o->chapters_input_file = i;
2397 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2398 o->chapters_input_file);
2402 if (o->chapters_input_file >= 0)
2403 copy_chapters(input_files[o->chapters_input_file], of,
2404 !o->metadata_chapters_manual);
2406 /* copy global metadata by default */
2407 if (!o->metadata_global_manual && nb_input_files){
2408 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2409 AV_DICT_DONT_OVERWRITE);
2410 if(o->recording_time != INT64_MAX)
2411 av_dict_set(&oc->metadata, "duration", NULL, 0);
2412 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2414 if (!o->metadata_streams_manual)
2415 for (i = of->ost_index; i < nb_output_streams; i++) {
2417 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2419 ist = input_streams[output_streams[i]->source_index];
2420 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2421 if (!output_streams[i]->stream_copy) {
2422 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2423 if (ist->autorotate)
2424 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2428 /* process manually set programs */
2429 for (i = 0; i < o->nb_program; i++) {
2430 const char *p = o->program[i].u.str;
2435 const char *p2 = av_get_token(&p, ":");
2436 const char *to_dealloc = p2;
2443 key = av_get_token(&p2, "=");
2445 av_freep(&to_dealloc);
2451 if (!strcmp(key, "program_num"))
2452 progid = strtol(p2, NULL, 0);
2453 av_freep(&to_dealloc);
2457 program = av_new_program(oc, progid);
2459 p = o->program[i].u.str;
2461 const char *p2 = av_get_token(&p, ":");
2462 const char *to_dealloc = p2;
2468 key = av_get_token(&p2, "=");
2470 av_log(NULL, AV_LOG_FATAL,
2471 "No '=' character in program string %s.\n",
2479 if (!strcmp(key, "title")) {
2480 av_dict_set(&program->metadata, "title", p2, 0);
2481 } else if (!strcmp(key, "program_num")) {
2482 } else if (!strcmp(key, "st")) {
2483 int st_num = strtol(p2, NULL, 0);
2484 av_program_add_stream_index(oc, progid, st_num);
2486 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2489 av_freep(&to_dealloc);
2494 /* process manually set metadata */
2495 for (i = 0; i < o->nb_metadata; i++) {
2498 const char *stream_spec;
2499 int index = 0, j, ret = 0;
2501 val = strchr(o->metadata[i].u.str, '=');
2503 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2504 o->metadata[i].u.str);
2509 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2511 for (j = 0; j < oc->nb_streams; j++) {
2512 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2513 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2514 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2515 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2516 ost->rotate_overridden = 1;
2528 if (index < 0 || index >= oc->nb_chapters) {
2529 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2532 m = &oc->chapters[index]->metadata;
2535 if (index < 0 || index >= oc->nb_programs) {
2536 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2539 m = &oc->programs[index]->metadata;
2542 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2545 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2552 static int opt_target(void *optctx, const char *opt, const char *arg)
2554 OptionsContext *o = optctx;
2555 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2556 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2558 if (!strncmp(arg, "pal-", 4)) {
2561 } else if (!strncmp(arg, "ntsc-", 5)) {
2564 } else if (!strncmp(arg, "film-", 5)) {
2568 /* Try to determine PAL/NTSC by peeking in the input files */
2569 if (nb_input_files) {
2571 for (j = 0; j < nb_input_files; j++) {
2572 for (i = 0; i < input_files[j]->nb_streams; i++) {
2573 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2574 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2577 fr = c->time_base.den * 1000 / c->time_base.num;
2581 } else if ((fr == 29970) || (fr == 23976)) {
2586 if (norm != UNKNOWN)
2590 if (norm != UNKNOWN)
2591 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2594 if (norm == UNKNOWN) {
2595 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2596 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2597 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2601 if (!strcmp(arg, "vcd")) {
2602 opt_video_codec(o, "c:v", "mpeg1video");
2603 opt_audio_codec(o, "c:a", "mp2");
2604 parse_option(o, "f", "vcd", options);
2606 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2607 parse_option(o, "r", frame_rates[norm], options);
2608 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2610 opt_default(NULL, "b:v", "1150000");
2611 opt_default(NULL, "maxrate:v", "1150000");
2612 opt_default(NULL, "minrate:v", "1150000");
2613 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2615 opt_default(NULL, "b:a", "224000");
2616 parse_option(o, "ar", "44100", options);
2617 parse_option(o, "ac", "2", options);
2619 opt_default(NULL, "packetsize", "2324");
2620 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2622 /* We have to offset the PTS, so that it is consistent with the SCR.
2623 SCR starts at 36000, but the first two packs contain only padding
2624 and the first pack from the other stream, respectively, may also have
2625 been written before.
2626 So the real data starts at SCR 36000+3*1200. */
2627 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2628 } else if (!strcmp(arg, "svcd")) {
2630 opt_video_codec(o, "c:v", "mpeg2video");
2631 opt_audio_codec(o, "c:a", "mp2");
2632 parse_option(o, "f", "svcd", options);
2634 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2635 parse_option(o, "r", frame_rates[norm], options);
2636 parse_option(o, "pix_fmt", "yuv420p", options);
2637 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2639 opt_default(NULL, "b:v", "2040000");
2640 opt_default(NULL, "maxrate:v", "2516000");
2641 opt_default(NULL, "minrate:v", "0"); // 1145000;
2642 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2643 opt_default(NULL, "scan_offset", "1");
2645 opt_default(NULL, "b:a", "224000");
2646 parse_option(o, "ar", "44100", options);
2648 opt_default(NULL, "packetsize", "2324");
2650 } else if (!strcmp(arg, "dvd")) {
2652 opt_video_codec(o, "c:v", "mpeg2video");
2653 opt_audio_codec(o, "c:a", "ac3");
2654 parse_option(o, "f", "dvd", options);
2656 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2657 parse_option(o, "r", frame_rates[norm], options);
2658 parse_option(o, "pix_fmt", "yuv420p", options);
2659 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2661 opt_default(NULL, "b:v", "6000000");
2662 opt_default(NULL, "maxrate:v", "9000000");
2663 opt_default(NULL, "minrate:v", "0"); // 1500000;
2664 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2666 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2667 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2669 opt_default(NULL, "b:a", "448000");
2670 parse_option(o, "ar", "48000", options);
2672 } else if (!strncmp(arg, "dv", 2)) {
2674 parse_option(o, "f", "dv", options);
2676 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2677 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2678 norm == PAL ? "yuv420p" : "yuv411p", options);
2679 parse_option(o, "r", frame_rates[norm], options);
2681 parse_option(o, "ar", "48000", options);
2682 parse_option(o, "ac", "2", options);
2685 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2686 return AVERROR(EINVAL);
2689 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2690 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2695 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2697 av_free (vstats_filename);
2698 vstats_filename = av_strdup (arg);
2702 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2705 time_t today2 = time(NULL);
2706 struct tm *today = localtime(&today2);
2708 if (!today) { // maybe tomorrow
2709 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2713 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2715 return opt_vstats_file(NULL, opt, filename);
2718 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2720 OptionsContext *o = optctx;
2721 return parse_option(o, "frames:v", arg, options);
2724 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2726 OptionsContext *o = optctx;
2727 return parse_option(o, "frames:a", arg, options);
2730 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2732 OptionsContext *o = optctx;
2733 return parse_option(o, "frames:d", arg, options);
2736 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2739 AVDictionary *cbak = codec_opts;
2740 AVDictionary *fbak = format_opts;
2744 ret = opt_default(NULL, opt, arg);
2746 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2747 av_dict_copy(&o->g->format_opts, format_opts, 0);
2748 av_dict_free(&codec_opts);
2749 av_dict_free(&format_opts);
2756 static int opt_preset(void *optctx, const char *opt, const char *arg)
2758 OptionsContext *o = optctx;
2760 char filename[1000], line[1000], tmp_line[1000];
2761 const char *codec_name = NULL;
2765 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2767 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2768 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2769 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2771 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2775 while (fgets(line, sizeof(line), f)) {
2776 char *key = tmp_line, *value, *endptr;
2778 if (strcspn(line, "#\n\r") == 0)
2780 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2781 if (!av_strtok(key, "=", &value) ||
2782 !av_strtok(value, "\r\n", &endptr)) {
2783 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2786 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2788 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2789 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2790 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2791 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2792 else if (opt_default_new(o, key, value) < 0) {
2793 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2794 filename, line, key, value);
2804 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2806 OptionsContext *o = optctx;
2807 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2808 int ret = parse_option(o, s, arg, options);
2813 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2815 OptionsContext *o = optctx;
2817 if(!strcmp(opt, "ab")){
2818 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2820 } else if(!strcmp(opt, "b")){
2821 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2822 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2825 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2829 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2831 OptionsContext *o = optctx;
2834 if(!strcmp(opt, "qscale")){
2835 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2836 return parse_option(o, "q:v", arg, options);
2838 s = av_asprintf("q%s", opt + 6);
2839 ret = parse_option(o, s, arg, options);
2844 static int opt_profile(void *optctx, const char *opt, const char *arg)
2846 OptionsContext *o = optctx;
2847 if(!strcmp(opt, "profile")){
2848 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2849 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2852 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2856 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2858 OptionsContext *o = optctx;
2859 return parse_option(o, "filter:v", arg, options);
2862 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2864 OptionsContext *o = optctx;
2865 return parse_option(o, "filter:a", arg, options);
2868 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2870 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2871 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2872 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2873 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2875 if (video_sync_method == VSYNC_AUTO)
2876 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2880 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2882 OptionsContext *o = optctx;
2883 char *tcr = av_asprintf("timecode=%s", arg);
2884 int ret = parse_option(o, "metadata:g", tcr, options);
2886 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2891 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2893 OptionsContext *o = optctx;
2894 char layout_str[32];
2897 int ret, channels, ac_str_size;
2900 layout = av_get_channel_layout(arg);
2902 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2903 return AVERROR(EINVAL);
2905 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2906 ret = opt_default_new(o, opt, layout_str);
2910 /* set 'ac' option based on channel layout */
2911 channels = av_get_channel_layout_nb_channels(layout);
2912 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2913 stream_str = strchr(opt, ':');
2914 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2915 ac_str = av_mallocz(ac_str_size);
2917 return AVERROR(ENOMEM);
2918 av_strlcpy(ac_str, "ac", 3);
2920 av_strlcat(ac_str, stream_str, ac_str_size);
2921 ret = parse_option(o, ac_str, layout_str, options);
2927 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2929 OptionsContext *o = optctx;
2930 return parse_option(o, "q:a", arg, options);
2933 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2935 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2936 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2937 return AVERROR(ENOMEM);
2938 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2939 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2940 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2941 return AVERROR(ENOMEM);
2943 input_stream_potentially_available = 1;
2948 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2950 uint8_t *graph_desc = read_file(arg);
2952 return AVERROR(EINVAL);
2954 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2955 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2956 return AVERROR(ENOMEM);
2957 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2958 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2960 input_stream_potentially_available = 1;
2965 void show_help_default(const char *opt, const char *arg)
2967 /* per-file options have at least one of those set */
2968 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2969 int show_advanced = 0, show_avoptions = 0;
2972 if (!strcmp(opt, "long"))
2974 else if (!strcmp(opt, "full"))
2975 show_advanced = show_avoptions = 1;
2977 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2982 printf("Getting help:\n"
2983 " -h -- print basic options\n"
2984 " -h long -- print more options\n"
2985 " -h full -- print all options (including all format and codec specific options, very long)\n"
2986 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2987 " See man %s for detailed description of the options.\n"
2988 "\n", program_name);
2990 show_help_options(options, "Print help / information / capabilities:",
2993 show_help_options(options, "Global options (affect whole program "
2994 "instead of just one file:",
2995 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2997 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2998 per_file | OPT_EXIT, 0);
3000 show_help_options(options, "Per-file main options:", 0,
3001 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3002 OPT_EXIT, per_file);
3004 show_help_options(options, "Advanced per-file options:",
3005 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3007 show_help_options(options, "Video options:",
3008 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3010 show_help_options(options, "Advanced Video options:",
3011 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3013 show_help_options(options, "Audio options:",
3014 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3016 show_help_options(options, "Advanced Audio options:",
3017 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3018 show_help_options(options, "Subtitle options:",
3019 OPT_SUBTITLE, 0, 0);
3022 if (show_avoptions) {
3023 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3024 show_help_children(avcodec_get_class(), flags);
3025 show_help_children(avformat_get_class(), flags);
3027 show_help_children(sws_get_class(), flags);
3029 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3030 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3034 void show_usage(void)
3036 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3037 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3038 av_log(NULL, AV_LOG_INFO, "\n");
3046 static const OptionGroupDef groups[] = {
3047 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
3048 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
3051 static int open_files(OptionGroupList *l, const char *inout,
3052 int (*open_file)(OptionsContext*, const char*))
3056 for (i = 0; i < l->nb_groups; i++) {
3057 OptionGroup *g = &l->groups[i];
3063 ret = parse_optgroup(&o, g);
3065 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3066 "%s.\n", inout, g->arg);
3070 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3071 ret = open_file(&o, g->arg);
3074 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3078 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3084 int ffmpeg_parse_options(int argc, char **argv)
3086 OptionParseContext octx;
3090 memset(&octx, 0, sizeof(octx));
3092 /* split the commandline into an internal representation */
3093 ret = split_commandline(&octx, argc, argv, options, groups,
3094 FF_ARRAY_ELEMS(groups));
3096 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3100 /* apply global options */
3101 ret = parse_optgroup(NULL, &octx.global_opts);
3103 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3107 /* open input files */
3108 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3110 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3114 /* create the complex filtergraphs */
3115 ret = init_complex_filters();
3117 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3121 /* open output files */
3122 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3124 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3128 /* configure the complex filtergraphs */
3129 ret = configure_complex_filters();
3131 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3136 uninit_parse_context(&octx);
3138 av_strerror(ret, error, sizeof(error));
3139 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3144 static int opt_progress(void *optctx, const char *opt, const char *arg)
3146 AVIOContext *avio = NULL;
3149 if (!strcmp(arg, "-"))
3151 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3153 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3154 arg, av_err2str(ret));
3157 progress_avio = avio;
3161 #define OFFSET(x) offsetof(OptionsContext, x)
3162 const OptionDef options[] = {
3164 #include "cmdutils_common_opts.h"
3165 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3166 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3167 "force format", "fmt" },
3168 { "y", OPT_BOOL, { &file_overwrite },
3169 "overwrite output files" },
3170 { "n", OPT_BOOL, { &no_file_overwrite },
3171 "never overwrite output files" },
3172 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3173 "Ignore unknown stream types" },
3174 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3175 "Copy unknown stream types" },
3176 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3177 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3178 "codec name", "codec" },
3179 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3180 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3181 "codec name", "codec" },
3182 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3183 OPT_OUTPUT, { .off = OFFSET(presets) },
3184 "preset name", "preset" },
3185 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3186 OPT_OUTPUT, { .func_arg = opt_map },
3187 "set input stream mapping",
3188 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3189 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3190 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3191 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3192 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3193 "set metadata information of outfile from infile",
3194 "outfile[,metadata]:infile[,metadata]" },
3195 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3196 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3197 "set chapters mapping", "input_file_index" },
3198 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3199 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3200 "record or transcode \"duration\" seconds of audio/video",
3202 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3203 "record or transcode stop time", "time_stop" },
3204 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3205 "set the limit file size in bytes", "limit_size" },
3206 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3207 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3208 "set the start time offset", "time_off" },
3209 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3210 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3211 "set the start time offset relative to EOF", "time_off" },
3212 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3213 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3214 "enable/disable seeking by timestamp with -ss" },
3215 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3216 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3217 "enable/disable accurate seeking with -ss" },
3218 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3219 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3220 "set the input ts offset", "time_off" },
3221 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3222 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3223 "set the input ts scale", "scale" },
3224 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3225 "set the recording timestamp ('now' to set the current time)", "time" },
3226 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3227 "add metadata", "string=string" },
3228 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3229 "add program with specified streams", "title=string:st=number..." },
3230 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3231 OPT_OUTPUT, { .func_arg = opt_data_frames },
3232 "set the number of data frames to output", "number" },
3233 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3234 "add timings for benchmarking" },
3235 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3236 "add timings for each task" },
3237 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3238 "write program-readable progress information", "url" },
3239 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3240 "enable or disable interaction on standard input" },
3241 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3242 "set max runtime in seconds", "limit" },
3243 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3244 "dump each input packet" },
3245 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3246 "when dumping packets, also dump the payload" },
3247 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3248 OPT_INPUT, { .off = OFFSET(rate_emu) },
3249 "read input at native frame rate", "" },
3250 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3251 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3252 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3253 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3254 "video sync method", "" },
3255 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3256 "frame drop threshold", "" },
3257 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3258 "audio sync method", "" },
3259 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3260 "audio drift threshold", "threshold" },
3261 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3262 "copy timestamps" },
3263 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3264 "shift input timestamps to start at 0 when using copyts" },
3265 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3266 "copy input stream time base when stream copying", "mode" },
3267 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3268 OPT_OUTPUT, { .off = OFFSET(shortest) },
3269 "finish encoding within shortest input" },
3270 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3271 OPT_OUTPUT, { .off = OFFSET(apad) },
3273 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3274 "timestamp discontinuity delta threshold", "threshold" },
3275 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3276 "timestamp error delta threshold", "threshold" },
3277 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3278 "exit on error", "error" },
3279 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3280 "abort on the specified condition flags", "flags" },
3281 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3282 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3283 "copy initial non-keyframes" },
3284 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3285 "copy or discard frames before start time" },
3286 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3287 "set the number of frames to output", "number" },
3288 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3289 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3290 "force codec tag/fourcc", "fourcc/tag" },
3291 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3292 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3293 "use fixed quality scale (VBR)", "q" },
3294 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3295 OPT_OUTPUT, { .func_arg = opt_qscale },
3296 "use fixed quality scale (VBR)", "q" },
3297 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3298 "set profile", "profile" },
3299 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3300 "set stream filtergraph", "filter_graph" },
3301 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3302 "read stream filtergraph description from a file", "filename" },
3303 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3304 "reinit filtergraph on input parameter changes", "" },
3305 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3306 "create a complex filtergraph", "graph_description" },
3307 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3308 "create a complex filtergraph", "graph_description" },
3309 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3310 "read complex filtergraph description from a file", "filename" },
3311 { "stats", OPT_BOOL, { &print_stats },
3312 "print progress report during encoding", },
3313 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3314 OPT_OUTPUT, { .func_arg = opt_attach },
3315 "add an attachment to the output file", "filename" },
3316 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3317 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3318 "extract an attachment into a file", "filename" },
3319 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3320 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3321 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3322 "print timestamp debugging info" },
3323 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3324 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3325 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3326 OPT_INPUT, { .off = OFFSET(discard) },
3328 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3329 OPT_OUTPUT, { .off = OFFSET(disposition) },
3330 "disposition", "" },
3331 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3332 { .off = OFFSET(thread_queue_size) },
3333 "set the maximum number of queued packets from the demuxer" },
3336 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3337 "set the number of video frames to output", "number" },
3338 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3339 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3340 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3341 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3342 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3343 "set frame size (WxH or abbreviation)", "size" },
3344 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3345 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3346 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3347 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3348 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3349 "set pixel format", "format" },
3350 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3351 "set the number of bits per raw sample", "number" },
3352 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3353 "deprecated use -g 1" },
3354 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3356 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3357 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3358 "rate control override for specific intervals", "override" },
3359 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3360 OPT_OUTPUT, { .func_arg = opt_video_codec },
3361 "force video codec ('copy' to copy stream)", "codec" },
3362 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3364 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3366 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3367 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3368 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3369 "select the pass number (1 to 3)", "n" },
3370 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3371 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3372 "select two pass log file name prefix", "prefix" },
3373 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3374 "this option is deprecated, use the yadif filter instead" },
3375 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3376 "calculate PSNR of compressed frames" },
3377 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3378 "dump video coding statistics to file" },
3379 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3380 "dump video coding statistics to file", "file" },
3381 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3382 "set video filters", "filter_graph" },
3383 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3384 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3385 "specify intra matrix coeffs", "matrix" },
3386 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3387 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3388 "specify inter matrix coeffs", "matrix" },
3389 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3390 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3391 "specify intra matrix coeffs", "matrix" },
3392 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3393 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3394 "top=1/bottom=0/auto=-1 field first", "" },
3395 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3396 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3397 "force video tag/fourcc", "fourcc/tag" },
3398 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3399 "show QP histogram" },
3400 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3401 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3402 "force the selected framerate, disable the best supported framerate selection" },
3403 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3404 OPT_OUTPUT, { .func_arg = opt_streamid },
3405 "set the value of an outfile streamid", "streamIndex:value" },
3406 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3407 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3408 "force key frames at specified timestamps", "timestamps" },
3409 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3410 "audio bitrate (please use -b:a)", "bitrate" },
3411 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3412 "video bitrate (please use -b:v)", "bitrate" },
3413 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3414 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3415 "use HW accelerated decoding", "hwaccel name" },
3416 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3417 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3418 "select a device for HW acceleration", "devicename" },
3419 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3420 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3421 "select output format used with HW accelerated decoding", "format" },
3422 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3423 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3425 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3426 "show available HW acceleration methods" },
3427 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3428 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3429 "automatically insert correct rotate filters" },
3430 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3431 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3434 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3435 "set the number of audio frames to output", "number" },
3436 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3437 "set audio quality (codec-specific)", "quality", },
3438 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3439 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3440 "set audio sampling rate (in Hz)", "rate" },
3441 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3442 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3443 "set number of audio channels", "channels" },
3444 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3446 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3447 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3448 "force audio codec ('copy' to copy stream)", "codec" },
3449 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3450 OPT_OUTPUT, { .func_arg = opt_old2new },
3451 "force audio tag/fourcc", "fourcc/tag" },
3452 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3453 "change audio volume (256=normal)" , "volume" },
3454 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3455 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3456 "set sample format", "format" },
3457 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3458 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3459 "set channel layout", "layout" },
3460 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3461 "set audio filters", "filter_graph" },
3462 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3463 "set the maximum number of channels to try to guess the channel layout" },
3465 /* subtitle options */
3466 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3467 "disable subtitle" },
3468 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3469 "force subtitle codec ('copy' to copy stream)", "codec" },
3470 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3471 , "force subtitle tag/fourcc", "fourcc/tag" },
3472 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3473 "fix subtitles duration" },
3474 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3475 "set canvas size (WxH or abbreviation)", "size" },
3478 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3479 "deprecated, use -channel", "channel" },
3480 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3481 "deprecated, use -standard", "standard" },
3482 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3485 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3486 "set the maximum demux-decode delay", "seconds" },
3487 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3488 "set the initial demux-decode delay", "seconds" },
3489 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3490 "override the options from ffserver", "" },
3491 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3492 "specify a file in which to print sdp information", "file" },
3494 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3495 "A comma-separated list of bitstream filters", "bitstream_filters" },
3496 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3497 "deprecated", "audio bitstream_filters" },
3498 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3499 "deprecated", "video bitstream_filters" },
3501 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3502 "set the audio options to the indicated preset", "preset" },
3503 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3504 "set the video options to the indicated preset", "preset" },
3505 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3506 "set the subtitle options to the indicated preset", "preset" },
3507 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3508 "set options from indicated preset file", "filename" },
3509 /* data codec support */
3510 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3511 "force data codec ('copy' to copy stream)", "codec" },
3512 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3516 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3517 "set VAAPI hardware device (DRM path or X11 display name)", "device" },