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[] = {
69 #if CONFIG_VIDEOTOOLBOX
70 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
73 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
76 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
80 AVBufferRef *hw_device_ctx;
81 HWDevice *filter_hw_device;
83 char *vstats_filename;
86 float audio_drift_threshold = 0.1;
87 float dts_delta_threshold = 10;
88 float dts_error_threshold = 3600*30;
90 int audio_volume = 256;
91 int audio_sync_method = 0;
92 int video_sync_method = VSYNC_AUTO;
93 float frame_drop_threshold = 0;
94 int do_deinterlace = 0;
96 int do_benchmark_all = 0;
100 int start_at_zero = 0;
103 int exit_on_error = 0;
104 int abort_on_flags = 0;
105 int print_stats = -1;
107 int stdin_interaction = 1;
108 int frame_bits_per_raw_sample = 0;
109 float max_error_rate = 2.0/3;
110 int filter_nbthreads = 0;
111 int filter_complex_nbthreads = 0;
112 int vstats_version = 2;
115 static int intra_only = 0;
116 static int file_overwrite = 0;
117 static int no_file_overwrite = 0;
118 static int do_psnr = 0;
119 static int input_sync;
120 static int override_ffserver = 0;
121 static int input_stream_potentially_available = 0;
122 static int ignore_unknown_streams = 0;
123 static int copy_unknown_streams = 0;
124 static int find_stream_info = 1;
126 static void uninit_options(OptionsContext *o)
128 const OptionDef *po = options;
131 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
133 void *dst = (uint8_t*)o + po->u.off;
135 if (po->flags & OPT_SPEC) {
136 SpecifierOpt **so = dst;
137 int i, *count = (int*)(so + 1);
138 for (i = 0; i < *count; i++) {
139 av_freep(&(*so)[i].specifier);
140 if (po->flags & OPT_STRING)
141 av_freep(&(*so)[i].u.str);
145 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
150 for (i = 0; i < o->nb_stream_maps; i++)
151 av_freep(&o->stream_maps[i].linklabel);
152 av_freep(&o->stream_maps);
153 av_freep(&o->audio_channel_maps);
154 av_freep(&o->streamid_map);
155 av_freep(&o->attachments);
158 static void init_options(OptionsContext *o)
160 memset(o, 0, sizeof(*o));
162 o->stop_time = INT64_MAX;
163 o->mux_max_delay = 0.7;
164 o->start_time = AV_NOPTS_VALUE;
165 o->start_time_eof = AV_NOPTS_VALUE;
166 o->recording_time = INT64_MAX;
167 o->limit_filesize = UINT64_MAX;
168 o->chapters_input_file = INT_MAX;
169 o->accurate_seek = 1;
172 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
174 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
177 printf("Hardware acceleration methods:\n");
178 while ((type = av_hwdevice_iterate_types(type)) !=
179 AV_HWDEVICE_TYPE_NONE)
180 printf("%s\n", av_hwdevice_get_type_name(type));
181 for (i = 0; hwaccels[i].name; i++)
182 printf("%s\n", hwaccels[i].name);
187 /* return a copy of the input with the stream specifiers removed from the keys */
188 static AVDictionary *strip_specifiers(AVDictionary *dict)
190 AVDictionaryEntry *e = NULL;
191 AVDictionary *ret = NULL;
193 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
194 char *p = strchr(e->key, ':');
198 av_dict_set(&ret, e->key, e->value, 0);
205 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
207 static const AVOption opts[] = {
208 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
209 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
212 static const AVClass class = {
214 .item_name = av_default_item_name,
216 .version = LIBAVUTIL_VERSION_INT,
218 const AVClass *pclass = &class;
220 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
223 static int opt_sameq(void *optctx, const char *opt, const char *arg)
225 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
226 "If you are looking for an option to preserve the quality (which is not "
227 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
229 return AVERROR(EINVAL);
232 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
234 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
235 return opt_default(optctx, "channel", arg);
238 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
240 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
241 return opt_default(optctx, "standard", arg);
244 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
246 OptionsContext *o = optctx;
247 return parse_option(o, "codec:a", arg, options);
250 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
252 OptionsContext *o = optctx;
253 return parse_option(o, "codec:v", arg, options);
256 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
258 OptionsContext *o = optctx;
259 return parse_option(o, "codec:s", arg, options);
262 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
264 OptionsContext *o = optctx;
265 return parse_option(o, "codec:d", arg, options);
268 static int opt_map(void *optctx, const char *opt, const char *arg)
270 OptionsContext *o = optctx;
272 int i, negative = 0, file_idx;
273 int sync_file_idx = -1, sync_stream_idx = 0;
282 map = av_strdup(arg);
284 return AVERROR(ENOMEM);
286 /* parse sync stream first, just pick first matching stream */
287 if (sync = strchr(map, ',')) {
289 sync_file_idx = strtol(sync + 1, &sync, 0);
290 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
291 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
296 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
297 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
298 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
302 if (i == input_files[sync_file_idx]->nb_streams) {
303 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
304 "match any streams.\n", arg);
311 /* this mapping refers to lavfi output */
312 const char *c = map + 1;
313 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
314 m = &o->stream_maps[o->nb_stream_maps - 1];
315 m->linklabel = av_get_token(&c, "]");
317 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
321 if (allow_unused = strchr(map, '?'))
323 file_idx = strtol(map, &p, 0);
324 if (file_idx >= nb_input_files || file_idx < 0) {
325 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
329 /* disable some already defined maps */
330 for (i = 0; i < o->nb_stream_maps; i++) {
331 m = &o->stream_maps[i];
332 if (file_idx == m->file_index &&
333 check_stream_specifier(input_files[m->file_index]->ctx,
334 input_files[m->file_index]->ctx->streams[m->stream_index],
335 *p == ':' ? p + 1 : p) > 0)
339 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
340 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
341 *p == ':' ? p + 1 : p) <= 0)
343 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
344 m = &o->stream_maps[o->nb_stream_maps - 1];
346 m->file_index = file_idx;
349 if (sync_file_idx >= 0) {
350 m->sync_file_index = sync_file_idx;
351 m->sync_stream_index = sync_stream_idx;
353 m->sync_file_index = file_idx;
354 m->sync_stream_index = i;
361 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
363 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
364 "To ignore this, add a trailing '?' to the map.\n", arg);
373 static int opt_attach(void *optctx, const char *opt, const char *arg)
375 OptionsContext *o = optctx;
376 GROW_ARRAY(o->attachments, o->nb_attachments);
377 o->attachments[o->nb_attachments - 1] = arg;
381 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
383 OptionsContext *o = optctx;
389 mapchan = av_strdup(arg);
391 return AVERROR(ENOMEM);
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;
407 n = sscanf(arg, "%d.%d.%d:%d.%d",
408 &m->file_idx, &m->stream_idx, &m->channel_idx,
409 &m->ofile_idx, &m->ostream_idx);
411 if (n != 3 && n != 5) {
412 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
413 "[file.stream.channel|-1][:syncfile:syncstream]\n");
417 if (n != 5) // only file.stream.channel specified
418 m->ofile_idx = m->ostream_idx = -1;
421 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
422 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
426 if (m->stream_idx < 0 ||
427 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
428 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
429 m->file_idx, m->stream_idx);
432 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
433 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
434 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
435 m->file_idx, m->stream_idx);
438 /* allow trailing ? to map_channel */
439 if (allow_unused = strchr(mapchan, '?'))
441 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
443 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
444 m->file_idx, m->stream_idx, m->channel_idx);
446 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
447 "To ignore this, add a trailing '?' to the map_channel.\n",
448 m->file_idx, m->stream_idx, m->channel_idx);
457 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
459 av_free(sdp_filename);
460 sdp_filename = av_strdup(arg);
465 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
468 const char *prefix = "vaapi:";
471 tmp = av_asprintf("%s%s", prefix, arg);
473 return AVERROR(ENOMEM);
474 err = hw_device_init_from_string(tmp, &dev);
478 hw_device_ctx = av_buffer_ref(dev->device_ref);
480 return AVERROR(ENOMEM);
485 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
487 if (!strcmp(arg, "list")) {
488 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
489 printf("Supported hardware device types:\n");
490 while ((type = av_hwdevice_iterate_types(type)) !=
491 AV_HWDEVICE_TYPE_NONE)
492 printf("%s\n", av_hwdevice_get_type_name(type));
496 return hw_device_init_from_string(arg, NULL);
500 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
502 if (filter_hw_device) {
503 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
504 return AVERROR(EINVAL);
506 filter_hw_device = hw_device_get_by_name(arg);
507 if (!filter_hw_device) {
508 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
509 return AVERROR(EINVAL);
515 * Parse a metadata specifier passed as 'arg' parameter.
516 * @param arg metadata string to parse
517 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
518 * @param index for type c/p, chapter/program index is written here
519 * @param stream_spec for type s, the stream specifier is written here
521 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
529 if (*(++arg) && *arg != ':') {
530 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
533 *stream_spec = *arg == ':' ? arg + 1 : "";
538 *index = strtol(++arg, NULL, 0);
541 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
548 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
550 AVDictionary **meta_in = NULL;
551 AVDictionary **meta_out = NULL;
553 char type_in, type_out;
554 const char *istream_spec = NULL, *ostream_spec = NULL;
555 int idx_in = 0, idx_out = 0;
557 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
558 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
561 if (type_out == 'g' || !*outspec)
562 o->metadata_global_manual = 1;
563 if (type_out == 's' || !*outspec)
564 o->metadata_streams_manual = 1;
565 if (type_out == 'c' || !*outspec)
566 o->metadata_chapters_manual = 1;
570 if (type_in == 'g' || type_out == 'g')
571 o->metadata_global_manual = 1;
572 if (type_in == 's' || type_out == 's')
573 o->metadata_streams_manual = 1;
574 if (type_in == 'c' || type_out == 'c')
575 o->metadata_chapters_manual = 1;
577 /* ic is NULL when just disabling automatic mappings */
581 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
582 if ((index) < 0 || (index) >= (nb_elems)) {\
583 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
588 #define SET_DICT(type, meta, context, index)\
591 meta = &context->metadata;\
594 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
595 meta = &context->chapters[index]->metadata;\
598 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
599 meta = &context->programs[index]->metadata;\
602 break; /* handled separately below */ \
603 default: av_assert0(0);\
606 SET_DICT(type_in, meta_in, ic, idx_in);
607 SET_DICT(type_out, meta_out, oc, idx_out);
609 /* for input streams choose first matching stream */
610 if (type_in == 's') {
611 for (i = 0; i < ic->nb_streams; i++) {
612 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
613 meta_in = &ic->streams[i]->metadata;
619 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
624 if (type_out == 's') {
625 for (i = 0; i < oc->nb_streams; i++) {
626 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
627 meta_out = &oc->streams[i]->metadata;
628 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
633 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
638 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
640 OptionsContext *o = optctx;
642 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
643 struct tm time = *gmtime((time_t*)&recording_timestamp);
644 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
646 parse_option(o, "metadata", buf, options);
648 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
649 "tag instead.\n", opt);
653 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
655 const AVCodecDescriptor *desc;
656 const char *codec_string = encoder ? "encoder" : "decoder";
660 avcodec_find_encoder_by_name(name) :
661 avcodec_find_decoder_by_name(name);
663 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
664 codec = encoder ? avcodec_find_encoder(desc->id) :
665 avcodec_find_decoder(desc->id);
667 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
668 codec_string, codec->name, desc->name);
672 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
675 if (codec->type != type) {
676 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
682 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
684 char *codec_name = NULL;
686 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
688 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
689 st->codecpar->codec_id = codec->id;
692 return avcodec_find_decoder(st->codecpar->codec_id);
695 /* Add all the streams from the given input file to the global
696 * list of input streams. */
697 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
701 for (i = 0; i < ic->nb_streams; i++) {
702 AVStream *st = ic->streams[i];
703 AVCodecParameters *par = st->codecpar;
704 InputStream *ist = av_mallocz(sizeof(*ist));
705 char *framerate = NULL, *hwaccel_device = NULL;
706 const char *hwaccel = NULL;
707 char *hwaccel_output_format = NULL;
708 char *codec_tag = NULL;
710 char *discard_str = NULL;
711 const AVClass *cc = avcodec_get_class();
712 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
717 GROW_ARRAY(input_streams, nb_input_streams);
718 input_streams[nb_input_streams - 1] = ist;
721 ist->file_index = nb_input_files;
723 st->discard = AVDISCARD_ALL;
725 ist->min_pts = INT64_MAX;
726 ist->max_pts = INT64_MIN;
729 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
732 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
734 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
736 uint32_t tag = strtol(codec_tag, &next, 0);
738 tag = AV_RL32(codec_tag);
739 st->codecpar->codec_tag = tag;
742 ist->dec = choose_decoder(o, ic, st);
743 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
745 ist->reinit_filters = -1;
746 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
748 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
749 ist->user_set_discard = AVDISCARD_NONE;
750 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
751 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
756 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
758 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
760 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
764 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
766 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
771 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
773 switch (par->codec_type) {
774 case AVMEDIA_TYPE_VIDEO:
776 ist->dec = avcodec_find_decoder(par->codec_id);
778 if (st->codec->lowres) {
779 ist->dec_ctx->lowres = st->codec->lowres;
780 ist->dec_ctx->width = st->codec->width;
781 ist->dec_ctx->height = st->codec->height;
782 ist->dec_ctx->coded_width = st->codec->coded_width;
783 ist->dec_ctx->coded_height = st->codec->coded_height;
787 // avformat_find_stream_info() doesn't set this for us anymore.
788 ist->dec_ctx->framerate = st->avg_frame_rate;
790 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
791 if (framerate && av_parse_video_rate(&ist->framerate,
793 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
798 ist->top_field_first = -1;
799 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
801 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
803 // The NVDEC hwaccels use a CUDA device, so remap the name here.
804 if (!strcmp(hwaccel, "nvdec"))
807 if (!strcmp(hwaccel, "none"))
808 ist->hwaccel_id = HWACCEL_NONE;
809 else if (!strcmp(hwaccel, "auto"))
810 ist->hwaccel_id = HWACCEL_AUTO;
812 enum AVHWDeviceType type;
814 for (i = 0; hwaccels[i].name; i++) {
815 if (!strcmp(hwaccels[i].name, hwaccel)) {
816 ist->hwaccel_id = hwaccels[i].id;
821 if (!ist->hwaccel_id) {
822 type = av_hwdevice_find_type_by_name(hwaccel);
823 if (type != AV_HWDEVICE_TYPE_NONE) {
824 ist->hwaccel_id = HWACCEL_GENERIC;
825 ist->hwaccel_device_type = type;
829 if (!ist->hwaccel_id) {
830 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
832 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
833 type = AV_HWDEVICE_TYPE_NONE;
834 while ((type = av_hwdevice_iterate_types(type)) !=
835 AV_HWDEVICE_TYPE_NONE)
836 av_log(NULL, AV_LOG_FATAL, "%s ",
837 av_hwdevice_get_type_name(type));
838 for (i = 0; hwaccels[i].name; i++)
839 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
840 av_log(NULL, AV_LOG_FATAL, "\n");
846 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
847 if (hwaccel_device) {
848 ist->hwaccel_device = av_strdup(hwaccel_device);
849 if (!ist->hwaccel_device)
853 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
854 hwaccel_output_format, ic, st);
855 if (hwaccel_output_format) {
856 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
857 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
858 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
859 "format: %s", hwaccel_output_format);
862 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
865 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
868 case AVMEDIA_TYPE_AUDIO:
869 ist->guess_layout_max = INT_MAX;
870 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
871 guess_input_channel_layout(ist);
873 case AVMEDIA_TYPE_DATA:
874 case AVMEDIA_TYPE_SUBTITLE: {
875 char *canvas_size = NULL;
877 ist->dec = avcodec_find_decoder(par->codec_id);
878 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
879 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
881 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
882 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
887 case AVMEDIA_TYPE_ATTACHMENT:
888 case AVMEDIA_TYPE_UNKNOWN:
894 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
896 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
902 static void assert_file_overwrite(const char *filename)
904 if (file_overwrite && no_file_overwrite) {
905 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
909 if (!file_overwrite) {
910 const char *proto_name = avio_find_protocol_name(filename);
911 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
912 if (stdin_interaction && !no_file_overwrite) {
913 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
916 signal(SIGINT, SIG_DFL);
918 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
924 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
931 static void dump_attachment(AVStream *st, const char *filename)
934 AVIOContext *out = NULL;
935 AVDictionaryEntry *e;
937 if (!st->codecpar->extradata_size) {
938 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
939 nb_input_files - 1, st->index);
942 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
945 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
946 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
950 assert_file_overwrite(filename);
952 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
953 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
958 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
963 static int open_input_file(OptionsContext *o, const char *filename)
967 AVInputFormat *file_iformat = NULL;
970 AVDictionary *unused_opts = NULL;
971 AVDictionaryEntry *e = NULL;
972 char * video_codec_name = NULL;
973 char * audio_codec_name = NULL;
974 char *subtitle_codec_name = NULL;
975 char * data_codec_name = NULL;
976 int scan_all_pmts_set = 0;
978 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
979 o->stop_time = INT64_MAX;
980 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
983 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
984 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
985 if (o->stop_time <= start_time) {
986 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
989 o->recording_time = o->stop_time - start_time;
994 if (!(file_iformat = av_find_input_format(o->format))) {
995 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1000 if (!strcmp(filename, "-"))
1003 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1004 strcmp(filename, "/dev/stdin");
1006 /* get default parameters from command line */
1007 ic = avformat_alloc_context();
1009 print_error(filename, AVERROR(ENOMEM));
1012 if (o->nb_audio_sample_rate) {
1013 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1015 if (o->nb_audio_channels) {
1016 /* because we set audio_channels based on both the "ac" and
1017 * "channel_layout" options, we need to check that the specified
1018 * demuxer actually has the "channels" option before setting it */
1019 if (file_iformat && file_iformat->priv_class &&
1020 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1021 AV_OPT_SEARCH_FAKE_OBJ)) {
1022 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1025 if (o->nb_frame_rates) {
1026 /* set the format-level framerate option;
1027 * this is important for video grabbers, e.g. x11 */
1028 if (file_iformat && file_iformat->priv_class &&
1029 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1030 AV_OPT_SEARCH_FAKE_OBJ)) {
1031 av_dict_set(&o->g->format_opts, "framerate",
1032 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1035 if (o->nb_frame_sizes) {
1036 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1038 if (o->nb_frame_pix_fmts)
1039 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1041 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1042 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1043 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1044 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1046 if (video_codec_name)
1047 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1048 if (audio_codec_name)
1049 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1050 if (subtitle_codec_name)
1051 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1052 if (data_codec_name)
1053 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1055 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1056 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1057 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1058 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1060 ic->flags |= AVFMT_FLAG_NONBLOCK;
1062 ic->flags |= AVFMT_FLAG_BITEXACT;
1063 ic->interrupt_callback = int_cb;
1065 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1066 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1067 scan_all_pmts_set = 1;
1069 /* open the input file with generic avformat function */
1070 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1072 print_error(filename, err);
1073 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1074 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1077 if (scan_all_pmts_set)
1078 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1079 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1080 assert_avoptions(o->g->format_opts);
1082 /* apply forced codec ids */
1083 for (i = 0; i < ic->nb_streams; i++)
1084 choose_decoder(o, ic, ic->streams[i]);
1086 if (find_stream_info) {
1087 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1088 int orig_nb_streams = ic->nb_streams;
1090 /* If not enough info to get the stream parameters, we decode the
1091 first frames to get it. (used in mpeg case for example) */
1092 ret = avformat_find_stream_info(ic, opts);
1094 for (i = 0; i < orig_nb_streams; i++)
1095 av_dict_free(&opts[i]);
1099 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1100 if (ic->nb_streams == 0) {
1101 avformat_close_input(&ic);
1107 if (o->start_time_eof != AV_NOPTS_VALUE) {
1108 if (ic->duration>0) {
1109 o->start_time = o->start_time_eof + ic->duration;
1111 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1113 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1114 /* add the stream start time */
1115 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1116 timestamp += ic->start_time;
1118 /* if seeking requested, we execute it */
1119 if (o->start_time != AV_NOPTS_VALUE) {
1120 int64_t seek_timestamp = timestamp;
1122 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1123 int dts_heuristic = 0;
1124 for (i=0; i<ic->nb_streams; i++) {
1125 const AVCodecParameters *par = ic->streams[i]->codecpar;
1126 if (par->video_delay)
1129 if (dts_heuristic) {
1130 seek_timestamp -= 3*AV_TIME_BASE / 23;
1133 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1135 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1136 filename, (double)timestamp / AV_TIME_BASE);
1140 /* update the current parameters so that they match the one of the input stream */
1141 add_input_streams(o, ic);
1143 /* dump the file content */
1144 av_dump_format(ic, nb_input_files, filename, 0);
1146 GROW_ARRAY(input_files, nb_input_files);
1147 f = av_mallocz(sizeof(*f));
1150 input_files[nb_input_files - 1] = f;
1153 f->ist_index = nb_input_streams - ic->nb_streams;
1154 f->start_time = o->start_time;
1155 f->recording_time = o->recording_time;
1156 f->input_ts_offset = o->input_ts_offset;
1157 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1158 f->nb_streams = ic->nb_streams;
1159 f->rate_emu = o->rate_emu;
1160 f->accurate_seek = o->accurate_seek;
1163 f->time_base = (AVRational){ 1, 1 };
1165 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1168 /* check if all codec options have been used */
1169 unused_opts = strip_specifiers(o->g->codec_opts);
1170 for (i = f->ist_index; i < nb_input_streams; i++) {
1172 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1173 AV_DICT_IGNORE_SUFFIX)))
1174 av_dict_set(&unused_opts, e->key, NULL, 0);
1178 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1179 const AVClass *class = avcodec_get_class();
1180 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1181 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1182 const AVClass *fclass = avformat_get_class();
1183 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1184 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1185 if (!option || foption)
1189 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1190 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1191 "input file #%d (%s) is not a decoding option.\n", e->key,
1192 option->help ? option->help : "", nb_input_files - 1,
1197 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1198 "input file #%d (%s) has not been used for any stream. The most "
1199 "likely reason is either wrong type (e.g. a video option with "
1200 "no video streams) or that it is a private option of some decoder "
1201 "which was not actually used for any stream.\n", e->key,
1202 option->help ? option->help : "", nb_input_files - 1, filename);
1204 av_dict_free(&unused_opts);
1206 for (i = 0; i < o->nb_dump_attachment; i++) {
1209 for (j = 0; j < ic->nb_streams; j++) {
1210 AVStream *st = ic->streams[j];
1212 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1213 dump_attachment(st, o->dump_attachment[i].u.str);
1217 input_stream_potentially_available = 1;
1222 static uint8_t *get_line(AVIOContext *s)
1228 if (avio_open_dyn_buf(&line) < 0) {
1229 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1233 while ((c = avio_r8(s)) && c != '\n')
1236 avio_close_dyn_buf(line, &buf);
1241 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1244 char filename[1000];
1245 const char *base[3] = { getenv("AVCONV_DATADIR"),
1250 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1254 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1255 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1256 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1259 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1260 i != 1 ? "" : "/.avconv", preset_name);
1261 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1267 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1269 enum AVMediaType type = ost->st->codecpar->codec_type;
1270 char *codec_name = NULL;
1272 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1273 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1275 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1276 NULL, ost->st->codecpar->codec_type);
1277 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1279 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1280 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1281 "probably disabled. Please choose an encoder manually.\n",
1282 ost->file_index, ost->index, s->oformat->name,
1283 avcodec_get_name(ost->st->codecpar->codec_id));
1284 return AVERROR_ENCODER_NOT_FOUND;
1286 } else if (!strcmp(codec_name, "copy"))
1287 ost->stream_copy = 1;
1289 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1290 ost->st->codecpar->codec_id = ost->enc->id;
1292 ost->encoding_needed = !ost->stream_copy;
1294 /* no encoding supported for other media types */
1295 ost->stream_copy = 1;
1296 ost->encoding_needed = 0;
1302 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1305 AVStream *st = avformat_new_stream(oc, NULL);
1306 int idx = oc->nb_streams - 1, ret = 0;
1307 const char *bsfs = NULL, *time_base = NULL;
1308 char *next, *codec_tag = NULL;
1313 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1317 if (oc->nb_streams - 1 < o->nb_streamid_map)
1318 st->id = o->streamid_map[oc->nb_streams - 1];
1320 GROW_ARRAY(output_streams, nb_output_streams);
1321 if (!(ost = av_mallocz(sizeof(*ost))))
1323 output_streams[nb_output_streams - 1] = ost;
1325 ost->file_index = nb_output_files - 1;
1328 st->codecpar->codec_type = type;
1330 ret = choose_encoder(o, oc, ost);
1332 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1333 "%d:%d\n", ost->file_index, ost->index);
1337 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1338 if (!ost->enc_ctx) {
1339 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1342 ost->enc_ctx->codec_type = type;
1344 ost->ref_par = avcodec_parameters_alloc();
1345 if (!ost->ref_par) {
1346 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1351 AVIOContext *s = NULL;
1352 char *buf = NULL, *arg = NULL, *preset = NULL;
1354 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1356 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1357 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1360 if (!buf[0] || buf[0] == '#') {
1364 if (!(arg = strchr(buf, '='))) {
1365 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1369 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1371 } while (!s->eof_reached);
1375 av_log(NULL, AV_LOG_FATAL,
1376 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1377 preset, ost->file_index, ost->index);
1381 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1386 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1388 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1391 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1392 q.num <= 0 || q.den <= 0) {
1393 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1399 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1402 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1404 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1407 ost->enc_timebase = q;
1410 ost->max_frames = INT64_MAX;
1411 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1412 for (i = 0; i<o->nb_max_frames; i++) {
1413 char *p = o->max_frames[i].specifier;
1414 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1415 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1420 ost->copy_prior_start = -1;
1421 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1423 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1424 while (bsfs && *bsfs) {
1425 const AVBitStreamFilter *filter;
1426 char *bsf, *bsf_options_str, *bsf_name;
1428 bsf = av_get_token(&bsfs, ",");
1431 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1435 filter = av_bsf_get_by_name(bsf_name);
1437 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1441 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1442 ost->nb_bitstream_filters + 1,
1443 sizeof(*ost->bsf_ctx));
1447 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1449 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1453 ost->nb_bitstream_filters++;
1455 if (bsf_options_str && filter->priv_class) {
1456 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1457 const char * shorthand[2] = {NULL};
1460 shorthand[0] = opt->name;
1462 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1464 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1474 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1476 uint32_t tag = strtol(codec_tag, &next, 0);
1478 tag = AV_RL32(codec_tag);
1479 ost->st->codecpar->codec_tag =
1480 ost->enc_ctx->codec_tag = tag;
1483 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1485 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1486 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1489 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1490 ost->disposition = av_strdup(ost->disposition);
1492 ost->max_muxing_queue_size = 128;
1493 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1494 ost->max_muxing_queue_size *= sizeof(AVPacket);
1496 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1497 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1499 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1501 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1502 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1503 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1505 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1507 ost->source_index = source_index;
1508 if (source_index >= 0) {
1509 ost->sync_ist = input_streams[source_index];
1510 input_streams[source_index]->discard = 0;
1511 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1513 ost->last_mux_dts = AV_NOPTS_VALUE;
1515 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1516 if (!ost->muxing_queue)
1522 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1525 const char *p = str;
1532 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1539 /* read file contents into a string */
1540 static uint8_t *read_file(const char *filename)
1542 AVIOContext *pb = NULL;
1543 AVIOContext *dyn_buf = NULL;
1544 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1545 uint8_t buf[1024], *str;
1548 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1552 ret = avio_open_dyn_buf(&dyn_buf);
1557 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1558 avio_write(dyn_buf, buf, ret);
1559 avio_w8(dyn_buf, 0);
1562 ret = avio_close_dyn_buf(dyn_buf, &str);
1568 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1571 AVStream *st = ost->st;
1573 if (ost->filters_script && ost->filters) {
1574 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1575 "output stream #%d:%d.\n", nb_output_files, st->index);
1579 if (ost->filters_script)
1580 return read_file(ost->filters_script);
1581 else if (ost->filters)
1582 return av_strdup(ost->filters);
1584 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1588 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1589 const OutputStream *ost, enum AVMediaType type)
1591 if (ost->filters_script || ost->filters) {
1592 av_log(NULL, AV_LOG_ERROR,
1593 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1594 "Filtering and streamcopy cannot be used together.\n",
1595 ost->filters ? "Filtergraph" : "Filtergraph script",
1596 ost->filters ? ost->filters : ost->filters_script,
1597 av_get_media_type_string(type), ost->file_index, ost->index);
1602 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1606 AVCodecContext *video_enc;
1607 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1609 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1611 video_enc = ost->enc_ctx;
1613 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1614 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1615 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1618 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1619 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1621 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1622 if (frame_aspect_ratio) {
1624 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1625 q.num <= 0 || q.den <= 0) {
1626 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1629 ost->frame_aspect_ratio = q;
1632 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1633 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1635 if (!ost->stream_copy) {
1636 const char *p = NULL;
1637 char *frame_size = NULL;
1638 char *frame_pix_fmt = NULL;
1639 char *intra_matrix = NULL, *inter_matrix = NULL;
1640 char *chroma_intra_matrix = NULL;
1644 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1645 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1646 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1650 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1651 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1652 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1653 ost->keep_pix_fmt = 1;
1654 if (!*++frame_pix_fmt)
1655 frame_pix_fmt = NULL;
1657 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1658 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1661 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1664 video_enc->gop_size = 0;
1665 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1667 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1668 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1671 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1673 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1674 if (chroma_intra_matrix) {
1675 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1677 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1680 video_enc->chroma_intra_matrix = p;
1681 parse_matrix_coeffs(p, chroma_intra_matrix);
1683 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1685 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1686 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1689 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1692 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1693 for (i = 0; p; i++) {
1695 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1697 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1700 video_enc->rc_override =
1701 av_realloc_array(video_enc->rc_override,
1702 i + 1, sizeof(RcOverride));
1703 if (!video_enc->rc_override) {
1704 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1707 video_enc->rc_override[i].start_frame = start;
1708 video_enc->rc_override[i].end_frame = end;
1710 video_enc->rc_override[i].qscale = q;
1711 video_enc->rc_override[i].quality_factor = 1.0;
1714 video_enc->rc_override[i].qscale = 0;
1715 video_enc->rc_override[i].quality_factor = -q/100.0;
1720 video_enc->rc_override_count = i;
1723 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1726 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1729 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1730 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1733 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1734 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1738 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1739 if (ost->logfile_prefix &&
1740 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1744 char logfilename[1024];
1747 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1748 ost->logfile_prefix ? ost->logfile_prefix :
1749 DEFAULT_PASS_LOGFILENAME_PREFIX,
1751 if (!strcmp(ost->enc->name, "libx264")) {
1752 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1754 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1755 char *logbuffer = read_file(logfilename);
1758 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1762 video_enc->stats_in = logbuffer;
1764 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1765 f = av_fopen_utf8(logfilename, "wb");
1767 av_log(NULL, AV_LOG_FATAL,
1768 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1769 logfilename, strerror(errno));
1777 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1778 if (ost->forced_keyframes)
1779 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1781 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1783 ost->top_field_first = -1;
1784 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1787 ost->avfilter = get_ost_filters(o, oc, ost);
1791 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1794 if (ost->stream_copy)
1795 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1800 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1805 AVCodecContext *audio_enc;
1807 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1810 audio_enc = ost->enc_ctx;
1811 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1813 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1814 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1816 if (!ost->stream_copy) {
1817 char *sample_fmt = NULL;
1819 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1821 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1823 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1824 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1828 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1830 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1831 ost->apad = av_strdup(ost->apad);
1833 ost->avfilter = get_ost_filters(o, oc, ost);
1837 /* check for channel mapping for this audio stream */
1838 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1839 AudioChannelMap *map = &o->audio_channel_maps[n];
1840 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1841 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1844 if (map->channel_idx == -1) {
1846 } else if (ost->source_index < 0) {
1847 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1848 ost->file_index, ost->st->index);
1851 ist = input_streams[ost->source_index];
1854 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1855 if (av_reallocp_array(&ost->audio_channels_map,
1856 ost->audio_channels_mapped + 1,
1857 sizeof(*ost->audio_channels_map)
1861 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1867 if (ost->stream_copy)
1868 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1873 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1877 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1878 if (!ost->stream_copy) {
1879 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1886 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1890 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1891 if (!ost->stream_copy) {
1892 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1899 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1901 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1902 ost->stream_copy = 1;
1907 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1911 AVCodecContext *subtitle_enc;
1913 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1915 subtitle_enc = ost->enc_ctx;
1917 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1919 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1921 if (!ost->stream_copy) {
1922 char *frame_size = NULL;
1924 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1925 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1926 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1934 /* arg format is "output-stream-index:streamid-value". */
1935 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1937 OptionsContext *o = optctx;
1942 av_strlcpy(idx_str, arg, sizeof(idx_str));
1943 p = strchr(idx_str, ':');
1945 av_log(NULL, AV_LOG_FATAL,
1946 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1951 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1952 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1953 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1957 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1959 AVFormatContext *is = ifile->ctx;
1960 AVFormatContext *os = ofile->ctx;
1964 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1966 return AVERROR(ENOMEM);
1969 for (i = 0; i < is->nb_chapters; i++) {
1970 AVChapter *in_ch = is->chapters[i], *out_ch;
1971 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1972 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1973 AV_TIME_BASE_Q, in_ch->time_base);
1974 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1975 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1978 if (in_ch->end < ts_off)
1980 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1983 out_ch = av_mallocz(sizeof(AVChapter));
1985 return AVERROR(ENOMEM);
1987 out_ch->id = in_ch->id;
1988 out_ch->time_base = in_ch->time_base;
1989 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1990 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1993 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1995 os->chapters[os->nb_chapters++] = out_ch;
2000 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
2003 AVFormatContext *ic = avformat_alloc_context();
2005 return AVERROR(ENOMEM);
2007 ic->interrupt_callback = int_cb;
2008 err = avformat_open_input(&ic, filename, NULL, NULL);
2011 /* copy stream format */
2012 for(i=0;i<ic->nb_streams;i++) {
2016 const char *enc_config;
2018 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
2020 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
2021 return AVERROR(EINVAL);
2023 if (codec->type == AVMEDIA_TYPE_AUDIO)
2024 opt_audio_codec(o, "c:a", codec->name);
2025 else if (codec->type == AVMEDIA_TYPE_VIDEO)
2026 opt_video_codec(o, "c:v", codec->name);
2027 ost = new_output_stream(o, s, codec->type, -1);
2030 avcodec_get_context_defaults3(st->codec, codec);
2031 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
2033 AVDictionary *opts = NULL;
2034 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
2035 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
2036 av_dict_free(&opts);
2039 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
2040 choose_sample_fmt(st, codec);
2041 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
2042 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
2043 avcodec_copy_context(ost->enc_ctx, st->codec);
2045 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
2048 avformat_close_input(&ic);
2052 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2053 AVFormatContext *oc)
2057 switch (ofilter->type) {
2058 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2059 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2061 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2066 ost->source_index = -1;
2067 ost->filter = ofilter;
2070 ofilter->format = -1;
2072 if (ost->stream_copy) {
2073 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2074 "which is fed from a complex filtergraph. Filtering and streamcopy "
2075 "cannot be used together.\n", ost->file_index, ost->index);
2079 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2080 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2081 av_log(NULL, AV_LOG_ERROR,
2082 "%s '%s' was specified through the %s option "
2083 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2084 "%s and -filter_complex cannot be used together for the same stream.\n",
2085 ost->filters ? "Filtergraph" : "Filtergraph script",
2086 ost->filters ? ost->filters : ost->filters_script,
2087 opt, ost->file_index, ost->index, opt);
2091 avfilter_inout_free(&ofilter->out_tmp);
2094 static int init_complex_filters(void)
2098 for (i = 0; i < nb_filtergraphs; i++) {
2099 ret = init_complex_filtergraph(filtergraphs[i]);
2106 static int open_output_file(OptionsContext *o, const char *filename)
2108 AVFormatContext *oc;
2110 AVOutputFormat *file_oformat;
2114 AVDictionary *unused_opts = NULL;
2115 AVDictionaryEntry *e = NULL;
2116 int format_flags = 0;
2118 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2119 o->stop_time = INT64_MAX;
2120 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2123 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2124 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2125 if (o->stop_time <= start_time) {
2126 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2129 o->recording_time = o->stop_time - start_time;
2133 GROW_ARRAY(output_files, nb_output_files);
2134 of = av_mallocz(sizeof(*of));
2137 output_files[nb_output_files - 1] = of;
2139 of->ost_index = nb_output_streams;
2140 of->recording_time = o->recording_time;
2141 of->start_time = o->start_time;
2142 of->limit_filesize = o->limit_filesize;
2143 of->shortest = o->shortest;
2144 av_dict_copy(&of->opts, o->g->format_opts, 0);
2146 if (!strcmp(filename, "-"))
2149 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2151 print_error(filename, err);
2156 if (o->recording_time != INT64_MAX)
2157 oc->duration = o->recording_time;
2159 file_oformat= oc->oformat;
2160 oc->interrupt_callback = int_cb;
2162 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2164 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2165 av_opt_eval_flags(oc, o, e->value, &format_flags);
2168 format_flags |= AVFMT_FLAG_BITEXACT;
2169 oc->flags |= AVFMT_FLAG_BITEXACT;
2172 /* create streams for all unlabeled output pads */
2173 for (i = 0; i < nb_filtergraphs; i++) {
2174 FilterGraph *fg = filtergraphs[i];
2175 for (j = 0; j < fg->nb_outputs; j++) {
2176 OutputFilter *ofilter = fg->outputs[j];
2178 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2181 switch (ofilter->type) {
2182 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2183 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2184 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2186 init_output_filter(ofilter, o, oc);
2190 /* ffserver seeking with date=... needs a date reference */
2191 if (!strcmp(file_oformat->name, "ffm") &&
2192 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2193 av_strstart(filename, "http:", NULL)) {
2194 int err = parse_option(o, "metadata", "creation_time=now", options);
2196 print_error(filename, err);
2201 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2202 av_strstart(filename, "http:", NULL)) {
2204 /* special case for files sent to ffserver: we get the stream
2205 parameters from ffserver */
2206 int err = read_ffserver_streams(o, oc, filename);
2208 print_error(filename, err);
2211 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2212 ost = output_streams[j];
2213 for (i = 0; i < nb_input_streams; i++) {
2214 ist = input_streams[i];
2215 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2217 ost->source_index= i;
2218 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2219 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2221 ist->st->discard = ist->user_set_discard;
2226 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
2230 } else if (!o->nb_stream_maps) {
2231 char *subtitle_codec_name = NULL;
2232 /* pick the "best" stream of each type */
2234 /* video: highest resolution */
2235 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2236 int area = 0, idx = -1;
2237 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2238 for (i = 0; i < nb_input_streams; i++) {
2240 ist = input_streams[i];
2241 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2242 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2244 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2246 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2253 new_video_stream(o, oc, idx);
2256 /* audio: most channels */
2257 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2258 int best_score = 0, idx = -1;
2259 for (i = 0; i < nb_input_streams; i++) {
2261 ist = input_streams[i];
2262 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2263 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2264 score > best_score) {
2270 new_audio_stream(o, oc, idx);
2273 /* subtitles: pick first */
2274 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2275 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2276 for (i = 0; i < nb_input_streams; i++)
2277 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2278 AVCodecDescriptor const *input_descriptor =
2279 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2280 AVCodecDescriptor const *output_descriptor = NULL;
2281 AVCodec const *output_codec =
2282 avcodec_find_encoder(oc->oformat->subtitle_codec);
2283 int input_props = 0, output_props = 0;
2285 output_descriptor = avcodec_descriptor_get(output_codec->id);
2286 if (input_descriptor)
2287 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2288 if (output_descriptor)
2289 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2290 if (subtitle_codec_name ||
2291 input_props & output_props ||
2292 // Map dvb teletext which has neither property to any output subtitle encoder
2293 input_descriptor && output_descriptor &&
2294 (!input_descriptor->props ||
2295 !output_descriptor->props)) {
2296 new_subtitle_stream(o, oc, i);
2301 /* Data only if codec id match */
2302 if (!o->data_disable ) {
2303 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2304 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2305 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2306 && input_streams[i]->st->codecpar->codec_id == codec_id )
2307 new_data_stream(o, oc, i);
2311 for (i = 0; i < o->nb_stream_maps; i++) {
2312 StreamMap *map = &o->stream_maps[i];
2317 if (map->linklabel) {
2319 OutputFilter *ofilter = NULL;
2322 for (j = 0; j < nb_filtergraphs; j++) {
2323 fg = filtergraphs[j];
2324 for (k = 0; k < fg->nb_outputs; k++) {
2325 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2326 if (out && !strcmp(out->name, map->linklabel)) {
2327 ofilter = fg->outputs[k];
2334 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2335 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2338 init_output_filter(ofilter, o, oc);
2340 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2342 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2343 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2345 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2347 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2349 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2353 switch (ist->st->codecpar->codec_type) {
2354 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2355 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2356 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2357 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2358 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2359 case AVMEDIA_TYPE_UNKNOWN:
2360 if (copy_unknown_streams) {
2361 ost = new_unknown_stream (o, oc, src_idx);
2365 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2366 "Cannot map stream #%d:%d - unsupported type.\n",
2367 map->file_index, map->stream_index);
2368 if (!ignore_unknown_streams) {
2369 av_log(NULL, AV_LOG_FATAL,
2370 "If you want unsupported types ignored instead "
2371 "of failing, please use the -ignore_unknown option\n"
2372 "If you want them copied, please use -copy_unknown\n");
2377 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2378 + map->sync_stream_index];
2383 /* handle attached files */
2384 for (i = 0; i < o->nb_attachments; i++) {
2386 uint8_t *attachment;
2390 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2391 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2395 if ((len = avio_size(pb)) <= 0) {
2396 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2400 if (!(attachment = av_malloc(len))) {
2401 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2405 avio_read(pb, attachment, len);
2407 ost = new_attachment_stream(o, oc, -1);
2408 ost->stream_copy = 0;
2409 ost->attachment_filename = o->attachments[i];
2410 ost->st->codecpar->extradata = attachment;
2411 ost->st->codecpar->extradata_size = len;
2413 p = strrchr(o->attachments[i], '/');
2414 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2418 #if FF_API_LAVF_AVCTX
2419 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2420 AVDictionaryEntry *e;
2421 ost = output_streams[i];
2423 if ((ost->stream_copy || ost->attachment_filename)
2424 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2425 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2426 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2431 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2432 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2433 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2437 /* check if all codec options have been used */
2438 unused_opts = strip_specifiers(o->g->codec_opts);
2439 for (i = of->ost_index; i < nb_output_streams; i++) {
2441 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2442 AV_DICT_IGNORE_SUFFIX)))
2443 av_dict_set(&unused_opts, e->key, NULL, 0);
2447 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2448 const AVClass *class = avcodec_get_class();
2449 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2450 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2451 const AVClass *fclass = avformat_get_class();
2452 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2453 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2454 if (!option || foption)
2458 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2459 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2460 "output file #%d (%s) is not an encoding option.\n", e->key,
2461 option->help ? option->help : "", nb_output_files - 1,
2466 // gop_timecode is injected by generic code but not always used
2467 if (!strcmp(e->key, "gop_timecode"))
2470 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2471 "output file #%d (%s) has not been used for any stream. The most "
2472 "likely reason is either wrong type (e.g. a video option with "
2473 "no video streams) or that it is a private option of some encoder "
2474 "which was not actually used for any stream.\n", e->key,
2475 option->help ? option->help : "", nb_output_files - 1, filename);
2477 av_dict_free(&unused_opts);
2479 /* set the decoding_needed flags and create simple filtergraphs */
2480 for (i = of->ost_index; i < nb_output_streams; i++) {
2481 OutputStream *ost = output_streams[i];
2483 if (ost->encoding_needed && ost->source_index >= 0) {
2484 InputStream *ist = input_streams[ost->source_index];
2485 ist->decoding_needed |= DECODING_FOR_OST;
2487 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2488 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2489 err = init_simple_filtergraph(ist, ost);
2491 av_log(NULL, AV_LOG_ERROR,
2492 "Error initializing a simple filtergraph between streams "
2493 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2494 nb_output_files - 1, ost->st->index);
2500 /* set the filter output constraints */
2502 OutputFilter *f = ost->filter;
2504 switch (ost->enc_ctx->codec_type) {
2505 case AVMEDIA_TYPE_VIDEO:
2506 f->frame_rate = ost->frame_rate;
2507 f->width = ost->enc_ctx->width;
2508 f->height = ost->enc_ctx->height;
2509 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2510 f->format = ost->enc_ctx->pix_fmt;
2511 } else if (ost->enc->pix_fmts) {
2513 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2515 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2518 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2521 case AVMEDIA_TYPE_AUDIO:
2522 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2523 f->format = ost->enc_ctx->sample_fmt;
2524 } else if (ost->enc->sample_fmts) {
2526 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2528 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2531 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2533 if (ost->enc_ctx->sample_rate) {
2534 f->sample_rate = ost->enc_ctx->sample_rate;
2535 } else if (ost->enc->supported_samplerates) {
2537 while (ost->enc->supported_samplerates[count])
2539 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2540 if (!f->sample_rates)
2542 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2543 (count + 1) * sizeof(*f->sample_rates));
2545 if (ost->enc_ctx->channels) {
2546 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2547 } else if (ost->enc->channel_layouts) {
2549 while (ost->enc->channel_layouts[count])
2551 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2552 if (!f->channel_layouts)
2554 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2555 (count + 1) * sizeof(*f->channel_layouts));
2562 /* check filename in case of an image number is expected */
2563 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2564 if (!av_filename_number_test(oc->filename)) {
2565 print_error(oc->filename, AVERROR(EINVAL));
2570 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2571 av_log(NULL, AV_LOG_ERROR,
2572 "No input streams but output needs an input stream\n");
2576 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2577 /* test if it already exists to avoid losing precious files */
2578 assert_file_overwrite(filename);
2581 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2582 &oc->interrupt_callback,
2584 print_error(filename, err);
2587 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2588 assert_file_overwrite(filename);
2590 if (o->mux_preload) {
2591 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2593 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2596 for (i = 0; i < o->nb_metadata_map; i++) {
2598 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2600 if (in_file_index >= nb_input_files) {
2601 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2604 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2605 in_file_index >= 0 ?
2606 input_files[in_file_index]->ctx : NULL, o);
2610 if (o->chapters_input_file >= nb_input_files) {
2611 if (o->chapters_input_file == INT_MAX) {
2612 /* copy chapters from the first input file that has them*/
2613 o->chapters_input_file = -1;
2614 for (i = 0; i < nb_input_files; i++)
2615 if (input_files[i]->ctx->nb_chapters) {
2616 o->chapters_input_file = i;
2620 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2621 o->chapters_input_file);
2625 if (o->chapters_input_file >= 0)
2626 copy_chapters(input_files[o->chapters_input_file], of,
2627 !o->metadata_chapters_manual);
2629 /* copy global metadata by default */
2630 if (!o->metadata_global_manual && nb_input_files){
2631 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2632 AV_DICT_DONT_OVERWRITE);
2633 if(o->recording_time != INT64_MAX)
2634 av_dict_set(&oc->metadata, "duration", NULL, 0);
2635 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2637 if (!o->metadata_streams_manual)
2638 for (i = of->ost_index; i < nb_output_streams; i++) {
2640 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2642 ist = input_streams[output_streams[i]->source_index];
2643 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2644 if (!output_streams[i]->stream_copy) {
2645 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2649 /* process manually set programs */
2650 for (i = 0; i < o->nb_program; i++) {
2651 const char *p = o->program[i].u.str;
2656 const char *p2 = av_get_token(&p, ":");
2657 const char *to_dealloc = p2;
2664 key = av_get_token(&p2, "=");
2666 av_freep(&to_dealloc);
2672 if (!strcmp(key, "program_num"))
2673 progid = strtol(p2, NULL, 0);
2674 av_freep(&to_dealloc);
2678 program = av_new_program(oc, progid);
2680 p = o->program[i].u.str;
2682 const char *p2 = av_get_token(&p, ":");
2683 const char *to_dealloc = p2;
2689 key = av_get_token(&p2, "=");
2691 av_log(NULL, AV_LOG_FATAL,
2692 "No '=' character in program string %s.\n",
2700 if (!strcmp(key, "title")) {
2701 av_dict_set(&program->metadata, "title", p2, 0);
2702 } else if (!strcmp(key, "program_num")) {
2703 } else if (!strcmp(key, "st")) {
2704 int st_num = strtol(p2, NULL, 0);
2705 av_program_add_stream_index(oc, progid, st_num);
2707 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2710 av_freep(&to_dealloc);
2715 /* process manually set metadata */
2716 for (i = 0; i < o->nb_metadata; i++) {
2719 const char *stream_spec;
2720 int index = 0, j, ret = 0;
2722 val = strchr(o->metadata[i].u.str, '=');
2724 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2725 o->metadata[i].u.str);
2730 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2732 for (j = 0; j < oc->nb_streams; j++) {
2733 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2734 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2735 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2737 double theta = av_strtod(val, &tail);
2739 ost->rotate_overridden = 1;
2740 ost->rotate_override_value = theta;
2743 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2755 if (index < 0 || index >= oc->nb_chapters) {
2756 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2759 m = &oc->chapters[index]->metadata;
2762 if (index < 0 || index >= oc->nb_programs) {
2763 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2766 m = &oc->programs[index]->metadata;
2769 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2772 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2779 static int opt_target(void *optctx, const char *opt, const char *arg)
2781 OptionsContext *o = optctx;
2782 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2783 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2785 if (!strncmp(arg, "pal-", 4)) {
2788 } else if (!strncmp(arg, "ntsc-", 5)) {
2791 } else if (!strncmp(arg, "film-", 5)) {
2795 /* Try to determine PAL/NTSC by peeking in the input files */
2796 if (nb_input_files) {
2798 for (j = 0; j < nb_input_files; j++) {
2799 for (i = 0; i < input_files[j]->nb_streams; i++) {
2800 AVStream *st = input_files[j]->ctx->streams[i];
2801 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2803 fr = st->time_base.den * 1000 / st->time_base.num;
2807 } else if ((fr == 29970) || (fr == 23976)) {
2812 if (norm != UNKNOWN)
2816 if (norm != UNKNOWN)
2817 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2820 if (norm == UNKNOWN) {
2821 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2822 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2823 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2827 if (!strcmp(arg, "vcd")) {
2828 opt_video_codec(o, "c:v", "mpeg1video");
2829 opt_audio_codec(o, "c:a", "mp2");
2830 parse_option(o, "f", "vcd", options);
2832 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2833 parse_option(o, "r", frame_rates[norm], options);
2834 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2836 opt_default(NULL, "b:v", "1150000");
2837 opt_default(NULL, "maxrate:v", "1150000");
2838 opt_default(NULL, "minrate:v", "1150000");
2839 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2841 opt_default(NULL, "b:a", "224000");
2842 parse_option(o, "ar", "44100", options);
2843 parse_option(o, "ac", "2", options);
2845 opt_default(NULL, "packetsize", "2324");
2846 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2848 /* We have to offset the PTS, so that it is consistent with the SCR.
2849 SCR starts at 36000, but the first two packs contain only padding
2850 and the first pack from the other stream, respectively, may also have
2851 been written before.
2852 So the real data starts at SCR 36000+3*1200. */
2853 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2854 } else if (!strcmp(arg, "svcd")) {
2856 opt_video_codec(o, "c:v", "mpeg2video");
2857 opt_audio_codec(o, "c:a", "mp2");
2858 parse_option(o, "f", "svcd", options);
2860 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2861 parse_option(o, "r", frame_rates[norm], options);
2862 parse_option(o, "pix_fmt", "yuv420p", options);
2863 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2865 opt_default(NULL, "b:v", "2040000");
2866 opt_default(NULL, "maxrate:v", "2516000");
2867 opt_default(NULL, "minrate:v", "0"); // 1145000;
2868 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2869 opt_default(NULL, "scan_offset", "1");
2871 opt_default(NULL, "b:a", "224000");
2872 parse_option(o, "ar", "44100", options);
2874 opt_default(NULL, "packetsize", "2324");
2876 } else if (!strcmp(arg, "dvd")) {
2878 opt_video_codec(o, "c:v", "mpeg2video");
2879 opt_audio_codec(o, "c:a", "ac3");
2880 parse_option(o, "f", "dvd", options);
2882 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2883 parse_option(o, "r", frame_rates[norm], options);
2884 parse_option(o, "pix_fmt", "yuv420p", options);
2885 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2887 opt_default(NULL, "b:v", "6000000");
2888 opt_default(NULL, "maxrate:v", "9000000");
2889 opt_default(NULL, "minrate:v", "0"); // 1500000;
2890 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2892 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2893 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2895 opt_default(NULL, "b:a", "448000");
2896 parse_option(o, "ar", "48000", options);
2898 } else if (!strncmp(arg, "dv", 2)) {
2900 parse_option(o, "f", "dv", options);
2902 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2903 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2904 norm == PAL ? "yuv420p" : "yuv411p", options);
2905 parse_option(o, "r", frame_rates[norm], options);
2907 parse_option(o, "ar", "48000", options);
2908 parse_option(o, "ac", "2", options);
2911 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2912 return AVERROR(EINVAL);
2915 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2916 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2921 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2923 av_free (vstats_filename);
2924 vstats_filename = av_strdup (arg);
2928 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2931 time_t today2 = time(NULL);
2932 struct tm *today = localtime(&today2);
2934 if (!today) { // maybe tomorrow
2935 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2939 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2941 return opt_vstats_file(NULL, opt, filename);
2944 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2946 OptionsContext *o = optctx;
2947 return parse_option(o, "frames:v", arg, options);
2950 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2952 OptionsContext *o = optctx;
2953 return parse_option(o, "frames:a", arg, options);
2956 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2958 OptionsContext *o = optctx;
2959 return parse_option(o, "frames:d", arg, options);
2962 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2965 AVDictionary *cbak = codec_opts;
2966 AVDictionary *fbak = format_opts;
2970 ret = opt_default(NULL, opt, arg);
2972 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2973 av_dict_copy(&o->g->format_opts, format_opts, 0);
2974 av_dict_free(&codec_opts);
2975 av_dict_free(&format_opts);
2982 static int opt_preset(void *optctx, const char *opt, const char *arg)
2984 OptionsContext *o = optctx;
2986 char filename[1000], line[1000], tmp_line[1000];
2987 const char *codec_name = NULL;
2991 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2993 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2994 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2995 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2997 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3001 while (fgets(line, sizeof(line), f)) {
3002 char *key = tmp_line, *value, *endptr;
3004 if (strcspn(line, "#\n\r") == 0)
3006 av_strlcpy(tmp_line, line, sizeof(tmp_line));
3007 if (!av_strtok(key, "=", &value) ||
3008 !av_strtok(value, "\r\n", &endptr)) {
3009 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3012 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3014 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3015 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3016 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3017 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3018 else if (opt_default_new(o, key, value) < 0) {
3019 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3020 filename, line, key, value);
3030 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3032 OptionsContext *o = optctx;
3033 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3034 int ret = parse_option(o, s, arg, options);
3039 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3041 OptionsContext *o = optctx;
3043 if(!strcmp(opt, "ab")){
3044 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3046 } else if(!strcmp(opt, "b")){
3047 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3048 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3051 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3055 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3057 OptionsContext *o = optctx;
3060 if(!strcmp(opt, "qscale")){
3061 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3062 return parse_option(o, "q:v", arg, options);
3064 s = av_asprintf("q%s", opt + 6);
3065 ret = parse_option(o, s, arg, options);
3070 static int opt_profile(void *optctx, const char *opt, const char *arg)
3072 OptionsContext *o = optctx;
3073 if(!strcmp(opt, "profile")){
3074 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3075 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3078 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3082 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3084 OptionsContext *o = optctx;
3085 return parse_option(o, "filter:v", arg, options);
3088 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3090 OptionsContext *o = optctx;
3091 return parse_option(o, "filter:a", arg, options);
3094 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3096 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3097 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3098 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3099 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3101 if (video_sync_method == VSYNC_AUTO)
3102 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3106 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3108 OptionsContext *o = optctx;
3109 char *tcr = av_asprintf("timecode=%s", arg);
3110 int ret = parse_option(o, "metadata:g", tcr, options);
3112 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3117 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3119 OptionsContext *o = optctx;
3120 char layout_str[32];
3123 int ret, channels, ac_str_size;
3126 layout = av_get_channel_layout(arg);
3128 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3129 return AVERROR(EINVAL);
3131 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3132 ret = opt_default_new(o, opt, layout_str);
3136 /* set 'ac' option based on channel layout */
3137 channels = av_get_channel_layout_nb_channels(layout);
3138 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3139 stream_str = strchr(opt, ':');
3140 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3141 ac_str = av_mallocz(ac_str_size);
3143 return AVERROR(ENOMEM);
3144 av_strlcpy(ac_str, "ac", 3);
3146 av_strlcat(ac_str, stream_str, ac_str_size);
3147 ret = parse_option(o, ac_str, layout_str, options);
3153 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3155 OptionsContext *o = optctx;
3156 return parse_option(o, "q:a", arg, options);
3159 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3161 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3162 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3163 return AVERROR(ENOMEM);
3164 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3165 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3166 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3167 return AVERROR(ENOMEM);
3169 input_stream_potentially_available = 1;
3174 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3176 uint8_t *graph_desc = read_file(arg);
3178 return AVERROR(EINVAL);
3180 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3181 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3182 return AVERROR(ENOMEM);
3183 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3184 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3186 input_stream_potentially_available = 1;
3191 void show_help_default(const char *opt, const char *arg)
3193 /* per-file options have at least one of those set */
3194 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3195 int show_advanced = 0, show_avoptions = 0;
3198 if (!strcmp(opt, "long"))
3200 else if (!strcmp(opt, "full"))
3201 show_advanced = show_avoptions = 1;
3203 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3208 printf("Getting help:\n"
3209 " -h -- print basic options\n"
3210 " -h long -- print more options\n"
3211 " -h full -- print all options (including all format and codec specific options, very long)\n"
3212 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3213 " See man %s for detailed description of the options.\n"
3214 "\n", program_name);
3216 show_help_options(options, "Print help / information / capabilities:",
3219 show_help_options(options, "Global options (affect whole program "
3220 "instead of just one file:",
3221 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3223 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3224 per_file | OPT_EXIT, 0);
3226 show_help_options(options, "Per-file main options:", 0,
3227 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3228 OPT_EXIT, per_file);
3230 show_help_options(options, "Advanced per-file options:",
3231 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3233 show_help_options(options, "Video options:",
3234 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3236 show_help_options(options, "Advanced Video options:",
3237 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3239 show_help_options(options, "Audio options:",
3240 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3242 show_help_options(options, "Advanced Audio options:",
3243 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3244 show_help_options(options, "Subtitle options:",
3245 OPT_SUBTITLE, 0, 0);
3248 if (show_avoptions) {
3249 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3250 show_help_children(avcodec_get_class(), flags);
3251 show_help_children(avformat_get_class(), flags);
3253 show_help_children(sws_get_class(), flags);
3255 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3256 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3260 void show_usage(void)
3262 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3263 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3264 av_log(NULL, AV_LOG_INFO, "\n");
3272 static const OptionGroupDef groups[] = {
3273 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3274 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3277 static int open_files(OptionGroupList *l, const char *inout,
3278 int (*open_file)(OptionsContext*, const char*))
3282 for (i = 0; i < l->nb_groups; i++) {
3283 OptionGroup *g = &l->groups[i];
3289 ret = parse_optgroup(&o, g);
3291 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3292 "%s.\n", inout, g->arg);
3296 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3297 ret = open_file(&o, g->arg);
3300 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3304 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3310 int ffmpeg_parse_options(int argc, char **argv)
3312 OptionParseContext octx;
3316 memset(&octx, 0, sizeof(octx));
3318 /* split the commandline into an internal representation */
3319 ret = split_commandline(&octx, argc, argv, options, groups,
3320 FF_ARRAY_ELEMS(groups));
3322 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3326 /* apply global options */
3327 ret = parse_optgroup(NULL, &octx.global_opts);
3329 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3333 /* configure terminal and setup signal handlers */
3336 /* open input files */
3337 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3339 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3343 /* create the complex filtergraphs */
3344 ret = init_complex_filters();
3346 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3350 /* open output files */
3351 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3353 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3357 check_filter_outputs();
3360 uninit_parse_context(&octx);
3362 av_strerror(ret, error, sizeof(error));
3363 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3368 static int opt_progress(void *optctx, const char *opt, const char *arg)
3370 AVIOContext *avio = NULL;
3373 if (!strcmp(arg, "-"))
3375 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3377 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3378 arg, av_err2str(ret));
3381 progress_avio = avio;
3385 #define OFFSET(x) offsetof(OptionsContext, x)
3386 const OptionDef options[] = {
3388 CMDUTILS_COMMON_OPTIONS
3389 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3390 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3391 "force format", "fmt" },
3392 { "y", OPT_BOOL, { &file_overwrite },
3393 "overwrite output files" },
3394 { "n", OPT_BOOL, { &no_file_overwrite },
3395 "never overwrite output files" },
3396 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3397 "Ignore unknown stream types" },
3398 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3399 "Copy unknown stream types" },
3400 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3401 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3402 "codec name", "codec" },
3403 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3404 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3405 "codec name", "codec" },
3406 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3407 OPT_OUTPUT, { .off = OFFSET(presets) },
3408 "preset name", "preset" },
3409 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3410 OPT_OUTPUT, { .func_arg = opt_map },
3411 "set input stream mapping",
3412 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3413 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3414 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3415 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3416 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3417 "set metadata information of outfile from infile",
3418 "outfile[,metadata]:infile[,metadata]" },
3419 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3420 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3421 "set chapters mapping", "input_file_index" },
3422 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3423 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3424 "record or transcode \"duration\" seconds of audio/video",
3426 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3427 "record or transcode stop time", "time_stop" },
3428 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3429 "set the limit file size in bytes", "limit_size" },
3430 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3431 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3432 "set the start time offset", "time_off" },
3433 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3434 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3435 "set the start time offset relative to EOF", "time_off" },
3436 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3437 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3438 "enable/disable seeking by timestamp with -ss" },
3439 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3440 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3441 "enable/disable accurate seeking with -ss" },
3442 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3443 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3444 "set the input ts offset", "time_off" },
3445 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3446 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3447 "set the input ts scale", "scale" },
3448 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3449 "set the recording timestamp ('now' to set the current time)", "time" },
3450 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3451 "add metadata", "string=string" },
3452 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3453 "add program with specified streams", "title=string:st=number..." },
3454 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3455 OPT_OUTPUT, { .func_arg = opt_data_frames },
3456 "set the number of data frames to output", "number" },
3457 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3458 "add timings for benchmarking" },
3459 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3460 "add timings for each task" },
3461 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3462 "write program-readable progress information", "url" },
3463 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3464 "enable or disable interaction on standard input" },
3465 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3466 "set max runtime in seconds", "limit" },
3467 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3468 "dump each input packet" },
3469 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3470 "when dumping packets, also dump the payload" },
3471 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3472 OPT_INPUT, { .off = OFFSET(rate_emu) },
3473 "read input at native frame rate", "" },
3474 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3475 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3476 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3477 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3478 "video sync method", "" },
3479 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3480 "frame drop threshold", "" },
3481 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3482 "audio sync method", "" },
3483 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3484 "audio drift threshold", "threshold" },
3485 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3486 "copy timestamps" },
3487 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3488 "shift input timestamps to start at 0 when using copyts" },
3489 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3490 "copy input stream time base when stream copying", "mode" },
3491 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3492 OPT_OUTPUT, { .off = OFFSET(shortest) },
3493 "finish encoding within shortest input" },
3494 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3495 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3497 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3498 OPT_OUTPUT, { .off = OFFSET(apad) },
3500 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3501 "timestamp discontinuity delta threshold", "threshold" },
3502 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3503 "timestamp error delta threshold", "threshold" },
3504 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3505 "exit on error", "error" },
3506 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3507 "abort on the specified condition flags", "flags" },
3508 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3509 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3510 "copy initial non-keyframes" },
3511 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3512 "copy or discard frames before start time" },
3513 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3514 "set the number of frames to output", "number" },
3515 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3516 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3517 "force codec tag/fourcc", "fourcc/tag" },
3518 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3519 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3520 "use fixed quality scale (VBR)", "q" },
3521 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3522 OPT_OUTPUT, { .func_arg = opt_qscale },
3523 "use fixed quality scale (VBR)", "q" },
3524 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3525 "set profile", "profile" },
3526 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3527 "set stream filtergraph", "filter_graph" },
3528 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3529 "number of non-complex filter threads" },
3530 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3531 "read stream filtergraph description from a file", "filename" },
3532 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3533 "reinit filtergraph on input parameter changes", "" },
3534 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3535 "create a complex filtergraph", "graph_description" },
3536 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3537 "number of threads for -filter_complex" },
3538 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3539 "create a complex filtergraph", "graph_description" },
3540 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3541 "read complex filtergraph description from a file", "filename" },
3542 { "stats", OPT_BOOL, { &print_stats },
3543 "print progress report during encoding", },
3544 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3545 OPT_OUTPUT, { .func_arg = opt_attach },
3546 "add an attachment to the output file", "filename" },
3547 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3548 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3549 "extract an attachment into a file", "filename" },
3550 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3551 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3552 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3553 "print timestamp debugging info" },
3554 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3555 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3556 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3557 OPT_INPUT, { .off = OFFSET(discard) },
3559 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3560 OPT_OUTPUT, { .off = OFFSET(disposition) },
3561 "disposition", "" },
3562 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3563 { .off = OFFSET(thread_queue_size) },
3564 "set the maximum number of queued packets from the demuxer" },
3565 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3566 "read and decode the streams to fill missing information with heuristics" },
3569 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3570 "set the number of video frames to output", "number" },
3571 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3572 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3573 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3574 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3575 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3576 "set frame size (WxH or abbreviation)", "size" },
3577 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3578 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3579 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3580 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3581 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3582 "set pixel format", "format" },
3583 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3584 "set the number of bits per raw sample", "number" },
3585 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3586 "deprecated use -g 1" },
3587 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3589 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3590 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3591 "rate control override for specific intervals", "override" },
3592 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3593 OPT_OUTPUT, { .func_arg = opt_video_codec },
3594 "force video codec ('copy' to copy stream)", "codec" },
3595 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3597 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3599 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3600 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3601 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3602 "select the pass number (1 to 3)", "n" },
3603 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3604 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3605 "select two pass log file name prefix", "prefix" },
3606 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3607 "this option is deprecated, use the yadif filter instead" },
3608 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3609 "calculate PSNR of compressed frames" },
3610 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3611 "dump video coding statistics to file" },
3612 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3613 "dump video coding statistics to file", "file" },
3614 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3615 "Version of the vstats format to use."},
3616 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3617 "set video filters", "filter_graph" },
3618 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3619 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3620 "specify intra matrix coeffs", "matrix" },
3621 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3622 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3623 "specify inter matrix coeffs", "matrix" },
3624 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3625 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3626 "specify intra matrix coeffs", "matrix" },
3627 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3628 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3629 "top=1/bottom=0/auto=-1 field first", "" },
3630 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3631 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3632 "force video tag/fourcc", "fourcc/tag" },
3633 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3634 "show QP histogram" },
3635 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3636 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3637 "force the selected framerate, disable the best supported framerate selection" },
3638 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3639 OPT_OUTPUT, { .func_arg = opt_streamid },
3640 "set the value of an outfile streamid", "streamIndex:value" },
3641 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3642 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3643 "force key frames at specified timestamps", "timestamps" },
3644 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3645 "audio bitrate (please use -b:a)", "bitrate" },
3646 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3647 "video bitrate (please use -b:v)", "bitrate" },
3648 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3649 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3650 "use HW accelerated decoding", "hwaccel name" },
3651 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3652 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3653 "select a device for HW acceleration", "devicename" },
3654 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3655 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3656 "select output format used with HW accelerated decoding", "format" },
3657 #if CONFIG_VIDEOTOOLBOX
3658 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3660 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3661 "show available HW acceleration methods" },
3662 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3663 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3664 "automatically insert correct rotate filters" },
3667 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3668 "set the number of audio frames to output", "number" },
3669 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3670 "set audio quality (codec-specific)", "quality", },
3671 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3672 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3673 "set audio sampling rate (in Hz)", "rate" },
3674 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3675 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3676 "set number of audio channels", "channels" },
3677 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3679 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3680 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3681 "force audio codec ('copy' to copy stream)", "codec" },
3682 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3683 OPT_OUTPUT, { .func_arg = opt_old2new },
3684 "force audio tag/fourcc", "fourcc/tag" },
3685 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3686 "change audio volume (256=normal)" , "volume" },
3687 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3688 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3689 "set sample format", "format" },
3690 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3691 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3692 "set channel layout", "layout" },
3693 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3694 "set audio filters", "filter_graph" },
3695 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3696 "set the maximum number of channels to try to guess the channel layout" },
3698 /* subtitle options */
3699 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3700 "disable subtitle" },
3701 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3702 "force subtitle codec ('copy' to copy stream)", "codec" },
3703 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3704 , "force subtitle tag/fourcc", "fourcc/tag" },
3705 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3706 "fix subtitles duration" },
3707 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3708 "set canvas size (WxH or abbreviation)", "size" },
3711 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3712 "deprecated, use -channel", "channel" },
3713 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3714 "deprecated, use -standard", "standard" },
3715 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3718 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3719 "set the maximum demux-decode delay", "seconds" },
3720 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3721 "set the initial demux-decode delay", "seconds" },
3722 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3723 "override the options from ffserver", "" },
3724 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3725 "specify a file in which to print sdp information", "file" },
3727 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3728 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3729 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3730 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3731 "two special values are defined - "
3732 "0 = use frame rate (video) or sample rate (audio),"
3733 "-1 = match source time base", "ratio" },
3735 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3736 "A comma-separated list of bitstream filters", "bitstream_filters" },
3737 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3738 "deprecated", "audio bitstream_filters" },
3739 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3740 "deprecated", "video bitstream_filters" },
3742 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3743 "set the audio options to the indicated preset", "preset" },
3744 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3745 "set the video options to the indicated preset", "preset" },
3746 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3747 "set the subtitle options to the indicated preset", "preset" },
3748 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3749 "set options from indicated preset file", "filename" },
3751 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3752 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3754 /* data codec support */
3755 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3756 "force data codec ('copy' to copy stream)", "codec" },
3757 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3761 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3762 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3766 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3767 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3770 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3771 "initialise hardware device", "args" },
3772 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3773 "set hardware device used when filtering", "device" },