2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
70 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
73 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
76 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
78 #if CONFIG_VIDEOTOOLBOX
79 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
82 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
85 { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
88 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
92 int hwaccel_lax_profile_check = 0;
93 AVBufferRef *hw_device_ctx;
95 char *vstats_filename;
98 float audio_drift_threshold = 0.1;
99 float dts_delta_threshold = 10;
100 float dts_error_threshold = 3600*30;
102 int audio_volume = 256;
103 int audio_sync_method = 0;
104 int video_sync_method = VSYNC_AUTO;
105 float frame_drop_threshold = 0;
106 int do_deinterlace = 0;
107 int do_benchmark = 0;
108 int do_benchmark_all = 0;
112 int start_at_zero = 0;
115 int exit_on_error = 0;
116 int abort_on_flags = 0;
117 int print_stats = -1;
119 int stdin_interaction = 1;
120 int frame_bits_per_raw_sample = 0;
121 float max_error_rate = 2.0/3;
124 static int intra_only = 0;
125 static int file_overwrite = 0;
126 static int no_file_overwrite = 0;
127 static int do_psnr = 0;
128 static int input_sync;
129 static int override_ffserver = 0;
130 static int input_stream_potentially_available = 0;
131 static int ignore_unknown_streams = 0;
132 static int copy_unknown_streams = 0;
134 static void uninit_options(OptionsContext *o)
136 const OptionDef *po = options;
139 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
141 void *dst = (uint8_t*)o + po->u.off;
143 if (po->flags & OPT_SPEC) {
144 SpecifierOpt **so = dst;
145 int i, *count = (int*)(so + 1);
146 for (i = 0; i < *count; i++) {
147 av_freep(&(*so)[i].specifier);
148 if (po->flags & OPT_STRING)
149 av_freep(&(*so)[i].u.str);
153 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
158 for (i = 0; i < o->nb_stream_maps; i++)
159 av_freep(&o->stream_maps[i].linklabel);
160 av_freep(&o->stream_maps);
161 av_freep(&o->audio_channel_maps);
162 av_freep(&o->streamid_map);
163 av_freep(&o->attachments);
166 static void init_options(OptionsContext *o)
168 memset(o, 0, sizeof(*o));
170 o->stop_time = INT64_MAX;
171 o->mux_max_delay = 0.7;
172 o->start_time = AV_NOPTS_VALUE;
173 o->start_time_eof = AV_NOPTS_VALUE;
174 o->recording_time = INT64_MAX;
175 o->limit_filesize = UINT64_MAX;
176 o->chapters_input_file = INT_MAX;
177 o->accurate_seek = 1;
180 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
184 printf("Hardware acceleration methods:\n");
185 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
186 printf("%s\n", hwaccels[i].name);
192 /* return a copy of the input with the stream specifiers removed from the keys */
193 static AVDictionary *strip_specifiers(AVDictionary *dict)
195 AVDictionaryEntry *e = NULL;
196 AVDictionary *ret = NULL;
198 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
199 char *p = strchr(e->key, ':');
203 av_dict_set(&ret, e->key, e->value, 0);
210 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
212 static const AVOption opts[] = {
213 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
214 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
217 static const AVClass class = {
219 .item_name = av_default_item_name,
221 .version = LIBAVUTIL_VERSION_INT,
223 const AVClass *pclass = &class;
225 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
228 static int opt_sameq(void *optctx, const char *opt, const char *arg)
230 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
231 "If you are looking for an option to preserve the quality (which is not "
232 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
234 return AVERROR(EINVAL);
237 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
239 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
240 return opt_default(optctx, "channel", arg);
243 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
245 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
246 return opt_default(optctx, "standard", arg);
249 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
251 OptionsContext *o = optctx;
252 return parse_option(o, "codec:a", arg, options);
255 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
257 OptionsContext *o = optctx;
258 return parse_option(o, "codec:v", arg, options);
261 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
263 OptionsContext *o = optctx;
264 return parse_option(o, "codec:s", arg, options);
267 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
269 OptionsContext *o = optctx;
270 return parse_option(o, "codec:d", arg, options);
273 static int opt_map(void *optctx, const char *opt, const char *arg)
275 OptionsContext *o = optctx;
277 int i, negative = 0, file_idx;
278 int sync_file_idx = -1, sync_stream_idx = 0;
287 map = av_strdup(arg);
289 return AVERROR(ENOMEM);
291 /* parse sync stream first, just pick first matching stream */
292 if (sync = strchr(map, ',')) {
294 sync_file_idx = strtol(sync + 1, &sync, 0);
295 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
296 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
301 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
302 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
303 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
307 if (i == input_files[sync_file_idx]->nb_streams) {
308 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
309 "match any streams.\n", arg);
316 /* this mapping refers to lavfi output */
317 const char *c = map + 1;
318 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
319 m = &o->stream_maps[o->nb_stream_maps - 1];
320 m->linklabel = av_get_token(&c, "]");
322 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
326 if (allow_unused = strchr(map, '?'))
328 file_idx = strtol(map, &p, 0);
329 if (file_idx >= nb_input_files || file_idx < 0) {
330 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
334 /* disable some already defined maps */
335 for (i = 0; i < o->nb_stream_maps; i++) {
336 m = &o->stream_maps[i];
337 if (file_idx == m->file_index &&
338 check_stream_specifier(input_files[m->file_index]->ctx,
339 input_files[m->file_index]->ctx->streams[m->stream_index],
340 *p == ':' ? p + 1 : p) > 0)
344 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
345 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
346 *p == ':' ? p + 1 : p) <= 0)
348 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
349 m = &o->stream_maps[o->nb_stream_maps - 1];
351 m->file_index = file_idx;
354 if (sync_file_idx >= 0) {
355 m->sync_file_index = sync_file_idx;
356 m->sync_stream_index = sync_stream_idx;
358 m->sync_file_index = file_idx;
359 m->sync_stream_index = i;
366 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
368 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
369 "To ignore this, add a trailing '?' to the map.\n", arg);
378 static int opt_attach(void *optctx, const char *opt, const char *arg)
380 OptionsContext *o = optctx;
381 GROW_ARRAY(o->attachments, o->nb_attachments);
382 o->attachments[o->nb_attachments - 1] = arg;
386 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
388 OptionsContext *o = optctx;
393 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
394 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
396 /* muted channel syntax */
397 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
398 if ((n == 1 || n == 3) && m->channel_idx == -1) {
399 m->file_idx = m->stream_idx = -1;
401 m->ofile_idx = m->ostream_idx = -1;
406 n = sscanf(arg, "%d.%d.%d:%d.%d",
407 &m->file_idx, &m->stream_idx, &m->channel_idx,
408 &m->ofile_idx, &m->ostream_idx);
410 if (n != 3 && n != 5) {
411 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
412 "[file.stream.channel|-1][:syncfile:syncstream]\n");
416 if (n != 5) // only file.stream.channel specified
417 m->ofile_idx = m->ostream_idx = -1;
420 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
421 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
425 if (m->stream_idx < 0 ||
426 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
427 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
428 m->file_idx, m->stream_idx);
431 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
432 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
433 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
434 m->file_idx, m->stream_idx);
437 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
438 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
439 m->file_idx, m->stream_idx, m->channel_idx);
445 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
447 av_free(sdp_filename);
448 sdp_filename = av_strdup(arg);
453 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
456 err = vaapi_device_init(arg);
464 * Parse a metadata specifier passed as 'arg' parameter.
465 * @param arg metadata string to parse
466 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
467 * @param index for type c/p, chapter/program index is written here
468 * @param stream_spec for type s, the stream specifier is written here
470 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
478 if (*(++arg) && *arg != ':') {
479 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
482 *stream_spec = *arg == ':' ? arg + 1 : "";
487 *index = strtol(++arg, NULL, 0);
490 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
497 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
499 AVDictionary **meta_in = NULL;
500 AVDictionary **meta_out = NULL;
502 char type_in, type_out;
503 const char *istream_spec = NULL, *ostream_spec = NULL;
504 int idx_in = 0, idx_out = 0;
506 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
507 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
510 if (type_out == 'g' || !*outspec)
511 o->metadata_global_manual = 1;
512 if (type_out == 's' || !*outspec)
513 o->metadata_streams_manual = 1;
514 if (type_out == 'c' || !*outspec)
515 o->metadata_chapters_manual = 1;
519 if (type_in == 'g' || type_out == 'g')
520 o->metadata_global_manual = 1;
521 if (type_in == 's' || type_out == 's')
522 o->metadata_streams_manual = 1;
523 if (type_in == 'c' || type_out == 'c')
524 o->metadata_chapters_manual = 1;
526 /* ic is NULL when just disabling automatic mappings */
530 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
531 if ((index) < 0 || (index) >= (nb_elems)) {\
532 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
537 #define SET_DICT(type, meta, context, index)\
540 meta = &context->metadata;\
543 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
544 meta = &context->chapters[index]->metadata;\
547 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
548 meta = &context->programs[index]->metadata;\
551 break; /* handled separately below */ \
552 default: av_assert0(0);\
555 SET_DICT(type_in, meta_in, ic, idx_in);
556 SET_DICT(type_out, meta_out, oc, idx_out);
558 /* for input streams choose first matching stream */
559 if (type_in == 's') {
560 for (i = 0; i < ic->nb_streams; i++) {
561 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
562 meta_in = &ic->streams[i]->metadata;
568 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
573 if (type_out == 's') {
574 for (i = 0; i < oc->nb_streams; i++) {
575 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
576 meta_out = &oc->streams[i]->metadata;
577 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
582 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
587 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
589 OptionsContext *o = optctx;
591 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
592 struct tm time = *gmtime((time_t*)&recording_timestamp);
593 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
595 parse_option(o, "metadata", buf, options);
597 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
598 "tag instead.\n", opt);
602 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
604 const AVCodecDescriptor *desc;
605 const char *codec_string = encoder ? "encoder" : "decoder";
609 avcodec_find_encoder_by_name(name) :
610 avcodec_find_decoder_by_name(name);
612 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
613 codec = encoder ? avcodec_find_encoder(desc->id) :
614 avcodec_find_decoder(desc->id);
616 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
617 codec_string, codec->name, desc->name);
621 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
624 if (codec->type != type) {
625 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
631 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
633 char *codec_name = NULL;
635 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
637 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
638 st->codec->codec_id = codec->id;
641 return avcodec_find_decoder(st->codec->codec_id);
644 /* Add all the streams from the given input file to the global
645 * list of input streams. */
646 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
650 for (i = 0; i < ic->nb_streams; i++) {
651 AVStream *st = ic->streams[i];
652 AVCodecContext *dec = st->codec;
653 InputStream *ist = av_mallocz(sizeof(*ist));
654 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
655 char *hwaccel_output_format = NULL;
656 char *codec_tag = NULL;
658 char *discard_str = NULL;
659 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
664 GROW_ARRAY(input_streams, nb_input_streams);
665 input_streams[nb_input_streams - 1] = ist;
668 ist->file_index = nb_input_files;
670 st->discard = AVDISCARD_ALL;
672 ist->min_pts = INT64_MAX;
673 ist->max_pts = INT64_MIN;
676 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
679 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
681 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
683 uint32_t tag = strtol(codec_tag, &next, 0);
685 tag = AV_RL32(codec_tag);
686 st->codec->codec_tag = tag;
689 ist->dec = choose_decoder(o, ic, st);
690 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
692 ist->reinit_filters = -1;
693 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
695 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
696 ist->user_set_discard = AVDISCARD_NONE;
697 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
698 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
703 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
705 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
707 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
711 ret = avcodec_copy_context(ist->dec_ctx, dec);
713 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
717 switch (dec->codec_type) {
718 case AVMEDIA_TYPE_VIDEO:
720 ist->dec = avcodec_find_decoder(dec->codec_id);
722 if (av_codec_get_lowres(dec)) {
723 dec->flags |= CODEC_FLAG_EMU_EDGE;
727 ist->resample_height = ist->dec_ctx->height;
728 ist->resample_width = ist->dec_ctx->width;
729 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
731 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
732 if (framerate && av_parse_video_rate(&ist->framerate,
734 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
739 ist->top_field_first = -1;
740 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
742 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
744 if (!strcmp(hwaccel, "none"))
745 ist->hwaccel_id = HWACCEL_NONE;
746 else if (!strcmp(hwaccel, "auto"))
747 ist->hwaccel_id = HWACCEL_AUTO;
750 for (i = 0; hwaccels[i].name; i++) {
751 if (!strcmp(hwaccels[i].name, hwaccel)) {
752 ist->hwaccel_id = hwaccels[i].id;
757 if (!ist->hwaccel_id) {
758 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
760 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
761 for (i = 0; hwaccels[i].name; i++)
762 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
763 av_log(NULL, AV_LOG_FATAL, "\n");
769 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
770 if (hwaccel_device) {
771 ist->hwaccel_device = av_strdup(hwaccel_device);
772 if (!ist->hwaccel_device)
776 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
777 hwaccel_output_format, ic, st);
778 if (hwaccel_output_format) {
779 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
780 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
781 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
782 "format: %s", hwaccel_output_format);
785 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
788 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
791 case AVMEDIA_TYPE_AUDIO:
792 ist->guess_layout_max = INT_MAX;
793 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
794 guess_input_channel_layout(ist);
796 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
797 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
798 ist->resample_channels = ist->dec_ctx->channels;
799 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
802 case AVMEDIA_TYPE_DATA:
803 case AVMEDIA_TYPE_SUBTITLE: {
804 char *canvas_size = NULL;
806 ist->dec = avcodec_find_decoder(dec->codec_id);
807 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
808 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
810 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
811 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
816 case AVMEDIA_TYPE_ATTACHMENT:
817 case AVMEDIA_TYPE_UNKNOWN:
825 static void assert_file_overwrite(const char *filename)
827 if (file_overwrite && no_file_overwrite) {
828 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
832 if (!file_overwrite) {
833 const char *proto_name = avio_find_protocol_name(filename);
834 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
835 if (stdin_interaction && !no_file_overwrite) {
836 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
839 signal(SIGINT, SIG_DFL);
841 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
847 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
854 static void dump_attachment(AVStream *st, const char *filename)
857 AVIOContext *out = NULL;
858 AVDictionaryEntry *e;
860 if (!st->codec->extradata_size) {
861 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
862 nb_input_files - 1, st->index);
865 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
868 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
869 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
873 assert_file_overwrite(filename);
875 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
876 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
881 avio_write(out, st->codec->extradata, st->codec->extradata_size);
886 static int open_input_file(OptionsContext *o, const char *filename)
890 AVInputFormat *file_iformat = NULL;
894 AVDictionary *unused_opts = NULL;
895 AVDictionaryEntry *e = NULL;
896 int orig_nb_streams; // number of streams before avformat_find_stream_info
897 char * video_codec_name = NULL;
898 char * audio_codec_name = NULL;
899 char *subtitle_codec_name = NULL;
900 char * data_codec_name = NULL;
901 int scan_all_pmts_set = 0;
904 if (!(file_iformat = av_find_input_format(o->format))) {
905 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
910 if (!strcmp(filename, "-"))
913 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
914 strcmp(filename, "/dev/stdin");
916 /* get default parameters from command line */
917 ic = avformat_alloc_context();
919 print_error(filename, AVERROR(ENOMEM));
922 if (o->nb_audio_sample_rate) {
923 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
925 if (o->nb_audio_channels) {
926 /* because we set audio_channels based on both the "ac" and
927 * "channel_layout" options, we need to check that the specified
928 * demuxer actually has the "channels" option before setting it */
929 if (file_iformat && file_iformat->priv_class &&
930 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
931 AV_OPT_SEARCH_FAKE_OBJ)) {
932 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
935 if (o->nb_frame_rates) {
936 /* set the format-level framerate option;
937 * this is important for video grabbers, e.g. x11 */
938 if (file_iformat && file_iformat->priv_class &&
939 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
940 AV_OPT_SEARCH_FAKE_OBJ)) {
941 av_dict_set(&o->g->format_opts, "framerate",
942 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
945 if (o->nb_frame_sizes) {
946 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
948 if (o->nb_frame_pix_fmts)
949 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
951 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
952 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
953 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
954 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
956 ic->video_codec_id = video_codec_name ?
957 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
958 ic->audio_codec_id = audio_codec_name ?
959 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
960 ic->subtitle_codec_id= subtitle_codec_name ?
961 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
962 ic->data_codec_id = data_codec_name ?
963 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
965 if (video_codec_name)
966 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
967 if (audio_codec_name)
968 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
969 if (subtitle_codec_name)
970 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
972 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
974 ic->flags |= AVFMT_FLAG_NONBLOCK;
975 ic->interrupt_callback = int_cb;
977 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
978 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
979 scan_all_pmts_set = 1;
981 /* open the input file with generic avformat function */
982 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
984 print_error(filename, err);
987 if (scan_all_pmts_set)
988 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
989 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
990 assert_avoptions(o->g->format_opts);
992 /* apply forced codec ids */
993 for (i = 0; i < ic->nb_streams; i++)
994 choose_decoder(o, ic, ic->streams[i]);
996 /* Set AVCodecContext options for avformat_find_stream_info */
997 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
998 orig_nb_streams = ic->nb_streams;
1000 /* If not enough info to get the stream parameters, we decode the
1001 first frames to get it. (used in mpeg case for example) */
1002 ret = avformat_find_stream_info(ic, opts);
1004 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1005 if (ic->nb_streams == 0) {
1006 avformat_close_input(&ic);
1011 if (o->start_time_eof != AV_NOPTS_VALUE) {
1012 if (ic->duration>0) {
1013 o->start_time = o->start_time_eof + ic->duration;
1015 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1017 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1018 /* add the stream start time */
1019 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1020 timestamp += ic->start_time;
1022 /* if seeking requested, we execute it */
1023 if (o->start_time != AV_NOPTS_VALUE) {
1024 int64_t seek_timestamp = timestamp;
1026 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1027 int dts_heuristic = 0;
1028 for (i=0; i<ic->nb_streams; i++) {
1029 AVCodecContext *avctx = ic->streams[i]->codec;
1030 if (avctx->has_b_frames)
1033 if (dts_heuristic) {
1034 seek_timestamp -= 3*AV_TIME_BASE / 23;
1037 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1039 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1040 filename, (double)timestamp / AV_TIME_BASE);
1044 /* update the current parameters so that they match the one of the input stream */
1045 add_input_streams(o, ic);
1047 /* dump the file content */
1048 av_dump_format(ic, nb_input_files, filename, 0);
1050 GROW_ARRAY(input_files, nb_input_files);
1051 f = av_mallocz(sizeof(*f));
1054 input_files[nb_input_files - 1] = f;
1057 f->ist_index = nb_input_streams - ic->nb_streams;
1058 f->start_time = o->start_time;
1059 f->recording_time = o->recording_time;
1060 f->input_ts_offset = o->input_ts_offset;
1061 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1062 f->nb_streams = ic->nb_streams;
1063 f->rate_emu = o->rate_emu;
1064 f->accurate_seek = o->accurate_seek;
1067 f->time_base = (AVRational){ 1, 1 };
1069 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1072 /* check if all codec options have been used */
1073 unused_opts = strip_specifiers(o->g->codec_opts);
1074 for (i = f->ist_index; i < nb_input_streams; i++) {
1076 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1077 AV_DICT_IGNORE_SUFFIX)))
1078 av_dict_set(&unused_opts, e->key, NULL, 0);
1082 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1083 const AVClass *class = avcodec_get_class();
1084 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1085 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1086 const AVClass *fclass = avformat_get_class();
1087 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1088 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1089 if (!option || foption)
1093 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1094 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1095 "input file #%d (%s) is not a decoding option.\n", e->key,
1096 option->help ? option->help : "", nb_input_files - 1,
1101 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1102 "input file #%d (%s) has not been used for any stream. The most "
1103 "likely reason is either wrong type (e.g. a video option with "
1104 "no video streams) or that it is a private option of some decoder "
1105 "which was not actually used for any stream.\n", e->key,
1106 option->help ? option->help : "", nb_input_files - 1, filename);
1108 av_dict_free(&unused_opts);
1110 for (i = 0; i < o->nb_dump_attachment; i++) {
1113 for (j = 0; j < ic->nb_streams; j++) {
1114 AVStream *st = ic->streams[j];
1116 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1117 dump_attachment(st, o->dump_attachment[i].u.str);
1121 for (i = 0; i < orig_nb_streams; i++)
1122 av_dict_free(&opts[i]);
1125 input_stream_potentially_available = 1;
1130 static uint8_t *get_line(AVIOContext *s)
1136 if (avio_open_dyn_buf(&line) < 0) {
1137 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1141 while ((c = avio_r8(s)) && c != '\n')
1144 avio_close_dyn_buf(line, &buf);
1149 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1152 char filename[1000];
1153 const char *base[3] = { getenv("AVCONV_DATADIR"),
1158 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1162 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1163 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1164 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1167 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1168 i != 1 ? "" : "/.avconv", preset_name);
1169 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1175 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1177 char *codec_name = NULL;
1179 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1181 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1182 NULL, ost->st->codec->codec_type);
1183 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1184 } else if (!strcmp(codec_name, "copy"))
1185 ost->stream_copy = 1;
1187 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1188 ost->st->codec->codec_id = ost->enc->id;
1192 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1195 AVStream *st = avformat_new_stream(oc, NULL);
1196 int idx = oc->nb_streams - 1, ret = 0;
1197 char *bsf = NULL, *next, *codec_tag = NULL;
1198 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1203 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1207 if (oc->nb_streams - 1 < o->nb_streamid_map)
1208 st->id = o->streamid_map[oc->nb_streams - 1];
1210 GROW_ARRAY(output_streams, nb_output_streams);
1211 if (!(ost = av_mallocz(sizeof(*ost))))
1213 output_streams[nb_output_streams - 1] = ost;
1215 ost->file_index = nb_output_files - 1;
1218 st->codec->codec_type = type;
1219 choose_encoder(o, oc, ost);
1221 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1222 if (!ost->enc_ctx) {
1223 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1226 ost->enc_ctx->codec_type = type;
1229 AVIOContext *s = NULL;
1230 char *buf = NULL, *arg = NULL, *preset = NULL;
1232 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1234 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1235 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1238 if (!buf[0] || buf[0] == '#') {
1242 if (!(arg = strchr(buf, '='))) {
1243 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1247 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1249 } while (!s->eof_reached);
1253 av_log(NULL, AV_LOG_FATAL,
1254 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1255 preset, ost->file_index, ost->index);
1259 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1262 ost->max_frames = INT64_MAX;
1263 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1264 for (i = 0; i<o->nb_max_frames; i++) {
1265 char *p = o->max_frames[i].specifier;
1266 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1267 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1272 ost->copy_prior_start = -1;
1273 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1275 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1278 if (next = strchr(bsf, ','))
1280 if (arg = strchr(bsf, '='))
1282 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1283 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1287 bsfc_prev->next = bsfc;
1289 ost->bitstream_filters = bsfc;
1291 if (!(bsfc->args = av_strdup(arg))) {
1292 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1300 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1302 uint32_t tag = strtol(codec_tag, &next, 0);
1304 tag = AV_RL32(codec_tag);
1305 ost->st->codec->codec_tag =
1306 ost->enc_ctx->codec_tag = tag;
1309 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1311 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1312 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1315 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1316 ost->disposition = av_strdup(ost->disposition);
1318 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1319 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1321 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1323 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1324 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1325 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1327 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1329 ost->source_index = source_index;
1330 if (source_index >= 0) {
1331 ost->sync_ist = input_streams[source_index];
1332 input_streams[source_index]->discard = 0;
1333 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1335 ost->last_mux_dts = AV_NOPTS_VALUE;
1340 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1343 const char *p = str;
1350 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1357 /* read file contents into a string */
1358 static uint8_t *read_file(const char *filename)
1360 AVIOContext *pb = NULL;
1361 AVIOContext *dyn_buf = NULL;
1362 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1363 uint8_t buf[1024], *str;
1366 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1370 ret = avio_open_dyn_buf(&dyn_buf);
1375 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1376 avio_write(dyn_buf, buf, ret);
1377 avio_w8(dyn_buf, 0);
1380 ret = avio_close_dyn_buf(dyn_buf, &str);
1386 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1389 AVStream *st = ost->st;
1391 if (ost->filters_script && ost->filters) {
1392 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1393 "output stream #%d:%d.\n", nb_output_files, st->index);
1397 if (ost->filters_script)
1398 return read_file(ost->filters_script);
1399 else if (ost->filters)
1400 return av_strdup(ost->filters);
1402 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1406 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1407 const OutputStream *ost, enum AVMediaType type)
1409 if (ost->filters_script || ost->filters) {
1410 av_log(NULL, AV_LOG_ERROR,
1411 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1412 "Filtering and streamcopy cannot be used together.\n",
1413 ost->filters ? "Filtergraph" : "Filtergraph script",
1414 ost->filters ? ost->filters : ost->filters_script,
1415 av_get_media_type_string(type), ost->file_index, ost->index);
1420 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1424 AVCodecContext *video_enc;
1425 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1427 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1429 video_enc = ost->enc_ctx;
1431 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1432 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1433 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1436 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1437 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1439 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1440 if (frame_aspect_ratio) {
1442 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1443 q.num <= 0 || q.den <= 0) {
1444 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1447 ost->frame_aspect_ratio = q;
1450 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1451 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1453 if (!ost->stream_copy) {
1454 const char *p = NULL;
1455 char *frame_size = NULL;
1456 char *frame_pix_fmt = NULL;
1457 char *intra_matrix = NULL, *inter_matrix = NULL;
1458 char *chroma_intra_matrix = NULL;
1462 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1463 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1464 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1468 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1469 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1470 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1471 ost->keep_pix_fmt = 1;
1472 if (!*++frame_pix_fmt)
1473 frame_pix_fmt = NULL;
1475 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1476 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1479 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1482 video_enc->gop_size = 0;
1483 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1485 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1486 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1489 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1491 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1492 if (chroma_intra_matrix) {
1493 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1495 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1498 av_codec_set_chroma_intra_matrix(video_enc, p);
1499 parse_matrix_coeffs(p, chroma_intra_matrix);
1501 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1503 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1504 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1507 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1510 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1511 for (i = 0; p; i++) {
1513 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1515 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1518 video_enc->rc_override =
1519 av_realloc_array(video_enc->rc_override,
1520 i + 1, sizeof(RcOverride));
1521 if (!video_enc->rc_override) {
1522 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1525 video_enc->rc_override[i].start_frame = start;
1526 video_enc->rc_override[i].end_frame = end;
1528 video_enc->rc_override[i].qscale = q;
1529 video_enc->rc_override[i].quality_factor = 1.0;
1532 video_enc->rc_override[i].qscale = 0;
1533 video_enc->rc_override[i].quality_factor = -q/100.0;
1538 video_enc->rc_override_count = i;
1541 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1544 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1547 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1548 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1551 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1552 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1556 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1557 if (ost->logfile_prefix &&
1558 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1562 char logfilename[1024];
1565 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1566 ost->logfile_prefix ? ost->logfile_prefix :
1567 DEFAULT_PASS_LOGFILENAME_PREFIX,
1569 if (!strcmp(ost->enc->name, "libx264")) {
1570 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1572 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1573 char *logbuffer = read_file(logfilename);
1576 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1580 video_enc->stats_in = logbuffer;
1582 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1583 f = av_fopen_utf8(logfilename, "wb");
1585 av_log(NULL, AV_LOG_FATAL,
1586 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1587 logfilename, strerror(errno));
1595 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1596 if (ost->forced_keyframes)
1597 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1599 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1601 ost->top_field_first = -1;
1602 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1605 ost->avfilter = get_ost_filters(o, oc, ost);
1609 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1612 if (ost->stream_copy)
1613 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1618 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1623 AVCodecContext *audio_enc;
1625 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1628 audio_enc = ost->enc_ctx;
1629 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1631 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1632 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1634 if (!ost->stream_copy) {
1635 char *sample_fmt = NULL;
1637 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1639 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1641 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1642 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1646 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1648 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1649 ost->apad = av_strdup(ost->apad);
1651 ost->avfilter = get_ost_filters(o, oc, ost);
1655 /* check for channel mapping for this audio stream */
1656 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1657 AudioChannelMap *map = &o->audio_channel_maps[n];
1658 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1659 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1662 if (map->channel_idx == -1) {
1664 } else if (ost->source_index < 0) {
1665 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1666 ost->file_index, ost->st->index);
1669 ist = input_streams[ost->source_index];
1672 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1673 if (av_reallocp_array(&ost->audio_channels_map,
1674 ost->audio_channels_mapped + 1,
1675 sizeof(*ost->audio_channels_map)
1679 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1685 if (ost->stream_copy)
1686 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1691 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1695 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1696 if (!ost->stream_copy) {
1697 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1704 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1708 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1709 if (!ost->stream_copy) {
1710 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1717 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1719 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1720 ost->stream_copy = 1;
1725 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1729 AVCodecContext *subtitle_enc;
1731 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1733 subtitle_enc = ost->enc_ctx;
1735 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1737 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1739 if (!ost->stream_copy) {
1740 char *frame_size = NULL;
1742 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1743 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1744 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1752 /* arg format is "output-stream-index:streamid-value". */
1753 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1755 OptionsContext *o = optctx;
1760 av_strlcpy(idx_str, arg, sizeof(idx_str));
1761 p = strchr(idx_str, ':');
1763 av_log(NULL, AV_LOG_FATAL,
1764 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1769 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1770 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1771 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1775 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1777 AVFormatContext *is = ifile->ctx;
1778 AVFormatContext *os = ofile->ctx;
1782 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1784 return AVERROR(ENOMEM);
1787 for (i = 0; i < is->nb_chapters; i++) {
1788 AVChapter *in_ch = is->chapters[i], *out_ch;
1789 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1790 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1791 AV_TIME_BASE_Q, in_ch->time_base);
1792 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1793 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1796 if (in_ch->end < ts_off)
1798 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1801 out_ch = av_mallocz(sizeof(AVChapter));
1803 return AVERROR(ENOMEM);
1805 out_ch->id = in_ch->id;
1806 out_ch->time_base = in_ch->time_base;
1807 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1808 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1811 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1813 os->chapters[os->nb_chapters++] = out_ch;
1818 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1821 AVFormatContext *ic = avformat_alloc_context();
1823 ic->interrupt_callback = int_cb;
1824 err = avformat_open_input(&ic, filename, NULL, NULL);
1827 /* copy stream format */
1828 for(i=0;i<ic->nb_streams;i++) {
1832 const char *enc_config;
1834 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1836 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1837 return AVERROR(EINVAL);
1839 if (codec->type == AVMEDIA_TYPE_AUDIO)
1840 opt_audio_codec(o, "c:a", codec->name);
1841 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1842 opt_video_codec(o, "c:v", codec->name);
1843 ost = new_output_stream(o, s, codec->type, -1);
1846 avcodec_get_context_defaults3(st->codec, codec);
1847 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1849 AVDictionary *opts = NULL;
1850 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1851 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1852 av_dict_free(&opts);
1855 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1856 choose_sample_fmt(st, codec);
1857 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1858 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1859 avcodec_copy_context(ost->enc_ctx, st->codec);
1861 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1864 avformat_close_input(&ic);
1868 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1869 AVFormatContext *oc)
1873 switch (ofilter->type) {
1874 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1875 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1877 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1882 ost->source_index = -1;
1883 ost->filter = ofilter;
1887 if (ost->stream_copy) {
1888 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1889 "which is fed from a complex filtergraph. Filtering and streamcopy "
1890 "cannot be used together.\n", ost->file_index, ost->index);
1894 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1895 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1896 av_log(NULL, AV_LOG_ERROR,
1897 "%s '%s' was specified through the %s option "
1898 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1899 "%s and -filter_complex cannot be used together for the same stream.\n",
1900 ost->filters ? "Filtergraph" : "Filtergraph script",
1901 ost->filters ? ost->filters : ost->filters_script,
1902 opt, ost->file_index, ost->index, opt);
1906 avfilter_inout_free(&ofilter->out_tmp);
1909 static int init_complex_filters(void)
1913 for (i = 0; i < nb_filtergraphs; i++) {
1914 ret = init_complex_filtergraph(filtergraphs[i]);
1921 static int configure_complex_filters(void)
1925 for (i = 0; i < nb_filtergraphs; i++)
1926 if (!filtergraphs[i]->graph &&
1927 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1932 static int open_output_file(OptionsContext *o, const char *filename)
1934 AVFormatContext *oc;
1936 AVOutputFormat *file_oformat;
1940 AVDictionary *unused_opts = NULL;
1941 AVDictionaryEntry *e = NULL;
1944 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1945 o->stop_time = INT64_MAX;
1946 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1949 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1950 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1951 if (o->stop_time <= start_time) {
1952 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1955 o->recording_time = o->stop_time - start_time;
1959 GROW_ARRAY(output_files, nb_output_files);
1960 of = av_mallocz(sizeof(*of));
1963 output_files[nb_output_files - 1] = of;
1965 of->ost_index = nb_output_streams;
1966 of->recording_time = o->recording_time;
1967 of->start_time = o->start_time;
1968 of->limit_filesize = o->limit_filesize;
1969 of->shortest = o->shortest;
1970 av_dict_copy(&of->opts, o->g->format_opts, 0);
1972 if (!strcmp(filename, "-"))
1975 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1977 print_error(filename, err);
1982 if (o->recording_time != INT64_MAX)
1983 oc->duration = o->recording_time;
1985 file_oformat= oc->oformat;
1986 oc->interrupt_callback = int_cb;
1988 /* create streams for all unlabeled output pads */
1989 for (i = 0; i < nb_filtergraphs; i++) {
1990 FilterGraph *fg = filtergraphs[i];
1991 for (j = 0; j < fg->nb_outputs; j++) {
1992 OutputFilter *ofilter = fg->outputs[j];
1994 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1997 switch (ofilter->type) {
1998 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1999 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2000 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2002 init_output_filter(ofilter, o, oc);
2006 /* ffserver seeking with date=... needs a date reference */
2007 if (!strcmp(file_oformat->name, "ffm") &&
2008 av_strstart(filename, "http:", NULL)) {
2009 int err = parse_option(o, "metadata", "creation_time=now", options);
2011 print_error(filename, err);
2016 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2017 av_strstart(filename, "http:", NULL)) {
2019 /* special case for files sent to ffserver: we get the stream
2020 parameters from ffserver */
2021 int err = read_ffserver_streams(o, oc, filename);
2023 print_error(filename, err);
2026 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2027 ost = output_streams[j];
2028 for (i = 0; i < nb_input_streams; i++) {
2029 ist = input_streams[i];
2030 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
2032 ost->source_index= i;
2033 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2034 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2036 ist->st->discard = ist->user_set_discard;
2041 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));
2045 } else if (!o->nb_stream_maps) {
2046 char *subtitle_codec_name = NULL;
2047 /* pick the "best" stream of each type */
2049 /* video: highest resolution */
2050 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2051 int area = 0, idx = -1;
2052 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2053 for (i = 0; i < nb_input_streams; i++) {
2055 ist = input_streams[i];
2056 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
2057 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2059 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2061 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2068 new_video_stream(o, oc, idx);
2071 /* audio: most channels */
2072 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2073 int best_score = 0, idx = -1;
2074 for (i = 0; i < nb_input_streams; i++) {
2076 ist = input_streams[i];
2077 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2078 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2079 score > best_score) {
2085 new_audio_stream(o, oc, idx);
2088 /* subtitles: pick first */
2089 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2090 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2091 for (i = 0; i < nb_input_streams; i++)
2092 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2093 AVCodecDescriptor const *input_descriptor =
2094 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2095 AVCodecDescriptor const *output_descriptor = NULL;
2096 AVCodec const *output_codec =
2097 avcodec_find_encoder(oc->oformat->subtitle_codec);
2098 int input_props = 0, output_props = 0;
2100 output_descriptor = avcodec_descriptor_get(output_codec->id);
2101 if (input_descriptor)
2102 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2103 if (output_descriptor)
2104 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2105 if (subtitle_codec_name ||
2106 input_props & output_props ||
2107 // Map dvb teletext which has neither property to any output subtitle encoder
2108 input_descriptor && output_descriptor &&
2109 (!input_descriptor->props ||
2110 !output_descriptor->props)) {
2111 new_subtitle_stream(o, oc, i);
2116 /* Data only if codec id match */
2117 if (!o->data_disable ) {
2118 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2119 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2120 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2121 && input_streams[i]->st->codec->codec_id == codec_id )
2122 new_data_stream(o, oc, i);
2126 for (i = 0; i < o->nb_stream_maps; i++) {
2127 StreamMap *map = &o->stream_maps[i];
2132 if (map->linklabel) {
2134 OutputFilter *ofilter = NULL;
2137 for (j = 0; j < nb_filtergraphs; j++) {
2138 fg = filtergraphs[j];
2139 for (k = 0; k < fg->nb_outputs; k++) {
2140 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2141 if (out && !strcmp(out->name, map->linklabel)) {
2142 ofilter = fg->outputs[k];
2149 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2150 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2153 init_output_filter(ofilter, o, oc);
2155 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2157 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2158 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2160 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2162 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2164 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2168 switch (ist->st->codec->codec_type) {
2169 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2170 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2171 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2172 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2173 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2174 case AVMEDIA_TYPE_UNKNOWN:
2175 if (copy_unknown_streams) {
2176 ost = new_unknown_stream (o, oc, src_idx);
2180 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2181 "Cannot map stream #%d:%d - unsupported type.\n",
2182 map->file_index, map->stream_index);
2183 if (!ignore_unknown_streams) {
2184 av_log(NULL, AV_LOG_FATAL,
2185 "If you want unsupported types ignored instead "
2186 "of failing, please use the -ignore_unknown option\n"
2187 "If you want them copied, please use -copy_unknown\n");
2192 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2193 + map->sync_stream_index];
2198 /* handle attached files */
2199 for (i = 0; i < o->nb_attachments; i++) {
2201 uint8_t *attachment;
2205 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2206 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2210 if ((len = avio_size(pb)) <= 0) {
2211 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2215 if (!(attachment = av_malloc(len))) {
2216 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2220 avio_read(pb, attachment, len);
2222 ost = new_attachment_stream(o, oc, -1);
2223 ost->stream_copy = 1;
2224 ost->attachment_filename = o->attachments[i];
2226 ost->st->codec->extradata = attachment;
2227 ost->st->codec->extradata_size = len;
2229 p = strrchr(o->attachments[i], '/');
2230 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2234 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2235 AVDictionaryEntry *e;
2236 ost = output_streams[i];
2238 if ((ost->stream_copy || ost->attachment_filename)
2239 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2240 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2241 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2245 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2246 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2247 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2251 /* check if all codec options have been used */
2252 unused_opts = strip_specifiers(o->g->codec_opts);
2253 for (i = of->ost_index; i < nb_output_streams; i++) {
2255 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2256 AV_DICT_IGNORE_SUFFIX)))
2257 av_dict_set(&unused_opts, e->key, NULL, 0);
2261 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2262 const AVClass *class = avcodec_get_class();
2263 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2264 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2265 const AVClass *fclass = avformat_get_class();
2266 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2267 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2268 if (!option || foption)
2272 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2273 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2274 "output file #%d (%s) is not an encoding option.\n", e->key,
2275 option->help ? option->help : "", nb_output_files - 1,
2280 // gop_timecode is injected by generic code but not always used
2281 if (!strcmp(e->key, "gop_timecode"))
2284 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2285 "output file #%d (%s) has not been used for any stream. The most "
2286 "likely reason is either wrong type (e.g. a video option with "
2287 "no video streams) or that it is a private option of some encoder "
2288 "which was not actually used for any stream.\n", e->key,
2289 option->help ? option->help : "", nb_output_files - 1, filename);
2291 av_dict_free(&unused_opts);
2293 /* set the encoding/decoding_needed flags */
2294 for (i = of->ost_index; i < nb_output_streams; i++) {
2295 OutputStream *ost = output_streams[i];
2297 ost->encoding_needed = !ost->stream_copy;
2298 if (ost->encoding_needed && ost->source_index >= 0) {
2299 InputStream *ist = input_streams[ost->source_index];
2300 ist->decoding_needed |= DECODING_FOR_OST;
2304 /* check filename in case of an image number is expected */
2305 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2306 if (!av_filename_number_test(oc->filename)) {
2307 print_error(oc->filename, AVERROR(EINVAL));
2312 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2313 av_log(NULL, AV_LOG_ERROR,
2314 "No input streams but output needs an input stream\n");
2318 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2319 /* test if it already exists to avoid losing precious files */
2320 assert_file_overwrite(filename);
2323 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2324 &oc->interrupt_callback,
2326 print_error(filename, err);
2329 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2330 assert_file_overwrite(filename);
2332 if (o->mux_preload) {
2333 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2335 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2338 for (i = 0; i < o->nb_metadata_map; i++) {
2340 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2342 if (in_file_index >= nb_input_files) {
2343 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2346 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2347 in_file_index >= 0 ?
2348 input_files[in_file_index]->ctx : NULL, o);
2352 if (o->chapters_input_file >= nb_input_files) {
2353 if (o->chapters_input_file == INT_MAX) {
2354 /* copy chapters from the first input file that has them*/
2355 o->chapters_input_file = -1;
2356 for (i = 0; i < nb_input_files; i++)
2357 if (input_files[i]->ctx->nb_chapters) {
2358 o->chapters_input_file = i;
2362 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2363 o->chapters_input_file);
2367 if (o->chapters_input_file >= 0)
2368 copy_chapters(input_files[o->chapters_input_file], of,
2369 !o->metadata_chapters_manual);
2371 /* copy global metadata by default */
2372 if (!o->metadata_global_manual && nb_input_files){
2373 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2374 AV_DICT_DONT_OVERWRITE);
2375 if(o->recording_time != INT64_MAX)
2376 av_dict_set(&oc->metadata, "duration", NULL, 0);
2377 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2379 if (!o->metadata_streams_manual)
2380 for (i = of->ost_index; i < nb_output_streams; i++) {
2382 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2384 ist = input_streams[output_streams[i]->source_index];
2385 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2386 if (!output_streams[i]->stream_copy) {
2387 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2388 if (ist->autorotate)
2389 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2393 /* process manually set programs */
2394 for (i = 0; i < o->nb_program; i++) {
2395 const char *p = o->program[i].u.str;
2400 const char *p2 = av_get_token(&p, ":");
2401 const char *to_dealloc = p2;
2408 key = av_get_token(&p2, "=");
2410 av_freep(&to_dealloc);
2416 if (!strcmp(key, "program_num"))
2417 progid = strtol(p2, NULL, 0);
2418 av_freep(&to_dealloc);
2422 program = av_new_program(oc, progid);
2424 p = o->program[i].u.str;
2426 const char *p2 = av_get_token(&p, ":");
2427 const char *to_dealloc = p2;
2433 key = av_get_token(&p2, "=");
2435 av_log(NULL, AV_LOG_FATAL,
2436 "No '=' character in program string %s.\n",
2444 if (!strcmp(key, "title")) {
2445 av_dict_set(&program->metadata, "title", p2, 0);
2446 } else if (!strcmp(key, "program_num")) {
2447 } else if (!strcmp(key, "st")) {
2448 int st_num = strtol(p2, NULL, 0);
2449 av_program_add_stream_index(oc, progid, st_num);
2451 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2454 av_freep(&to_dealloc);
2459 /* process manually set metadata */
2460 for (i = 0; i < o->nb_metadata; i++) {
2463 const char *stream_spec;
2464 int index = 0, j, ret = 0;
2466 val = strchr(o->metadata[i].u.str, '=');
2468 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2469 o->metadata[i].u.str);
2474 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2476 for (j = 0; j < oc->nb_streams; j++) {
2477 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2478 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2479 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2480 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2481 ost->rotate_overridden = 1;
2493 if (index < 0 || index >= oc->nb_chapters) {
2494 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2497 m = &oc->chapters[index]->metadata;
2500 if (index < 0 || index >= oc->nb_programs) {
2501 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2504 m = &oc->programs[index]->metadata;
2507 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2510 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2517 static int opt_target(void *optctx, const char *opt, const char *arg)
2519 OptionsContext *o = optctx;
2520 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2521 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2523 if (!strncmp(arg, "pal-", 4)) {
2526 } else if (!strncmp(arg, "ntsc-", 5)) {
2529 } else if (!strncmp(arg, "film-", 5)) {
2533 /* Try to determine PAL/NTSC by peeking in the input files */
2534 if (nb_input_files) {
2536 for (j = 0; j < nb_input_files; j++) {
2537 for (i = 0; i < input_files[j]->nb_streams; i++) {
2538 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2539 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2542 fr = c->time_base.den * 1000 / c->time_base.num;
2546 } else if ((fr == 29970) || (fr == 23976)) {
2551 if (norm != UNKNOWN)
2555 if (norm != UNKNOWN)
2556 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2559 if (norm == UNKNOWN) {
2560 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2561 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2562 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2566 if (!strcmp(arg, "vcd")) {
2567 opt_video_codec(o, "c:v", "mpeg1video");
2568 opt_audio_codec(o, "c:a", "mp2");
2569 parse_option(o, "f", "vcd", options);
2571 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2572 parse_option(o, "r", frame_rates[norm], options);
2573 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2575 opt_default(NULL, "b:v", "1150000");
2576 opt_default(NULL, "maxrate:v", "1150000");
2577 opt_default(NULL, "minrate:v", "1150000");
2578 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2580 opt_default(NULL, "b:a", "224000");
2581 parse_option(o, "ar", "44100", options);
2582 parse_option(o, "ac", "2", options);
2584 opt_default(NULL, "packetsize", "2324");
2585 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2587 /* We have to offset the PTS, so that it is consistent with the SCR.
2588 SCR starts at 36000, but the first two packs contain only padding
2589 and the first pack from the other stream, respectively, may also have
2590 been written before.
2591 So the real data starts at SCR 36000+3*1200. */
2592 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2593 } else if (!strcmp(arg, "svcd")) {
2595 opt_video_codec(o, "c:v", "mpeg2video");
2596 opt_audio_codec(o, "c:a", "mp2");
2597 parse_option(o, "f", "svcd", options);
2599 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2600 parse_option(o, "r", frame_rates[norm], options);
2601 parse_option(o, "pix_fmt", "yuv420p", options);
2602 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2604 opt_default(NULL, "b:v", "2040000");
2605 opt_default(NULL, "maxrate:v", "2516000");
2606 opt_default(NULL, "minrate:v", "0"); // 1145000;
2607 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2608 opt_default(NULL, "scan_offset", "1");
2610 opt_default(NULL, "b:a", "224000");
2611 parse_option(o, "ar", "44100", options);
2613 opt_default(NULL, "packetsize", "2324");
2615 } else if (!strcmp(arg, "dvd")) {
2617 opt_video_codec(o, "c:v", "mpeg2video");
2618 opt_audio_codec(o, "c:a", "ac3");
2619 parse_option(o, "f", "dvd", options);
2621 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2622 parse_option(o, "r", frame_rates[norm], options);
2623 parse_option(o, "pix_fmt", "yuv420p", options);
2624 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2626 opt_default(NULL, "b:v", "6000000");
2627 opt_default(NULL, "maxrate:v", "9000000");
2628 opt_default(NULL, "minrate:v", "0"); // 1500000;
2629 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2631 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2632 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2634 opt_default(NULL, "b:a", "448000");
2635 parse_option(o, "ar", "48000", options);
2637 } else if (!strncmp(arg, "dv", 2)) {
2639 parse_option(o, "f", "dv", options);
2641 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2642 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2643 norm == PAL ? "yuv420p" : "yuv411p", options);
2644 parse_option(o, "r", frame_rates[norm], options);
2646 parse_option(o, "ar", "48000", options);
2647 parse_option(o, "ac", "2", options);
2650 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2651 return AVERROR(EINVAL);
2654 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2655 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2660 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2662 av_free (vstats_filename);
2663 vstats_filename = av_strdup (arg);
2667 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2670 time_t today2 = time(NULL);
2671 struct tm *today = localtime(&today2);
2673 if (!today) { // maybe tomorrow
2674 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2678 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2680 return opt_vstats_file(NULL, opt, filename);
2683 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2685 OptionsContext *o = optctx;
2686 return parse_option(o, "frames:v", arg, options);
2689 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2691 OptionsContext *o = optctx;
2692 return parse_option(o, "frames:a", arg, options);
2695 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2697 OptionsContext *o = optctx;
2698 return parse_option(o, "frames:d", arg, options);
2701 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2704 AVDictionary *cbak = codec_opts;
2705 AVDictionary *fbak = format_opts;
2709 ret = opt_default(NULL, opt, arg);
2711 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2712 av_dict_copy(&o->g->format_opts, format_opts, 0);
2713 av_dict_free(&codec_opts);
2714 av_dict_free(&format_opts);
2721 static int opt_preset(void *optctx, const char *opt, const char *arg)
2723 OptionsContext *o = optctx;
2725 char filename[1000], line[1000], tmp_line[1000];
2726 const char *codec_name = NULL;
2730 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2732 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2733 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2734 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2736 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2740 while (fgets(line, sizeof(line), f)) {
2741 char *key = tmp_line, *value, *endptr;
2743 if (strcspn(line, "#\n\r") == 0)
2745 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2746 if (!av_strtok(key, "=", &value) ||
2747 !av_strtok(value, "\r\n", &endptr)) {
2748 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2751 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2753 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2754 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2755 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2756 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2757 else if (opt_default_new(o, key, value) < 0) {
2758 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2759 filename, line, key, value);
2769 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2771 OptionsContext *o = optctx;
2772 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2773 int ret = parse_option(o, s, arg, options);
2778 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2780 OptionsContext *o = optctx;
2782 if(!strcmp(opt, "ab")){
2783 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2785 } else if(!strcmp(opt, "b")){
2786 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2787 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2790 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2794 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2796 OptionsContext *o = optctx;
2799 if(!strcmp(opt, "qscale")){
2800 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2801 return parse_option(o, "q:v", arg, options);
2803 s = av_asprintf("q%s", opt + 6);
2804 ret = parse_option(o, s, arg, options);
2809 static int opt_profile(void *optctx, const char *opt, const char *arg)
2811 OptionsContext *o = optctx;
2812 if(!strcmp(opt, "profile")){
2813 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2814 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2817 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2821 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2823 OptionsContext *o = optctx;
2824 return parse_option(o, "filter:v", arg, options);
2827 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2829 OptionsContext *o = optctx;
2830 return parse_option(o, "filter:a", arg, options);
2833 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2835 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2836 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2837 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2838 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2840 if (video_sync_method == VSYNC_AUTO)
2841 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2845 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2847 OptionsContext *o = optctx;
2848 char *tcr = av_asprintf("timecode=%s", arg);
2849 int ret = parse_option(o, "metadata:g", tcr, options);
2851 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2856 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2858 OptionsContext *o = optctx;
2859 char layout_str[32];
2862 int ret, channels, ac_str_size;
2865 layout = av_get_channel_layout(arg);
2867 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2868 return AVERROR(EINVAL);
2870 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2871 ret = opt_default_new(o, opt, layout_str);
2875 /* set 'ac' option based on channel layout */
2876 channels = av_get_channel_layout_nb_channels(layout);
2877 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2878 stream_str = strchr(opt, ':');
2879 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2880 ac_str = av_mallocz(ac_str_size);
2882 return AVERROR(ENOMEM);
2883 av_strlcpy(ac_str, "ac", 3);
2885 av_strlcat(ac_str, stream_str, ac_str_size);
2886 ret = parse_option(o, ac_str, layout_str, options);
2892 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2894 OptionsContext *o = optctx;
2895 return parse_option(o, "q:a", arg, options);
2898 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2900 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2901 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2902 return AVERROR(ENOMEM);
2903 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2904 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2905 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2906 return AVERROR(ENOMEM);
2908 input_stream_potentially_available = 1;
2913 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2915 uint8_t *graph_desc = read_file(arg);
2917 return AVERROR(EINVAL);
2919 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2920 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2921 return AVERROR(ENOMEM);
2922 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2923 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2925 input_stream_potentially_available = 1;
2930 void show_help_default(const char *opt, const char *arg)
2932 /* per-file options have at least one of those set */
2933 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2934 int show_advanced = 0, show_avoptions = 0;
2937 if (!strcmp(opt, "long"))
2939 else if (!strcmp(opt, "full"))
2940 show_advanced = show_avoptions = 1;
2942 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2947 printf("Getting help:\n"
2948 " -h -- print basic options\n"
2949 " -h long -- print more options\n"
2950 " -h full -- print all options (including all format and codec specific options, very long)\n"
2951 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2952 " See man %s for detailed description of the options.\n"
2953 "\n", program_name);
2955 show_help_options(options, "Print help / information / capabilities:",
2958 show_help_options(options, "Global options (affect whole program "
2959 "instead of just one file:",
2960 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2962 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2963 per_file | OPT_EXIT, 0);
2965 show_help_options(options, "Per-file main options:", 0,
2966 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2967 OPT_EXIT, per_file);
2969 show_help_options(options, "Advanced per-file options:",
2970 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2972 show_help_options(options, "Video options:",
2973 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2975 show_help_options(options, "Advanced Video options:",
2976 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2978 show_help_options(options, "Audio options:",
2979 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2981 show_help_options(options, "Advanced Audio options:",
2982 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2983 show_help_options(options, "Subtitle options:",
2984 OPT_SUBTITLE, 0, 0);
2987 if (show_avoptions) {
2988 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2989 show_help_children(avcodec_get_class(), flags);
2990 show_help_children(avformat_get_class(), flags);
2992 show_help_children(sws_get_class(), flags);
2994 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2995 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2999 void show_usage(void)
3001 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3002 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3003 av_log(NULL, AV_LOG_INFO, "\n");
3011 static const OptionGroupDef groups[] = {
3012 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
3013 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
3016 static int open_files(OptionGroupList *l, const char *inout,
3017 int (*open_file)(OptionsContext*, const char*))
3021 for (i = 0; i < l->nb_groups; i++) {
3022 OptionGroup *g = &l->groups[i];
3028 ret = parse_optgroup(&o, g);
3030 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3031 "%s.\n", inout, g->arg);
3035 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3036 ret = open_file(&o, g->arg);
3039 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3043 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3049 int ffmpeg_parse_options(int argc, char **argv)
3051 OptionParseContext octx;
3055 memset(&octx, 0, sizeof(octx));
3057 /* split the commandline into an internal representation */
3058 ret = split_commandline(&octx, argc, argv, options, groups,
3059 FF_ARRAY_ELEMS(groups));
3061 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3065 /* apply global options */
3066 ret = parse_optgroup(NULL, &octx.global_opts);
3068 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3072 /* open input files */
3073 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3075 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3079 /* create the complex filtergraphs */
3080 ret = init_complex_filters();
3082 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3086 /* open output files */
3087 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3089 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3093 /* configure the complex filtergraphs */
3094 ret = configure_complex_filters();
3096 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3101 uninit_parse_context(&octx);
3103 av_strerror(ret, error, sizeof(error));
3104 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3109 static int opt_progress(void *optctx, const char *opt, const char *arg)
3111 AVIOContext *avio = NULL;
3114 if (!strcmp(arg, "-"))
3116 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3118 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3119 arg, av_err2str(ret));
3122 progress_avio = avio;
3126 #define OFFSET(x) offsetof(OptionsContext, x)
3127 const OptionDef options[] = {
3129 #include "cmdutils_common_opts.h"
3130 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3131 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3132 "force format", "fmt" },
3133 { "y", OPT_BOOL, { &file_overwrite },
3134 "overwrite output files" },
3135 { "n", OPT_BOOL, { &no_file_overwrite },
3136 "never overwrite output files" },
3137 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3138 "Ignore unknown stream types" },
3139 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3140 "Copy unknown stream types" },
3141 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3142 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3143 "codec name", "codec" },
3144 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3145 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3146 "codec name", "codec" },
3147 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3148 OPT_OUTPUT, { .off = OFFSET(presets) },
3149 "preset name", "preset" },
3150 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3151 OPT_OUTPUT, { .func_arg = opt_map },
3152 "set input stream mapping",
3153 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3154 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3155 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3156 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3157 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3158 "set metadata information of outfile from infile",
3159 "outfile[,metadata]:infile[,metadata]" },
3160 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3161 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3162 "set chapters mapping", "input_file_index" },
3163 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3164 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3165 "record or transcode \"duration\" seconds of audio/video",
3167 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3168 "record or transcode stop time", "time_stop" },
3169 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3170 "set the limit file size in bytes", "limit_size" },
3171 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3172 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3173 "set the start time offset", "time_off" },
3174 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3175 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3176 "set the start time offset relative to EOF", "time_off" },
3177 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3178 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3179 "enable/disable seeking by timestamp with -ss" },
3180 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3181 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3182 "enable/disable accurate seeking with -ss" },
3183 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3184 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3185 "set the input ts offset", "time_off" },
3186 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3187 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3188 "set the input ts scale", "scale" },
3189 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3190 "set the recording timestamp ('now' to set the current time)", "time" },
3191 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3192 "add metadata", "string=string" },
3193 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3194 "add program with specified streams", "title=string:st=number..." },
3195 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3196 OPT_OUTPUT, { .func_arg = opt_data_frames },
3197 "set the number of data frames to output", "number" },
3198 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3199 "add timings for benchmarking" },
3200 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3201 "add timings for each task" },
3202 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3203 "write program-readable progress information", "url" },
3204 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3205 "enable or disable interaction on standard input" },
3206 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3207 "set max runtime in seconds", "limit" },
3208 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3209 "dump each input packet" },
3210 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3211 "when dumping packets, also dump the payload" },
3212 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3213 OPT_INPUT, { .off = OFFSET(rate_emu) },
3214 "read input at native frame rate", "" },
3215 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3216 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3217 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3218 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3219 "video sync method", "" },
3220 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3221 "frame drop threshold", "" },
3222 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3223 "audio sync method", "" },
3224 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3225 "audio drift threshold", "threshold" },
3226 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3227 "copy timestamps" },
3228 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3229 "shift input timestamps to start at 0 when using copyts" },
3230 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3231 "copy input stream time base when stream copying", "mode" },
3232 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3233 OPT_OUTPUT, { .off = OFFSET(shortest) },
3234 "finish encoding within shortest input" },
3235 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3236 OPT_OUTPUT, { .off = OFFSET(apad) },
3238 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3239 "timestamp discontinuity delta threshold", "threshold" },
3240 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3241 "timestamp error delta threshold", "threshold" },
3242 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3243 "exit on error", "error" },
3244 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3245 "abort on the specified condition flags", "flags" },
3246 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3247 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3248 "copy initial non-keyframes" },
3249 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3250 "copy or discard frames before start time" },
3251 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3252 "set the number of frames to output", "number" },
3253 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3254 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3255 "force codec tag/fourcc", "fourcc/tag" },
3256 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3257 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3258 "use fixed quality scale (VBR)", "q" },
3259 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3260 OPT_OUTPUT, { .func_arg = opt_qscale },
3261 "use fixed quality scale (VBR)", "q" },
3262 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3263 "set profile", "profile" },
3264 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3265 "set stream filtergraph", "filter_graph" },
3266 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3267 "read stream filtergraph description from a file", "filename" },
3268 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3269 "reinit filtergraph on input parameter changes", "" },
3270 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3271 "create a complex filtergraph", "graph_description" },
3272 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3273 "create a complex filtergraph", "graph_description" },
3274 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3275 "read complex filtergraph description from a file", "filename" },
3276 { "stats", OPT_BOOL, { &print_stats },
3277 "print progress report during encoding", },
3278 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3279 OPT_OUTPUT, { .func_arg = opt_attach },
3280 "add an attachment to the output file", "filename" },
3281 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3282 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3283 "extract an attachment into a file", "filename" },
3284 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3285 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3286 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3287 "print timestamp debugging info" },
3288 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3289 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3290 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3291 OPT_INPUT, { .off = OFFSET(discard) },
3293 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3294 OPT_OUTPUT, { .off = OFFSET(disposition) },
3295 "disposition", "" },
3296 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3297 { .off = OFFSET(thread_queue_size) },
3298 "set the maximum number of queued packets from the demuxer" },
3301 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3302 "set the number of video frames to output", "number" },
3303 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3304 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3305 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3306 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3307 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3308 "set frame size (WxH or abbreviation)", "size" },
3309 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3310 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3311 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3312 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3313 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3314 "set pixel format", "format" },
3315 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3316 "set the number of bits per raw sample", "number" },
3317 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3318 "deprecated use -g 1" },
3319 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3321 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3322 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3323 "rate control override for specific intervals", "override" },
3324 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3325 OPT_OUTPUT, { .func_arg = opt_video_codec },
3326 "force video codec ('copy' to copy stream)", "codec" },
3327 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3329 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3331 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3332 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3333 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3334 "select the pass number (1 to 3)", "n" },
3335 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3336 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3337 "select two pass log file name prefix", "prefix" },
3338 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3339 "this option is deprecated, use the yadif filter instead" },
3340 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3341 "calculate PSNR of compressed frames" },
3342 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3343 "dump video coding statistics to file" },
3344 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3345 "dump video coding statistics to file", "file" },
3346 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3347 "set video filters", "filter_graph" },
3348 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3349 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3350 "specify intra matrix coeffs", "matrix" },
3351 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3352 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3353 "specify inter matrix coeffs", "matrix" },
3354 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3355 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3356 "specify intra matrix coeffs", "matrix" },
3357 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3358 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3359 "top=1/bottom=0/auto=-1 field first", "" },
3360 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3361 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3362 "force video tag/fourcc", "fourcc/tag" },
3363 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3364 "show QP histogram" },
3365 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3366 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3367 "force the selected framerate, disable the best supported framerate selection" },
3368 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3369 OPT_OUTPUT, { .func_arg = opt_streamid },
3370 "set the value of an outfile streamid", "streamIndex:value" },
3371 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3372 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3373 "force key frames at specified timestamps", "timestamps" },
3374 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3375 "audio bitrate (please use -b:a)", "bitrate" },
3376 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3377 "video bitrate (please use -b:v)", "bitrate" },
3378 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3379 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3380 "use HW accelerated decoding", "hwaccel name" },
3381 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3382 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3383 "select a device for HW acceleration", "devicename" },
3384 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3385 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3386 "select output format used with HW accelerated decoding", "format" },
3387 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3388 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3390 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3391 "show available HW acceleration methods" },
3392 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3393 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3394 "automatically insert correct rotate filters" },
3395 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3396 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3399 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3400 "set the number of audio frames to output", "number" },
3401 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3402 "set audio quality (codec-specific)", "quality", },
3403 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3404 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3405 "set audio sampling rate (in Hz)", "rate" },
3406 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3407 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3408 "set number of audio channels", "channels" },
3409 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3411 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3412 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3413 "force audio codec ('copy' to copy stream)", "codec" },
3414 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3415 OPT_OUTPUT, { .func_arg = opt_old2new },
3416 "force audio tag/fourcc", "fourcc/tag" },
3417 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3418 "change audio volume (256=normal)" , "volume" },
3419 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3420 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3421 "set sample format", "format" },
3422 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3423 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3424 "set channel layout", "layout" },
3425 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3426 "set audio filters", "filter_graph" },
3427 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3428 "set the maximum number of channels to try to guess the channel layout" },
3430 /* subtitle options */
3431 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3432 "disable subtitle" },
3433 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3434 "force subtitle codec ('copy' to copy stream)", "codec" },
3435 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3436 , "force subtitle tag/fourcc", "fourcc/tag" },
3437 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3438 "fix subtitles duration" },
3439 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3440 "set canvas size (WxH or abbreviation)", "size" },
3443 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3444 "deprecated, use -channel", "channel" },
3445 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3446 "deprecated, use -standard", "standard" },
3447 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3450 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3451 "set the maximum demux-decode delay", "seconds" },
3452 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3453 "set the initial demux-decode delay", "seconds" },
3454 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3455 "override the options from ffserver", "" },
3456 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3457 "specify a file in which to print sdp information", "file" },
3459 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3460 "A comma-separated list of bitstream filters", "bitstream_filters" },
3461 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3462 "deprecated", "audio bitstream_filters" },
3463 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3464 "deprecated", "video bitstream_filters" },
3466 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3467 "set the audio options to the indicated preset", "preset" },
3468 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3469 "set the video options to the indicated preset", "preset" },
3470 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3471 "set the subtitle options to the indicated preset", "preset" },
3472 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3473 "set options from indicated preset file", "filename" },
3474 /* data codec support */
3475 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3476 "force data codec ('copy' to copy stream)", "codec" },
3477 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3481 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3482 "set VAAPI hardware device (DRM path or X11 display name)", "device" },