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 },
82 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA,
83 AV_HWDEVICE_TYPE_NONE },
85 #if CONFIG_VIDEOTOOLBOX
86 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX,
87 AV_HWDEVICE_TYPE_NONE },
90 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV,
91 AV_HWDEVICE_TYPE_NONE },
94 { "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
95 AV_HWDEVICE_TYPE_VAAPI },
98 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
99 AV_HWDEVICE_TYPE_NONE },
103 int hwaccel_lax_profile_check = 0;
104 AVBufferRef *hw_device_ctx;
105 HWDevice *filter_hw_device;
107 char *vstats_filename;
110 float audio_drift_threshold = 0.1;
111 float dts_delta_threshold = 10;
112 float dts_error_threshold = 3600*30;
114 int audio_volume = 256;
115 int audio_sync_method = 0;
116 int video_sync_method = VSYNC_AUTO;
117 float frame_drop_threshold = 0;
118 int do_deinterlace = 0;
119 int do_benchmark = 0;
120 int do_benchmark_all = 0;
124 int start_at_zero = 0;
127 int exit_on_error = 0;
128 int abort_on_flags = 0;
129 int print_stats = -1;
131 int stdin_interaction = 1;
132 int frame_bits_per_raw_sample = 0;
133 float max_error_rate = 2.0/3;
134 int filter_nbthreads = 0;
135 int filter_complex_nbthreads = 0;
136 int vstats_version = 2;
139 static int intra_only = 0;
140 static int file_overwrite = 0;
141 static int no_file_overwrite = 0;
142 static int do_psnr = 0;
143 static int input_sync;
144 static int override_ffserver = 0;
145 static int input_stream_potentially_available = 0;
146 static int ignore_unknown_streams = 0;
147 static int copy_unknown_streams = 0;
148 static int find_stream_info = 1;
150 static void uninit_options(OptionsContext *o)
152 const OptionDef *po = options;
155 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
157 void *dst = (uint8_t*)o + po->u.off;
159 if (po->flags & OPT_SPEC) {
160 SpecifierOpt **so = dst;
161 int i, *count = (int*)(so + 1);
162 for (i = 0; i < *count; i++) {
163 av_freep(&(*so)[i].specifier);
164 if (po->flags & OPT_STRING)
165 av_freep(&(*so)[i].u.str);
169 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
174 for (i = 0; i < o->nb_stream_maps; i++)
175 av_freep(&o->stream_maps[i].linklabel);
176 av_freep(&o->stream_maps);
177 av_freep(&o->audio_channel_maps);
178 av_freep(&o->streamid_map);
179 av_freep(&o->attachments);
182 static void init_options(OptionsContext *o)
184 memset(o, 0, sizeof(*o));
186 o->stop_time = INT64_MAX;
187 o->mux_max_delay = 0.7;
188 o->start_time = AV_NOPTS_VALUE;
189 o->start_time_eof = AV_NOPTS_VALUE;
190 o->recording_time = INT64_MAX;
191 o->limit_filesize = UINT64_MAX;
192 o->chapters_input_file = INT_MAX;
193 o->accurate_seek = 1;
196 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
200 printf("Hardware acceleration methods:\n");
201 for (i = 0; hwaccels[i].name; i++) {
202 printf("%s\n", hwaccels[i].name);
208 /* return a copy of the input with the stream specifiers removed from the keys */
209 static AVDictionary *strip_specifiers(AVDictionary *dict)
211 AVDictionaryEntry *e = NULL;
212 AVDictionary *ret = NULL;
214 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
215 char *p = strchr(e->key, ':');
219 av_dict_set(&ret, e->key, e->value, 0);
226 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
228 static const AVOption opts[] = {
229 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
230 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
233 static const AVClass class = {
235 .item_name = av_default_item_name,
237 .version = LIBAVUTIL_VERSION_INT,
239 const AVClass *pclass = &class;
241 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
244 static int opt_sameq(void *optctx, const char *opt, const char *arg)
246 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
247 "If you are looking for an option to preserve the quality (which is not "
248 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
250 return AVERROR(EINVAL);
253 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
255 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
256 return opt_default(optctx, "channel", arg);
259 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
261 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
262 return opt_default(optctx, "standard", arg);
265 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
267 OptionsContext *o = optctx;
268 return parse_option(o, "codec:a", arg, options);
271 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
273 OptionsContext *o = optctx;
274 return parse_option(o, "codec:v", arg, options);
277 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
279 OptionsContext *o = optctx;
280 return parse_option(o, "codec:s", arg, options);
283 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
285 OptionsContext *o = optctx;
286 return parse_option(o, "codec:d", arg, options);
289 static int opt_map(void *optctx, const char *opt, const char *arg)
291 OptionsContext *o = optctx;
293 int i, negative = 0, file_idx;
294 int sync_file_idx = -1, sync_stream_idx = 0;
303 map = av_strdup(arg);
305 return AVERROR(ENOMEM);
307 /* parse sync stream first, just pick first matching stream */
308 if (sync = strchr(map, ',')) {
310 sync_file_idx = strtol(sync + 1, &sync, 0);
311 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
312 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
317 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
318 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
319 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
323 if (i == input_files[sync_file_idx]->nb_streams) {
324 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
325 "match any streams.\n", arg);
332 /* this mapping refers to lavfi output */
333 const char *c = map + 1;
334 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
335 m = &o->stream_maps[o->nb_stream_maps - 1];
336 m->linklabel = av_get_token(&c, "]");
338 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
342 if (allow_unused = strchr(map, '?'))
344 file_idx = strtol(map, &p, 0);
345 if (file_idx >= nb_input_files || file_idx < 0) {
346 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
350 /* disable some already defined maps */
351 for (i = 0; i < o->nb_stream_maps; i++) {
352 m = &o->stream_maps[i];
353 if (file_idx == m->file_index &&
354 check_stream_specifier(input_files[m->file_index]->ctx,
355 input_files[m->file_index]->ctx->streams[m->stream_index],
356 *p == ':' ? p + 1 : p) > 0)
360 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
361 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
362 *p == ':' ? p + 1 : p) <= 0)
364 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
365 m = &o->stream_maps[o->nb_stream_maps - 1];
367 m->file_index = file_idx;
370 if (sync_file_idx >= 0) {
371 m->sync_file_index = sync_file_idx;
372 m->sync_stream_index = sync_stream_idx;
374 m->sync_file_index = file_idx;
375 m->sync_stream_index = i;
382 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
384 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
385 "To ignore this, add a trailing '?' to the map.\n", arg);
394 static int opt_attach(void *optctx, const char *opt, const char *arg)
396 OptionsContext *o = optctx;
397 GROW_ARRAY(o->attachments, o->nb_attachments);
398 o->attachments[o->nb_attachments - 1] = arg;
402 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
404 OptionsContext *o = optctx;
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;
422 n = sscanf(arg, "%d.%d.%d:%d.%d",
423 &m->file_idx, &m->stream_idx, &m->channel_idx,
424 &m->ofile_idx, &m->ostream_idx);
426 if (n != 3 && n != 5) {
427 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
428 "[file.stream.channel|-1][:syncfile:syncstream]\n");
432 if (n != 5) // only file.stream.channel specified
433 m->ofile_idx = m->ostream_idx = -1;
436 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
437 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
441 if (m->stream_idx < 0 ||
442 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
443 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
444 m->file_idx, m->stream_idx);
447 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
448 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
449 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
450 m->file_idx, m->stream_idx);
453 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
454 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
455 m->file_idx, m->stream_idx, m->channel_idx);
461 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
463 av_free(sdp_filename);
464 sdp_filename = av_strdup(arg);
469 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
472 const char *prefix = "vaapi:";
475 tmp = av_asprintf("%s%s", prefix, arg);
477 return AVERROR(ENOMEM);
478 err = hw_device_init_from_string(tmp, &dev);
482 hw_device_ctx = av_buffer_ref(dev->device_ref);
484 return AVERROR(ENOMEM);
489 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
491 if (!strcmp(arg, "list")) {
492 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
493 printf("Supported hardware device types:\n");
494 while ((type = av_hwdevice_iterate_types(type)) !=
495 AV_HWDEVICE_TYPE_NONE)
496 printf("%s\n", av_hwdevice_get_type_name(type));
500 return hw_device_init_from_string(arg, NULL);
504 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
506 if (filter_hw_device) {
507 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
508 return AVERROR(EINVAL);
510 filter_hw_device = hw_device_get_by_name(arg);
511 if (!filter_hw_device) {
512 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
513 return AVERROR(EINVAL);
519 * Parse a metadata specifier passed as 'arg' parameter.
520 * @param arg metadata string to parse
521 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
522 * @param index for type c/p, chapter/program index is written here
523 * @param stream_spec for type s, the stream specifier is written here
525 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
533 if (*(++arg) && *arg != ':') {
534 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
537 *stream_spec = *arg == ':' ? arg + 1 : "";
542 *index = strtol(++arg, NULL, 0);
545 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
552 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
554 AVDictionary **meta_in = NULL;
555 AVDictionary **meta_out = NULL;
557 char type_in, type_out;
558 const char *istream_spec = NULL, *ostream_spec = NULL;
559 int idx_in = 0, idx_out = 0;
561 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
562 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
565 if (type_out == 'g' || !*outspec)
566 o->metadata_global_manual = 1;
567 if (type_out == 's' || !*outspec)
568 o->metadata_streams_manual = 1;
569 if (type_out == 'c' || !*outspec)
570 o->metadata_chapters_manual = 1;
574 if (type_in == 'g' || type_out == 'g')
575 o->metadata_global_manual = 1;
576 if (type_in == 's' || type_out == 's')
577 o->metadata_streams_manual = 1;
578 if (type_in == 'c' || type_out == 'c')
579 o->metadata_chapters_manual = 1;
581 /* ic is NULL when just disabling automatic mappings */
585 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
586 if ((index) < 0 || (index) >= (nb_elems)) {\
587 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
592 #define SET_DICT(type, meta, context, index)\
595 meta = &context->metadata;\
598 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
599 meta = &context->chapters[index]->metadata;\
602 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
603 meta = &context->programs[index]->metadata;\
606 break; /* handled separately below */ \
607 default: av_assert0(0);\
610 SET_DICT(type_in, meta_in, ic, idx_in);
611 SET_DICT(type_out, meta_out, oc, idx_out);
613 /* for input streams choose first matching stream */
614 if (type_in == 's') {
615 for (i = 0; i < ic->nb_streams; i++) {
616 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
617 meta_in = &ic->streams[i]->metadata;
623 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
628 if (type_out == 's') {
629 for (i = 0; i < oc->nb_streams; i++) {
630 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
631 meta_out = &oc->streams[i]->metadata;
632 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
637 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
642 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
644 OptionsContext *o = optctx;
646 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
647 struct tm time = *gmtime((time_t*)&recording_timestamp);
648 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
650 parse_option(o, "metadata", buf, options);
652 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
653 "tag instead.\n", opt);
657 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
659 const AVCodecDescriptor *desc;
660 const char *codec_string = encoder ? "encoder" : "decoder";
664 avcodec_find_encoder_by_name(name) :
665 avcodec_find_decoder_by_name(name);
667 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
668 codec = encoder ? avcodec_find_encoder(desc->id) :
669 avcodec_find_decoder(desc->id);
671 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
672 codec_string, codec->name, desc->name);
676 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
679 if (codec->type != type) {
680 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
686 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
688 char *codec_name = NULL;
690 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
692 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
693 st->codecpar->codec_id = codec->id;
696 return avcodec_find_decoder(st->codecpar->codec_id);
699 /* Add all the streams from the given input file to the global
700 * list of input streams. */
701 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
705 for (i = 0; i < ic->nb_streams; i++) {
706 AVStream *st = ic->streams[i];
707 AVCodecParameters *par = st->codecpar;
708 InputStream *ist = av_mallocz(sizeof(*ist));
709 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
710 char *hwaccel_output_format = NULL;
711 char *codec_tag = NULL;
713 char *discard_str = NULL;
714 const AVClass *cc = avcodec_get_class();
715 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
720 GROW_ARRAY(input_streams, nb_input_streams);
721 input_streams[nb_input_streams - 1] = ist;
724 ist->file_index = nb_input_files;
726 st->discard = AVDISCARD_ALL;
728 ist->min_pts = INT64_MAX;
729 ist->max_pts = INT64_MIN;
732 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
735 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
737 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
739 uint32_t tag = strtol(codec_tag, &next, 0);
741 tag = AV_RL32(codec_tag);
742 st->codecpar->codec_tag = tag;
745 ist->dec = choose_decoder(o, ic, st);
746 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
748 ist->reinit_filters = -1;
749 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
751 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
752 ist->user_set_discard = AVDISCARD_NONE;
753 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
754 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
759 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
761 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
763 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
767 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
769 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
773 switch (par->codec_type) {
774 case AVMEDIA_TYPE_VIDEO:
776 ist->dec = avcodec_find_decoder(par->codec_id);
778 if (av_codec_get_lowres(st->codec)) {
779 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
780 ist->dec_ctx->width = st->codec->width;
781 ist->dec_ctx->height = st->codec->height;
782 ist->dec_ctx->coded_width = st->codec->coded_width;
783 ist->dec_ctx->coded_height = st->codec->coded_height;
784 ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
788 // avformat_find_stream_info() doesn't set this for us anymore.
789 ist->dec_ctx->framerate = st->avg_frame_rate;
791 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
792 if (framerate && av_parse_video_rate(&ist->framerate,
794 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
799 ist->top_field_first = -1;
800 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
802 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
804 if (!strcmp(hwaccel, "none"))
805 ist->hwaccel_id = HWACCEL_NONE;
806 else if (!strcmp(hwaccel, "auto"))
807 ist->hwaccel_id = HWACCEL_AUTO;
810 for (i = 0; hwaccels[i].name; i++) {
811 if (!strcmp(hwaccels[i].name, hwaccel)) {
812 ist->hwaccel_id = hwaccels[i].id;
817 if (!ist->hwaccel_id) {
818 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
820 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
821 for (i = 0; hwaccels[i].name; i++)
822 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
823 av_log(NULL, AV_LOG_FATAL, "\n");
829 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
830 if (hwaccel_device) {
831 ist->hwaccel_device = av_strdup(hwaccel_device);
832 if (!ist->hwaccel_device)
836 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
837 hwaccel_output_format, ic, st);
838 if (hwaccel_output_format) {
839 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
840 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
841 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
842 "format: %s", hwaccel_output_format);
845 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
848 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
851 case AVMEDIA_TYPE_AUDIO:
852 ist->guess_layout_max = INT_MAX;
853 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
854 guess_input_channel_layout(ist);
856 case AVMEDIA_TYPE_DATA:
857 case AVMEDIA_TYPE_SUBTITLE: {
858 char *canvas_size = NULL;
860 ist->dec = avcodec_find_decoder(par->codec_id);
861 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
862 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
864 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
865 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
870 case AVMEDIA_TYPE_ATTACHMENT:
871 case AVMEDIA_TYPE_UNKNOWN:
877 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
879 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
885 static void assert_file_overwrite(const char *filename)
887 if (file_overwrite && no_file_overwrite) {
888 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
892 if (!file_overwrite) {
893 const char *proto_name = avio_find_protocol_name(filename);
894 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
895 if (stdin_interaction && !no_file_overwrite) {
896 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
899 signal(SIGINT, SIG_DFL);
901 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
907 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
914 static void dump_attachment(AVStream *st, const char *filename)
917 AVIOContext *out = NULL;
918 AVDictionaryEntry *e;
920 if (!st->codecpar->extradata_size) {
921 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
922 nb_input_files - 1, st->index);
925 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
928 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
929 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
933 assert_file_overwrite(filename);
935 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
936 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
941 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
946 static int open_input_file(OptionsContext *o, const char *filename)
950 AVInputFormat *file_iformat = NULL;
953 AVDictionary *unused_opts = NULL;
954 AVDictionaryEntry *e = NULL;
955 char * video_codec_name = NULL;
956 char * audio_codec_name = NULL;
957 char *subtitle_codec_name = NULL;
958 char * data_codec_name = NULL;
959 int scan_all_pmts_set = 0;
962 if (!(file_iformat = av_find_input_format(o->format))) {
963 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
968 if (!strcmp(filename, "-"))
971 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
972 strcmp(filename, "/dev/stdin");
974 /* get default parameters from command line */
975 ic = avformat_alloc_context();
977 print_error(filename, AVERROR(ENOMEM));
980 ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
981 if (o->nb_audio_sample_rate) {
982 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
984 if (o->nb_audio_channels) {
985 /* because we set audio_channels based on both the "ac" and
986 * "channel_layout" options, we need to check that the specified
987 * demuxer actually has the "channels" option before setting it */
988 if (file_iformat && file_iformat->priv_class &&
989 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
990 AV_OPT_SEARCH_FAKE_OBJ)) {
991 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
994 if (o->nb_frame_rates) {
995 /* set the format-level framerate option;
996 * this is important for video grabbers, e.g. x11 */
997 if (file_iformat && file_iformat->priv_class &&
998 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
999 AV_OPT_SEARCH_FAKE_OBJ)) {
1000 av_dict_set(&o->g->format_opts, "framerate",
1001 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1004 if (o->nb_frame_sizes) {
1005 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1007 if (o->nb_frame_pix_fmts)
1008 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1010 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1011 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1012 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1013 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1015 ic->video_codec_id = video_codec_name ?
1016 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
1017 ic->audio_codec_id = audio_codec_name ?
1018 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
1019 ic->subtitle_codec_id= subtitle_codec_name ?
1020 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
1021 ic->data_codec_id = data_codec_name ?
1022 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
1024 if (video_codec_name)
1025 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
1026 if (audio_codec_name)
1027 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
1028 if (subtitle_codec_name)
1029 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
1030 if (data_codec_name)
1031 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
1033 ic->flags |= AVFMT_FLAG_NONBLOCK;
1034 ic->interrupt_callback = int_cb;
1036 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1037 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1038 scan_all_pmts_set = 1;
1040 /* open the input file with generic avformat function */
1041 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1043 print_error(filename, err);
1044 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1045 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1048 if (scan_all_pmts_set)
1049 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1050 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1051 assert_avoptions(o->g->format_opts);
1053 /* apply forced codec ids */
1054 for (i = 0; i < ic->nb_streams; i++)
1055 choose_decoder(o, ic, ic->streams[i]);
1057 if (find_stream_info) {
1058 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1059 int orig_nb_streams = ic->nb_streams;
1061 /* If not enough info to get the stream parameters, we decode the
1062 first frames to get it. (used in mpeg case for example) */
1063 ret = avformat_find_stream_info(ic, opts);
1065 for (i = 0; i < orig_nb_streams; i++)
1066 av_dict_free(&opts[i]);
1070 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1071 if (ic->nb_streams == 0) {
1072 avformat_close_input(&ic);
1078 if (o->start_time_eof != AV_NOPTS_VALUE) {
1079 if (ic->duration>0) {
1080 o->start_time = o->start_time_eof + ic->duration;
1082 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1084 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1085 /* add the stream start time */
1086 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1087 timestamp += ic->start_time;
1089 /* if seeking requested, we execute it */
1090 if (o->start_time != AV_NOPTS_VALUE) {
1091 int64_t seek_timestamp = timestamp;
1093 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1094 int dts_heuristic = 0;
1095 for (i=0; i<ic->nb_streams; i++) {
1096 const AVCodecParameters *par = ic->streams[i]->codecpar;
1097 if (par->video_delay)
1100 if (dts_heuristic) {
1101 seek_timestamp -= 3*AV_TIME_BASE / 23;
1104 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1106 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1107 filename, (double)timestamp / AV_TIME_BASE);
1111 /* update the current parameters so that they match the one of the input stream */
1112 add_input_streams(o, ic);
1114 /* dump the file content */
1115 av_dump_format(ic, nb_input_files, filename, 0);
1117 GROW_ARRAY(input_files, nb_input_files);
1118 f = av_mallocz(sizeof(*f));
1121 input_files[nb_input_files - 1] = f;
1124 f->ist_index = nb_input_streams - ic->nb_streams;
1125 f->start_time = o->start_time;
1126 f->recording_time = o->recording_time;
1127 f->input_ts_offset = o->input_ts_offset;
1128 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1129 f->nb_streams = ic->nb_streams;
1130 f->rate_emu = o->rate_emu;
1131 f->accurate_seek = o->accurate_seek;
1134 f->time_base = (AVRational){ 1, 1 };
1136 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1139 /* check if all codec options have been used */
1140 unused_opts = strip_specifiers(o->g->codec_opts);
1141 for (i = f->ist_index; i < nb_input_streams; i++) {
1143 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1144 AV_DICT_IGNORE_SUFFIX)))
1145 av_dict_set(&unused_opts, e->key, NULL, 0);
1149 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1150 const AVClass *class = avcodec_get_class();
1151 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1152 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1153 const AVClass *fclass = avformat_get_class();
1154 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1155 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1156 if (!option || foption)
1160 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1161 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1162 "input file #%d (%s) is not a decoding option.\n", e->key,
1163 option->help ? option->help : "", nb_input_files - 1,
1168 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1169 "input file #%d (%s) has not been used for any stream. The most "
1170 "likely reason is either wrong type (e.g. a video option with "
1171 "no video streams) or that it is a private option of some decoder "
1172 "which was not actually used for any stream.\n", e->key,
1173 option->help ? option->help : "", nb_input_files - 1, filename);
1175 av_dict_free(&unused_opts);
1177 for (i = 0; i < o->nb_dump_attachment; i++) {
1180 for (j = 0; j < ic->nb_streams; j++) {
1181 AVStream *st = ic->streams[j];
1183 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1184 dump_attachment(st, o->dump_attachment[i].u.str);
1188 input_stream_potentially_available = 1;
1193 static uint8_t *get_line(AVIOContext *s)
1199 if (avio_open_dyn_buf(&line) < 0) {
1200 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1204 while ((c = avio_r8(s)) && c != '\n')
1207 avio_close_dyn_buf(line, &buf);
1212 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1215 char filename[1000];
1216 const char *base[3] = { getenv("AVCONV_DATADIR"),
1221 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1225 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1226 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1227 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1230 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1231 i != 1 ? "" : "/.avconv", preset_name);
1232 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1238 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1240 enum AVMediaType type = ost->st->codecpar->codec_type;
1241 char *codec_name = NULL;
1243 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1244 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1246 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1247 NULL, ost->st->codecpar->codec_type);
1248 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1250 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1251 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1252 "probably disabled. Please choose an encoder manually.\n",
1253 ost->file_index, ost->index, s->oformat->name,
1254 avcodec_get_name(ost->st->codecpar->codec_id));
1255 return AVERROR_ENCODER_NOT_FOUND;
1257 } else if (!strcmp(codec_name, "copy"))
1258 ost->stream_copy = 1;
1260 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1261 ost->st->codecpar->codec_id = ost->enc->id;
1263 ost->encoding_needed = !ost->stream_copy;
1265 /* no encoding supported for other media types */
1266 ost->stream_copy = 1;
1267 ost->encoding_needed = 0;
1273 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1276 AVStream *st = avformat_new_stream(oc, NULL);
1277 int idx = oc->nb_streams - 1, ret = 0;
1278 const char *bsfs = NULL, *time_base = NULL;
1279 char *next, *codec_tag = NULL;
1284 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1288 if (oc->nb_streams - 1 < o->nb_streamid_map)
1289 st->id = o->streamid_map[oc->nb_streams - 1];
1291 GROW_ARRAY(output_streams, nb_output_streams);
1292 if (!(ost = av_mallocz(sizeof(*ost))))
1294 output_streams[nb_output_streams - 1] = ost;
1296 ost->file_index = nb_output_files - 1;
1299 st->codecpar->codec_type = type;
1301 ret = choose_encoder(o, oc, ost);
1303 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1304 "%d:%d\n", ost->file_index, ost->index);
1308 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1309 if (!ost->enc_ctx) {
1310 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1313 ost->enc_ctx->codec_type = type;
1315 ost->ref_par = avcodec_parameters_alloc();
1316 if (!ost->ref_par) {
1317 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1322 AVIOContext *s = NULL;
1323 char *buf = NULL, *arg = NULL, *preset = NULL;
1325 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1327 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1328 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1331 if (!buf[0] || buf[0] == '#') {
1335 if (!(arg = strchr(buf, '='))) {
1336 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1340 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1342 } while (!s->eof_reached);
1346 av_log(NULL, AV_LOG_FATAL,
1347 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1348 preset, ost->file_index, ost->index);
1352 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1355 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1358 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1359 q.num <= 0 || q.den <= 0) {
1360 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1366 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1369 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1371 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1374 ost->enc_timebase = q;
1377 ost->max_frames = INT64_MAX;
1378 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1379 for (i = 0; i<o->nb_max_frames; i++) {
1380 char *p = o->max_frames[i].specifier;
1381 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1382 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1387 ost->copy_prior_start = -1;
1388 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1390 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1391 while (bsfs && *bsfs) {
1392 const AVBitStreamFilter *filter;
1393 char *bsf, *bsf_options_str, *bsf_name;
1395 bsf = av_get_token(&bsfs, ",");
1398 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1402 filter = av_bsf_get_by_name(bsf_name);
1404 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1408 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1409 ost->nb_bitstream_filters + 1,
1410 sizeof(*ost->bsf_ctx));
1414 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1416 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1420 ost->nb_bitstream_filters++;
1422 if (bsf_options_str && filter->priv_class) {
1423 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1424 const char * shorthand[2] = {NULL};
1427 shorthand[0] = opt->name;
1429 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1431 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1441 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1443 uint32_t tag = strtol(codec_tag, &next, 0);
1445 tag = AV_RL32(codec_tag);
1446 ost->st->codecpar->codec_tag =
1447 ost->enc_ctx->codec_tag = tag;
1450 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1452 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1453 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1456 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1457 ost->disposition = av_strdup(ost->disposition);
1459 ost->max_muxing_queue_size = 128;
1460 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1461 ost->max_muxing_queue_size *= sizeof(AVPacket);
1463 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1464 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1466 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1468 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1469 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1470 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1472 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1474 ost->source_index = source_index;
1475 if (source_index >= 0) {
1476 ost->sync_ist = input_streams[source_index];
1477 input_streams[source_index]->discard = 0;
1478 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1480 ost->last_mux_dts = AV_NOPTS_VALUE;
1482 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1483 if (!ost->muxing_queue)
1489 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1492 const char *p = str;
1499 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1506 /* read file contents into a string */
1507 static uint8_t *read_file(const char *filename)
1509 AVIOContext *pb = NULL;
1510 AVIOContext *dyn_buf = NULL;
1511 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1512 uint8_t buf[1024], *str;
1515 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1519 ret = avio_open_dyn_buf(&dyn_buf);
1524 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1525 avio_write(dyn_buf, buf, ret);
1526 avio_w8(dyn_buf, 0);
1529 ret = avio_close_dyn_buf(dyn_buf, &str);
1535 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1538 AVStream *st = ost->st;
1540 if (ost->filters_script && ost->filters) {
1541 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1542 "output stream #%d:%d.\n", nb_output_files, st->index);
1546 if (ost->filters_script)
1547 return read_file(ost->filters_script);
1548 else if (ost->filters)
1549 return av_strdup(ost->filters);
1551 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1555 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1556 const OutputStream *ost, enum AVMediaType type)
1558 if (ost->filters_script || ost->filters) {
1559 av_log(NULL, AV_LOG_ERROR,
1560 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1561 "Filtering and streamcopy cannot be used together.\n",
1562 ost->filters ? "Filtergraph" : "Filtergraph script",
1563 ost->filters ? ost->filters : ost->filters_script,
1564 av_get_media_type_string(type), ost->file_index, ost->index);
1569 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1573 AVCodecContext *video_enc;
1574 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1576 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1578 video_enc = ost->enc_ctx;
1580 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1581 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1582 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1585 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1586 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1588 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1589 if (frame_aspect_ratio) {
1591 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1592 q.num <= 0 || q.den <= 0) {
1593 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1596 ost->frame_aspect_ratio = q;
1599 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1600 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1602 if (!ost->stream_copy) {
1603 const char *p = NULL;
1604 char *frame_size = NULL;
1605 char *frame_pix_fmt = NULL;
1606 char *intra_matrix = NULL, *inter_matrix = NULL;
1607 char *chroma_intra_matrix = NULL;
1611 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1612 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1613 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1617 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1618 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1619 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1620 ost->keep_pix_fmt = 1;
1621 if (!*++frame_pix_fmt)
1622 frame_pix_fmt = NULL;
1624 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1625 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1628 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1631 video_enc->gop_size = 0;
1632 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1634 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1635 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1638 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1640 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1641 if (chroma_intra_matrix) {
1642 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1644 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1647 av_codec_set_chroma_intra_matrix(video_enc, p);
1648 parse_matrix_coeffs(p, chroma_intra_matrix);
1650 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1652 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1653 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1656 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1659 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1660 for (i = 0; p; i++) {
1662 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1664 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1667 video_enc->rc_override =
1668 av_realloc_array(video_enc->rc_override,
1669 i + 1, sizeof(RcOverride));
1670 if (!video_enc->rc_override) {
1671 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1674 video_enc->rc_override[i].start_frame = start;
1675 video_enc->rc_override[i].end_frame = end;
1677 video_enc->rc_override[i].qscale = q;
1678 video_enc->rc_override[i].quality_factor = 1.0;
1681 video_enc->rc_override[i].qscale = 0;
1682 video_enc->rc_override[i].quality_factor = -q/100.0;
1687 video_enc->rc_override_count = i;
1690 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1693 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1696 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1697 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1700 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1701 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1705 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1706 if (ost->logfile_prefix &&
1707 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1711 char logfilename[1024];
1714 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1715 ost->logfile_prefix ? ost->logfile_prefix :
1716 DEFAULT_PASS_LOGFILENAME_PREFIX,
1718 if (!strcmp(ost->enc->name, "libx264")) {
1719 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1721 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1722 char *logbuffer = read_file(logfilename);
1725 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1729 video_enc->stats_in = logbuffer;
1731 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1732 f = av_fopen_utf8(logfilename, "wb");
1734 av_log(NULL, AV_LOG_FATAL,
1735 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1736 logfilename, strerror(errno));
1744 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1745 if (ost->forced_keyframes)
1746 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1748 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1750 ost->top_field_first = -1;
1751 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1754 ost->avfilter = get_ost_filters(o, oc, ost);
1758 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1761 if (ost->stream_copy)
1762 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1767 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1772 AVCodecContext *audio_enc;
1774 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1777 audio_enc = ost->enc_ctx;
1778 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1780 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1781 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1783 if (!ost->stream_copy) {
1784 char *sample_fmt = NULL;
1786 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1788 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1790 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1791 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1795 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1797 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1798 ost->apad = av_strdup(ost->apad);
1800 ost->avfilter = get_ost_filters(o, oc, ost);
1804 /* check for channel mapping for this audio stream */
1805 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1806 AudioChannelMap *map = &o->audio_channel_maps[n];
1807 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1808 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1811 if (map->channel_idx == -1) {
1813 } else if (ost->source_index < 0) {
1814 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1815 ost->file_index, ost->st->index);
1818 ist = input_streams[ost->source_index];
1821 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1822 if (av_reallocp_array(&ost->audio_channels_map,
1823 ost->audio_channels_mapped + 1,
1824 sizeof(*ost->audio_channels_map)
1828 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1834 if (ost->stream_copy)
1835 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1840 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1844 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1845 if (!ost->stream_copy) {
1846 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1853 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1857 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1858 if (!ost->stream_copy) {
1859 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1866 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1868 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1869 ost->stream_copy = 1;
1874 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1878 AVCodecContext *subtitle_enc;
1880 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1882 subtitle_enc = ost->enc_ctx;
1884 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1886 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1888 if (!ost->stream_copy) {
1889 char *frame_size = NULL;
1891 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1892 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1893 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1901 /* arg format is "output-stream-index:streamid-value". */
1902 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1904 OptionsContext *o = optctx;
1909 av_strlcpy(idx_str, arg, sizeof(idx_str));
1910 p = strchr(idx_str, ':');
1912 av_log(NULL, AV_LOG_FATAL,
1913 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1918 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1919 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1920 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1924 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1926 AVFormatContext *is = ifile->ctx;
1927 AVFormatContext *os = ofile->ctx;
1931 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1933 return AVERROR(ENOMEM);
1936 for (i = 0; i < is->nb_chapters; i++) {
1937 AVChapter *in_ch = is->chapters[i], *out_ch;
1938 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1939 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1940 AV_TIME_BASE_Q, in_ch->time_base);
1941 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1942 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1945 if (in_ch->end < ts_off)
1947 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1950 out_ch = av_mallocz(sizeof(AVChapter));
1952 return AVERROR(ENOMEM);
1954 out_ch->id = in_ch->id;
1955 out_ch->time_base = in_ch->time_base;
1956 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1957 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1960 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1962 os->chapters[os->nb_chapters++] = out_ch;
1967 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1970 AVFormatContext *ic = avformat_alloc_context();
1972 ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
1973 ic->interrupt_callback = int_cb;
1974 err = avformat_open_input(&ic, filename, NULL, NULL);
1977 /* copy stream format */
1978 for(i=0;i<ic->nb_streams;i++) {
1982 const char *enc_config;
1984 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1986 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1987 return AVERROR(EINVAL);
1989 if (codec->type == AVMEDIA_TYPE_AUDIO)
1990 opt_audio_codec(o, "c:a", codec->name);
1991 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1992 opt_video_codec(o, "c:v", codec->name);
1993 ost = new_output_stream(o, s, codec->type, -1);
1996 avcodec_get_context_defaults3(st->codec, codec);
1997 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1999 AVDictionary *opts = NULL;
2000 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
2001 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
2002 av_dict_free(&opts);
2005 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
2006 choose_sample_fmt(st, codec);
2007 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
2008 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
2009 avcodec_copy_context(ost->enc_ctx, st->codec);
2011 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
2014 avformat_close_input(&ic);
2018 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2019 AVFormatContext *oc)
2023 switch (ofilter->type) {
2024 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2025 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2027 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2032 ost->source_index = -1;
2033 ost->filter = ofilter;
2036 ofilter->format = -1;
2038 if (ost->stream_copy) {
2039 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2040 "which is fed from a complex filtergraph. Filtering and streamcopy "
2041 "cannot be used together.\n", ost->file_index, ost->index);
2045 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2046 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2047 av_log(NULL, AV_LOG_ERROR,
2048 "%s '%s' was specified through the %s option "
2049 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2050 "%s and -filter_complex cannot be used together for the same stream.\n",
2051 ost->filters ? "Filtergraph" : "Filtergraph script",
2052 ost->filters ? ost->filters : ost->filters_script,
2053 opt, ost->file_index, ost->index, opt);
2057 avfilter_inout_free(&ofilter->out_tmp);
2060 static int init_complex_filters(void)
2064 for (i = 0; i < nb_filtergraphs; i++) {
2065 ret = init_complex_filtergraph(filtergraphs[i]);
2072 static int open_output_file(OptionsContext *o, const char *filename)
2074 AVFormatContext *oc;
2076 AVOutputFormat *file_oformat;
2080 AVDictionary *unused_opts = NULL;
2081 AVDictionaryEntry *e = NULL;
2082 int format_flags = 0;
2084 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2085 o->stop_time = INT64_MAX;
2086 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2089 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2090 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2091 if (o->stop_time <= start_time) {
2092 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2095 o->recording_time = o->stop_time - start_time;
2099 GROW_ARRAY(output_files, nb_output_files);
2100 of = av_mallocz(sizeof(*of));
2103 output_files[nb_output_files - 1] = of;
2105 of->ost_index = nb_output_streams;
2106 of->recording_time = o->recording_time;
2107 of->start_time = o->start_time;
2108 of->limit_filesize = o->limit_filesize;
2109 of->shortest = o->shortest;
2110 av_dict_copy(&of->opts, o->g->format_opts, 0);
2112 if (!strcmp(filename, "-"))
2115 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2117 print_error(filename, err);
2122 if (o->recording_time != INT64_MAX)
2123 oc->duration = o->recording_time;
2125 file_oformat= oc->oformat;
2126 oc->interrupt_callback = int_cb;
2128 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2130 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2131 av_opt_eval_flags(oc, o, e->value, &format_flags);
2134 /* create streams for all unlabeled output pads */
2135 for (i = 0; i < nb_filtergraphs; i++) {
2136 FilterGraph *fg = filtergraphs[i];
2137 for (j = 0; j < fg->nb_outputs; j++) {
2138 OutputFilter *ofilter = fg->outputs[j];
2140 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2143 switch (ofilter->type) {
2144 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2145 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2146 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2148 init_output_filter(ofilter, o, oc);
2152 /* ffserver seeking with date=... needs a date reference */
2153 if (!strcmp(file_oformat->name, "ffm") &&
2154 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2155 av_strstart(filename, "http:", NULL)) {
2156 int err = parse_option(o, "metadata", "creation_time=now", options);
2158 print_error(filename, err);
2163 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2164 av_strstart(filename, "http:", NULL)) {
2166 /* special case for files sent to ffserver: we get the stream
2167 parameters from ffserver */
2168 int err = read_ffserver_streams(o, oc, filename);
2170 print_error(filename, err);
2173 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2174 ost = output_streams[j];
2175 for (i = 0; i < nb_input_streams; i++) {
2176 ist = input_streams[i];
2177 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2179 ost->source_index= i;
2180 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2181 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2183 ist->st->discard = ist->user_set_discard;
2188 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));
2192 } else if (!o->nb_stream_maps) {
2193 char *subtitle_codec_name = NULL;
2194 /* pick the "best" stream of each type */
2196 /* video: highest resolution */
2197 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2198 int area = 0, idx = -1;
2199 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2200 for (i = 0; i < nb_input_streams; i++) {
2202 ist = input_streams[i];
2203 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2204 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2206 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2208 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2215 new_video_stream(o, oc, idx);
2218 /* audio: most channels */
2219 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2220 int best_score = 0, idx = -1;
2221 for (i = 0; i < nb_input_streams; i++) {
2223 ist = input_streams[i];
2224 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2225 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2226 score > best_score) {
2232 new_audio_stream(o, oc, idx);
2235 /* subtitles: pick first */
2236 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2237 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2238 for (i = 0; i < nb_input_streams; i++)
2239 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2240 AVCodecDescriptor const *input_descriptor =
2241 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2242 AVCodecDescriptor const *output_descriptor = NULL;
2243 AVCodec const *output_codec =
2244 avcodec_find_encoder(oc->oformat->subtitle_codec);
2245 int input_props = 0, output_props = 0;
2247 output_descriptor = avcodec_descriptor_get(output_codec->id);
2248 if (input_descriptor)
2249 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2250 if (output_descriptor)
2251 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2252 if (subtitle_codec_name ||
2253 input_props & output_props ||
2254 // Map dvb teletext which has neither property to any output subtitle encoder
2255 input_descriptor && output_descriptor &&
2256 (!input_descriptor->props ||
2257 !output_descriptor->props)) {
2258 new_subtitle_stream(o, oc, i);
2263 /* Data only if codec id match */
2264 if (!o->data_disable ) {
2265 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2266 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2267 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2268 && input_streams[i]->st->codecpar->codec_id == codec_id )
2269 new_data_stream(o, oc, i);
2273 for (i = 0; i < o->nb_stream_maps; i++) {
2274 StreamMap *map = &o->stream_maps[i];
2279 if (map->linklabel) {
2281 OutputFilter *ofilter = NULL;
2284 for (j = 0; j < nb_filtergraphs; j++) {
2285 fg = filtergraphs[j];
2286 for (k = 0; k < fg->nb_outputs; k++) {
2287 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2288 if (out && !strcmp(out->name, map->linklabel)) {
2289 ofilter = fg->outputs[k];
2296 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2297 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2300 init_output_filter(ofilter, o, oc);
2302 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2304 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2305 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2307 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2309 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2311 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2315 switch (ist->st->codecpar->codec_type) {
2316 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2317 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2318 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2319 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2320 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2321 case AVMEDIA_TYPE_UNKNOWN:
2322 if (copy_unknown_streams) {
2323 ost = new_unknown_stream (o, oc, src_idx);
2327 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2328 "Cannot map stream #%d:%d - unsupported type.\n",
2329 map->file_index, map->stream_index);
2330 if (!ignore_unknown_streams) {
2331 av_log(NULL, AV_LOG_FATAL,
2332 "If you want unsupported types ignored instead "
2333 "of failing, please use the -ignore_unknown option\n"
2334 "If you want them copied, please use -copy_unknown\n");
2339 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2340 + map->sync_stream_index];
2345 /* handle attached files */
2346 for (i = 0; i < o->nb_attachments; i++) {
2348 uint8_t *attachment;
2352 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2353 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2357 if ((len = avio_size(pb)) <= 0) {
2358 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2362 if (!(attachment = av_malloc(len))) {
2363 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2367 avio_read(pb, attachment, len);
2369 ost = new_attachment_stream(o, oc, -1);
2370 ost->stream_copy = 0;
2371 ost->attachment_filename = o->attachments[i];
2372 ost->st->codecpar->extradata = attachment;
2373 ost->st->codecpar->extradata_size = len;
2375 p = strrchr(o->attachments[i], '/');
2376 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2380 #if FF_API_LAVF_AVCTX
2381 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2382 AVDictionaryEntry *e;
2383 ost = output_streams[i];
2385 if ((ost->stream_copy || ost->attachment_filename)
2386 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2387 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2388 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2393 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2394 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2395 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2399 /* check if all codec options have been used */
2400 unused_opts = strip_specifiers(o->g->codec_opts);
2401 for (i = of->ost_index; i < nb_output_streams; i++) {
2403 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2404 AV_DICT_IGNORE_SUFFIX)))
2405 av_dict_set(&unused_opts, e->key, NULL, 0);
2409 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2410 const AVClass *class = avcodec_get_class();
2411 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2412 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2413 const AVClass *fclass = avformat_get_class();
2414 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2415 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2416 if (!option || foption)
2420 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2421 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2422 "output file #%d (%s) is not an encoding option.\n", e->key,
2423 option->help ? option->help : "", nb_output_files - 1,
2428 // gop_timecode is injected by generic code but not always used
2429 if (!strcmp(e->key, "gop_timecode"))
2432 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2433 "output file #%d (%s) has not been used for any stream. The most "
2434 "likely reason is either wrong type (e.g. a video option with "
2435 "no video streams) or that it is a private option of some encoder "
2436 "which was not actually used for any stream.\n", e->key,
2437 option->help ? option->help : "", nb_output_files - 1, filename);
2439 av_dict_free(&unused_opts);
2441 /* set the decoding_needed flags and create simple filtergraphs */
2442 for (i = of->ost_index; i < nb_output_streams; i++) {
2443 OutputStream *ost = output_streams[i];
2445 if (ost->encoding_needed && ost->source_index >= 0) {
2446 InputStream *ist = input_streams[ost->source_index];
2447 ist->decoding_needed |= DECODING_FOR_OST;
2449 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2450 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2451 err = init_simple_filtergraph(ist, ost);
2453 av_log(NULL, AV_LOG_ERROR,
2454 "Error initializing a simple filtergraph between streams "
2455 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2456 nb_output_files - 1, ost->st->index);
2462 /* set the filter output constraints */
2464 OutputFilter *f = ost->filter;
2466 switch (ost->enc_ctx->codec_type) {
2467 case AVMEDIA_TYPE_VIDEO:
2468 f->frame_rate = ost->frame_rate;
2469 f->width = ost->enc_ctx->width;
2470 f->height = ost->enc_ctx->height;
2471 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2472 f->format = ost->enc_ctx->pix_fmt;
2473 } else if (ost->enc->pix_fmts) {
2475 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2477 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2480 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2483 case AVMEDIA_TYPE_AUDIO:
2484 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2485 f->format = ost->enc_ctx->sample_fmt;
2486 } else if (ost->enc->sample_fmts) {
2488 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2490 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2493 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2495 if (ost->enc_ctx->sample_rate) {
2496 f->sample_rate = ost->enc_ctx->sample_rate;
2497 } else if (ost->enc->supported_samplerates) {
2499 while (ost->enc->supported_samplerates[count])
2501 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2502 if (!f->sample_rates)
2504 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2505 (count + 1) * sizeof(*f->sample_rates));
2507 if (ost->enc_ctx->channels) {
2508 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2509 } else if (ost->enc->channel_layouts) {
2511 while (ost->enc->channel_layouts[count])
2513 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2514 if (!f->channel_layouts)
2516 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2517 (count + 1) * sizeof(*f->channel_layouts));
2524 /* check filename in case of an image number is expected */
2525 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2526 if (!av_filename_number_test(oc->filename)) {
2527 print_error(oc->filename, AVERROR(EINVAL));
2532 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2533 av_log(NULL, AV_LOG_ERROR,
2534 "No input streams but output needs an input stream\n");
2538 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2539 /* test if it already exists to avoid losing precious files */
2540 assert_file_overwrite(filename);
2543 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2544 &oc->interrupt_callback,
2546 print_error(filename, err);
2549 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2550 assert_file_overwrite(filename);
2552 if (o->mux_preload) {
2553 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2555 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2558 for (i = 0; i < o->nb_metadata_map; i++) {
2560 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2562 if (in_file_index >= nb_input_files) {
2563 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2566 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2567 in_file_index >= 0 ?
2568 input_files[in_file_index]->ctx : NULL, o);
2572 if (o->chapters_input_file >= nb_input_files) {
2573 if (o->chapters_input_file == INT_MAX) {
2574 /* copy chapters from the first input file that has them*/
2575 o->chapters_input_file = -1;
2576 for (i = 0; i < nb_input_files; i++)
2577 if (input_files[i]->ctx->nb_chapters) {
2578 o->chapters_input_file = i;
2582 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2583 o->chapters_input_file);
2587 if (o->chapters_input_file >= 0)
2588 copy_chapters(input_files[o->chapters_input_file], of,
2589 !o->metadata_chapters_manual);
2591 /* copy global metadata by default */
2592 if (!o->metadata_global_manual && nb_input_files){
2593 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2594 AV_DICT_DONT_OVERWRITE);
2595 if(o->recording_time != INT64_MAX)
2596 av_dict_set(&oc->metadata, "duration", NULL, 0);
2597 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2599 if (!o->metadata_streams_manual)
2600 for (i = of->ost_index; i < nb_output_streams; i++) {
2602 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2604 ist = input_streams[output_streams[i]->source_index];
2605 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2606 if (!output_streams[i]->stream_copy) {
2607 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2611 /* process manually set programs */
2612 for (i = 0; i < o->nb_program; i++) {
2613 const char *p = o->program[i].u.str;
2618 const char *p2 = av_get_token(&p, ":");
2619 const char *to_dealloc = p2;
2626 key = av_get_token(&p2, "=");
2628 av_freep(&to_dealloc);
2634 if (!strcmp(key, "program_num"))
2635 progid = strtol(p2, NULL, 0);
2636 av_freep(&to_dealloc);
2640 program = av_new_program(oc, progid);
2642 p = o->program[i].u.str;
2644 const char *p2 = av_get_token(&p, ":");
2645 const char *to_dealloc = p2;
2651 key = av_get_token(&p2, "=");
2653 av_log(NULL, AV_LOG_FATAL,
2654 "No '=' character in program string %s.\n",
2662 if (!strcmp(key, "title")) {
2663 av_dict_set(&program->metadata, "title", p2, 0);
2664 } else if (!strcmp(key, "program_num")) {
2665 } else if (!strcmp(key, "st")) {
2666 int st_num = strtol(p2, NULL, 0);
2667 av_program_add_stream_index(oc, progid, st_num);
2669 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2672 av_freep(&to_dealloc);
2677 /* process manually set metadata */
2678 for (i = 0; i < o->nb_metadata; i++) {
2681 const char *stream_spec;
2682 int index = 0, j, ret = 0;
2684 val = strchr(o->metadata[i].u.str, '=');
2686 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2687 o->metadata[i].u.str);
2692 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2694 for (j = 0; j < oc->nb_streams; j++) {
2695 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2696 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2697 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2699 double theta = av_strtod(val, &tail);
2701 ost->rotate_overridden = 1;
2702 ost->rotate_override_value = theta;
2705 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2717 if (index < 0 || index >= oc->nb_chapters) {
2718 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2721 m = &oc->chapters[index]->metadata;
2724 if (index < 0 || index >= oc->nb_programs) {
2725 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2728 m = &oc->programs[index]->metadata;
2731 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2734 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2741 static int opt_target(void *optctx, const char *opt, const char *arg)
2743 OptionsContext *o = optctx;
2744 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2745 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2747 if (!strncmp(arg, "pal-", 4)) {
2750 } else if (!strncmp(arg, "ntsc-", 5)) {
2753 } else if (!strncmp(arg, "film-", 5)) {
2757 /* Try to determine PAL/NTSC by peeking in the input files */
2758 if (nb_input_files) {
2760 for (j = 0; j < nb_input_files; j++) {
2761 for (i = 0; i < input_files[j]->nb_streams; i++) {
2762 AVStream *st = input_files[j]->ctx->streams[i];
2763 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2765 fr = st->time_base.den * 1000 / st->time_base.num;
2769 } else if ((fr == 29970) || (fr == 23976)) {
2774 if (norm != UNKNOWN)
2778 if (norm != UNKNOWN)
2779 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2782 if (norm == UNKNOWN) {
2783 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2784 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2785 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2789 if (!strcmp(arg, "vcd")) {
2790 opt_video_codec(o, "c:v", "mpeg1video");
2791 opt_audio_codec(o, "c:a", "mp2");
2792 parse_option(o, "f", "vcd", options);
2794 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2795 parse_option(o, "r", frame_rates[norm], options);
2796 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2798 opt_default(NULL, "b:v", "1150000");
2799 opt_default(NULL, "maxrate:v", "1150000");
2800 opt_default(NULL, "minrate:v", "1150000");
2801 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2803 opt_default(NULL, "b:a", "224000");
2804 parse_option(o, "ar", "44100", options);
2805 parse_option(o, "ac", "2", options);
2807 opt_default(NULL, "packetsize", "2324");
2808 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2810 /* We have to offset the PTS, so that it is consistent with the SCR.
2811 SCR starts at 36000, but the first two packs contain only padding
2812 and the first pack from the other stream, respectively, may also have
2813 been written before.
2814 So the real data starts at SCR 36000+3*1200. */
2815 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2816 } else if (!strcmp(arg, "svcd")) {
2818 opt_video_codec(o, "c:v", "mpeg2video");
2819 opt_audio_codec(o, "c:a", "mp2");
2820 parse_option(o, "f", "svcd", options);
2822 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2823 parse_option(o, "r", frame_rates[norm], options);
2824 parse_option(o, "pix_fmt", "yuv420p", options);
2825 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2827 opt_default(NULL, "b:v", "2040000");
2828 opt_default(NULL, "maxrate:v", "2516000");
2829 opt_default(NULL, "minrate:v", "0"); // 1145000;
2830 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2831 opt_default(NULL, "scan_offset", "1");
2833 opt_default(NULL, "b:a", "224000");
2834 parse_option(o, "ar", "44100", options);
2836 opt_default(NULL, "packetsize", "2324");
2838 } else if (!strcmp(arg, "dvd")) {
2840 opt_video_codec(o, "c:v", "mpeg2video");
2841 opt_audio_codec(o, "c:a", "ac3");
2842 parse_option(o, "f", "dvd", options);
2844 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2845 parse_option(o, "r", frame_rates[norm], options);
2846 parse_option(o, "pix_fmt", "yuv420p", options);
2847 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2849 opt_default(NULL, "b:v", "6000000");
2850 opt_default(NULL, "maxrate:v", "9000000");
2851 opt_default(NULL, "minrate:v", "0"); // 1500000;
2852 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2854 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2855 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2857 opt_default(NULL, "b:a", "448000");
2858 parse_option(o, "ar", "48000", options);
2860 } else if (!strncmp(arg, "dv", 2)) {
2862 parse_option(o, "f", "dv", options);
2864 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2865 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2866 norm == PAL ? "yuv420p" : "yuv411p", options);
2867 parse_option(o, "r", frame_rates[norm], options);
2869 parse_option(o, "ar", "48000", options);
2870 parse_option(o, "ac", "2", options);
2873 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2874 return AVERROR(EINVAL);
2877 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2878 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2883 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2885 av_free (vstats_filename);
2886 vstats_filename = av_strdup (arg);
2890 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2893 time_t today2 = time(NULL);
2894 struct tm *today = localtime(&today2);
2896 if (!today) { // maybe tomorrow
2897 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2901 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2903 return opt_vstats_file(NULL, opt, filename);
2906 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2908 OptionsContext *o = optctx;
2909 return parse_option(o, "frames:v", arg, options);
2912 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2914 OptionsContext *o = optctx;
2915 return parse_option(o, "frames:a", arg, options);
2918 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2920 OptionsContext *o = optctx;
2921 return parse_option(o, "frames:d", arg, options);
2924 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2927 AVDictionary *cbak = codec_opts;
2928 AVDictionary *fbak = format_opts;
2932 ret = opt_default(NULL, opt, arg);
2934 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2935 av_dict_copy(&o->g->format_opts, format_opts, 0);
2936 av_dict_free(&codec_opts);
2937 av_dict_free(&format_opts);
2944 static int opt_preset(void *optctx, const char *opt, const char *arg)
2946 OptionsContext *o = optctx;
2948 char filename[1000], line[1000], tmp_line[1000];
2949 const char *codec_name = NULL;
2953 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2955 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2956 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2957 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2959 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2963 while (fgets(line, sizeof(line), f)) {
2964 char *key = tmp_line, *value, *endptr;
2966 if (strcspn(line, "#\n\r") == 0)
2968 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2969 if (!av_strtok(key, "=", &value) ||
2970 !av_strtok(value, "\r\n", &endptr)) {
2971 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2974 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2976 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2977 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2978 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2979 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2980 else if (opt_default_new(o, key, value) < 0) {
2981 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2982 filename, line, key, value);
2992 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2994 OptionsContext *o = optctx;
2995 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2996 int ret = parse_option(o, s, arg, options);
3001 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3003 OptionsContext *o = optctx;
3005 if(!strcmp(opt, "ab")){
3006 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3008 } else if(!strcmp(opt, "b")){
3009 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3010 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3013 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3017 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3019 OptionsContext *o = optctx;
3022 if(!strcmp(opt, "qscale")){
3023 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3024 return parse_option(o, "q:v", arg, options);
3026 s = av_asprintf("q%s", opt + 6);
3027 ret = parse_option(o, s, arg, options);
3032 static int opt_profile(void *optctx, const char *opt, const char *arg)
3034 OptionsContext *o = optctx;
3035 if(!strcmp(opt, "profile")){
3036 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3037 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3040 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3044 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3046 OptionsContext *o = optctx;
3047 return parse_option(o, "filter:v", arg, options);
3050 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3052 OptionsContext *o = optctx;
3053 return parse_option(o, "filter:a", arg, options);
3056 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3058 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3059 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3060 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3061 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3063 if (video_sync_method == VSYNC_AUTO)
3064 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3068 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3070 OptionsContext *o = optctx;
3071 char *tcr = av_asprintf("timecode=%s", arg);
3072 int ret = parse_option(o, "metadata:g", tcr, options);
3074 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3079 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3081 OptionsContext *o = optctx;
3082 char layout_str[32];
3085 int ret, channels, ac_str_size;
3088 layout = av_get_channel_layout(arg);
3090 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3091 return AVERROR(EINVAL);
3093 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3094 ret = opt_default_new(o, opt, layout_str);
3098 /* set 'ac' option based on channel layout */
3099 channels = av_get_channel_layout_nb_channels(layout);
3100 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3101 stream_str = strchr(opt, ':');
3102 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3103 ac_str = av_mallocz(ac_str_size);
3105 return AVERROR(ENOMEM);
3106 av_strlcpy(ac_str, "ac", 3);
3108 av_strlcat(ac_str, stream_str, ac_str_size);
3109 ret = parse_option(o, ac_str, layout_str, options);
3115 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3117 OptionsContext *o = optctx;
3118 return parse_option(o, "q:a", arg, options);
3121 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3123 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3124 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3125 return AVERROR(ENOMEM);
3126 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3127 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3128 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3129 return AVERROR(ENOMEM);
3131 input_stream_potentially_available = 1;
3136 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3138 uint8_t *graph_desc = read_file(arg);
3140 return AVERROR(EINVAL);
3142 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3143 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3144 return AVERROR(ENOMEM);
3145 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3146 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3148 input_stream_potentially_available = 1;
3153 void show_help_default(const char *opt, const char *arg)
3155 /* per-file options have at least one of those set */
3156 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3157 int show_advanced = 0, show_avoptions = 0;
3160 if (!strcmp(opt, "long"))
3162 else if (!strcmp(opt, "full"))
3163 show_advanced = show_avoptions = 1;
3165 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3170 printf("Getting help:\n"
3171 " -h -- print basic options\n"
3172 " -h long -- print more options\n"
3173 " -h full -- print all options (including all format and codec specific options, very long)\n"
3174 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3175 " See man %s for detailed description of the options.\n"
3176 "\n", program_name);
3178 show_help_options(options, "Print help / information / capabilities:",
3181 show_help_options(options, "Global options (affect whole program "
3182 "instead of just one file:",
3183 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3185 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3186 per_file | OPT_EXIT, 0);
3188 show_help_options(options, "Per-file main options:", 0,
3189 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3190 OPT_EXIT, per_file);
3192 show_help_options(options, "Advanced per-file options:",
3193 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3195 show_help_options(options, "Video options:",
3196 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3198 show_help_options(options, "Advanced Video options:",
3199 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3201 show_help_options(options, "Audio options:",
3202 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3204 show_help_options(options, "Advanced Audio options:",
3205 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3206 show_help_options(options, "Subtitle options:",
3207 OPT_SUBTITLE, 0, 0);
3210 if (show_avoptions) {
3211 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3212 show_help_children(avcodec_get_class(), flags);
3213 show_help_children(avformat_get_class(), flags);
3215 show_help_children(sws_get_class(), flags);
3217 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3218 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3222 void show_usage(void)
3224 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3225 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3226 av_log(NULL, AV_LOG_INFO, "\n");
3234 static const OptionGroupDef groups[] = {
3235 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3236 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3239 static int open_files(OptionGroupList *l, const char *inout,
3240 int (*open_file)(OptionsContext*, const char*))
3244 for (i = 0; i < l->nb_groups; i++) {
3245 OptionGroup *g = &l->groups[i];
3251 ret = parse_optgroup(&o, g);
3253 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3254 "%s.\n", inout, g->arg);
3258 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3259 ret = open_file(&o, g->arg);
3262 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3266 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3272 int ffmpeg_parse_options(int argc, char **argv)
3274 OptionParseContext octx;
3278 memset(&octx, 0, sizeof(octx));
3280 /* split the commandline into an internal representation */
3281 ret = split_commandline(&octx, argc, argv, options, groups,
3282 FF_ARRAY_ELEMS(groups));
3284 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3288 /* apply global options */
3289 ret = parse_optgroup(NULL, &octx.global_opts);
3291 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3295 /* configure terminal and setup signal handlers */
3298 /* open input files */
3299 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3301 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3305 /* create the complex filtergraphs */
3306 ret = init_complex_filters();
3308 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3312 /* open output files */
3313 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3315 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3319 check_filter_outputs();
3322 uninit_parse_context(&octx);
3324 av_strerror(ret, error, sizeof(error));
3325 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3330 static int opt_progress(void *optctx, const char *opt, const char *arg)
3332 AVIOContext *avio = NULL;
3335 if (!strcmp(arg, "-"))
3337 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3339 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3340 arg, av_err2str(ret));
3343 progress_avio = avio;
3347 #define OFFSET(x) offsetof(OptionsContext, x)
3348 const OptionDef options[] = {
3350 CMDUTILS_COMMON_OPTIONS
3351 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3352 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3353 "force format", "fmt" },
3354 { "y", OPT_BOOL, { &file_overwrite },
3355 "overwrite output files" },
3356 { "n", OPT_BOOL, { &no_file_overwrite },
3357 "never overwrite output files" },
3358 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3359 "Ignore unknown stream types" },
3360 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3361 "Copy unknown stream types" },
3362 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3363 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3364 "codec name", "codec" },
3365 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3366 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3367 "codec name", "codec" },
3368 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3369 OPT_OUTPUT, { .off = OFFSET(presets) },
3370 "preset name", "preset" },
3371 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3372 OPT_OUTPUT, { .func_arg = opt_map },
3373 "set input stream mapping",
3374 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3375 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3376 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3377 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3378 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3379 "set metadata information of outfile from infile",
3380 "outfile[,metadata]:infile[,metadata]" },
3381 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3382 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3383 "set chapters mapping", "input_file_index" },
3384 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3385 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3386 "record or transcode \"duration\" seconds of audio/video",
3388 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3389 "record or transcode stop time", "time_stop" },
3390 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3391 "set the limit file size in bytes", "limit_size" },
3392 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3393 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3394 "set the start time offset", "time_off" },
3395 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3396 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3397 "set the start time offset relative to EOF", "time_off" },
3398 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3399 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3400 "enable/disable seeking by timestamp with -ss" },
3401 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3402 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3403 "enable/disable accurate seeking with -ss" },
3404 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3405 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3406 "set the input ts offset", "time_off" },
3407 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3408 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3409 "set the input ts scale", "scale" },
3410 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3411 "set the recording timestamp ('now' to set the current time)", "time" },
3412 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3413 "add metadata", "string=string" },
3414 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3415 "add program with specified streams", "title=string:st=number..." },
3416 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3417 OPT_OUTPUT, { .func_arg = opt_data_frames },
3418 "set the number of data frames to output", "number" },
3419 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3420 "add timings for benchmarking" },
3421 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3422 "add timings for each task" },
3423 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3424 "write program-readable progress information", "url" },
3425 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3426 "enable or disable interaction on standard input" },
3427 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3428 "set max runtime in seconds", "limit" },
3429 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3430 "dump each input packet" },
3431 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3432 "when dumping packets, also dump the payload" },
3433 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3434 OPT_INPUT, { .off = OFFSET(rate_emu) },
3435 "read input at native frame rate", "" },
3436 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3437 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3438 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3439 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3440 "video sync method", "" },
3441 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3442 "frame drop threshold", "" },
3443 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3444 "audio sync method", "" },
3445 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3446 "audio drift threshold", "threshold" },
3447 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3448 "copy timestamps" },
3449 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3450 "shift input timestamps to start at 0 when using copyts" },
3451 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3452 "copy input stream time base when stream copying", "mode" },
3453 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3454 OPT_OUTPUT, { .off = OFFSET(shortest) },
3455 "finish encoding within shortest input" },
3456 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3457 OPT_OUTPUT, { .off = OFFSET(apad) },
3459 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3460 "timestamp discontinuity delta threshold", "threshold" },
3461 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3462 "timestamp error delta threshold", "threshold" },
3463 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3464 "exit on error", "error" },
3465 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3466 "abort on the specified condition flags", "flags" },
3467 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3468 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3469 "copy initial non-keyframes" },
3470 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3471 "copy or discard frames before start time" },
3472 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3473 "set the number of frames to output", "number" },
3474 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3475 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3476 "force codec tag/fourcc", "fourcc/tag" },
3477 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3478 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3479 "use fixed quality scale (VBR)", "q" },
3480 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3481 OPT_OUTPUT, { .func_arg = opt_qscale },
3482 "use fixed quality scale (VBR)", "q" },
3483 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3484 "set profile", "profile" },
3485 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3486 "set stream filtergraph", "filter_graph" },
3487 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3488 "number of non-complex filter threads" },
3489 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3490 "read stream filtergraph description from a file", "filename" },
3491 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3492 "reinit filtergraph on input parameter changes", "" },
3493 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3494 "create a complex filtergraph", "graph_description" },
3495 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3496 "number of threads for -filter_complex" },
3497 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3498 "create a complex filtergraph", "graph_description" },
3499 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3500 "read complex filtergraph description from a file", "filename" },
3501 { "stats", OPT_BOOL, { &print_stats },
3502 "print progress report during encoding", },
3503 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3504 OPT_OUTPUT, { .func_arg = opt_attach },
3505 "add an attachment to the output file", "filename" },
3506 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3507 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3508 "extract an attachment into a file", "filename" },
3509 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3510 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3511 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3512 "print timestamp debugging info" },
3513 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3514 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3515 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3516 OPT_INPUT, { .off = OFFSET(discard) },
3518 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3519 OPT_OUTPUT, { .off = OFFSET(disposition) },
3520 "disposition", "" },
3521 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3522 { .off = OFFSET(thread_queue_size) },
3523 "set the maximum number of queued packets from the demuxer" },
3524 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3525 "read and decode the streams to fill missing information with heuristics" },
3528 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3529 "set the number of video frames to output", "number" },
3530 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3531 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3532 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3533 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3534 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3535 "set frame size (WxH or abbreviation)", "size" },
3536 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3537 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3538 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3539 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3540 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3541 "set pixel format", "format" },
3542 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3543 "set the number of bits per raw sample", "number" },
3544 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3545 "deprecated use -g 1" },
3546 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3548 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3549 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3550 "rate control override for specific intervals", "override" },
3551 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3552 OPT_OUTPUT, { .func_arg = opt_video_codec },
3553 "force video codec ('copy' to copy stream)", "codec" },
3554 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3556 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3558 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3559 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3560 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3561 "select the pass number (1 to 3)", "n" },
3562 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3563 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3564 "select two pass log file name prefix", "prefix" },
3565 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3566 "this option is deprecated, use the yadif filter instead" },
3567 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3568 "calculate PSNR of compressed frames" },
3569 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3570 "dump video coding statistics to file" },
3571 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3572 "dump video coding statistics to file", "file" },
3573 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3574 "Version of the vstats format to use."},
3575 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3576 "set video filters", "filter_graph" },
3577 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3578 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3579 "specify intra matrix coeffs", "matrix" },
3580 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3581 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3582 "specify inter matrix coeffs", "matrix" },
3583 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3584 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3585 "specify intra matrix coeffs", "matrix" },
3586 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3587 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3588 "top=1/bottom=0/auto=-1 field first", "" },
3589 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3590 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3591 "force video tag/fourcc", "fourcc/tag" },
3592 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3593 "show QP histogram" },
3594 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3595 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3596 "force the selected framerate, disable the best supported framerate selection" },
3597 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3598 OPT_OUTPUT, { .func_arg = opt_streamid },
3599 "set the value of an outfile streamid", "streamIndex:value" },
3600 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3601 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3602 "force key frames at specified timestamps", "timestamps" },
3603 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3604 "audio bitrate (please use -b:a)", "bitrate" },
3605 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3606 "video bitrate (please use -b:v)", "bitrate" },
3607 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3608 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3609 "use HW accelerated decoding", "hwaccel name" },
3610 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3611 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3612 "select a device for HW acceleration", "devicename" },
3613 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3614 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3615 "select output format used with HW accelerated decoding", "format" },
3616 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3617 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3619 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3620 "show available HW acceleration methods" },
3621 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3622 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3623 "automatically insert correct rotate filters" },
3624 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3625 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3628 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3629 "set the number of audio frames to output", "number" },
3630 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3631 "set audio quality (codec-specific)", "quality", },
3632 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3633 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3634 "set audio sampling rate (in Hz)", "rate" },
3635 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3636 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3637 "set number of audio channels", "channels" },
3638 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3640 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3641 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3642 "force audio codec ('copy' to copy stream)", "codec" },
3643 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3644 OPT_OUTPUT, { .func_arg = opt_old2new },
3645 "force audio tag/fourcc", "fourcc/tag" },
3646 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3647 "change audio volume (256=normal)" , "volume" },
3648 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3649 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3650 "set sample format", "format" },
3651 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3652 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3653 "set channel layout", "layout" },
3654 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3655 "set audio filters", "filter_graph" },
3656 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3657 "set the maximum number of channels to try to guess the channel layout" },
3659 /* subtitle options */
3660 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3661 "disable subtitle" },
3662 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3663 "force subtitle codec ('copy' to copy stream)", "codec" },
3664 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3665 , "force subtitle tag/fourcc", "fourcc/tag" },
3666 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3667 "fix subtitles duration" },
3668 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3669 "set canvas size (WxH or abbreviation)", "size" },
3672 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3673 "deprecated, use -channel", "channel" },
3674 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3675 "deprecated, use -standard", "standard" },
3676 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3679 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3680 "set the maximum demux-decode delay", "seconds" },
3681 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3682 "set the initial demux-decode delay", "seconds" },
3683 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3684 "override the options from ffserver", "" },
3685 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3686 "specify a file in which to print sdp information", "file" },
3688 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3689 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3690 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3691 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3692 "two special values are defined - "
3693 "0 = use frame rate (video) or sample rate (audio),"
3694 "-1 = match source time base", "ratio" },
3696 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3697 "A comma-separated list of bitstream filters", "bitstream_filters" },
3698 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3699 "deprecated", "audio bitstream_filters" },
3700 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3701 "deprecated", "video bitstream_filters" },
3703 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3704 "set the audio options to the indicated preset", "preset" },
3705 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3706 "set the video options to the indicated preset", "preset" },
3707 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3708 "set the subtitle options to the indicated preset", "preset" },
3709 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3710 "set options from indicated preset file", "filename" },
3712 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3713 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3715 /* data codec support */
3716 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3717 "force data codec ('copy' to copy stream)", "codec" },
3718 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3722 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3723 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3727 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3728 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3731 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3732 "initialise hardware device", "args" },
3733 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3734 "set hardware device used when filtering", "device" },