2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
70 { "vdpau", hwaccel_decode_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU,
71 AV_HWDEVICE_TYPE_VDPAU },
74 { "d3d11va", hwaccel_decode_init, HWACCEL_D3D11VA, AV_PIX_FMT_D3D11,
75 AV_HWDEVICE_TYPE_D3D11VA },
78 { "dxva2", hwaccel_decode_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD,
79 AV_HWDEVICE_TYPE_DXVA2 },
81 #if CONFIG_VIDEOTOOLBOX
82 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX,
83 AV_HWDEVICE_TYPE_NONE },
86 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV,
87 AV_HWDEVICE_TYPE_NONE },
90 { "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
91 AV_HWDEVICE_TYPE_VAAPI },
94 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
95 AV_HWDEVICE_TYPE_NONE },
99 AVBufferRef *hw_device_ctx;
100 HWDevice *filter_hw_device;
102 char *vstats_filename;
105 float audio_drift_threshold = 0.1;
106 float dts_delta_threshold = 10;
107 float dts_error_threshold = 3600*30;
109 int audio_volume = 256;
110 int audio_sync_method = 0;
111 int video_sync_method = VSYNC_AUTO;
112 float frame_drop_threshold = 0;
113 int do_deinterlace = 0;
114 int do_benchmark = 0;
115 int do_benchmark_all = 0;
119 int start_at_zero = 0;
122 int exit_on_error = 0;
123 int abort_on_flags = 0;
124 int print_stats = -1;
126 int stdin_interaction = 1;
127 int frame_bits_per_raw_sample = 0;
128 float max_error_rate = 2.0/3;
129 int filter_nbthreads = 0;
130 int filter_complex_nbthreads = 0;
131 int vstats_version = 2;
134 static int intra_only = 0;
135 static int file_overwrite = 0;
136 static int no_file_overwrite = 0;
137 static int do_psnr = 0;
138 static int input_sync;
139 static int override_ffserver = 0;
140 static int input_stream_potentially_available = 0;
141 static int ignore_unknown_streams = 0;
142 static int copy_unknown_streams = 0;
143 static int find_stream_info = 1;
145 static void uninit_options(OptionsContext *o)
147 const OptionDef *po = options;
150 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
152 void *dst = (uint8_t*)o + po->u.off;
154 if (po->flags & OPT_SPEC) {
155 SpecifierOpt **so = dst;
156 int i, *count = (int*)(so + 1);
157 for (i = 0; i < *count; i++) {
158 av_freep(&(*so)[i].specifier);
159 if (po->flags & OPT_STRING)
160 av_freep(&(*so)[i].u.str);
164 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
169 for (i = 0; i < o->nb_stream_maps; i++)
170 av_freep(&o->stream_maps[i].linklabel);
171 av_freep(&o->stream_maps);
172 av_freep(&o->audio_channel_maps);
173 av_freep(&o->streamid_map);
174 av_freep(&o->attachments);
177 static void init_options(OptionsContext *o)
179 memset(o, 0, sizeof(*o));
181 o->stop_time = INT64_MAX;
182 o->mux_max_delay = 0.7;
183 o->start_time = AV_NOPTS_VALUE;
184 o->start_time_eof = AV_NOPTS_VALUE;
185 o->recording_time = INT64_MAX;
186 o->limit_filesize = UINT64_MAX;
187 o->chapters_input_file = INT_MAX;
188 o->accurate_seek = 1;
191 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
195 printf("Hardware acceleration methods:\n");
196 for (i = 0; hwaccels[i].name; i++) {
197 printf("%s\n", hwaccels[i].name);
203 /* return a copy of the input with the stream specifiers removed from the keys */
204 static AVDictionary *strip_specifiers(AVDictionary *dict)
206 AVDictionaryEntry *e = NULL;
207 AVDictionary *ret = NULL;
209 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
210 char *p = strchr(e->key, ':');
214 av_dict_set(&ret, e->key, e->value, 0);
221 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
223 static const AVOption opts[] = {
224 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
225 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
228 static const AVClass class = {
230 .item_name = av_default_item_name,
232 .version = LIBAVUTIL_VERSION_INT,
234 const AVClass *pclass = &class;
236 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
239 static int opt_sameq(void *optctx, const char *opt, const char *arg)
241 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
242 "If you are looking for an option to preserve the quality (which is not "
243 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
245 return AVERROR(EINVAL);
248 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
250 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
251 return opt_default(optctx, "channel", arg);
254 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
256 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
257 return opt_default(optctx, "standard", arg);
260 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
262 OptionsContext *o = optctx;
263 return parse_option(o, "codec:a", arg, options);
266 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
268 OptionsContext *o = optctx;
269 return parse_option(o, "codec:v", arg, options);
272 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
274 OptionsContext *o = optctx;
275 return parse_option(o, "codec:s", arg, options);
278 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
280 OptionsContext *o = optctx;
281 return parse_option(o, "codec:d", arg, options);
284 static int opt_map(void *optctx, const char *opt, const char *arg)
286 OptionsContext *o = optctx;
288 int i, negative = 0, file_idx;
289 int sync_file_idx = -1, sync_stream_idx = 0;
298 map = av_strdup(arg);
300 return AVERROR(ENOMEM);
302 /* parse sync stream first, just pick first matching stream */
303 if (sync = strchr(map, ',')) {
305 sync_file_idx = strtol(sync + 1, &sync, 0);
306 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
307 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
312 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
313 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
314 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
318 if (i == input_files[sync_file_idx]->nb_streams) {
319 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
320 "match any streams.\n", arg);
327 /* this mapping refers to lavfi output */
328 const char *c = map + 1;
329 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
330 m = &o->stream_maps[o->nb_stream_maps - 1];
331 m->linklabel = av_get_token(&c, "]");
333 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
337 if (allow_unused = strchr(map, '?'))
339 file_idx = strtol(map, &p, 0);
340 if (file_idx >= nb_input_files || file_idx < 0) {
341 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
345 /* disable some already defined maps */
346 for (i = 0; i < o->nb_stream_maps; i++) {
347 m = &o->stream_maps[i];
348 if (file_idx == m->file_index &&
349 check_stream_specifier(input_files[m->file_index]->ctx,
350 input_files[m->file_index]->ctx->streams[m->stream_index],
351 *p == ':' ? p + 1 : p) > 0)
355 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
356 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
357 *p == ':' ? p + 1 : p) <= 0)
359 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
360 m = &o->stream_maps[o->nb_stream_maps - 1];
362 m->file_index = file_idx;
365 if (sync_file_idx >= 0) {
366 m->sync_file_index = sync_file_idx;
367 m->sync_stream_index = sync_stream_idx;
369 m->sync_file_index = file_idx;
370 m->sync_stream_index = i;
377 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
379 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
380 "To ignore this, add a trailing '?' to the map.\n", arg);
389 static int opt_attach(void *optctx, const char *opt, const char *arg)
391 OptionsContext *o = optctx;
392 GROW_ARRAY(o->attachments, o->nb_attachments);
393 o->attachments[o->nb_attachments - 1] = arg;
397 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
399 OptionsContext *o = optctx;
405 mapchan = av_strdup(arg);
407 return AVERROR(ENOMEM);
409 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
410 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
412 /* muted channel syntax */
413 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
414 if ((n == 1 || n == 3) && m->channel_idx == -1) {
415 m->file_idx = m->stream_idx = -1;
417 m->ofile_idx = m->ostream_idx = -1;
423 n = sscanf(arg, "%d.%d.%d:%d.%d",
424 &m->file_idx, &m->stream_idx, &m->channel_idx,
425 &m->ofile_idx, &m->ostream_idx);
427 if (n != 3 && n != 5) {
428 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
429 "[file.stream.channel|-1][:syncfile:syncstream]\n");
433 if (n != 5) // only file.stream.channel specified
434 m->ofile_idx = m->ostream_idx = -1;
437 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
438 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
442 if (m->stream_idx < 0 ||
443 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
444 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
445 m->file_idx, m->stream_idx);
448 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
449 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
450 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
451 m->file_idx, m->stream_idx);
454 /* allow trailing ? to map_channel */
455 if (allow_unused = strchr(mapchan, '?'))
457 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
459 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
460 m->file_idx, m->stream_idx, m->channel_idx);
462 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
463 "To ignore this, add a trailing '?' to the map_channel.\n",
464 m->file_idx, m->stream_idx, m->channel_idx);
473 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
475 av_free(sdp_filename);
476 sdp_filename = av_strdup(arg);
481 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
484 const char *prefix = "vaapi:";
487 tmp = av_asprintf("%s%s", prefix, arg);
489 return AVERROR(ENOMEM);
490 err = hw_device_init_from_string(tmp, &dev);
494 hw_device_ctx = av_buffer_ref(dev->device_ref);
496 return AVERROR(ENOMEM);
501 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
503 if (!strcmp(arg, "list")) {
504 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
505 printf("Supported hardware device types:\n");
506 while ((type = av_hwdevice_iterate_types(type)) !=
507 AV_HWDEVICE_TYPE_NONE)
508 printf("%s\n", av_hwdevice_get_type_name(type));
512 return hw_device_init_from_string(arg, NULL);
516 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
518 if (filter_hw_device) {
519 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
520 return AVERROR(EINVAL);
522 filter_hw_device = hw_device_get_by_name(arg);
523 if (!filter_hw_device) {
524 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
525 return AVERROR(EINVAL);
531 * Parse a metadata specifier passed as 'arg' parameter.
532 * @param arg metadata string to parse
533 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
534 * @param index for type c/p, chapter/program index is written here
535 * @param stream_spec for type s, the stream specifier is written here
537 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
545 if (*(++arg) && *arg != ':') {
546 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
549 *stream_spec = *arg == ':' ? arg + 1 : "";
554 *index = strtol(++arg, NULL, 0);
557 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
564 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
566 AVDictionary **meta_in = NULL;
567 AVDictionary **meta_out = NULL;
569 char type_in, type_out;
570 const char *istream_spec = NULL, *ostream_spec = NULL;
571 int idx_in = 0, idx_out = 0;
573 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
574 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
577 if (type_out == 'g' || !*outspec)
578 o->metadata_global_manual = 1;
579 if (type_out == 's' || !*outspec)
580 o->metadata_streams_manual = 1;
581 if (type_out == 'c' || !*outspec)
582 o->metadata_chapters_manual = 1;
586 if (type_in == 'g' || type_out == 'g')
587 o->metadata_global_manual = 1;
588 if (type_in == 's' || type_out == 's')
589 o->metadata_streams_manual = 1;
590 if (type_in == 'c' || type_out == 'c')
591 o->metadata_chapters_manual = 1;
593 /* ic is NULL when just disabling automatic mappings */
597 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
598 if ((index) < 0 || (index) >= (nb_elems)) {\
599 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
604 #define SET_DICT(type, meta, context, index)\
607 meta = &context->metadata;\
610 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
611 meta = &context->chapters[index]->metadata;\
614 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
615 meta = &context->programs[index]->metadata;\
618 break; /* handled separately below */ \
619 default: av_assert0(0);\
622 SET_DICT(type_in, meta_in, ic, idx_in);
623 SET_DICT(type_out, meta_out, oc, idx_out);
625 /* for input streams choose first matching stream */
626 if (type_in == 's') {
627 for (i = 0; i < ic->nb_streams; i++) {
628 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
629 meta_in = &ic->streams[i]->metadata;
635 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
640 if (type_out == 's') {
641 for (i = 0; i < oc->nb_streams; i++) {
642 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
643 meta_out = &oc->streams[i]->metadata;
644 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
649 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
654 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
656 OptionsContext *o = optctx;
658 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
659 struct tm time = *gmtime((time_t*)&recording_timestamp);
660 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
662 parse_option(o, "metadata", buf, options);
664 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
665 "tag instead.\n", opt);
669 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
671 const AVCodecDescriptor *desc;
672 const char *codec_string = encoder ? "encoder" : "decoder";
676 avcodec_find_encoder_by_name(name) :
677 avcodec_find_decoder_by_name(name);
679 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
680 codec = encoder ? avcodec_find_encoder(desc->id) :
681 avcodec_find_decoder(desc->id);
683 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
684 codec_string, codec->name, desc->name);
688 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
691 if (codec->type != type) {
692 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
698 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
700 char *codec_name = NULL;
702 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
704 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
705 st->codecpar->codec_id = codec->id;
708 return avcodec_find_decoder(st->codecpar->codec_id);
711 /* Add all the streams from the given input file to the global
712 * list of input streams. */
713 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
717 for (i = 0; i < ic->nb_streams; i++) {
718 AVStream *st = ic->streams[i];
719 AVCodecParameters *par = st->codecpar;
720 InputStream *ist = av_mallocz(sizeof(*ist));
721 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
722 char *hwaccel_output_format = NULL;
723 char *codec_tag = NULL;
725 char *discard_str = NULL;
726 const AVClass *cc = avcodec_get_class();
727 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
732 GROW_ARRAY(input_streams, nb_input_streams);
733 input_streams[nb_input_streams - 1] = ist;
736 ist->file_index = nb_input_files;
738 st->discard = AVDISCARD_ALL;
740 ist->min_pts = INT64_MAX;
741 ist->max_pts = INT64_MIN;
744 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
747 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
749 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
751 uint32_t tag = strtol(codec_tag, &next, 0);
753 tag = AV_RL32(codec_tag);
754 st->codecpar->codec_tag = tag;
757 ist->dec = choose_decoder(o, ic, st);
758 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
760 ist->reinit_filters = -1;
761 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
763 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
764 ist->user_set_discard = AVDISCARD_NONE;
765 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
766 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
771 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
773 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
775 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
779 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
781 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
786 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
788 switch (par->codec_type) {
789 case AVMEDIA_TYPE_VIDEO:
791 ist->dec = avcodec_find_decoder(par->codec_id);
793 if (av_codec_get_lowres(st->codec)) {
794 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
795 ist->dec_ctx->width = st->codec->width;
796 ist->dec_ctx->height = st->codec->height;
797 ist->dec_ctx->coded_width = st->codec->coded_width;
798 ist->dec_ctx->coded_height = st->codec->coded_height;
802 // avformat_find_stream_info() doesn't set this for us anymore.
803 ist->dec_ctx->framerate = st->avg_frame_rate;
805 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
806 if (framerate && av_parse_video_rate(&ist->framerate,
808 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
813 ist->top_field_first = -1;
814 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
816 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
818 if (!strcmp(hwaccel, "none"))
819 ist->hwaccel_id = HWACCEL_NONE;
820 else if (!strcmp(hwaccel, "auto"))
821 ist->hwaccel_id = HWACCEL_AUTO;
824 for (i = 0; hwaccels[i].name; i++) {
825 if (!strcmp(hwaccels[i].name, hwaccel)) {
826 ist->hwaccel_id = hwaccels[i].id;
831 if (!ist->hwaccel_id) {
832 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
834 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
835 for (i = 0; hwaccels[i].name; i++)
836 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
837 av_log(NULL, AV_LOG_FATAL, "\n");
843 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
844 if (hwaccel_device) {
845 ist->hwaccel_device = av_strdup(hwaccel_device);
846 if (!ist->hwaccel_device)
850 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
851 hwaccel_output_format, ic, st);
852 if (hwaccel_output_format) {
853 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
854 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
855 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
856 "format: %s", hwaccel_output_format);
859 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
862 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
865 case AVMEDIA_TYPE_AUDIO:
866 ist->guess_layout_max = INT_MAX;
867 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
868 guess_input_channel_layout(ist);
870 case AVMEDIA_TYPE_DATA:
871 case AVMEDIA_TYPE_SUBTITLE: {
872 char *canvas_size = NULL;
874 ist->dec = avcodec_find_decoder(par->codec_id);
875 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
876 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
878 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
879 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
884 case AVMEDIA_TYPE_ATTACHMENT:
885 case AVMEDIA_TYPE_UNKNOWN:
891 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
893 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
899 static void assert_file_overwrite(const char *filename)
901 if (file_overwrite && no_file_overwrite) {
902 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
906 if (!file_overwrite) {
907 const char *proto_name = avio_find_protocol_name(filename);
908 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
909 if (stdin_interaction && !no_file_overwrite) {
910 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
913 signal(SIGINT, SIG_DFL);
915 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
921 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
928 static void dump_attachment(AVStream *st, const char *filename)
931 AVIOContext *out = NULL;
932 AVDictionaryEntry *e;
934 if (!st->codecpar->extradata_size) {
935 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
936 nb_input_files - 1, st->index);
939 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
942 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
943 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
947 assert_file_overwrite(filename);
949 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
950 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
955 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
960 static int open_input_file(OptionsContext *o, const char *filename)
964 AVInputFormat *file_iformat = NULL;
967 AVDictionary *unused_opts = NULL;
968 AVDictionaryEntry *e = NULL;
969 char * video_codec_name = NULL;
970 char * audio_codec_name = NULL;
971 char *subtitle_codec_name = NULL;
972 char * data_codec_name = NULL;
973 int scan_all_pmts_set = 0;
976 if (!(file_iformat = av_find_input_format(o->format))) {
977 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
982 if (!strcmp(filename, "-"))
985 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
986 strcmp(filename, "/dev/stdin");
988 /* get default parameters from command line */
989 ic = avformat_alloc_context();
991 print_error(filename, AVERROR(ENOMEM));
994 if (o->nb_audio_sample_rate) {
995 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
997 if (o->nb_audio_channels) {
998 /* because we set audio_channels based on both the "ac" and
999 * "channel_layout" options, we need to check that the specified
1000 * demuxer actually has the "channels" option before setting it */
1001 if (file_iformat && file_iformat->priv_class &&
1002 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1003 AV_OPT_SEARCH_FAKE_OBJ)) {
1004 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1007 if (o->nb_frame_rates) {
1008 /* set the format-level framerate option;
1009 * this is important for video grabbers, e.g. x11 */
1010 if (file_iformat && file_iformat->priv_class &&
1011 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1012 AV_OPT_SEARCH_FAKE_OBJ)) {
1013 av_dict_set(&o->g->format_opts, "framerate",
1014 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1017 if (o->nb_frame_sizes) {
1018 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1020 if (o->nb_frame_pix_fmts)
1021 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1023 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1024 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1025 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1026 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1028 if (video_codec_name)
1029 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1030 if (audio_codec_name)
1031 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1032 if (subtitle_codec_name)
1033 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1034 if (data_codec_name)
1035 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1037 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1038 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1039 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1040 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1042 ic->flags |= AVFMT_FLAG_NONBLOCK;
1044 ic->flags |= AVFMT_FLAG_BITEXACT;
1045 ic->interrupt_callback = int_cb;
1047 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1048 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1049 scan_all_pmts_set = 1;
1051 /* open the input file with generic avformat function */
1052 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1054 print_error(filename, err);
1055 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1056 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1059 if (scan_all_pmts_set)
1060 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1061 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1062 assert_avoptions(o->g->format_opts);
1064 /* apply forced codec ids */
1065 for (i = 0; i < ic->nb_streams; i++)
1066 choose_decoder(o, ic, ic->streams[i]);
1068 if (find_stream_info) {
1069 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1070 int orig_nb_streams = ic->nb_streams;
1072 /* If not enough info to get the stream parameters, we decode the
1073 first frames to get it. (used in mpeg case for example) */
1074 ret = avformat_find_stream_info(ic, opts);
1076 for (i = 0; i < orig_nb_streams; i++)
1077 av_dict_free(&opts[i]);
1081 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1082 if (ic->nb_streams == 0) {
1083 avformat_close_input(&ic);
1089 if (o->start_time_eof != AV_NOPTS_VALUE) {
1090 if (ic->duration>0) {
1091 o->start_time = o->start_time_eof + ic->duration;
1093 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1095 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1096 /* add the stream start time */
1097 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1098 timestamp += ic->start_time;
1100 /* if seeking requested, we execute it */
1101 if (o->start_time != AV_NOPTS_VALUE) {
1102 int64_t seek_timestamp = timestamp;
1104 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1105 int dts_heuristic = 0;
1106 for (i=0; i<ic->nb_streams; i++) {
1107 const AVCodecParameters *par = ic->streams[i]->codecpar;
1108 if (par->video_delay)
1111 if (dts_heuristic) {
1112 seek_timestamp -= 3*AV_TIME_BASE / 23;
1115 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1117 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1118 filename, (double)timestamp / AV_TIME_BASE);
1122 /* update the current parameters so that they match the one of the input stream */
1123 add_input_streams(o, ic);
1125 /* dump the file content */
1126 av_dump_format(ic, nb_input_files, filename, 0);
1128 GROW_ARRAY(input_files, nb_input_files);
1129 f = av_mallocz(sizeof(*f));
1132 input_files[nb_input_files - 1] = f;
1135 f->ist_index = nb_input_streams - ic->nb_streams;
1136 f->start_time = o->start_time;
1137 f->recording_time = o->recording_time;
1138 f->input_ts_offset = o->input_ts_offset;
1139 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1140 f->nb_streams = ic->nb_streams;
1141 f->rate_emu = o->rate_emu;
1142 f->accurate_seek = o->accurate_seek;
1145 f->time_base = (AVRational){ 1, 1 };
1147 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1150 /* check if all codec options have been used */
1151 unused_opts = strip_specifiers(o->g->codec_opts);
1152 for (i = f->ist_index; i < nb_input_streams; i++) {
1154 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1155 AV_DICT_IGNORE_SUFFIX)))
1156 av_dict_set(&unused_opts, e->key, NULL, 0);
1160 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1161 const AVClass *class = avcodec_get_class();
1162 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1163 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1164 const AVClass *fclass = avformat_get_class();
1165 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1166 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1167 if (!option || foption)
1171 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1172 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1173 "input file #%d (%s) is not a decoding option.\n", e->key,
1174 option->help ? option->help : "", nb_input_files - 1,
1179 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1180 "input file #%d (%s) has not been used for any stream. The most "
1181 "likely reason is either wrong type (e.g. a video option with "
1182 "no video streams) or that it is a private option of some decoder "
1183 "which was not actually used for any stream.\n", e->key,
1184 option->help ? option->help : "", nb_input_files - 1, filename);
1186 av_dict_free(&unused_opts);
1188 for (i = 0; i < o->nb_dump_attachment; i++) {
1191 for (j = 0; j < ic->nb_streams; j++) {
1192 AVStream *st = ic->streams[j];
1194 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1195 dump_attachment(st, o->dump_attachment[i].u.str);
1199 input_stream_potentially_available = 1;
1204 static uint8_t *get_line(AVIOContext *s)
1210 if (avio_open_dyn_buf(&line) < 0) {
1211 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1215 while ((c = avio_r8(s)) && c != '\n')
1218 avio_close_dyn_buf(line, &buf);
1223 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1226 char filename[1000];
1227 const char *base[3] = { getenv("AVCONV_DATADIR"),
1232 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1236 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1237 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1238 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1241 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1242 i != 1 ? "" : "/.avconv", preset_name);
1243 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1249 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1251 enum AVMediaType type = ost->st->codecpar->codec_type;
1252 char *codec_name = NULL;
1254 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1255 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1257 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1258 NULL, ost->st->codecpar->codec_type);
1259 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1261 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1262 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1263 "probably disabled. Please choose an encoder manually.\n",
1264 ost->file_index, ost->index, s->oformat->name,
1265 avcodec_get_name(ost->st->codecpar->codec_id));
1266 return AVERROR_ENCODER_NOT_FOUND;
1268 } else if (!strcmp(codec_name, "copy"))
1269 ost->stream_copy = 1;
1271 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1272 ost->st->codecpar->codec_id = ost->enc->id;
1274 ost->encoding_needed = !ost->stream_copy;
1276 /* no encoding supported for other media types */
1277 ost->stream_copy = 1;
1278 ost->encoding_needed = 0;
1284 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1287 AVStream *st = avformat_new_stream(oc, NULL);
1288 int idx = oc->nb_streams - 1, ret = 0;
1289 const char *bsfs = NULL, *time_base = NULL;
1290 char *next, *codec_tag = NULL;
1295 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1299 if (oc->nb_streams - 1 < o->nb_streamid_map)
1300 st->id = o->streamid_map[oc->nb_streams - 1];
1302 GROW_ARRAY(output_streams, nb_output_streams);
1303 if (!(ost = av_mallocz(sizeof(*ost))))
1305 output_streams[nb_output_streams - 1] = ost;
1307 ost->file_index = nb_output_files - 1;
1310 st->codecpar->codec_type = type;
1312 ret = choose_encoder(o, oc, ost);
1314 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1315 "%d:%d\n", ost->file_index, ost->index);
1319 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1320 if (!ost->enc_ctx) {
1321 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1324 ost->enc_ctx->codec_type = type;
1326 ost->ref_par = avcodec_parameters_alloc();
1327 if (!ost->ref_par) {
1328 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1333 AVIOContext *s = NULL;
1334 char *buf = NULL, *arg = NULL, *preset = NULL;
1336 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1338 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1339 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1342 if (!buf[0] || buf[0] == '#') {
1346 if (!(arg = strchr(buf, '='))) {
1347 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1351 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1353 } while (!s->eof_reached);
1357 av_log(NULL, AV_LOG_FATAL,
1358 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1359 preset, ost->file_index, ost->index);
1363 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1368 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1370 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1373 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1374 q.num <= 0 || q.den <= 0) {
1375 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1381 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1384 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1386 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1389 ost->enc_timebase = q;
1392 ost->max_frames = INT64_MAX;
1393 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1394 for (i = 0; i<o->nb_max_frames; i++) {
1395 char *p = o->max_frames[i].specifier;
1396 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1397 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1402 ost->copy_prior_start = -1;
1403 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1405 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1406 while (bsfs && *bsfs) {
1407 const AVBitStreamFilter *filter;
1408 char *bsf, *bsf_options_str, *bsf_name;
1410 bsf = av_get_token(&bsfs, ",");
1413 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1417 filter = av_bsf_get_by_name(bsf_name);
1419 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1423 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1424 ost->nb_bitstream_filters + 1,
1425 sizeof(*ost->bsf_ctx));
1429 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1431 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1435 ost->nb_bitstream_filters++;
1437 if (bsf_options_str && filter->priv_class) {
1438 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1439 const char * shorthand[2] = {NULL};
1442 shorthand[0] = opt->name;
1444 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1446 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1456 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1458 uint32_t tag = strtol(codec_tag, &next, 0);
1460 tag = AV_RL32(codec_tag);
1461 ost->st->codecpar->codec_tag =
1462 ost->enc_ctx->codec_tag = tag;
1465 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1467 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1468 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1471 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1472 ost->disposition = av_strdup(ost->disposition);
1474 ost->max_muxing_queue_size = 128;
1475 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1476 ost->max_muxing_queue_size *= sizeof(AVPacket);
1478 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1479 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1481 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1483 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1484 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1485 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1487 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1489 ost->source_index = source_index;
1490 if (source_index >= 0) {
1491 ost->sync_ist = input_streams[source_index];
1492 input_streams[source_index]->discard = 0;
1493 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1495 ost->last_mux_dts = AV_NOPTS_VALUE;
1497 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1498 if (!ost->muxing_queue)
1504 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1507 const char *p = str;
1514 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1521 /* read file contents into a string */
1522 static uint8_t *read_file(const char *filename)
1524 AVIOContext *pb = NULL;
1525 AVIOContext *dyn_buf = NULL;
1526 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1527 uint8_t buf[1024], *str;
1530 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1534 ret = avio_open_dyn_buf(&dyn_buf);
1539 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1540 avio_write(dyn_buf, buf, ret);
1541 avio_w8(dyn_buf, 0);
1544 ret = avio_close_dyn_buf(dyn_buf, &str);
1550 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1553 AVStream *st = ost->st;
1555 if (ost->filters_script && ost->filters) {
1556 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1557 "output stream #%d:%d.\n", nb_output_files, st->index);
1561 if (ost->filters_script)
1562 return read_file(ost->filters_script);
1563 else if (ost->filters)
1564 return av_strdup(ost->filters);
1566 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1570 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1571 const OutputStream *ost, enum AVMediaType type)
1573 if (ost->filters_script || ost->filters) {
1574 av_log(NULL, AV_LOG_ERROR,
1575 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1576 "Filtering and streamcopy cannot be used together.\n",
1577 ost->filters ? "Filtergraph" : "Filtergraph script",
1578 ost->filters ? ost->filters : ost->filters_script,
1579 av_get_media_type_string(type), ost->file_index, ost->index);
1584 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1588 AVCodecContext *video_enc;
1589 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1591 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1593 video_enc = ost->enc_ctx;
1595 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1596 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1597 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1600 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1601 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1603 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1604 if (frame_aspect_ratio) {
1606 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1607 q.num <= 0 || q.den <= 0) {
1608 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1611 ost->frame_aspect_ratio = q;
1614 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1615 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1617 if (!ost->stream_copy) {
1618 const char *p = NULL;
1619 char *frame_size = NULL;
1620 char *frame_pix_fmt = NULL;
1621 char *intra_matrix = NULL, *inter_matrix = NULL;
1622 char *chroma_intra_matrix = NULL;
1626 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1627 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1628 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1632 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1633 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1634 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1635 ost->keep_pix_fmt = 1;
1636 if (!*++frame_pix_fmt)
1637 frame_pix_fmt = NULL;
1639 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1640 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1643 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1646 video_enc->gop_size = 0;
1647 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1649 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1650 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1653 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1655 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1656 if (chroma_intra_matrix) {
1657 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1659 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1662 av_codec_set_chroma_intra_matrix(video_enc, p);
1663 parse_matrix_coeffs(p, chroma_intra_matrix);
1665 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1667 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1668 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1671 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1674 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1675 for (i = 0; p; i++) {
1677 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1679 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1682 video_enc->rc_override =
1683 av_realloc_array(video_enc->rc_override,
1684 i + 1, sizeof(RcOverride));
1685 if (!video_enc->rc_override) {
1686 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1689 video_enc->rc_override[i].start_frame = start;
1690 video_enc->rc_override[i].end_frame = end;
1692 video_enc->rc_override[i].qscale = q;
1693 video_enc->rc_override[i].quality_factor = 1.0;
1696 video_enc->rc_override[i].qscale = 0;
1697 video_enc->rc_override[i].quality_factor = -q/100.0;
1702 video_enc->rc_override_count = i;
1705 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1708 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1711 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1712 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1715 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1716 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1720 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1721 if (ost->logfile_prefix &&
1722 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1726 char logfilename[1024];
1729 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1730 ost->logfile_prefix ? ost->logfile_prefix :
1731 DEFAULT_PASS_LOGFILENAME_PREFIX,
1733 if (!strcmp(ost->enc->name, "libx264")) {
1734 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1736 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1737 char *logbuffer = read_file(logfilename);
1740 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1744 video_enc->stats_in = logbuffer;
1746 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1747 f = av_fopen_utf8(logfilename, "wb");
1749 av_log(NULL, AV_LOG_FATAL,
1750 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1751 logfilename, strerror(errno));
1759 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1760 if (ost->forced_keyframes)
1761 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1763 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1765 ost->top_field_first = -1;
1766 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1769 ost->avfilter = get_ost_filters(o, oc, ost);
1773 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1776 if (ost->stream_copy)
1777 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1782 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1787 AVCodecContext *audio_enc;
1789 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1792 audio_enc = ost->enc_ctx;
1793 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1795 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1796 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1798 if (!ost->stream_copy) {
1799 char *sample_fmt = NULL;
1801 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1803 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1805 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1806 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1810 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1812 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1813 ost->apad = av_strdup(ost->apad);
1815 ost->avfilter = get_ost_filters(o, oc, ost);
1819 /* check for channel mapping for this audio stream */
1820 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1821 AudioChannelMap *map = &o->audio_channel_maps[n];
1822 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1823 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1826 if (map->channel_idx == -1) {
1828 } else if (ost->source_index < 0) {
1829 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1830 ost->file_index, ost->st->index);
1833 ist = input_streams[ost->source_index];
1836 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1837 if (av_reallocp_array(&ost->audio_channels_map,
1838 ost->audio_channels_mapped + 1,
1839 sizeof(*ost->audio_channels_map)
1843 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1849 if (ost->stream_copy)
1850 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1855 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1859 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1860 if (!ost->stream_copy) {
1861 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1868 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1872 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1873 if (!ost->stream_copy) {
1874 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1881 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1883 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1884 ost->stream_copy = 1;
1889 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1893 AVCodecContext *subtitle_enc;
1895 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1897 subtitle_enc = ost->enc_ctx;
1899 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1901 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1903 if (!ost->stream_copy) {
1904 char *frame_size = NULL;
1906 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1907 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1908 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1916 /* arg format is "output-stream-index:streamid-value". */
1917 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1919 OptionsContext *o = optctx;
1924 av_strlcpy(idx_str, arg, sizeof(idx_str));
1925 p = strchr(idx_str, ':');
1927 av_log(NULL, AV_LOG_FATAL,
1928 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1933 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1934 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1935 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1939 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1941 AVFormatContext *is = ifile->ctx;
1942 AVFormatContext *os = ofile->ctx;
1946 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1948 return AVERROR(ENOMEM);
1951 for (i = 0; i < is->nb_chapters; i++) {
1952 AVChapter *in_ch = is->chapters[i], *out_ch;
1953 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1954 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1955 AV_TIME_BASE_Q, in_ch->time_base);
1956 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1957 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1960 if (in_ch->end < ts_off)
1962 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1965 out_ch = av_mallocz(sizeof(AVChapter));
1967 return AVERROR(ENOMEM);
1969 out_ch->id = in_ch->id;
1970 out_ch->time_base = in_ch->time_base;
1971 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1972 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1975 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1977 os->chapters[os->nb_chapters++] = out_ch;
1982 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1985 AVFormatContext *ic = avformat_alloc_context();
1987 ic->interrupt_callback = int_cb;
1988 err = avformat_open_input(&ic, filename, NULL, NULL);
1991 /* copy stream format */
1992 for(i=0;i<ic->nb_streams;i++) {
1996 const char *enc_config;
1998 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
2000 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
2001 return AVERROR(EINVAL);
2003 if (codec->type == AVMEDIA_TYPE_AUDIO)
2004 opt_audio_codec(o, "c:a", codec->name);
2005 else if (codec->type == AVMEDIA_TYPE_VIDEO)
2006 opt_video_codec(o, "c:v", codec->name);
2007 ost = new_output_stream(o, s, codec->type, -1);
2010 avcodec_get_context_defaults3(st->codec, codec);
2011 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
2013 AVDictionary *opts = NULL;
2014 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
2015 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
2016 av_dict_free(&opts);
2019 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
2020 choose_sample_fmt(st, codec);
2021 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
2022 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
2023 avcodec_copy_context(ost->enc_ctx, st->codec);
2025 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
2028 avformat_close_input(&ic);
2032 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2033 AVFormatContext *oc)
2037 switch (ofilter->type) {
2038 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2039 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2041 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2046 ost->source_index = -1;
2047 ost->filter = ofilter;
2050 ofilter->format = -1;
2052 if (ost->stream_copy) {
2053 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2054 "which is fed from a complex filtergraph. Filtering and streamcopy "
2055 "cannot be used together.\n", ost->file_index, ost->index);
2059 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2060 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2061 av_log(NULL, AV_LOG_ERROR,
2062 "%s '%s' was specified through the %s option "
2063 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2064 "%s and -filter_complex cannot be used together for the same stream.\n",
2065 ost->filters ? "Filtergraph" : "Filtergraph script",
2066 ost->filters ? ost->filters : ost->filters_script,
2067 opt, ost->file_index, ost->index, opt);
2071 avfilter_inout_free(&ofilter->out_tmp);
2074 static int init_complex_filters(void)
2078 for (i = 0; i < nb_filtergraphs; i++) {
2079 ret = init_complex_filtergraph(filtergraphs[i]);
2086 static int open_output_file(OptionsContext *o, const char *filename)
2088 AVFormatContext *oc;
2090 AVOutputFormat *file_oformat;
2094 AVDictionary *unused_opts = NULL;
2095 AVDictionaryEntry *e = NULL;
2096 int format_flags = 0;
2098 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2099 o->stop_time = INT64_MAX;
2100 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2103 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2104 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2105 if (o->stop_time <= start_time) {
2106 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2109 o->recording_time = o->stop_time - start_time;
2113 GROW_ARRAY(output_files, nb_output_files);
2114 of = av_mallocz(sizeof(*of));
2117 output_files[nb_output_files - 1] = of;
2119 of->ost_index = nb_output_streams;
2120 of->recording_time = o->recording_time;
2121 of->start_time = o->start_time;
2122 of->limit_filesize = o->limit_filesize;
2123 of->shortest = o->shortest;
2124 av_dict_copy(&of->opts, o->g->format_opts, 0);
2126 if (!strcmp(filename, "-"))
2129 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2131 print_error(filename, err);
2136 if (o->recording_time != INT64_MAX)
2137 oc->duration = o->recording_time;
2139 file_oformat= oc->oformat;
2140 oc->interrupt_callback = int_cb;
2142 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2144 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2145 av_opt_eval_flags(oc, o, e->value, &format_flags);
2148 format_flags |= AVFMT_FLAG_BITEXACT;
2149 oc->flags |= AVFMT_FLAG_BITEXACT;
2152 /* create streams for all unlabeled output pads */
2153 for (i = 0; i < nb_filtergraphs; i++) {
2154 FilterGraph *fg = filtergraphs[i];
2155 for (j = 0; j < fg->nb_outputs; j++) {
2156 OutputFilter *ofilter = fg->outputs[j];
2158 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2161 switch (ofilter->type) {
2162 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2163 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2164 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2166 init_output_filter(ofilter, o, oc);
2170 /* ffserver seeking with date=... needs a date reference */
2171 if (!strcmp(file_oformat->name, "ffm") &&
2172 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2173 av_strstart(filename, "http:", NULL)) {
2174 int err = parse_option(o, "metadata", "creation_time=now", options);
2176 print_error(filename, err);
2181 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2182 av_strstart(filename, "http:", NULL)) {
2184 /* special case for files sent to ffserver: we get the stream
2185 parameters from ffserver */
2186 int err = read_ffserver_streams(o, oc, filename);
2188 print_error(filename, err);
2191 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2192 ost = output_streams[j];
2193 for (i = 0; i < nb_input_streams; i++) {
2194 ist = input_streams[i];
2195 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2197 ost->source_index= i;
2198 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2199 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2201 ist->st->discard = ist->user_set_discard;
2206 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));
2210 } else if (!o->nb_stream_maps) {
2211 char *subtitle_codec_name = NULL;
2212 /* pick the "best" stream of each type */
2214 /* video: highest resolution */
2215 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2216 int area = 0, idx = -1;
2217 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2218 for (i = 0; i < nb_input_streams; i++) {
2220 ist = input_streams[i];
2221 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2222 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2224 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2226 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2233 new_video_stream(o, oc, idx);
2236 /* audio: most channels */
2237 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2238 int best_score = 0, idx = -1;
2239 for (i = 0; i < nb_input_streams; i++) {
2241 ist = input_streams[i];
2242 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2243 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2244 score > best_score) {
2250 new_audio_stream(o, oc, idx);
2253 /* subtitles: pick first */
2254 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2255 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2256 for (i = 0; i < nb_input_streams; i++)
2257 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2258 AVCodecDescriptor const *input_descriptor =
2259 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2260 AVCodecDescriptor const *output_descriptor = NULL;
2261 AVCodec const *output_codec =
2262 avcodec_find_encoder(oc->oformat->subtitle_codec);
2263 int input_props = 0, output_props = 0;
2265 output_descriptor = avcodec_descriptor_get(output_codec->id);
2266 if (input_descriptor)
2267 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2268 if (output_descriptor)
2269 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2270 if (subtitle_codec_name ||
2271 input_props & output_props ||
2272 // Map dvb teletext which has neither property to any output subtitle encoder
2273 input_descriptor && output_descriptor &&
2274 (!input_descriptor->props ||
2275 !output_descriptor->props)) {
2276 new_subtitle_stream(o, oc, i);
2281 /* Data only if codec id match */
2282 if (!o->data_disable ) {
2283 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2284 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2285 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2286 && input_streams[i]->st->codecpar->codec_id == codec_id )
2287 new_data_stream(o, oc, i);
2291 for (i = 0; i < o->nb_stream_maps; i++) {
2292 StreamMap *map = &o->stream_maps[i];
2297 if (map->linklabel) {
2299 OutputFilter *ofilter = NULL;
2302 for (j = 0; j < nb_filtergraphs; j++) {
2303 fg = filtergraphs[j];
2304 for (k = 0; k < fg->nb_outputs; k++) {
2305 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2306 if (out && !strcmp(out->name, map->linklabel)) {
2307 ofilter = fg->outputs[k];
2314 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2315 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2318 init_output_filter(ofilter, o, oc);
2320 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2322 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2323 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2325 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2327 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2329 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2333 switch (ist->st->codecpar->codec_type) {
2334 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2335 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2336 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2337 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2338 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2339 case AVMEDIA_TYPE_UNKNOWN:
2340 if (copy_unknown_streams) {
2341 ost = new_unknown_stream (o, oc, src_idx);
2345 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2346 "Cannot map stream #%d:%d - unsupported type.\n",
2347 map->file_index, map->stream_index);
2348 if (!ignore_unknown_streams) {
2349 av_log(NULL, AV_LOG_FATAL,
2350 "If you want unsupported types ignored instead "
2351 "of failing, please use the -ignore_unknown option\n"
2352 "If you want them copied, please use -copy_unknown\n");
2357 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2358 + map->sync_stream_index];
2363 /* handle attached files */
2364 for (i = 0; i < o->nb_attachments; i++) {
2366 uint8_t *attachment;
2370 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2371 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2375 if ((len = avio_size(pb)) <= 0) {
2376 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2380 if (!(attachment = av_malloc(len))) {
2381 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2385 avio_read(pb, attachment, len);
2387 ost = new_attachment_stream(o, oc, -1);
2388 ost->stream_copy = 0;
2389 ost->attachment_filename = o->attachments[i];
2390 ost->st->codecpar->extradata = attachment;
2391 ost->st->codecpar->extradata_size = len;
2393 p = strrchr(o->attachments[i], '/');
2394 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2398 #if FF_API_LAVF_AVCTX
2399 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2400 AVDictionaryEntry *e;
2401 ost = output_streams[i];
2403 if ((ost->stream_copy || ost->attachment_filename)
2404 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2405 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2406 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2411 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2412 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2413 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2417 /* check if all codec options have been used */
2418 unused_opts = strip_specifiers(o->g->codec_opts);
2419 for (i = of->ost_index; i < nb_output_streams; i++) {
2421 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2422 AV_DICT_IGNORE_SUFFIX)))
2423 av_dict_set(&unused_opts, e->key, NULL, 0);
2427 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2428 const AVClass *class = avcodec_get_class();
2429 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2430 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2431 const AVClass *fclass = avformat_get_class();
2432 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2433 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2434 if (!option || foption)
2438 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2439 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2440 "output file #%d (%s) is not an encoding option.\n", e->key,
2441 option->help ? option->help : "", nb_output_files - 1,
2446 // gop_timecode is injected by generic code but not always used
2447 if (!strcmp(e->key, "gop_timecode"))
2450 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2451 "output file #%d (%s) has not been used for any stream. The most "
2452 "likely reason is either wrong type (e.g. a video option with "
2453 "no video streams) or that it is a private option of some encoder "
2454 "which was not actually used for any stream.\n", e->key,
2455 option->help ? option->help : "", nb_output_files - 1, filename);
2457 av_dict_free(&unused_opts);
2459 /* set the decoding_needed flags and create simple filtergraphs */
2460 for (i = of->ost_index; i < nb_output_streams; i++) {
2461 OutputStream *ost = output_streams[i];
2463 if (ost->encoding_needed && ost->source_index >= 0) {
2464 InputStream *ist = input_streams[ost->source_index];
2465 ist->decoding_needed |= DECODING_FOR_OST;
2467 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2468 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2469 err = init_simple_filtergraph(ist, ost);
2471 av_log(NULL, AV_LOG_ERROR,
2472 "Error initializing a simple filtergraph between streams "
2473 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2474 nb_output_files - 1, ost->st->index);
2480 /* set the filter output constraints */
2482 OutputFilter *f = ost->filter;
2484 switch (ost->enc_ctx->codec_type) {
2485 case AVMEDIA_TYPE_VIDEO:
2486 f->frame_rate = ost->frame_rate;
2487 f->width = ost->enc_ctx->width;
2488 f->height = ost->enc_ctx->height;
2489 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2490 f->format = ost->enc_ctx->pix_fmt;
2491 } else if (ost->enc->pix_fmts) {
2493 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2495 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2498 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2501 case AVMEDIA_TYPE_AUDIO:
2502 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2503 f->format = ost->enc_ctx->sample_fmt;
2504 } else if (ost->enc->sample_fmts) {
2506 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2508 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2511 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2513 if (ost->enc_ctx->sample_rate) {
2514 f->sample_rate = ost->enc_ctx->sample_rate;
2515 } else if (ost->enc->supported_samplerates) {
2517 while (ost->enc->supported_samplerates[count])
2519 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2520 if (!f->sample_rates)
2522 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2523 (count + 1) * sizeof(*f->sample_rates));
2525 if (ost->enc_ctx->channels) {
2526 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2527 } else if (ost->enc->channel_layouts) {
2529 while (ost->enc->channel_layouts[count])
2531 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2532 if (!f->channel_layouts)
2534 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2535 (count + 1) * sizeof(*f->channel_layouts));
2542 /* check filename in case of an image number is expected */
2543 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2544 if (!av_filename_number_test(oc->filename)) {
2545 print_error(oc->filename, AVERROR(EINVAL));
2550 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2551 av_log(NULL, AV_LOG_ERROR,
2552 "No input streams but output needs an input stream\n");
2556 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2557 /* test if it already exists to avoid losing precious files */
2558 assert_file_overwrite(filename);
2561 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2562 &oc->interrupt_callback,
2564 print_error(filename, err);
2567 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2568 assert_file_overwrite(filename);
2570 if (o->mux_preload) {
2571 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2573 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2576 for (i = 0; i < o->nb_metadata_map; i++) {
2578 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2580 if (in_file_index >= nb_input_files) {
2581 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2584 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2585 in_file_index >= 0 ?
2586 input_files[in_file_index]->ctx : NULL, o);
2590 if (o->chapters_input_file >= nb_input_files) {
2591 if (o->chapters_input_file == INT_MAX) {
2592 /* copy chapters from the first input file that has them*/
2593 o->chapters_input_file = -1;
2594 for (i = 0; i < nb_input_files; i++)
2595 if (input_files[i]->ctx->nb_chapters) {
2596 o->chapters_input_file = i;
2600 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2601 o->chapters_input_file);
2605 if (o->chapters_input_file >= 0)
2606 copy_chapters(input_files[o->chapters_input_file], of,
2607 !o->metadata_chapters_manual);
2609 /* copy global metadata by default */
2610 if (!o->metadata_global_manual && nb_input_files){
2611 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2612 AV_DICT_DONT_OVERWRITE);
2613 if(o->recording_time != INT64_MAX)
2614 av_dict_set(&oc->metadata, "duration", NULL, 0);
2615 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2617 if (!o->metadata_streams_manual)
2618 for (i = of->ost_index; i < nb_output_streams; i++) {
2620 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2622 ist = input_streams[output_streams[i]->source_index];
2623 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2624 if (!output_streams[i]->stream_copy) {
2625 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2629 /* process manually set programs */
2630 for (i = 0; i < o->nb_program; i++) {
2631 const char *p = o->program[i].u.str;
2636 const char *p2 = av_get_token(&p, ":");
2637 const char *to_dealloc = p2;
2644 key = av_get_token(&p2, "=");
2646 av_freep(&to_dealloc);
2652 if (!strcmp(key, "program_num"))
2653 progid = strtol(p2, NULL, 0);
2654 av_freep(&to_dealloc);
2658 program = av_new_program(oc, progid);
2660 p = o->program[i].u.str;
2662 const char *p2 = av_get_token(&p, ":");
2663 const char *to_dealloc = p2;
2669 key = av_get_token(&p2, "=");
2671 av_log(NULL, AV_LOG_FATAL,
2672 "No '=' character in program string %s.\n",
2680 if (!strcmp(key, "title")) {
2681 av_dict_set(&program->metadata, "title", p2, 0);
2682 } else if (!strcmp(key, "program_num")) {
2683 } else if (!strcmp(key, "st")) {
2684 int st_num = strtol(p2, NULL, 0);
2685 av_program_add_stream_index(oc, progid, st_num);
2687 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2690 av_freep(&to_dealloc);
2695 /* process manually set metadata */
2696 for (i = 0; i < o->nb_metadata; i++) {
2699 const char *stream_spec;
2700 int index = 0, j, ret = 0;
2702 val = strchr(o->metadata[i].u.str, '=');
2704 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2705 o->metadata[i].u.str);
2710 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2712 for (j = 0; j < oc->nb_streams; j++) {
2713 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2714 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2715 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2717 double theta = av_strtod(val, &tail);
2719 ost->rotate_overridden = 1;
2720 ost->rotate_override_value = theta;
2723 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2735 if (index < 0 || index >= oc->nb_chapters) {
2736 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2739 m = &oc->chapters[index]->metadata;
2742 if (index < 0 || index >= oc->nb_programs) {
2743 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2746 m = &oc->programs[index]->metadata;
2749 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2752 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2759 static int opt_target(void *optctx, const char *opt, const char *arg)
2761 OptionsContext *o = optctx;
2762 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2763 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2765 if (!strncmp(arg, "pal-", 4)) {
2768 } else if (!strncmp(arg, "ntsc-", 5)) {
2771 } else if (!strncmp(arg, "film-", 5)) {
2775 /* Try to determine PAL/NTSC by peeking in the input files */
2776 if (nb_input_files) {
2778 for (j = 0; j < nb_input_files; j++) {
2779 for (i = 0; i < input_files[j]->nb_streams; i++) {
2780 AVStream *st = input_files[j]->ctx->streams[i];
2781 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2783 fr = st->time_base.den * 1000 / st->time_base.num;
2787 } else if ((fr == 29970) || (fr == 23976)) {
2792 if (norm != UNKNOWN)
2796 if (norm != UNKNOWN)
2797 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2800 if (norm == UNKNOWN) {
2801 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2802 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2803 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2807 if (!strcmp(arg, "vcd")) {
2808 opt_video_codec(o, "c:v", "mpeg1video");
2809 opt_audio_codec(o, "c:a", "mp2");
2810 parse_option(o, "f", "vcd", options);
2812 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2813 parse_option(o, "r", frame_rates[norm], options);
2814 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2816 opt_default(NULL, "b:v", "1150000");
2817 opt_default(NULL, "maxrate:v", "1150000");
2818 opt_default(NULL, "minrate:v", "1150000");
2819 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2821 opt_default(NULL, "b:a", "224000");
2822 parse_option(o, "ar", "44100", options);
2823 parse_option(o, "ac", "2", options);
2825 opt_default(NULL, "packetsize", "2324");
2826 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2828 /* We have to offset the PTS, so that it is consistent with the SCR.
2829 SCR starts at 36000, but the first two packs contain only padding
2830 and the first pack from the other stream, respectively, may also have
2831 been written before.
2832 So the real data starts at SCR 36000+3*1200. */
2833 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2834 } else if (!strcmp(arg, "svcd")) {
2836 opt_video_codec(o, "c:v", "mpeg2video");
2837 opt_audio_codec(o, "c:a", "mp2");
2838 parse_option(o, "f", "svcd", options);
2840 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2841 parse_option(o, "r", frame_rates[norm], options);
2842 parse_option(o, "pix_fmt", "yuv420p", options);
2843 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2845 opt_default(NULL, "b:v", "2040000");
2846 opt_default(NULL, "maxrate:v", "2516000");
2847 opt_default(NULL, "minrate:v", "0"); // 1145000;
2848 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2849 opt_default(NULL, "scan_offset", "1");
2851 opt_default(NULL, "b:a", "224000");
2852 parse_option(o, "ar", "44100", options);
2854 opt_default(NULL, "packetsize", "2324");
2856 } else if (!strcmp(arg, "dvd")) {
2858 opt_video_codec(o, "c:v", "mpeg2video");
2859 opt_audio_codec(o, "c:a", "ac3");
2860 parse_option(o, "f", "dvd", options);
2862 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2863 parse_option(o, "r", frame_rates[norm], options);
2864 parse_option(o, "pix_fmt", "yuv420p", options);
2865 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2867 opt_default(NULL, "b:v", "6000000");
2868 opt_default(NULL, "maxrate:v", "9000000");
2869 opt_default(NULL, "minrate:v", "0"); // 1500000;
2870 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2872 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2873 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2875 opt_default(NULL, "b:a", "448000");
2876 parse_option(o, "ar", "48000", options);
2878 } else if (!strncmp(arg, "dv", 2)) {
2880 parse_option(o, "f", "dv", options);
2882 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2883 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2884 norm == PAL ? "yuv420p" : "yuv411p", options);
2885 parse_option(o, "r", frame_rates[norm], options);
2887 parse_option(o, "ar", "48000", options);
2888 parse_option(o, "ac", "2", options);
2891 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2892 return AVERROR(EINVAL);
2895 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2896 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2901 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2903 av_free (vstats_filename);
2904 vstats_filename = av_strdup (arg);
2908 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2911 time_t today2 = time(NULL);
2912 struct tm *today = localtime(&today2);
2914 if (!today) { // maybe tomorrow
2915 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2919 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2921 return opt_vstats_file(NULL, opt, filename);
2924 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2926 OptionsContext *o = optctx;
2927 return parse_option(o, "frames:v", arg, options);
2930 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2932 OptionsContext *o = optctx;
2933 return parse_option(o, "frames:a", arg, options);
2936 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2938 OptionsContext *o = optctx;
2939 return parse_option(o, "frames:d", arg, options);
2942 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2945 AVDictionary *cbak = codec_opts;
2946 AVDictionary *fbak = format_opts;
2950 ret = opt_default(NULL, opt, arg);
2952 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2953 av_dict_copy(&o->g->format_opts, format_opts, 0);
2954 av_dict_free(&codec_opts);
2955 av_dict_free(&format_opts);
2962 static int opt_preset(void *optctx, const char *opt, const char *arg)
2964 OptionsContext *o = optctx;
2966 char filename[1000], line[1000], tmp_line[1000];
2967 const char *codec_name = NULL;
2971 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2973 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2974 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2975 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2977 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2981 while (fgets(line, sizeof(line), f)) {
2982 char *key = tmp_line, *value, *endptr;
2984 if (strcspn(line, "#\n\r") == 0)
2986 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2987 if (!av_strtok(key, "=", &value) ||
2988 !av_strtok(value, "\r\n", &endptr)) {
2989 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2992 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2994 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2995 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2996 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2997 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2998 else if (opt_default_new(o, key, value) < 0) {
2999 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3000 filename, line, key, value);
3010 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3012 OptionsContext *o = optctx;
3013 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3014 int ret = parse_option(o, s, arg, options);
3019 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3021 OptionsContext *o = optctx;
3023 if(!strcmp(opt, "ab")){
3024 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3026 } else if(!strcmp(opt, "b")){
3027 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3028 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3031 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3035 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3037 OptionsContext *o = optctx;
3040 if(!strcmp(opt, "qscale")){
3041 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3042 return parse_option(o, "q:v", arg, options);
3044 s = av_asprintf("q%s", opt + 6);
3045 ret = parse_option(o, s, arg, options);
3050 static int opt_profile(void *optctx, const char *opt, const char *arg)
3052 OptionsContext *o = optctx;
3053 if(!strcmp(opt, "profile")){
3054 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3055 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3058 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3062 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3064 OptionsContext *o = optctx;
3065 return parse_option(o, "filter:v", arg, options);
3068 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3070 OptionsContext *o = optctx;
3071 return parse_option(o, "filter:a", arg, options);
3074 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3076 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3077 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3078 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3079 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3081 if (video_sync_method == VSYNC_AUTO)
3082 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3086 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3088 OptionsContext *o = optctx;
3089 char *tcr = av_asprintf("timecode=%s", arg);
3090 int ret = parse_option(o, "metadata:g", tcr, options);
3092 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3097 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3099 OptionsContext *o = optctx;
3100 char layout_str[32];
3103 int ret, channels, ac_str_size;
3106 layout = av_get_channel_layout(arg);
3108 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3109 return AVERROR(EINVAL);
3111 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3112 ret = opt_default_new(o, opt, layout_str);
3116 /* set 'ac' option based on channel layout */
3117 channels = av_get_channel_layout_nb_channels(layout);
3118 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3119 stream_str = strchr(opt, ':');
3120 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3121 ac_str = av_mallocz(ac_str_size);
3123 return AVERROR(ENOMEM);
3124 av_strlcpy(ac_str, "ac", 3);
3126 av_strlcat(ac_str, stream_str, ac_str_size);
3127 ret = parse_option(o, ac_str, layout_str, options);
3133 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3135 OptionsContext *o = optctx;
3136 return parse_option(o, "q:a", arg, options);
3139 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3141 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3142 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3143 return AVERROR(ENOMEM);
3144 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3145 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3146 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3147 return AVERROR(ENOMEM);
3149 input_stream_potentially_available = 1;
3154 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3156 uint8_t *graph_desc = read_file(arg);
3158 return AVERROR(EINVAL);
3160 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3161 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3162 return AVERROR(ENOMEM);
3163 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3164 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3166 input_stream_potentially_available = 1;
3171 void show_help_default(const char *opt, const char *arg)
3173 /* per-file options have at least one of those set */
3174 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3175 int show_advanced = 0, show_avoptions = 0;
3178 if (!strcmp(opt, "long"))
3180 else if (!strcmp(opt, "full"))
3181 show_advanced = show_avoptions = 1;
3183 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3188 printf("Getting help:\n"
3189 " -h -- print basic options\n"
3190 " -h long -- print more options\n"
3191 " -h full -- print all options (including all format and codec specific options, very long)\n"
3192 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3193 " See man %s for detailed description of the options.\n"
3194 "\n", program_name);
3196 show_help_options(options, "Print help / information / capabilities:",
3199 show_help_options(options, "Global options (affect whole program "
3200 "instead of just one file:",
3201 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3203 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3204 per_file | OPT_EXIT, 0);
3206 show_help_options(options, "Per-file main options:", 0,
3207 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3208 OPT_EXIT, per_file);
3210 show_help_options(options, "Advanced per-file options:",
3211 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3213 show_help_options(options, "Video options:",
3214 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3216 show_help_options(options, "Advanced Video options:",
3217 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3219 show_help_options(options, "Audio options:",
3220 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3222 show_help_options(options, "Advanced Audio options:",
3223 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3224 show_help_options(options, "Subtitle options:",
3225 OPT_SUBTITLE, 0, 0);
3228 if (show_avoptions) {
3229 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3230 show_help_children(avcodec_get_class(), flags);
3231 show_help_children(avformat_get_class(), flags);
3233 show_help_children(sws_get_class(), flags);
3235 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3236 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3240 void show_usage(void)
3242 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3243 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3244 av_log(NULL, AV_LOG_INFO, "\n");
3252 static const OptionGroupDef groups[] = {
3253 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3254 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3257 static int open_files(OptionGroupList *l, const char *inout,
3258 int (*open_file)(OptionsContext*, const char*))
3262 for (i = 0; i < l->nb_groups; i++) {
3263 OptionGroup *g = &l->groups[i];
3269 ret = parse_optgroup(&o, g);
3271 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3272 "%s.\n", inout, g->arg);
3276 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3277 ret = open_file(&o, g->arg);
3280 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3284 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3290 int ffmpeg_parse_options(int argc, char **argv)
3292 OptionParseContext octx;
3296 memset(&octx, 0, sizeof(octx));
3298 /* split the commandline into an internal representation */
3299 ret = split_commandline(&octx, argc, argv, options, groups,
3300 FF_ARRAY_ELEMS(groups));
3302 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3306 /* apply global options */
3307 ret = parse_optgroup(NULL, &octx.global_opts);
3309 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3313 /* configure terminal and setup signal handlers */
3316 /* open input files */
3317 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3319 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3323 /* create the complex filtergraphs */
3324 ret = init_complex_filters();
3326 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3330 /* open output files */
3331 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3333 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3337 check_filter_outputs();
3340 uninit_parse_context(&octx);
3342 av_strerror(ret, error, sizeof(error));
3343 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3348 static int opt_progress(void *optctx, const char *opt, const char *arg)
3350 AVIOContext *avio = NULL;
3353 if (!strcmp(arg, "-"))
3355 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3357 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3358 arg, av_err2str(ret));
3361 progress_avio = avio;
3365 #define OFFSET(x) offsetof(OptionsContext, x)
3366 const OptionDef options[] = {
3368 CMDUTILS_COMMON_OPTIONS
3369 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3370 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3371 "force format", "fmt" },
3372 { "y", OPT_BOOL, { &file_overwrite },
3373 "overwrite output files" },
3374 { "n", OPT_BOOL, { &no_file_overwrite },
3375 "never overwrite output files" },
3376 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3377 "Ignore unknown stream types" },
3378 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3379 "Copy unknown stream types" },
3380 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3381 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3382 "codec name", "codec" },
3383 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3384 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3385 "codec name", "codec" },
3386 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3387 OPT_OUTPUT, { .off = OFFSET(presets) },
3388 "preset name", "preset" },
3389 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3390 OPT_OUTPUT, { .func_arg = opt_map },
3391 "set input stream mapping",
3392 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3393 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3394 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3395 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3396 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3397 "set metadata information of outfile from infile",
3398 "outfile[,metadata]:infile[,metadata]" },
3399 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3400 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3401 "set chapters mapping", "input_file_index" },
3402 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3403 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3404 "record or transcode \"duration\" seconds of audio/video",
3406 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3407 "record or transcode stop time", "time_stop" },
3408 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3409 "set the limit file size in bytes", "limit_size" },
3410 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3411 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3412 "set the start time offset", "time_off" },
3413 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3414 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3415 "set the start time offset relative to EOF", "time_off" },
3416 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3417 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3418 "enable/disable seeking by timestamp with -ss" },
3419 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3420 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3421 "enable/disable accurate seeking with -ss" },
3422 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3423 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3424 "set the input ts offset", "time_off" },
3425 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3426 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3427 "set the input ts scale", "scale" },
3428 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3429 "set the recording timestamp ('now' to set the current time)", "time" },
3430 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3431 "add metadata", "string=string" },
3432 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3433 "add program with specified streams", "title=string:st=number..." },
3434 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3435 OPT_OUTPUT, { .func_arg = opt_data_frames },
3436 "set the number of data frames to output", "number" },
3437 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3438 "add timings for benchmarking" },
3439 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3440 "add timings for each task" },
3441 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3442 "write program-readable progress information", "url" },
3443 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3444 "enable or disable interaction on standard input" },
3445 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3446 "set max runtime in seconds", "limit" },
3447 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3448 "dump each input packet" },
3449 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3450 "when dumping packets, also dump the payload" },
3451 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3452 OPT_INPUT, { .off = OFFSET(rate_emu) },
3453 "read input at native frame rate", "" },
3454 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3455 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3456 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3457 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3458 "video sync method", "" },
3459 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3460 "frame drop threshold", "" },
3461 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3462 "audio sync method", "" },
3463 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3464 "audio drift threshold", "threshold" },
3465 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3466 "copy timestamps" },
3467 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3468 "shift input timestamps to start at 0 when using copyts" },
3469 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3470 "copy input stream time base when stream copying", "mode" },
3471 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3472 OPT_OUTPUT, { .off = OFFSET(shortest) },
3473 "finish encoding within shortest input" },
3474 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3475 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3477 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3478 OPT_OUTPUT, { .off = OFFSET(apad) },
3480 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3481 "timestamp discontinuity delta threshold", "threshold" },
3482 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3483 "timestamp error delta threshold", "threshold" },
3484 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3485 "exit on error", "error" },
3486 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3487 "abort on the specified condition flags", "flags" },
3488 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3489 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3490 "copy initial non-keyframes" },
3491 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3492 "copy or discard frames before start time" },
3493 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3494 "set the number of frames to output", "number" },
3495 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3496 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3497 "force codec tag/fourcc", "fourcc/tag" },
3498 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3499 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3500 "use fixed quality scale (VBR)", "q" },
3501 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3502 OPT_OUTPUT, { .func_arg = opt_qscale },
3503 "use fixed quality scale (VBR)", "q" },
3504 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3505 "set profile", "profile" },
3506 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3507 "set stream filtergraph", "filter_graph" },
3508 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3509 "number of non-complex filter threads" },
3510 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3511 "read stream filtergraph description from a file", "filename" },
3512 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3513 "reinit filtergraph on input parameter changes", "" },
3514 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3515 "create a complex filtergraph", "graph_description" },
3516 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3517 "number of threads for -filter_complex" },
3518 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3519 "create a complex filtergraph", "graph_description" },
3520 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3521 "read complex filtergraph description from a file", "filename" },
3522 { "stats", OPT_BOOL, { &print_stats },
3523 "print progress report during encoding", },
3524 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3525 OPT_OUTPUT, { .func_arg = opt_attach },
3526 "add an attachment to the output file", "filename" },
3527 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3528 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3529 "extract an attachment into a file", "filename" },
3530 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3531 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3532 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3533 "print timestamp debugging info" },
3534 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3535 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3536 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3537 OPT_INPUT, { .off = OFFSET(discard) },
3539 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3540 OPT_OUTPUT, { .off = OFFSET(disposition) },
3541 "disposition", "" },
3542 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3543 { .off = OFFSET(thread_queue_size) },
3544 "set the maximum number of queued packets from the demuxer" },
3545 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3546 "read and decode the streams to fill missing information with heuristics" },
3549 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3550 "set the number of video frames to output", "number" },
3551 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3552 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3553 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3554 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3555 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3556 "set frame size (WxH or abbreviation)", "size" },
3557 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3558 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3559 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3560 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3561 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3562 "set pixel format", "format" },
3563 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3564 "set the number of bits per raw sample", "number" },
3565 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3566 "deprecated use -g 1" },
3567 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3569 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3570 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3571 "rate control override for specific intervals", "override" },
3572 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3573 OPT_OUTPUT, { .func_arg = opt_video_codec },
3574 "force video codec ('copy' to copy stream)", "codec" },
3575 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3577 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3579 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3580 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3581 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3582 "select the pass number (1 to 3)", "n" },
3583 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3584 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3585 "select two pass log file name prefix", "prefix" },
3586 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3587 "this option is deprecated, use the yadif filter instead" },
3588 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3589 "calculate PSNR of compressed frames" },
3590 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3591 "dump video coding statistics to file" },
3592 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3593 "dump video coding statistics to file", "file" },
3594 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3595 "Version of the vstats format to use."},
3596 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3597 "set video filters", "filter_graph" },
3598 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3599 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3600 "specify intra matrix coeffs", "matrix" },
3601 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3602 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3603 "specify inter matrix coeffs", "matrix" },
3604 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3605 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3606 "specify intra matrix coeffs", "matrix" },
3607 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3608 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3609 "top=1/bottom=0/auto=-1 field first", "" },
3610 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3611 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3612 "force video tag/fourcc", "fourcc/tag" },
3613 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3614 "show QP histogram" },
3615 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3616 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3617 "force the selected framerate, disable the best supported framerate selection" },
3618 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3619 OPT_OUTPUT, { .func_arg = opt_streamid },
3620 "set the value of an outfile streamid", "streamIndex:value" },
3621 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3622 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3623 "force key frames at specified timestamps", "timestamps" },
3624 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3625 "audio bitrate (please use -b:a)", "bitrate" },
3626 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3627 "video bitrate (please use -b:v)", "bitrate" },
3628 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3629 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3630 "use HW accelerated decoding", "hwaccel name" },
3631 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3632 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3633 "select a device for HW acceleration", "devicename" },
3634 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3635 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3636 "select output format used with HW accelerated decoding", "format" },
3637 #if CONFIG_VIDEOTOOLBOX
3638 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3640 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3641 "show available HW acceleration methods" },
3642 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3643 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3644 "automatically insert correct rotate filters" },
3647 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3648 "set the number of audio frames to output", "number" },
3649 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3650 "set audio quality (codec-specific)", "quality", },
3651 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3652 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3653 "set audio sampling rate (in Hz)", "rate" },
3654 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3655 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3656 "set number of audio channels", "channels" },
3657 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3659 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3660 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3661 "force audio codec ('copy' to copy stream)", "codec" },
3662 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3663 OPT_OUTPUT, { .func_arg = opt_old2new },
3664 "force audio tag/fourcc", "fourcc/tag" },
3665 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3666 "change audio volume (256=normal)" , "volume" },
3667 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3668 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3669 "set sample format", "format" },
3670 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3671 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3672 "set channel layout", "layout" },
3673 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3674 "set audio filters", "filter_graph" },
3675 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3676 "set the maximum number of channels to try to guess the channel layout" },
3678 /* subtitle options */
3679 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3680 "disable subtitle" },
3681 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3682 "force subtitle codec ('copy' to copy stream)", "codec" },
3683 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3684 , "force subtitle tag/fourcc", "fourcc/tag" },
3685 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3686 "fix subtitles duration" },
3687 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3688 "set canvas size (WxH or abbreviation)", "size" },
3691 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3692 "deprecated, use -channel", "channel" },
3693 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3694 "deprecated, use -standard", "standard" },
3695 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3698 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3699 "set the maximum demux-decode delay", "seconds" },
3700 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3701 "set the initial demux-decode delay", "seconds" },
3702 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3703 "override the options from ffserver", "" },
3704 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3705 "specify a file in which to print sdp information", "file" },
3707 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3708 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3709 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3710 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3711 "two special values are defined - "
3712 "0 = use frame rate (video) or sample rate (audio),"
3713 "-1 = match source time base", "ratio" },
3715 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3716 "A comma-separated list of bitstream filters", "bitstream_filters" },
3717 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3718 "deprecated", "audio bitstream_filters" },
3719 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3720 "deprecated", "video bitstream_filters" },
3722 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3723 "set the audio options to the indicated preset", "preset" },
3724 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3725 "set the video options to the indicated preset", "preset" },
3726 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3727 "set the subtitle options to the indicated preset", "preset" },
3728 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3729 "set options from indicated preset file", "filename" },
3731 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3732 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3734 /* data codec support */
3735 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3736 "force data codec ('copy' to copy stream)", "codec" },
3737 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3741 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3742 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3746 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3747 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3750 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3751 "initialise hardware device", "args" },
3752 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3753 "set hardware device used when filtering", "device" },