2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
70 { "vdpau", hwaccel_decode_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU,
71 AV_HWDEVICE_TYPE_VDPAU },
74 { "d3d11va", hwaccel_decode_init, HWACCEL_D3D11VA, AV_PIX_FMT_D3D11,
75 AV_HWDEVICE_TYPE_D3D11VA },
78 { "dxva2", hwaccel_decode_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD,
79 AV_HWDEVICE_TYPE_DXVA2 },
81 #if CONFIG_VIDEOTOOLBOX
82 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX,
83 AV_HWDEVICE_TYPE_NONE },
86 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV,
87 AV_HWDEVICE_TYPE_NONE },
90 { "vaapi", hwaccel_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI,
91 AV_HWDEVICE_TYPE_VAAPI },
94 { "nvdec", hwaccel_decode_init, HWACCEL_NVDEC, AV_PIX_FMT_CUDA,
95 AV_HWDEVICE_TYPE_CUDA },
98 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA,
99 AV_HWDEVICE_TYPE_NONE },
103 AVBufferRef *hw_device_ctx;
104 HWDevice *filter_hw_device;
106 char *vstats_filename;
109 float audio_drift_threshold = 0.1;
110 float dts_delta_threshold = 10;
111 float dts_error_threshold = 3600*30;
113 int audio_volume = 256;
114 int audio_sync_method = 0;
115 int video_sync_method = VSYNC_AUTO;
116 float frame_drop_threshold = 0;
117 int do_deinterlace = 0;
118 int do_benchmark = 0;
119 int do_benchmark_all = 0;
123 int start_at_zero = 0;
126 int exit_on_error = 0;
127 int abort_on_flags = 0;
128 int print_stats = -1;
130 int stdin_interaction = 1;
131 int frame_bits_per_raw_sample = 0;
132 float max_error_rate = 2.0/3;
133 int filter_nbthreads = 0;
134 int filter_complex_nbthreads = 0;
135 int vstats_version = 2;
138 static int intra_only = 0;
139 static int file_overwrite = 0;
140 static int no_file_overwrite = 0;
141 static int do_psnr = 0;
142 static int input_sync;
143 static int override_ffserver = 0;
144 static int input_stream_potentially_available = 0;
145 static int ignore_unknown_streams = 0;
146 static int copy_unknown_streams = 0;
147 static int find_stream_info = 1;
149 static void uninit_options(OptionsContext *o)
151 const OptionDef *po = options;
154 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
156 void *dst = (uint8_t*)o + po->u.off;
158 if (po->flags & OPT_SPEC) {
159 SpecifierOpt **so = dst;
160 int i, *count = (int*)(so + 1);
161 for (i = 0; i < *count; i++) {
162 av_freep(&(*so)[i].specifier);
163 if (po->flags & OPT_STRING)
164 av_freep(&(*so)[i].u.str);
168 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
173 for (i = 0; i < o->nb_stream_maps; i++)
174 av_freep(&o->stream_maps[i].linklabel);
175 av_freep(&o->stream_maps);
176 av_freep(&o->audio_channel_maps);
177 av_freep(&o->streamid_map);
178 av_freep(&o->attachments);
181 static void init_options(OptionsContext *o)
183 memset(o, 0, sizeof(*o));
185 o->stop_time = INT64_MAX;
186 o->mux_max_delay = 0.7;
187 o->start_time = AV_NOPTS_VALUE;
188 o->start_time_eof = AV_NOPTS_VALUE;
189 o->recording_time = INT64_MAX;
190 o->limit_filesize = UINT64_MAX;
191 o->chapters_input_file = INT_MAX;
192 o->accurate_seek = 1;
195 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
199 printf("Hardware acceleration methods:\n");
200 for (i = 0; hwaccels[i].name; i++) {
201 printf("%s\n", hwaccels[i].name);
207 /* return a copy of the input with the stream specifiers removed from the keys */
208 static AVDictionary *strip_specifiers(AVDictionary *dict)
210 AVDictionaryEntry *e = NULL;
211 AVDictionary *ret = NULL;
213 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
214 char *p = strchr(e->key, ':');
218 av_dict_set(&ret, e->key, e->value, 0);
225 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
227 static const AVOption opts[] = {
228 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
229 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
232 static const AVClass class = {
234 .item_name = av_default_item_name,
236 .version = LIBAVUTIL_VERSION_INT,
238 const AVClass *pclass = &class;
240 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
243 static int opt_sameq(void *optctx, const char *opt, const char *arg)
245 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
246 "If you are looking for an option to preserve the quality (which is not "
247 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
249 return AVERROR(EINVAL);
252 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
254 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
255 return opt_default(optctx, "channel", arg);
258 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
260 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
261 return opt_default(optctx, "standard", arg);
264 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
266 OptionsContext *o = optctx;
267 return parse_option(o, "codec:a", arg, options);
270 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
272 OptionsContext *o = optctx;
273 return parse_option(o, "codec:v", arg, options);
276 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
278 OptionsContext *o = optctx;
279 return parse_option(o, "codec:s", arg, options);
282 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
284 OptionsContext *o = optctx;
285 return parse_option(o, "codec:d", arg, options);
288 static int opt_map(void *optctx, const char *opt, const char *arg)
290 OptionsContext *o = optctx;
292 int i, negative = 0, file_idx;
293 int sync_file_idx = -1, sync_stream_idx = 0;
302 map = av_strdup(arg);
304 return AVERROR(ENOMEM);
306 /* parse sync stream first, just pick first matching stream */
307 if (sync = strchr(map, ',')) {
309 sync_file_idx = strtol(sync + 1, &sync, 0);
310 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
311 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
316 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
317 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
318 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
322 if (i == input_files[sync_file_idx]->nb_streams) {
323 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
324 "match any streams.\n", arg);
331 /* this mapping refers to lavfi output */
332 const char *c = map + 1;
333 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
334 m = &o->stream_maps[o->nb_stream_maps - 1];
335 m->linklabel = av_get_token(&c, "]");
337 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
341 if (allow_unused = strchr(map, '?'))
343 file_idx = strtol(map, &p, 0);
344 if (file_idx >= nb_input_files || file_idx < 0) {
345 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
349 /* disable some already defined maps */
350 for (i = 0; i < o->nb_stream_maps; i++) {
351 m = &o->stream_maps[i];
352 if (file_idx == m->file_index &&
353 check_stream_specifier(input_files[m->file_index]->ctx,
354 input_files[m->file_index]->ctx->streams[m->stream_index],
355 *p == ':' ? p + 1 : p) > 0)
359 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
360 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
361 *p == ':' ? p + 1 : p) <= 0)
363 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
364 m = &o->stream_maps[o->nb_stream_maps - 1];
366 m->file_index = file_idx;
369 if (sync_file_idx >= 0) {
370 m->sync_file_index = sync_file_idx;
371 m->sync_stream_index = sync_stream_idx;
373 m->sync_file_index = file_idx;
374 m->sync_stream_index = i;
381 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
383 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
384 "To ignore this, add a trailing '?' to the map.\n", arg);
393 static int opt_attach(void *optctx, const char *opt, const char *arg)
395 OptionsContext *o = optctx;
396 GROW_ARRAY(o->attachments, o->nb_attachments);
397 o->attachments[o->nb_attachments - 1] = arg;
401 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
403 OptionsContext *o = optctx;
409 mapchan = av_strdup(arg);
411 return AVERROR(ENOMEM);
413 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
414 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
416 /* muted channel syntax */
417 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
418 if ((n == 1 || n == 3) && m->channel_idx == -1) {
419 m->file_idx = m->stream_idx = -1;
421 m->ofile_idx = m->ostream_idx = -1;
427 n = sscanf(arg, "%d.%d.%d:%d.%d",
428 &m->file_idx, &m->stream_idx, &m->channel_idx,
429 &m->ofile_idx, &m->ostream_idx);
431 if (n != 3 && n != 5) {
432 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
433 "[file.stream.channel|-1][:syncfile:syncstream]\n");
437 if (n != 5) // only file.stream.channel specified
438 m->ofile_idx = m->ostream_idx = -1;
441 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
442 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
446 if (m->stream_idx < 0 ||
447 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
448 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
449 m->file_idx, m->stream_idx);
452 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
453 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
454 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
455 m->file_idx, m->stream_idx);
458 /* allow trailing ? to map_channel */
459 if (allow_unused = strchr(mapchan, '?'))
461 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
463 av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
464 m->file_idx, m->stream_idx, m->channel_idx);
466 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n"
467 "To ignore this, add a trailing '?' to the map_channel.\n",
468 m->file_idx, m->stream_idx, m->channel_idx);
477 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
479 av_free(sdp_filename);
480 sdp_filename = av_strdup(arg);
485 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
488 const char *prefix = "vaapi:";
491 tmp = av_asprintf("%s%s", prefix, arg);
493 return AVERROR(ENOMEM);
494 err = hw_device_init_from_string(tmp, &dev);
498 hw_device_ctx = av_buffer_ref(dev->device_ref);
500 return AVERROR(ENOMEM);
505 static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
507 if (!strcmp(arg, "list")) {
508 enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
509 printf("Supported hardware device types:\n");
510 while ((type = av_hwdevice_iterate_types(type)) !=
511 AV_HWDEVICE_TYPE_NONE)
512 printf("%s\n", av_hwdevice_get_type_name(type));
516 return hw_device_init_from_string(arg, NULL);
520 static int opt_filter_hw_device(void *optctx, const char *opt, const char *arg)
522 if (filter_hw_device) {
523 av_log(NULL, AV_LOG_ERROR, "Only one filter device can be used.\n");
524 return AVERROR(EINVAL);
526 filter_hw_device = hw_device_get_by_name(arg);
527 if (!filter_hw_device) {
528 av_log(NULL, AV_LOG_ERROR, "Invalid filter device %s.\n", arg);
529 return AVERROR(EINVAL);
535 * Parse a metadata specifier passed as 'arg' parameter.
536 * @param arg metadata string to parse
537 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
538 * @param index for type c/p, chapter/program index is written here
539 * @param stream_spec for type s, the stream specifier is written here
541 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
549 if (*(++arg) && *arg != ':') {
550 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
553 *stream_spec = *arg == ':' ? arg + 1 : "";
558 *index = strtol(++arg, NULL, 0);
561 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
568 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
570 AVDictionary **meta_in = NULL;
571 AVDictionary **meta_out = NULL;
573 char type_in, type_out;
574 const char *istream_spec = NULL, *ostream_spec = NULL;
575 int idx_in = 0, idx_out = 0;
577 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
578 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
581 if (type_out == 'g' || !*outspec)
582 o->metadata_global_manual = 1;
583 if (type_out == 's' || !*outspec)
584 o->metadata_streams_manual = 1;
585 if (type_out == 'c' || !*outspec)
586 o->metadata_chapters_manual = 1;
590 if (type_in == 'g' || type_out == 'g')
591 o->metadata_global_manual = 1;
592 if (type_in == 's' || type_out == 's')
593 o->metadata_streams_manual = 1;
594 if (type_in == 'c' || type_out == 'c')
595 o->metadata_chapters_manual = 1;
597 /* ic is NULL when just disabling automatic mappings */
601 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
602 if ((index) < 0 || (index) >= (nb_elems)) {\
603 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
608 #define SET_DICT(type, meta, context, index)\
611 meta = &context->metadata;\
614 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
615 meta = &context->chapters[index]->metadata;\
618 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
619 meta = &context->programs[index]->metadata;\
622 break; /* handled separately below */ \
623 default: av_assert0(0);\
626 SET_DICT(type_in, meta_in, ic, idx_in);
627 SET_DICT(type_out, meta_out, oc, idx_out);
629 /* for input streams choose first matching stream */
630 if (type_in == 's') {
631 for (i = 0; i < ic->nb_streams; i++) {
632 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
633 meta_in = &ic->streams[i]->metadata;
639 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
644 if (type_out == 's') {
645 for (i = 0; i < oc->nb_streams; i++) {
646 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
647 meta_out = &oc->streams[i]->metadata;
648 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
653 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
658 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
660 OptionsContext *o = optctx;
662 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
663 struct tm time = *gmtime((time_t*)&recording_timestamp);
664 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
666 parse_option(o, "metadata", buf, options);
668 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
669 "tag instead.\n", opt);
673 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
675 const AVCodecDescriptor *desc;
676 const char *codec_string = encoder ? "encoder" : "decoder";
680 avcodec_find_encoder_by_name(name) :
681 avcodec_find_decoder_by_name(name);
683 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
684 codec = encoder ? avcodec_find_encoder(desc->id) :
685 avcodec_find_decoder(desc->id);
687 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
688 codec_string, codec->name, desc->name);
692 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
695 if (codec->type != type) {
696 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
702 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
704 char *codec_name = NULL;
706 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
708 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
709 st->codecpar->codec_id = codec->id;
712 return avcodec_find_decoder(st->codecpar->codec_id);
715 /* Add all the streams from the given input file to the global
716 * list of input streams. */
717 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
721 for (i = 0; i < ic->nb_streams; i++) {
722 AVStream *st = ic->streams[i];
723 AVCodecParameters *par = st->codecpar;
724 InputStream *ist = av_mallocz(sizeof(*ist));
725 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
726 char *hwaccel_output_format = NULL;
727 char *codec_tag = NULL;
729 char *discard_str = NULL;
730 const AVClass *cc = avcodec_get_class();
731 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
736 GROW_ARRAY(input_streams, nb_input_streams);
737 input_streams[nb_input_streams - 1] = ist;
740 ist->file_index = nb_input_files;
742 st->discard = AVDISCARD_ALL;
744 ist->min_pts = INT64_MAX;
745 ist->max_pts = INT64_MIN;
748 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
751 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
753 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
755 uint32_t tag = strtol(codec_tag, &next, 0);
757 tag = AV_RL32(codec_tag);
758 st->codecpar->codec_tag = tag;
761 ist->dec = choose_decoder(o, ic, st);
762 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
764 ist->reinit_filters = -1;
765 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
767 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
768 ist->user_set_discard = AVDISCARD_NONE;
769 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
770 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
775 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
777 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
779 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
783 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
785 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
790 ist->dec_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
792 switch (par->codec_type) {
793 case AVMEDIA_TYPE_VIDEO:
795 ist->dec = avcodec_find_decoder(par->codec_id);
797 if (st->codec->lowres) {
798 ist->dec_ctx->lowres = st->codec->lowres;
799 ist->dec_ctx->width = st->codec->width;
800 ist->dec_ctx->height = st->codec->height;
801 ist->dec_ctx->coded_width = st->codec->coded_width;
802 ist->dec_ctx->coded_height = st->codec->coded_height;
806 // avformat_find_stream_info() doesn't set this for us anymore.
807 ist->dec_ctx->framerate = st->avg_frame_rate;
809 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
810 if (framerate && av_parse_video_rate(&ist->framerate,
812 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
817 ist->top_field_first = -1;
818 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
820 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
822 if (!strcmp(hwaccel, "none"))
823 ist->hwaccel_id = HWACCEL_NONE;
824 else if (!strcmp(hwaccel, "auto"))
825 ist->hwaccel_id = HWACCEL_AUTO;
828 for (i = 0; hwaccels[i].name; i++) {
829 if (!strcmp(hwaccels[i].name, hwaccel)) {
830 ist->hwaccel_id = hwaccels[i].id;
835 if (!ist->hwaccel_id) {
836 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
838 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
839 for (i = 0; hwaccels[i].name; i++)
840 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
841 av_log(NULL, AV_LOG_FATAL, "\n");
847 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
848 if (hwaccel_device) {
849 ist->hwaccel_device = av_strdup(hwaccel_device);
850 if (!ist->hwaccel_device)
854 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
855 hwaccel_output_format, ic, st);
856 if (hwaccel_output_format) {
857 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
858 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
859 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
860 "format: %s", hwaccel_output_format);
863 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
866 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
869 case AVMEDIA_TYPE_AUDIO:
870 ist->guess_layout_max = INT_MAX;
871 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
872 guess_input_channel_layout(ist);
874 case AVMEDIA_TYPE_DATA:
875 case AVMEDIA_TYPE_SUBTITLE: {
876 char *canvas_size = NULL;
878 ist->dec = avcodec_find_decoder(par->codec_id);
879 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
880 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
882 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
883 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
888 case AVMEDIA_TYPE_ATTACHMENT:
889 case AVMEDIA_TYPE_UNKNOWN:
895 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
897 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
903 static void assert_file_overwrite(const char *filename)
905 if (file_overwrite && no_file_overwrite) {
906 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
910 if (!file_overwrite) {
911 const char *proto_name = avio_find_protocol_name(filename);
912 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
913 if (stdin_interaction && !no_file_overwrite) {
914 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
917 signal(SIGINT, SIG_DFL);
919 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
925 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
932 static void dump_attachment(AVStream *st, const char *filename)
935 AVIOContext *out = NULL;
936 AVDictionaryEntry *e;
938 if (!st->codecpar->extradata_size) {
939 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
940 nb_input_files - 1, st->index);
943 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
946 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
947 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
951 assert_file_overwrite(filename);
953 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
954 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
959 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
964 static int open_input_file(OptionsContext *o, const char *filename)
968 AVInputFormat *file_iformat = NULL;
971 AVDictionary *unused_opts = NULL;
972 AVDictionaryEntry *e = NULL;
973 char * video_codec_name = NULL;
974 char * audio_codec_name = NULL;
975 char *subtitle_codec_name = NULL;
976 char * data_codec_name = NULL;
977 int scan_all_pmts_set = 0;
979 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
980 o->stop_time = INT64_MAX;
981 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
984 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
985 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
986 if (o->stop_time <= start_time) {
987 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
990 o->recording_time = o->stop_time - start_time;
995 if (!(file_iformat = av_find_input_format(o->format))) {
996 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1001 if (!strcmp(filename, "-"))
1004 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1005 strcmp(filename, "/dev/stdin");
1007 /* get default parameters from command line */
1008 ic = avformat_alloc_context();
1010 print_error(filename, AVERROR(ENOMEM));
1013 if (o->nb_audio_sample_rate) {
1014 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
1016 if (o->nb_audio_channels) {
1017 /* because we set audio_channels based on both the "ac" and
1018 * "channel_layout" options, we need to check that the specified
1019 * demuxer actually has the "channels" option before setting it */
1020 if (file_iformat && file_iformat->priv_class &&
1021 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
1022 AV_OPT_SEARCH_FAKE_OBJ)) {
1023 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
1026 if (o->nb_frame_rates) {
1027 /* set the format-level framerate option;
1028 * this is important for video grabbers, e.g. x11 */
1029 if (file_iformat && file_iformat->priv_class &&
1030 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
1031 AV_OPT_SEARCH_FAKE_OBJ)) {
1032 av_dict_set(&o->g->format_opts, "framerate",
1033 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
1036 if (o->nb_frame_sizes) {
1037 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
1039 if (o->nb_frame_pix_fmts)
1040 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
1042 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
1043 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
1044 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
1045 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
1047 if (video_codec_name)
1048 ic->video_codec = find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
1049 if (audio_codec_name)
1050 ic->audio_codec = find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
1051 if (subtitle_codec_name)
1052 ic->subtitle_codec = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
1053 if (data_codec_name)
1054 ic->data_codec = find_codec_or_die(data_codec_name , AVMEDIA_TYPE_DATA , 0);
1056 ic->video_codec_id = video_codec_name ? ic->video_codec->id : AV_CODEC_ID_NONE;
1057 ic->audio_codec_id = audio_codec_name ? ic->audio_codec->id : AV_CODEC_ID_NONE;
1058 ic->subtitle_codec_id = subtitle_codec_name ? ic->subtitle_codec->id : AV_CODEC_ID_NONE;
1059 ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1061 ic->flags |= AVFMT_FLAG_NONBLOCK;
1063 ic->flags |= AVFMT_FLAG_BITEXACT;
1064 ic->interrupt_callback = int_cb;
1066 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1067 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1068 scan_all_pmts_set = 1;
1070 /* open the input file with generic avformat function */
1071 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1073 print_error(filename, err);
1074 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1075 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1078 if (scan_all_pmts_set)
1079 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1080 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1081 assert_avoptions(o->g->format_opts);
1083 /* apply forced codec ids */
1084 for (i = 0; i < ic->nb_streams; i++)
1085 choose_decoder(o, ic, ic->streams[i]);
1087 if (find_stream_info) {
1088 AVDictionary **opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1089 int orig_nb_streams = ic->nb_streams;
1091 /* If not enough info to get the stream parameters, we decode the
1092 first frames to get it. (used in mpeg case for example) */
1093 ret = avformat_find_stream_info(ic, opts);
1095 for (i = 0; i < orig_nb_streams; i++)
1096 av_dict_free(&opts[i]);
1100 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1101 if (ic->nb_streams == 0) {
1102 avformat_close_input(&ic);
1108 if (o->start_time_eof != AV_NOPTS_VALUE) {
1109 if (ic->duration>0) {
1110 o->start_time = o->start_time_eof + ic->duration;
1112 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1114 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1115 /* add the stream start time */
1116 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1117 timestamp += ic->start_time;
1119 /* if seeking requested, we execute it */
1120 if (o->start_time != AV_NOPTS_VALUE) {
1121 int64_t seek_timestamp = timestamp;
1123 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1124 int dts_heuristic = 0;
1125 for (i=0; i<ic->nb_streams; i++) {
1126 const AVCodecParameters *par = ic->streams[i]->codecpar;
1127 if (par->video_delay)
1130 if (dts_heuristic) {
1131 seek_timestamp -= 3*AV_TIME_BASE / 23;
1134 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1136 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1137 filename, (double)timestamp / AV_TIME_BASE);
1141 /* update the current parameters so that they match the one of the input stream */
1142 add_input_streams(o, ic);
1144 /* dump the file content */
1145 av_dump_format(ic, nb_input_files, filename, 0);
1147 GROW_ARRAY(input_files, nb_input_files);
1148 f = av_mallocz(sizeof(*f));
1151 input_files[nb_input_files - 1] = f;
1154 f->ist_index = nb_input_streams - ic->nb_streams;
1155 f->start_time = o->start_time;
1156 f->recording_time = o->recording_time;
1157 f->input_ts_offset = o->input_ts_offset;
1158 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1159 f->nb_streams = ic->nb_streams;
1160 f->rate_emu = o->rate_emu;
1161 f->accurate_seek = o->accurate_seek;
1164 f->time_base = (AVRational){ 1, 1 };
1166 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1169 /* check if all codec options have been used */
1170 unused_opts = strip_specifiers(o->g->codec_opts);
1171 for (i = f->ist_index; i < nb_input_streams; i++) {
1173 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1174 AV_DICT_IGNORE_SUFFIX)))
1175 av_dict_set(&unused_opts, e->key, NULL, 0);
1179 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1180 const AVClass *class = avcodec_get_class();
1181 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1182 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1183 const AVClass *fclass = avformat_get_class();
1184 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1185 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1186 if (!option || foption)
1190 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1191 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1192 "input file #%d (%s) is not a decoding option.\n", e->key,
1193 option->help ? option->help : "", nb_input_files - 1,
1198 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1199 "input file #%d (%s) has not been used for any stream. The most "
1200 "likely reason is either wrong type (e.g. a video option with "
1201 "no video streams) or that it is a private option of some decoder "
1202 "which was not actually used for any stream.\n", e->key,
1203 option->help ? option->help : "", nb_input_files - 1, filename);
1205 av_dict_free(&unused_opts);
1207 for (i = 0; i < o->nb_dump_attachment; i++) {
1210 for (j = 0; j < ic->nb_streams; j++) {
1211 AVStream *st = ic->streams[j];
1213 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1214 dump_attachment(st, o->dump_attachment[i].u.str);
1218 input_stream_potentially_available = 1;
1223 static uint8_t *get_line(AVIOContext *s)
1229 if (avio_open_dyn_buf(&line) < 0) {
1230 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1234 while ((c = avio_r8(s)) && c != '\n')
1237 avio_close_dyn_buf(line, &buf);
1242 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1245 char filename[1000];
1246 const char *base[3] = { getenv("AVCONV_DATADIR"),
1251 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1255 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1256 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1257 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1260 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1261 i != 1 ? "" : "/.avconv", preset_name);
1262 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1268 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1270 enum AVMediaType type = ost->st->codecpar->codec_type;
1271 char *codec_name = NULL;
1273 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1274 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1276 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1277 NULL, ost->st->codecpar->codec_type);
1278 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1280 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1281 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1282 "probably disabled. Please choose an encoder manually.\n",
1283 ost->file_index, ost->index, s->oformat->name,
1284 avcodec_get_name(ost->st->codecpar->codec_id));
1285 return AVERROR_ENCODER_NOT_FOUND;
1287 } else if (!strcmp(codec_name, "copy"))
1288 ost->stream_copy = 1;
1290 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1291 ost->st->codecpar->codec_id = ost->enc->id;
1293 ost->encoding_needed = !ost->stream_copy;
1295 /* no encoding supported for other media types */
1296 ost->stream_copy = 1;
1297 ost->encoding_needed = 0;
1303 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1306 AVStream *st = avformat_new_stream(oc, NULL);
1307 int idx = oc->nb_streams - 1, ret = 0;
1308 const char *bsfs = NULL, *time_base = NULL;
1309 char *next, *codec_tag = NULL;
1314 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1318 if (oc->nb_streams - 1 < o->nb_streamid_map)
1319 st->id = o->streamid_map[oc->nb_streams - 1];
1321 GROW_ARRAY(output_streams, nb_output_streams);
1322 if (!(ost = av_mallocz(sizeof(*ost))))
1324 output_streams[nb_output_streams - 1] = ost;
1326 ost->file_index = nb_output_files - 1;
1329 st->codecpar->codec_type = type;
1331 ret = choose_encoder(o, oc, ost);
1333 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1334 "%d:%d\n", ost->file_index, ost->index);
1338 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1339 if (!ost->enc_ctx) {
1340 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1343 ost->enc_ctx->codec_type = type;
1345 ost->ref_par = avcodec_parameters_alloc();
1346 if (!ost->ref_par) {
1347 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1352 AVIOContext *s = NULL;
1353 char *buf = NULL, *arg = NULL, *preset = NULL;
1355 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1357 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1358 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1361 if (!buf[0] || buf[0] == '#') {
1365 if (!(arg = strchr(buf, '='))) {
1366 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1370 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1372 } while (!s->eof_reached);
1376 av_log(NULL, AV_LOG_FATAL,
1377 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1378 preset, ost->file_index, ost->index);
1382 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1387 ost->enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
1389 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1392 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1393 q.num <= 0 || q.den <= 0) {
1394 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1400 MATCH_PER_STREAM_OPT(enc_time_bases, str, time_base, oc, st);
1403 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1405 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1408 ost->enc_timebase = q;
1411 ost->max_frames = INT64_MAX;
1412 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1413 for (i = 0; i<o->nb_max_frames; i++) {
1414 char *p = o->max_frames[i].specifier;
1415 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1416 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1421 ost->copy_prior_start = -1;
1422 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1424 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1425 while (bsfs && *bsfs) {
1426 const AVBitStreamFilter *filter;
1427 char *bsf, *bsf_options_str, *bsf_name;
1429 bsf = av_get_token(&bsfs, ",");
1432 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1436 filter = av_bsf_get_by_name(bsf_name);
1438 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1442 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1443 ost->nb_bitstream_filters + 1,
1444 sizeof(*ost->bsf_ctx));
1448 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1450 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1454 ost->nb_bitstream_filters++;
1456 if (bsf_options_str && filter->priv_class) {
1457 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1458 const char * shorthand[2] = {NULL};
1461 shorthand[0] = opt->name;
1463 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1465 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1475 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1477 uint32_t tag = strtol(codec_tag, &next, 0);
1479 tag = AV_RL32(codec_tag);
1480 ost->st->codecpar->codec_tag =
1481 ost->enc_ctx->codec_tag = tag;
1484 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1486 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1487 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1490 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1491 ost->disposition = av_strdup(ost->disposition);
1493 ost->max_muxing_queue_size = 128;
1494 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1495 ost->max_muxing_queue_size *= sizeof(AVPacket);
1497 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1498 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1500 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1502 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1503 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1504 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1506 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1508 ost->source_index = source_index;
1509 if (source_index >= 0) {
1510 ost->sync_ist = input_streams[source_index];
1511 input_streams[source_index]->discard = 0;
1512 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1514 ost->last_mux_dts = AV_NOPTS_VALUE;
1516 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1517 if (!ost->muxing_queue)
1523 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1526 const char *p = str;
1533 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1540 /* read file contents into a string */
1541 static uint8_t *read_file(const char *filename)
1543 AVIOContext *pb = NULL;
1544 AVIOContext *dyn_buf = NULL;
1545 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1546 uint8_t buf[1024], *str;
1549 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1553 ret = avio_open_dyn_buf(&dyn_buf);
1558 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1559 avio_write(dyn_buf, buf, ret);
1560 avio_w8(dyn_buf, 0);
1563 ret = avio_close_dyn_buf(dyn_buf, &str);
1569 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1572 AVStream *st = ost->st;
1574 if (ost->filters_script && ost->filters) {
1575 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1576 "output stream #%d:%d.\n", nb_output_files, st->index);
1580 if (ost->filters_script)
1581 return read_file(ost->filters_script);
1582 else if (ost->filters)
1583 return av_strdup(ost->filters);
1585 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1589 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1590 const OutputStream *ost, enum AVMediaType type)
1592 if (ost->filters_script || ost->filters) {
1593 av_log(NULL, AV_LOG_ERROR,
1594 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1595 "Filtering and streamcopy cannot be used together.\n",
1596 ost->filters ? "Filtergraph" : "Filtergraph script",
1597 ost->filters ? ost->filters : ost->filters_script,
1598 av_get_media_type_string(type), ost->file_index, ost->index);
1603 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1607 AVCodecContext *video_enc;
1608 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1610 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1612 video_enc = ost->enc_ctx;
1614 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1615 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1616 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1619 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1620 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1622 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1623 if (frame_aspect_ratio) {
1625 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1626 q.num <= 0 || q.den <= 0) {
1627 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1630 ost->frame_aspect_ratio = q;
1633 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1634 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1636 if (!ost->stream_copy) {
1637 const char *p = NULL;
1638 char *frame_size = NULL;
1639 char *frame_pix_fmt = NULL;
1640 char *intra_matrix = NULL, *inter_matrix = NULL;
1641 char *chroma_intra_matrix = NULL;
1645 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1646 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1647 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1651 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1652 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1653 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1654 ost->keep_pix_fmt = 1;
1655 if (!*++frame_pix_fmt)
1656 frame_pix_fmt = NULL;
1658 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1659 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1662 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1665 video_enc->gop_size = 0;
1666 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1668 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1669 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1672 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1674 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1675 if (chroma_intra_matrix) {
1676 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1678 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1681 video_enc->chroma_intra_matrix = p;
1682 parse_matrix_coeffs(p, chroma_intra_matrix);
1684 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1686 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1687 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1690 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1693 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1694 for (i = 0; p; i++) {
1696 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1698 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1701 video_enc->rc_override =
1702 av_realloc_array(video_enc->rc_override,
1703 i + 1, sizeof(RcOverride));
1704 if (!video_enc->rc_override) {
1705 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1708 video_enc->rc_override[i].start_frame = start;
1709 video_enc->rc_override[i].end_frame = end;
1711 video_enc->rc_override[i].qscale = q;
1712 video_enc->rc_override[i].quality_factor = 1.0;
1715 video_enc->rc_override[i].qscale = 0;
1716 video_enc->rc_override[i].quality_factor = -q/100.0;
1721 video_enc->rc_override_count = i;
1724 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1727 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1730 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1731 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1734 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1735 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1739 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1740 if (ost->logfile_prefix &&
1741 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1745 char logfilename[1024];
1748 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1749 ost->logfile_prefix ? ost->logfile_prefix :
1750 DEFAULT_PASS_LOGFILENAME_PREFIX,
1752 if (!strcmp(ost->enc->name, "libx264")) {
1753 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1755 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1756 char *logbuffer = read_file(logfilename);
1759 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1763 video_enc->stats_in = logbuffer;
1765 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1766 f = av_fopen_utf8(logfilename, "wb");
1768 av_log(NULL, AV_LOG_FATAL,
1769 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1770 logfilename, strerror(errno));
1778 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1779 if (ost->forced_keyframes)
1780 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1782 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1784 ost->top_field_first = -1;
1785 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1788 ost->avfilter = get_ost_filters(o, oc, ost);
1792 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1795 if (ost->stream_copy)
1796 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1801 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1806 AVCodecContext *audio_enc;
1808 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1811 audio_enc = ost->enc_ctx;
1812 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1814 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1815 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1817 if (!ost->stream_copy) {
1818 char *sample_fmt = NULL;
1820 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1822 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1824 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1825 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1829 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1831 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1832 ost->apad = av_strdup(ost->apad);
1834 ost->avfilter = get_ost_filters(o, oc, ost);
1838 /* check for channel mapping for this audio stream */
1839 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1840 AudioChannelMap *map = &o->audio_channel_maps[n];
1841 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1842 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1845 if (map->channel_idx == -1) {
1847 } else if (ost->source_index < 0) {
1848 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1849 ost->file_index, ost->st->index);
1852 ist = input_streams[ost->source_index];
1855 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1856 if (av_reallocp_array(&ost->audio_channels_map,
1857 ost->audio_channels_mapped + 1,
1858 sizeof(*ost->audio_channels_map)
1862 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1868 if (ost->stream_copy)
1869 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1874 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1878 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1879 if (!ost->stream_copy) {
1880 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1887 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1891 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1892 if (!ost->stream_copy) {
1893 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1900 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1902 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1903 ost->stream_copy = 1;
1908 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1912 AVCodecContext *subtitle_enc;
1914 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1916 subtitle_enc = ost->enc_ctx;
1918 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1920 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1922 if (!ost->stream_copy) {
1923 char *frame_size = NULL;
1925 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1926 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1927 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1935 /* arg format is "output-stream-index:streamid-value". */
1936 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1938 OptionsContext *o = optctx;
1943 av_strlcpy(idx_str, arg, sizeof(idx_str));
1944 p = strchr(idx_str, ':');
1946 av_log(NULL, AV_LOG_FATAL,
1947 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1952 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1953 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1954 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1958 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1960 AVFormatContext *is = ifile->ctx;
1961 AVFormatContext *os = ofile->ctx;
1965 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1967 return AVERROR(ENOMEM);
1970 for (i = 0; i < is->nb_chapters; i++) {
1971 AVChapter *in_ch = is->chapters[i], *out_ch;
1972 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1973 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1974 AV_TIME_BASE_Q, in_ch->time_base);
1975 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1976 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1979 if (in_ch->end < ts_off)
1981 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1984 out_ch = av_mallocz(sizeof(AVChapter));
1986 return AVERROR(ENOMEM);
1988 out_ch->id = in_ch->id;
1989 out_ch->time_base = in_ch->time_base;
1990 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1991 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1994 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1996 os->chapters[os->nb_chapters++] = out_ch;
2001 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
2004 AVFormatContext *ic = avformat_alloc_context();
2006 ic->interrupt_callback = int_cb;
2007 err = avformat_open_input(&ic, filename, NULL, NULL);
2010 /* copy stream format */
2011 for(i=0;i<ic->nb_streams;i++) {
2015 const char *enc_config;
2017 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
2019 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
2020 return AVERROR(EINVAL);
2022 if (codec->type == AVMEDIA_TYPE_AUDIO)
2023 opt_audio_codec(o, "c:a", codec->name);
2024 else if (codec->type == AVMEDIA_TYPE_VIDEO)
2025 opt_video_codec(o, "c:v", codec->name);
2026 ost = new_output_stream(o, s, codec->type, -1);
2029 avcodec_get_context_defaults3(st->codec, codec);
2030 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
2032 AVDictionary *opts = NULL;
2033 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
2034 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
2035 av_dict_free(&opts);
2038 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
2039 choose_sample_fmt(st, codec);
2040 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
2041 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
2042 avcodec_copy_context(ost->enc_ctx, st->codec);
2044 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
2047 avformat_close_input(&ic);
2051 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
2052 AVFormatContext *oc)
2056 switch (ofilter->type) {
2057 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
2058 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
2060 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
2065 ost->source_index = -1;
2066 ost->filter = ofilter;
2069 ofilter->format = -1;
2071 if (ost->stream_copy) {
2072 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
2073 "which is fed from a complex filtergraph. Filtering and streamcopy "
2074 "cannot be used together.\n", ost->file_index, ost->index);
2078 if (ost->avfilter && (ost->filters || ost->filters_script)) {
2079 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
2080 av_log(NULL, AV_LOG_ERROR,
2081 "%s '%s' was specified through the %s option "
2082 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2083 "%s and -filter_complex cannot be used together for the same stream.\n",
2084 ost->filters ? "Filtergraph" : "Filtergraph script",
2085 ost->filters ? ost->filters : ost->filters_script,
2086 opt, ost->file_index, ost->index, opt);
2090 avfilter_inout_free(&ofilter->out_tmp);
2093 static int init_complex_filters(void)
2097 for (i = 0; i < nb_filtergraphs; i++) {
2098 ret = init_complex_filtergraph(filtergraphs[i]);
2105 static int open_output_file(OptionsContext *o, const char *filename)
2107 AVFormatContext *oc;
2109 AVOutputFormat *file_oformat;
2113 AVDictionary *unused_opts = NULL;
2114 AVDictionaryEntry *e = NULL;
2115 int format_flags = 0;
2117 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2118 o->stop_time = INT64_MAX;
2119 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2122 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2123 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2124 if (o->stop_time <= start_time) {
2125 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2128 o->recording_time = o->stop_time - start_time;
2132 GROW_ARRAY(output_files, nb_output_files);
2133 of = av_mallocz(sizeof(*of));
2136 output_files[nb_output_files - 1] = of;
2138 of->ost_index = nb_output_streams;
2139 of->recording_time = o->recording_time;
2140 of->start_time = o->start_time;
2141 of->limit_filesize = o->limit_filesize;
2142 of->shortest = o->shortest;
2143 av_dict_copy(&of->opts, o->g->format_opts, 0);
2145 if (!strcmp(filename, "-"))
2148 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2150 print_error(filename, err);
2155 if (o->recording_time != INT64_MAX)
2156 oc->duration = o->recording_time;
2158 file_oformat= oc->oformat;
2159 oc->interrupt_callback = int_cb;
2161 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2163 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2164 av_opt_eval_flags(oc, o, e->value, &format_flags);
2167 format_flags |= AVFMT_FLAG_BITEXACT;
2168 oc->flags |= AVFMT_FLAG_BITEXACT;
2171 /* create streams for all unlabeled output pads */
2172 for (i = 0; i < nb_filtergraphs; i++) {
2173 FilterGraph *fg = filtergraphs[i];
2174 for (j = 0; j < fg->nb_outputs; j++) {
2175 OutputFilter *ofilter = fg->outputs[j];
2177 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2180 switch (ofilter->type) {
2181 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2182 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2183 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2185 init_output_filter(ofilter, o, oc);
2189 /* ffserver seeking with date=... needs a date reference */
2190 if (!strcmp(file_oformat->name, "ffm") &&
2191 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2192 av_strstart(filename, "http:", NULL)) {
2193 int err = parse_option(o, "metadata", "creation_time=now", options);
2195 print_error(filename, err);
2200 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2201 av_strstart(filename, "http:", NULL)) {
2203 /* special case for files sent to ffserver: we get the stream
2204 parameters from ffserver */
2205 int err = read_ffserver_streams(o, oc, filename);
2207 print_error(filename, err);
2210 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2211 ost = output_streams[j];
2212 for (i = 0; i < nb_input_streams; i++) {
2213 ist = input_streams[i];
2214 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2216 ost->source_index= i;
2217 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2218 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2220 ist->st->discard = ist->user_set_discard;
2225 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));
2229 } else if (!o->nb_stream_maps) {
2230 char *subtitle_codec_name = NULL;
2231 /* pick the "best" stream of each type */
2233 /* video: highest resolution */
2234 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2235 int area = 0, idx = -1;
2236 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2237 for (i = 0; i < nb_input_streams; i++) {
2239 ist = input_streams[i];
2240 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2241 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2243 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2245 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2252 new_video_stream(o, oc, idx);
2255 /* audio: most channels */
2256 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2257 int best_score = 0, idx = -1;
2258 for (i = 0; i < nb_input_streams; i++) {
2260 ist = input_streams[i];
2261 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2262 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2263 score > best_score) {
2269 new_audio_stream(o, oc, idx);
2272 /* subtitles: pick first */
2273 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2274 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2275 for (i = 0; i < nb_input_streams; i++)
2276 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2277 AVCodecDescriptor const *input_descriptor =
2278 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2279 AVCodecDescriptor const *output_descriptor = NULL;
2280 AVCodec const *output_codec =
2281 avcodec_find_encoder(oc->oformat->subtitle_codec);
2282 int input_props = 0, output_props = 0;
2284 output_descriptor = avcodec_descriptor_get(output_codec->id);
2285 if (input_descriptor)
2286 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2287 if (output_descriptor)
2288 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2289 if (subtitle_codec_name ||
2290 input_props & output_props ||
2291 // Map dvb teletext which has neither property to any output subtitle encoder
2292 input_descriptor && output_descriptor &&
2293 (!input_descriptor->props ||
2294 !output_descriptor->props)) {
2295 new_subtitle_stream(o, oc, i);
2300 /* Data only if codec id match */
2301 if (!o->data_disable ) {
2302 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2303 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2304 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2305 && input_streams[i]->st->codecpar->codec_id == codec_id )
2306 new_data_stream(o, oc, i);
2310 for (i = 0; i < o->nb_stream_maps; i++) {
2311 StreamMap *map = &o->stream_maps[i];
2316 if (map->linklabel) {
2318 OutputFilter *ofilter = NULL;
2321 for (j = 0; j < nb_filtergraphs; j++) {
2322 fg = filtergraphs[j];
2323 for (k = 0; k < fg->nb_outputs; k++) {
2324 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2325 if (out && !strcmp(out->name, map->linklabel)) {
2326 ofilter = fg->outputs[k];
2333 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2334 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2337 init_output_filter(ofilter, o, oc);
2339 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2341 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2342 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2344 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2346 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2348 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2352 switch (ist->st->codecpar->codec_type) {
2353 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2354 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2355 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2356 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2357 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2358 case AVMEDIA_TYPE_UNKNOWN:
2359 if (copy_unknown_streams) {
2360 ost = new_unknown_stream (o, oc, src_idx);
2364 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2365 "Cannot map stream #%d:%d - unsupported type.\n",
2366 map->file_index, map->stream_index);
2367 if (!ignore_unknown_streams) {
2368 av_log(NULL, AV_LOG_FATAL,
2369 "If you want unsupported types ignored instead "
2370 "of failing, please use the -ignore_unknown option\n"
2371 "If you want them copied, please use -copy_unknown\n");
2376 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2377 + map->sync_stream_index];
2382 /* handle attached files */
2383 for (i = 0; i < o->nb_attachments; i++) {
2385 uint8_t *attachment;
2389 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2390 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2394 if ((len = avio_size(pb)) <= 0) {
2395 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2399 if (!(attachment = av_malloc(len))) {
2400 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2404 avio_read(pb, attachment, len);
2406 ost = new_attachment_stream(o, oc, -1);
2407 ost->stream_copy = 0;
2408 ost->attachment_filename = o->attachments[i];
2409 ost->st->codecpar->extradata = attachment;
2410 ost->st->codecpar->extradata_size = len;
2412 p = strrchr(o->attachments[i], '/');
2413 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2417 #if FF_API_LAVF_AVCTX
2418 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2419 AVDictionaryEntry *e;
2420 ost = output_streams[i];
2422 if ((ost->stream_copy || ost->attachment_filename)
2423 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2424 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2425 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2430 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2431 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2432 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2436 /* check if all codec options have been used */
2437 unused_opts = strip_specifiers(o->g->codec_opts);
2438 for (i = of->ost_index; i < nb_output_streams; i++) {
2440 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2441 AV_DICT_IGNORE_SUFFIX)))
2442 av_dict_set(&unused_opts, e->key, NULL, 0);
2446 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2447 const AVClass *class = avcodec_get_class();
2448 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2449 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2450 const AVClass *fclass = avformat_get_class();
2451 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2452 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2453 if (!option || foption)
2457 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2458 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2459 "output file #%d (%s) is not an encoding option.\n", e->key,
2460 option->help ? option->help : "", nb_output_files - 1,
2465 // gop_timecode is injected by generic code but not always used
2466 if (!strcmp(e->key, "gop_timecode"))
2469 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2470 "output file #%d (%s) has not been used for any stream. The most "
2471 "likely reason is either wrong type (e.g. a video option with "
2472 "no video streams) or that it is a private option of some encoder "
2473 "which was not actually used for any stream.\n", e->key,
2474 option->help ? option->help : "", nb_output_files - 1, filename);
2476 av_dict_free(&unused_opts);
2478 /* set the decoding_needed flags and create simple filtergraphs */
2479 for (i = of->ost_index; i < nb_output_streams; i++) {
2480 OutputStream *ost = output_streams[i];
2482 if (ost->encoding_needed && ost->source_index >= 0) {
2483 InputStream *ist = input_streams[ost->source_index];
2484 ist->decoding_needed |= DECODING_FOR_OST;
2486 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2487 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2488 err = init_simple_filtergraph(ist, ost);
2490 av_log(NULL, AV_LOG_ERROR,
2491 "Error initializing a simple filtergraph between streams "
2492 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2493 nb_output_files - 1, ost->st->index);
2499 /* set the filter output constraints */
2501 OutputFilter *f = ost->filter;
2503 switch (ost->enc_ctx->codec_type) {
2504 case AVMEDIA_TYPE_VIDEO:
2505 f->frame_rate = ost->frame_rate;
2506 f->width = ost->enc_ctx->width;
2507 f->height = ost->enc_ctx->height;
2508 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2509 f->format = ost->enc_ctx->pix_fmt;
2510 } else if (ost->enc->pix_fmts) {
2512 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2514 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2517 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2520 case AVMEDIA_TYPE_AUDIO:
2521 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2522 f->format = ost->enc_ctx->sample_fmt;
2523 } else if (ost->enc->sample_fmts) {
2525 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2527 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2530 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2532 if (ost->enc_ctx->sample_rate) {
2533 f->sample_rate = ost->enc_ctx->sample_rate;
2534 } else if (ost->enc->supported_samplerates) {
2536 while (ost->enc->supported_samplerates[count])
2538 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2539 if (!f->sample_rates)
2541 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2542 (count + 1) * sizeof(*f->sample_rates));
2544 if (ost->enc_ctx->channels) {
2545 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2546 } else if (ost->enc->channel_layouts) {
2548 while (ost->enc->channel_layouts[count])
2550 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2551 if (!f->channel_layouts)
2553 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2554 (count + 1) * sizeof(*f->channel_layouts));
2561 /* check filename in case of an image number is expected */
2562 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2563 if (!av_filename_number_test(oc->filename)) {
2564 print_error(oc->filename, AVERROR(EINVAL));
2569 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2570 av_log(NULL, AV_LOG_ERROR,
2571 "No input streams but output needs an input stream\n");
2575 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2576 /* test if it already exists to avoid losing precious files */
2577 assert_file_overwrite(filename);
2580 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2581 &oc->interrupt_callback,
2583 print_error(filename, err);
2586 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2587 assert_file_overwrite(filename);
2589 if (o->mux_preload) {
2590 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2592 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2595 for (i = 0; i < o->nb_metadata_map; i++) {
2597 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2599 if (in_file_index >= nb_input_files) {
2600 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2603 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2604 in_file_index >= 0 ?
2605 input_files[in_file_index]->ctx : NULL, o);
2609 if (o->chapters_input_file >= nb_input_files) {
2610 if (o->chapters_input_file == INT_MAX) {
2611 /* copy chapters from the first input file that has them*/
2612 o->chapters_input_file = -1;
2613 for (i = 0; i < nb_input_files; i++)
2614 if (input_files[i]->ctx->nb_chapters) {
2615 o->chapters_input_file = i;
2619 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2620 o->chapters_input_file);
2624 if (o->chapters_input_file >= 0)
2625 copy_chapters(input_files[o->chapters_input_file], of,
2626 !o->metadata_chapters_manual);
2628 /* copy global metadata by default */
2629 if (!o->metadata_global_manual && nb_input_files){
2630 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2631 AV_DICT_DONT_OVERWRITE);
2632 if(o->recording_time != INT64_MAX)
2633 av_dict_set(&oc->metadata, "duration", NULL, 0);
2634 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2636 if (!o->metadata_streams_manual)
2637 for (i = of->ost_index; i < nb_output_streams; i++) {
2639 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2641 ist = input_streams[output_streams[i]->source_index];
2642 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2643 if (!output_streams[i]->stream_copy) {
2644 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2648 /* process manually set programs */
2649 for (i = 0; i < o->nb_program; i++) {
2650 const char *p = o->program[i].u.str;
2655 const char *p2 = av_get_token(&p, ":");
2656 const char *to_dealloc = p2;
2663 key = av_get_token(&p2, "=");
2665 av_freep(&to_dealloc);
2671 if (!strcmp(key, "program_num"))
2672 progid = strtol(p2, NULL, 0);
2673 av_freep(&to_dealloc);
2677 program = av_new_program(oc, progid);
2679 p = o->program[i].u.str;
2681 const char *p2 = av_get_token(&p, ":");
2682 const char *to_dealloc = p2;
2688 key = av_get_token(&p2, "=");
2690 av_log(NULL, AV_LOG_FATAL,
2691 "No '=' character in program string %s.\n",
2699 if (!strcmp(key, "title")) {
2700 av_dict_set(&program->metadata, "title", p2, 0);
2701 } else if (!strcmp(key, "program_num")) {
2702 } else if (!strcmp(key, "st")) {
2703 int st_num = strtol(p2, NULL, 0);
2704 av_program_add_stream_index(oc, progid, st_num);
2706 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2709 av_freep(&to_dealloc);
2714 /* process manually set metadata */
2715 for (i = 0; i < o->nb_metadata; i++) {
2718 const char *stream_spec;
2719 int index = 0, j, ret = 0;
2721 val = strchr(o->metadata[i].u.str, '=');
2723 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2724 o->metadata[i].u.str);
2729 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2731 for (j = 0; j < oc->nb_streams; j++) {
2732 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2733 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2734 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2736 double theta = av_strtod(val, &tail);
2738 ost->rotate_overridden = 1;
2739 ost->rotate_override_value = theta;
2742 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2754 if (index < 0 || index >= oc->nb_chapters) {
2755 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2758 m = &oc->chapters[index]->metadata;
2761 if (index < 0 || index >= oc->nb_programs) {
2762 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2765 m = &oc->programs[index]->metadata;
2768 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2771 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2778 static int opt_target(void *optctx, const char *opt, const char *arg)
2780 OptionsContext *o = optctx;
2781 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2782 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2784 if (!strncmp(arg, "pal-", 4)) {
2787 } else if (!strncmp(arg, "ntsc-", 5)) {
2790 } else if (!strncmp(arg, "film-", 5)) {
2794 /* Try to determine PAL/NTSC by peeking in the input files */
2795 if (nb_input_files) {
2797 for (j = 0; j < nb_input_files; j++) {
2798 for (i = 0; i < input_files[j]->nb_streams; i++) {
2799 AVStream *st = input_files[j]->ctx->streams[i];
2800 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2802 fr = st->time_base.den * 1000 / st->time_base.num;
2806 } else if ((fr == 29970) || (fr == 23976)) {
2811 if (norm != UNKNOWN)
2815 if (norm != UNKNOWN)
2816 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2819 if (norm == UNKNOWN) {
2820 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2821 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2822 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2826 if (!strcmp(arg, "vcd")) {
2827 opt_video_codec(o, "c:v", "mpeg1video");
2828 opt_audio_codec(o, "c:a", "mp2");
2829 parse_option(o, "f", "vcd", options);
2831 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2832 parse_option(o, "r", frame_rates[norm], options);
2833 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2835 opt_default(NULL, "b:v", "1150000");
2836 opt_default(NULL, "maxrate:v", "1150000");
2837 opt_default(NULL, "minrate:v", "1150000");
2838 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2840 opt_default(NULL, "b:a", "224000");
2841 parse_option(o, "ar", "44100", options);
2842 parse_option(o, "ac", "2", options);
2844 opt_default(NULL, "packetsize", "2324");
2845 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2847 /* We have to offset the PTS, so that it is consistent with the SCR.
2848 SCR starts at 36000, but the first two packs contain only padding
2849 and the first pack from the other stream, respectively, may also have
2850 been written before.
2851 So the real data starts at SCR 36000+3*1200. */
2852 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2853 } else if (!strcmp(arg, "svcd")) {
2855 opt_video_codec(o, "c:v", "mpeg2video");
2856 opt_audio_codec(o, "c:a", "mp2");
2857 parse_option(o, "f", "svcd", options);
2859 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2860 parse_option(o, "r", frame_rates[norm], options);
2861 parse_option(o, "pix_fmt", "yuv420p", options);
2862 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2864 opt_default(NULL, "b:v", "2040000");
2865 opt_default(NULL, "maxrate:v", "2516000");
2866 opt_default(NULL, "minrate:v", "0"); // 1145000;
2867 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2868 opt_default(NULL, "scan_offset", "1");
2870 opt_default(NULL, "b:a", "224000");
2871 parse_option(o, "ar", "44100", options);
2873 opt_default(NULL, "packetsize", "2324");
2875 } else if (!strcmp(arg, "dvd")) {
2877 opt_video_codec(o, "c:v", "mpeg2video");
2878 opt_audio_codec(o, "c:a", "ac3");
2879 parse_option(o, "f", "dvd", options);
2881 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2882 parse_option(o, "r", frame_rates[norm], options);
2883 parse_option(o, "pix_fmt", "yuv420p", options);
2884 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2886 opt_default(NULL, "b:v", "6000000");
2887 opt_default(NULL, "maxrate:v", "9000000");
2888 opt_default(NULL, "minrate:v", "0"); // 1500000;
2889 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2891 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2892 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2894 opt_default(NULL, "b:a", "448000");
2895 parse_option(o, "ar", "48000", options);
2897 } else if (!strncmp(arg, "dv", 2)) {
2899 parse_option(o, "f", "dv", options);
2901 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2902 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2903 norm == PAL ? "yuv420p" : "yuv411p", options);
2904 parse_option(o, "r", frame_rates[norm], options);
2906 parse_option(o, "ar", "48000", options);
2907 parse_option(o, "ac", "2", options);
2910 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2911 return AVERROR(EINVAL);
2914 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2915 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2920 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2922 av_free (vstats_filename);
2923 vstats_filename = av_strdup (arg);
2927 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2930 time_t today2 = time(NULL);
2931 struct tm *today = localtime(&today2);
2933 if (!today) { // maybe tomorrow
2934 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2938 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2940 return opt_vstats_file(NULL, opt, filename);
2943 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2945 OptionsContext *o = optctx;
2946 return parse_option(o, "frames:v", arg, options);
2949 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2951 OptionsContext *o = optctx;
2952 return parse_option(o, "frames:a", arg, options);
2955 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2957 OptionsContext *o = optctx;
2958 return parse_option(o, "frames:d", arg, options);
2961 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2964 AVDictionary *cbak = codec_opts;
2965 AVDictionary *fbak = format_opts;
2969 ret = opt_default(NULL, opt, arg);
2971 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2972 av_dict_copy(&o->g->format_opts, format_opts, 0);
2973 av_dict_free(&codec_opts);
2974 av_dict_free(&format_opts);
2981 static int opt_preset(void *optctx, const char *opt, const char *arg)
2983 OptionsContext *o = optctx;
2985 char filename[1000], line[1000], tmp_line[1000];
2986 const char *codec_name = NULL;
2990 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2992 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2993 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2994 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2996 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
3000 while (fgets(line, sizeof(line), f)) {
3001 char *key = tmp_line, *value, *endptr;
3003 if (strcspn(line, "#\n\r") == 0)
3005 av_strlcpy(tmp_line, line, sizeof(tmp_line));
3006 if (!av_strtok(key, "=", &value) ||
3007 !av_strtok(value, "\r\n", &endptr)) {
3008 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3011 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3013 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
3014 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
3015 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3016 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
3017 else if (opt_default_new(o, key, value) < 0) {
3018 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3019 filename, line, key, value);
3029 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3031 OptionsContext *o = optctx;
3032 char *s = av_asprintf("%s:%c", opt + 1, *opt);
3033 int ret = parse_option(o, s, arg, options);
3038 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3040 OptionsContext *o = optctx;
3042 if(!strcmp(opt, "ab")){
3043 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3045 } else if(!strcmp(opt, "b")){
3046 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3047 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3050 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3054 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3056 OptionsContext *o = optctx;
3059 if(!strcmp(opt, "qscale")){
3060 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3061 return parse_option(o, "q:v", arg, options);
3063 s = av_asprintf("q%s", opt + 6);
3064 ret = parse_option(o, s, arg, options);
3069 static int opt_profile(void *optctx, const char *opt, const char *arg)
3071 OptionsContext *o = optctx;
3072 if(!strcmp(opt, "profile")){
3073 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3074 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3077 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3081 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3083 OptionsContext *o = optctx;
3084 return parse_option(o, "filter:v", arg, options);
3087 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3089 OptionsContext *o = optctx;
3090 return parse_option(o, "filter:a", arg, options);
3093 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3095 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3096 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3097 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3098 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3100 if (video_sync_method == VSYNC_AUTO)
3101 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3105 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3107 OptionsContext *o = optctx;
3108 char *tcr = av_asprintf("timecode=%s", arg);
3109 int ret = parse_option(o, "metadata:g", tcr, options);
3111 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3116 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3118 OptionsContext *o = optctx;
3119 char layout_str[32];
3122 int ret, channels, ac_str_size;
3125 layout = av_get_channel_layout(arg);
3127 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3128 return AVERROR(EINVAL);
3130 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3131 ret = opt_default_new(o, opt, layout_str);
3135 /* set 'ac' option based on channel layout */
3136 channels = av_get_channel_layout_nb_channels(layout);
3137 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3138 stream_str = strchr(opt, ':');
3139 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3140 ac_str = av_mallocz(ac_str_size);
3142 return AVERROR(ENOMEM);
3143 av_strlcpy(ac_str, "ac", 3);
3145 av_strlcat(ac_str, stream_str, ac_str_size);
3146 ret = parse_option(o, ac_str, layout_str, options);
3152 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3154 OptionsContext *o = optctx;
3155 return parse_option(o, "q:a", arg, options);
3158 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3160 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3161 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3162 return AVERROR(ENOMEM);
3163 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3164 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3165 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3166 return AVERROR(ENOMEM);
3168 input_stream_potentially_available = 1;
3173 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3175 uint8_t *graph_desc = read_file(arg);
3177 return AVERROR(EINVAL);
3179 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3180 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3181 return AVERROR(ENOMEM);
3182 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3183 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3185 input_stream_potentially_available = 1;
3190 void show_help_default(const char *opt, const char *arg)
3192 /* per-file options have at least one of those set */
3193 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3194 int show_advanced = 0, show_avoptions = 0;
3197 if (!strcmp(opt, "long"))
3199 else if (!strcmp(opt, "full"))
3200 show_advanced = show_avoptions = 1;
3202 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3207 printf("Getting help:\n"
3208 " -h -- print basic options\n"
3209 " -h long -- print more options\n"
3210 " -h full -- print all options (including all format and codec specific options, very long)\n"
3211 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3212 " See man %s for detailed description of the options.\n"
3213 "\n", program_name);
3215 show_help_options(options, "Print help / information / capabilities:",
3218 show_help_options(options, "Global options (affect whole program "
3219 "instead of just one file:",
3220 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3222 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3223 per_file | OPT_EXIT, 0);
3225 show_help_options(options, "Per-file main options:", 0,
3226 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3227 OPT_EXIT, per_file);
3229 show_help_options(options, "Advanced per-file options:",
3230 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3232 show_help_options(options, "Video options:",
3233 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3235 show_help_options(options, "Advanced Video options:",
3236 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3238 show_help_options(options, "Audio options:",
3239 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3241 show_help_options(options, "Advanced Audio options:",
3242 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3243 show_help_options(options, "Subtitle options:",
3244 OPT_SUBTITLE, 0, 0);
3247 if (show_avoptions) {
3248 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3249 show_help_children(avcodec_get_class(), flags);
3250 show_help_children(avformat_get_class(), flags);
3252 show_help_children(sws_get_class(), flags);
3254 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3255 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3259 void show_usage(void)
3261 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3262 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3263 av_log(NULL, AV_LOG_INFO, "\n");
3271 static const OptionGroupDef groups[] = {
3272 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3273 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3276 static int open_files(OptionGroupList *l, const char *inout,
3277 int (*open_file)(OptionsContext*, const char*))
3281 for (i = 0; i < l->nb_groups; i++) {
3282 OptionGroup *g = &l->groups[i];
3288 ret = parse_optgroup(&o, g);
3290 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3291 "%s.\n", inout, g->arg);
3295 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3296 ret = open_file(&o, g->arg);
3299 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3303 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3309 int ffmpeg_parse_options(int argc, char **argv)
3311 OptionParseContext octx;
3315 memset(&octx, 0, sizeof(octx));
3317 /* split the commandline into an internal representation */
3318 ret = split_commandline(&octx, argc, argv, options, groups,
3319 FF_ARRAY_ELEMS(groups));
3321 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3325 /* apply global options */
3326 ret = parse_optgroup(NULL, &octx.global_opts);
3328 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3332 /* configure terminal and setup signal handlers */
3335 /* open input files */
3336 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3338 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3342 /* create the complex filtergraphs */
3343 ret = init_complex_filters();
3345 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3349 /* open output files */
3350 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3352 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3356 check_filter_outputs();
3359 uninit_parse_context(&octx);
3361 av_strerror(ret, error, sizeof(error));
3362 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3367 static int opt_progress(void *optctx, const char *opt, const char *arg)
3369 AVIOContext *avio = NULL;
3372 if (!strcmp(arg, "-"))
3374 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3376 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3377 arg, av_err2str(ret));
3380 progress_avio = avio;
3384 #define OFFSET(x) offsetof(OptionsContext, x)
3385 const OptionDef options[] = {
3387 CMDUTILS_COMMON_OPTIONS
3388 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3389 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3390 "force format", "fmt" },
3391 { "y", OPT_BOOL, { &file_overwrite },
3392 "overwrite output files" },
3393 { "n", OPT_BOOL, { &no_file_overwrite },
3394 "never overwrite output files" },
3395 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3396 "Ignore unknown stream types" },
3397 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3398 "Copy unknown stream types" },
3399 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3400 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3401 "codec name", "codec" },
3402 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3403 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3404 "codec name", "codec" },
3405 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3406 OPT_OUTPUT, { .off = OFFSET(presets) },
3407 "preset name", "preset" },
3408 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3409 OPT_OUTPUT, { .func_arg = opt_map },
3410 "set input stream mapping",
3411 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3412 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3413 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3414 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3415 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3416 "set metadata information of outfile from infile",
3417 "outfile[,metadata]:infile[,metadata]" },
3418 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3419 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3420 "set chapters mapping", "input_file_index" },
3421 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3422 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3423 "record or transcode \"duration\" seconds of audio/video",
3425 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3426 "record or transcode stop time", "time_stop" },
3427 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3428 "set the limit file size in bytes", "limit_size" },
3429 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3430 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3431 "set the start time offset", "time_off" },
3432 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3433 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3434 "set the start time offset relative to EOF", "time_off" },
3435 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3436 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3437 "enable/disable seeking by timestamp with -ss" },
3438 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3439 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3440 "enable/disable accurate seeking with -ss" },
3441 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3442 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3443 "set the input ts offset", "time_off" },
3444 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3445 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3446 "set the input ts scale", "scale" },
3447 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3448 "set the recording timestamp ('now' to set the current time)", "time" },
3449 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3450 "add metadata", "string=string" },
3451 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3452 "add program with specified streams", "title=string:st=number..." },
3453 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3454 OPT_OUTPUT, { .func_arg = opt_data_frames },
3455 "set the number of data frames to output", "number" },
3456 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3457 "add timings for benchmarking" },
3458 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3459 "add timings for each task" },
3460 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3461 "write program-readable progress information", "url" },
3462 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3463 "enable or disable interaction on standard input" },
3464 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3465 "set max runtime in seconds", "limit" },
3466 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3467 "dump each input packet" },
3468 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3469 "when dumping packets, also dump the payload" },
3470 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3471 OPT_INPUT, { .off = OFFSET(rate_emu) },
3472 "read input at native frame rate", "" },
3473 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3474 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3475 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3476 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3477 "video sync method", "" },
3478 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3479 "frame drop threshold", "" },
3480 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3481 "audio sync method", "" },
3482 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3483 "audio drift threshold", "threshold" },
3484 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3485 "copy timestamps" },
3486 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3487 "shift input timestamps to start at 0 when using copyts" },
3488 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3489 "copy input stream time base when stream copying", "mode" },
3490 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3491 OPT_OUTPUT, { .off = OFFSET(shortest) },
3492 "finish encoding within shortest input" },
3493 { "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3494 OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) },
3496 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3497 OPT_OUTPUT, { .off = OFFSET(apad) },
3499 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3500 "timestamp discontinuity delta threshold", "threshold" },
3501 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3502 "timestamp error delta threshold", "threshold" },
3503 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3504 "exit on error", "error" },
3505 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3506 "abort on the specified condition flags", "flags" },
3507 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3508 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3509 "copy initial non-keyframes" },
3510 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3511 "copy or discard frames before start time" },
3512 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3513 "set the number of frames to output", "number" },
3514 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3515 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3516 "force codec tag/fourcc", "fourcc/tag" },
3517 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3518 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3519 "use fixed quality scale (VBR)", "q" },
3520 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3521 OPT_OUTPUT, { .func_arg = opt_qscale },
3522 "use fixed quality scale (VBR)", "q" },
3523 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3524 "set profile", "profile" },
3525 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3526 "set stream filtergraph", "filter_graph" },
3527 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3528 "number of non-complex filter threads" },
3529 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3530 "read stream filtergraph description from a file", "filename" },
3531 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3532 "reinit filtergraph on input parameter changes", "" },
3533 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3534 "create a complex filtergraph", "graph_description" },
3535 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3536 "number of threads for -filter_complex" },
3537 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3538 "create a complex filtergraph", "graph_description" },
3539 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3540 "read complex filtergraph description from a file", "filename" },
3541 { "stats", OPT_BOOL, { &print_stats },
3542 "print progress report during encoding", },
3543 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3544 OPT_OUTPUT, { .func_arg = opt_attach },
3545 "add an attachment to the output file", "filename" },
3546 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3547 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3548 "extract an attachment into a file", "filename" },
3549 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3550 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3551 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3552 "print timestamp debugging info" },
3553 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3554 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3555 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3556 OPT_INPUT, { .off = OFFSET(discard) },
3558 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3559 OPT_OUTPUT, { .off = OFFSET(disposition) },
3560 "disposition", "" },
3561 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3562 { .off = OFFSET(thread_queue_size) },
3563 "set the maximum number of queued packets from the demuxer" },
3564 { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3565 "read and decode the streams to fill missing information with heuristics" },
3568 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3569 "set the number of video frames to output", "number" },
3570 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3571 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3572 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3573 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3574 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3575 "set frame size (WxH or abbreviation)", "size" },
3576 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3577 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3578 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3579 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3580 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3581 "set pixel format", "format" },
3582 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3583 "set the number of bits per raw sample", "number" },
3584 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3585 "deprecated use -g 1" },
3586 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3588 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3589 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3590 "rate control override for specific intervals", "override" },
3591 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3592 OPT_OUTPUT, { .func_arg = opt_video_codec },
3593 "force video codec ('copy' to copy stream)", "codec" },
3594 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3596 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3598 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3599 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3600 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3601 "select the pass number (1 to 3)", "n" },
3602 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3603 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3604 "select two pass log file name prefix", "prefix" },
3605 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3606 "this option is deprecated, use the yadif filter instead" },
3607 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3608 "calculate PSNR of compressed frames" },
3609 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3610 "dump video coding statistics to file" },
3611 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3612 "dump video coding statistics to file", "file" },
3613 { "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3614 "Version of the vstats format to use."},
3615 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3616 "set video filters", "filter_graph" },
3617 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3618 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3619 "specify intra matrix coeffs", "matrix" },
3620 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3621 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3622 "specify inter matrix coeffs", "matrix" },
3623 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3624 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3625 "specify intra matrix coeffs", "matrix" },
3626 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3627 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3628 "top=1/bottom=0/auto=-1 field first", "" },
3629 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3630 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3631 "force video tag/fourcc", "fourcc/tag" },
3632 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3633 "show QP histogram" },
3634 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3635 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3636 "force the selected framerate, disable the best supported framerate selection" },
3637 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3638 OPT_OUTPUT, { .func_arg = opt_streamid },
3639 "set the value of an outfile streamid", "streamIndex:value" },
3640 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3641 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3642 "force key frames at specified timestamps", "timestamps" },
3643 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3644 "audio bitrate (please use -b:a)", "bitrate" },
3645 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3646 "video bitrate (please use -b:v)", "bitrate" },
3647 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3648 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3649 "use HW accelerated decoding", "hwaccel name" },
3650 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3651 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3652 "select a device for HW acceleration", "devicename" },
3653 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3654 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3655 "select output format used with HW accelerated decoding", "format" },
3656 #if CONFIG_VIDEOTOOLBOX
3657 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3659 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3660 "show available HW acceleration methods" },
3661 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3662 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3663 "automatically insert correct rotate filters" },
3666 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3667 "set the number of audio frames to output", "number" },
3668 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3669 "set audio quality (codec-specific)", "quality", },
3670 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3671 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3672 "set audio sampling rate (in Hz)", "rate" },
3673 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3674 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3675 "set number of audio channels", "channels" },
3676 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3678 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3679 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3680 "force audio codec ('copy' to copy stream)", "codec" },
3681 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3682 OPT_OUTPUT, { .func_arg = opt_old2new },
3683 "force audio tag/fourcc", "fourcc/tag" },
3684 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3685 "change audio volume (256=normal)" , "volume" },
3686 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3687 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3688 "set sample format", "format" },
3689 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3690 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3691 "set channel layout", "layout" },
3692 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3693 "set audio filters", "filter_graph" },
3694 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3695 "set the maximum number of channels to try to guess the channel layout" },
3697 /* subtitle options */
3698 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3699 "disable subtitle" },
3700 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3701 "force subtitle codec ('copy' to copy stream)", "codec" },
3702 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3703 , "force subtitle tag/fourcc", "fourcc/tag" },
3704 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3705 "fix subtitles duration" },
3706 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3707 "set canvas size (WxH or abbreviation)", "size" },
3710 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3711 "deprecated, use -channel", "channel" },
3712 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3713 "deprecated, use -standard", "standard" },
3714 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3717 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3718 "set the maximum demux-decode delay", "seconds" },
3719 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3720 "set the initial demux-decode delay", "seconds" },
3721 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3722 "override the options from ffserver", "" },
3723 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3724 "specify a file in which to print sdp information", "file" },
3726 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3727 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3728 { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3729 "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3730 "two special values are defined - "
3731 "0 = use frame rate (video) or sample rate (audio),"
3732 "-1 = match source time base", "ratio" },
3734 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3735 "A comma-separated list of bitstream filters", "bitstream_filters" },
3736 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3737 "deprecated", "audio bitstream_filters" },
3738 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3739 "deprecated", "video bitstream_filters" },
3741 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3742 "set the audio options to the indicated preset", "preset" },
3743 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3744 "set the video options to the indicated preset", "preset" },
3745 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3746 "set the subtitle options to the indicated preset", "preset" },
3747 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3748 "set options from indicated preset file", "filename" },
3750 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3751 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3753 /* data codec support */
3754 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3755 "force data codec ('copy' to copy stream)", "codec" },
3756 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3760 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3761 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3765 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3766 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3769 { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3770 "initialise hardware device", "args" },
3771 { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3772 "set hardware device used when filtering", "device" },