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 MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
82 float audio_drift_threshold = 0.1;
83 float dts_delta_threshold = 10;
84 float dts_error_threshold = 3600*30;
86 int audio_volume = 256;
87 int audio_sync_method = 0;
88 int video_sync_method = VSYNC_AUTO;
89 int do_deinterlace = 0;
91 int do_benchmark_all = 0;
95 int start_at_zero = 0;
98 int exit_on_error = 0;
101 int stdin_interaction = 1;
102 int frame_bits_per_raw_sample = 0;
103 float max_error_rate = 2.0/3;
106 static int intra_only = 0;
107 static int file_overwrite = 0;
108 static int no_file_overwrite = 0;
109 static int do_psnr = 0;
110 static int input_sync;
111 static int override_ffserver = 0;
113 static void uninit_options(OptionsContext *o)
115 const OptionDef *po = options;
118 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
120 void *dst = (uint8_t*)o + po->u.off;
122 if (po->flags & OPT_SPEC) {
123 SpecifierOpt **so = dst;
124 int i, *count = (int*)(so + 1);
125 for (i = 0; i < *count; i++) {
126 av_freep(&(*so)[i].specifier);
127 if (po->flags & OPT_STRING)
128 av_freep(&(*so)[i].u.str);
132 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
137 for (i = 0; i < o->nb_stream_maps; i++)
138 av_freep(&o->stream_maps[i].linklabel);
139 av_freep(&o->stream_maps);
140 av_freep(&o->audio_channel_maps);
141 av_freep(&o->streamid_map);
142 av_freep(&o->attachments);
145 static void init_options(OptionsContext *o)
147 memset(o, 0, sizeof(*o));
149 o->stop_time = INT64_MAX;
150 o->mux_max_delay = 0.7;
151 o->start_time = AV_NOPTS_VALUE;
152 o->recording_time = INT64_MAX;
153 o->limit_filesize = UINT64_MAX;
154 o->chapters_input_file = INT_MAX;
155 o->accurate_seek = 1;
158 /* return a copy of the input with the stream specifiers removed from the keys */
159 static AVDictionary *strip_specifiers(AVDictionary *dict)
161 AVDictionaryEntry *e = NULL;
162 AVDictionary *ret = NULL;
164 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
165 char *p = strchr(e->key, ':');
169 av_dict_set(&ret, e->key, e->value, 0);
176 static int opt_sameq(void *optctx, const char *opt, const char *arg)
178 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
179 "If you are looking for an option to preserve the quality (which is not "
180 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
182 return AVERROR(EINVAL);
185 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
187 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
188 return opt_default(optctx, "channel", arg);
191 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
193 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
194 return opt_default(optctx, "standard", arg);
197 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
199 OptionsContext *o = optctx;
200 return parse_option(o, "codec:a", arg, options);
203 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
205 OptionsContext *o = optctx;
206 return parse_option(o, "codec:v", arg, options);
209 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
211 OptionsContext *o = optctx;
212 return parse_option(o, "codec:s", arg, options);
215 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
217 OptionsContext *o = optctx;
218 return parse_option(o, "codec:d", arg, options);
221 static int opt_map(void *optctx, const char *opt, const char *arg)
223 OptionsContext *o = optctx;
225 int i, negative = 0, file_idx;
226 int sync_file_idx = -1, sync_stream_idx = 0;
234 map = av_strdup(arg);
236 return AVERROR(ENOMEM);
238 /* parse sync stream first, just pick first matching stream */
239 if (sync = strchr(map, ',')) {
241 sync_file_idx = strtol(sync + 1, &sync, 0);
242 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
243 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
248 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
249 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
250 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
254 if (i == input_files[sync_file_idx]->nb_streams) {
255 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
256 "match any streams.\n", arg);
263 /* this mapping refers to lavfi output */
264 const char *c = map + 1;
265 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
266 m = &o->stream_maps[o->nb_stream_maps - 1];
267 m->linklabel = av_get_token(&c, "]");
269 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
273 file_idx = strtol(map, &p, 0);
274 if (file_idx >= nb_input_files || file_idx < 0) {
275 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
279 /* disable some already defined maps */
280 for (i = 0; i < o->nb_stream_maps; i++) {
281 m = &o->stream_maps[i];
282 if (file_idx == m->file_index &&
283 check_stream_specifier(input_files[m->file_index]->ctx,
284 input_files[m->file_index]->ctx->streams[m->stream_index],
285 *p == ':' ? p + 1 : p) > 0)
289 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
290 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
291 *p == ':' ? p + 1 : p) <= 0)
293 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
294 m = &o->stream_maps[o->nb_stream_maps - 1];
296 m->file_index = file_idx;
299 if (sync_file_idx >= 0) {
300 m->sync_file_index = sync_file_idx;
301 m->sync_stream_index = sync_stream_idx;
303 m->sync_file_index = file_idx;
304 m->sync_stream_index = i;
310 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
318 static int opt_attach(void *optctx, const char *opt, const char *arg)
320 OptionsContext *o = optctx;
321 GROW_ARRAY(o->attachments, o->nb_attachments);
322 o->attachments[o->nb_attachments - 1] = arg;
326 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
328 OptionsContext *o = optctx;
333 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
334 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
336 /* muted channel syntax */
337 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
338 if ((n == 1 || n == 3) && m->channel_idx == -1) {
339 m->file_idx = m->stream_idx = -1;
341 m->ofile_idx = m->ostream_idx = -1;
346 n = sscanf(arg, "%d.%d.%d:%d.%d",
347 &m->file_idx, &m->stream_idx, &m->channel_idx,
348 &m->ofile_idx, &m->ostream_idx);
350 if (n != 3 && n != 5) {
351 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
352 "[file.stream.channel|-1][:syncfile:syncstream]\n");
356 if (n != 5) // only file.stream.channel specified
357 m->ofile_idx = m->ostream_idx = -1;
360 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
361 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
365 if (m->stream_idx < 0 ||
366 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
367 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
368 m->file_idx, m->stream_idx);
371 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
372 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
373 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
374 m->file_idx, m->stream_idx);
377 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
378 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
379 m->file_idx, m->stream_idx, m->channel_idx);
385 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
387 av_free(sdp_filename);
388 sdp_filename = av_strdup(arg);
393 * Parse a metadata specifier passed as 'arg' parameter.
394 * @param arg metadata string to parse
395 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
396 * @param index for type c/p, chapter/program index is written here
397 * @param stream_spec for type s, the stream specifier is written here
399 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
407 if (*(++arg) && *arg != ':') {
408 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
411 *stream_spec = *arg == ':' ? arg + 1 : "";
416 *index = strtol(++arg, NULL, 0);
419 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
426 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
428 AVDictionary **meta_in = NULL;
429 AVDictionary **meta_out = NULL;
431 char type_in, type_out;
432 const char *istream_spec = NULL, *ostream_spec = NULL;
433 int idx_in = 0, idx_out = 0;
435 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
436 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
439 if (type_out == 'g' || !*outspec)
440 o->metadata_global_manual = 1;
441 if (type_out == 's' || !*outspec)
442 o->metadata_streams_manual = 1;
443 if (type_out == 'c' || !*outspec)
444 o->metadata_chapters_manual = 1;
448 if (type_in == 'g' || type_out == 'g')
449 o->metadata_global_manual = 1;
450 if (type_in == 's' || type_out == 's')
451 o->metadata_streams_manual = 1;
452 if (type_in == 'c' || type_out == 'c')
453 o->metadata_chapters_manual = 1;
455 /* ic is NULL when just disabling automatic mappings */
459 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
460 if ((index) < 0 || (index) >= (nb_elems)) {\
461 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
466 #define SET_DICT(type, meta, context, index)\
469 meta = &context->metadata;\
472 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
473 meta = &context->chapters[index]->metadata;\
476 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
477 meta = &context->programs[index]->metadata;\
480 break; /* handled separately below */ \
481 default: av_assert0(0);\
484 SET_DICT(type_in, meta_in, ic, idx_in);
485 SET_DICT(type_out, meta_out, oc, idx_out);
487 /* for input streams choose first matching stream */
488 if (type_in == 's') {
489 for (i = 0; i < ic->nb_streams; i++) {
490 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
491 meta_in = &ic->streams[i]->metadata;
497 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
502 if (type_out == 's') {
503 for (i = 0; i < oc->nb_streams; i++) {
504 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
505 meta_out = &oc->streams[i]->metadata;
506 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
511 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
516 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
518 OptionsContext *o = optctx;
520 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
521 struct tm time = *gmtime((time_t*)&recording_timestamp);
522 if (!strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time))
524 parse_option(o, "metadata", buf, options);
526 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
527 "tag instead.\n", opt);
531 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
533 const AVCodecDescriptor *desc;
534 const char *codec_string = encoder ? "encoder" : "decoder";
538 avcodec_find_encoder_by_name(name) :
539 avcodec_find_decoder_by_name(name);
541 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
542 codec = encoder ? avcodec_find_encoder(desc->id) :
543 avcodec_find_decoder(desc->id);
545 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
546 codec_string, codec->name, desc->name);
550 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
553 if (codec->type != type) {
554 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
560 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
562 char *codec_name = NULL;
564 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
566 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
567 st->codec->codec_id = codec->id;
570 return avcodec_find_decoder(st->codec->codec_id);
573 /* Add all the streams from the given input file to the global
574 * list of input streams. */
575 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
579 for (i = 0; i < ic->nb_streams; i++) {
580 AVStream *st = ic->streams[i];
581 AVCodecContext *dec = st->codec;
582 InputStream *ist = av_mallocz(sizeof(*ist));
583 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
584 char *codec_tag = NULL;
586 char *discard_str = NULL;
587 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
592 GROW_ARRAY(input_streams, nb_input_streams);
593 input_streams[nb_input_streams - 1] = ist;
596 ist->file_index = nb_input_files;
598 st->discard = AVDISCARD_ALL;
601 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
603 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
605 uint32_t tag = strtol(codec_tag, &next, 0);
607 tag = AV_RL32(codec_tag);
608 st->codec->codec_tag = tag;
611 ist->dec = choose_decoder(o, ic, st);
612 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
614 ist->reinit_filters = -1;
615 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
617 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
618 ist->user_set_discard = AVDISCARD_NONE;
619 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
620 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
625 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
627 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
629 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
633 ret = avcodec_copy_context(ist->dec_ctx, dec);
635 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
639 switch (dec->codec_type) {
640 case AVMEDIA_TYPE_VIDEO:
642 ist->dec = avcodec_find_decoder(dec->codec_id);
643 if (av_codec_get_lowres(dec)) {
644 dec->flags |= CODEC_FLAG_EMU_EDGE;
647 ist->resample_height = ist->dec_ctx->height;
648 ist->resample_width = ist->dec_ctx->width;
649 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
651 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
652 if (framerate && av_parse_video_rate(&ist->framerate,
654 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
659 ist->top_field_first = -1;
660 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
662 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
664 if (!strcmp(hwaccel, "none"))
665 ist->hwaccel_id = HWACCEL_NONE;
666 else if (!strcmp(hwaccel, "auto"))
667 ist->hwaccel_id = HWACCEL_AUTO;
670 for (i = 0; hwaccels[i].name; i++) {
671 if (!strcmp(hwaccels[i].name, hwaccel)) {
672 ist->hwaccel_id = hwaccels[i].id;
677 if (!ist->hwaccel_id) {
678 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
680 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
681 for (i = 0; hwaccels[i].name; i++)
682 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
683 av_log(NULL, AV_LOG_FATAL, "\n");
689 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
690 if (hwaccel_device) {
691 ist->hwaccel_device = av_strdup(hwaccel_device);
692 if (!ist->hwaccel_device)
695 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
698 case AVMEDIA_TYPE_AUDIO:
699 ist->guess_layout_max = INT_MAX;
700 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
701 guess_input_channel_layout(ist);
703 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
704 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
705 ist->resample_channels = ist->dec_ctx->channels;
706 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
709 case AVMEDIA_TYPE_DATA:
710 case AVMEDIA_TYPE_SUBTITLE: {
711 char *canvas_size = NULL;
713 ist->dec = avcodec_find_decoder(dec->codec_id);
714 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
715 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
717 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
718 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
723 case AVMEDIA_TYPE_ATTACHMENT:
724 case AVMEDIA_TYPE_UNKNOWN:
732 static void assert_file_overwrite(const char *filename)
734 if (file_overwrite && no_file_overwrite) {
735 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
739 if (!file_overwrite) {
740 const char *proto_name = avio_find_protocol_name(filename);
741 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
742 if (stdin_interaction && !no_file_overwrite) {
743 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
746 signal(SIGINT, SIG_DFL);
748 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
754 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
761 static void dump_attachment(AVStream *st, const char *filename)
764 AVIOContext *out = NULL;
765 AVDictionaryEntry *e;
767 if (!st->codec->extradata_size) {
768 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
769 nb_input_files - 1, st->index);
772 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
775 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
776 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
780 assert_file_overwrite(filename);
782 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
783 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
788 avio_write(out, st->codec->extradata, st->codec->extradata_size);
793 static int open_input_file(OptionsContext *o, const char *filename)
797 AVInputFormat *file_iformat = NULL;
801 AVDictionary *unused_opts = NULL;
802 AVDictionaryEntry *e = NULL;
803 int orig_nb_streams; // number of streams before avformat_find_stream_info
804 char * video_codec_name = NULL;
805 char * audio_codec_name = NULL;
806 char *subtitle_codec_name = NULL;
807 int scan_all_pmts_set = 0;
810 if (!(file_iformat = av_find_input_format(o->format))) {
811 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
816 if (!strcmp(filename, "-"))
819 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
820 strcmp(filename, "/dev/stdin");
822 /* get default parameters from command line */
823 ic = avformat_alloc_context();
825 print_error(filename, AVERROR(ENOMEM));
828 if (o->nb_audio_sample_rate) {
829 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
831 if (o->nb_audio_channels) {
832 /* because we set audio_channels based on both the "ac" and
833 * "channel_layout" options, we need to check that the specified
834 * demuxer actually has the "channels" option before setting it */
835 if (file_iformat && file_iformat->priv_class &&
836 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
837 AV_OPT_SEARCH_FAKE_OBJ)) {
838 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
841 if (o->nb_frame_rates) {
842 /* set the format-level framerate option;
843 * this is important for video grabbers, e.g. x11 */
844 if (file_iformat && file_iformat->priv_class &&
845 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
846 AV_OPT_SEARCH_FAKE_OBJ)) {
847 av_dict_set(&o->g->format_opts, "framerate",
848 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
851 if (o->nb_frame_sizes) {
852 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
854 if (o->nb_frame_pix_fmts)
855 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
857 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
858 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
859 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
861 ic->video_codec_id = video_codec_name ?
862 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
863 ic->audio_codec_id = audio_codec_name ?
864 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
865 ic->subtitle_codec_id= subtitle_codec_name ?
866 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
868 if (video_codec_name)
869 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
870 if (audio_codec_name)
871 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
872 if (subtitle_codec_name)
873 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
875 ic->flags |= AVFMT_FLAG_NONBLOCK;
876 ic->interrupt_callback = int_cb;
878 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
879 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
880 scan_all_pmts_set = 1;
882 /* open the input file with generic avformat function */
883 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
885 print_error(filename, err);
888 if (scan_all_pmts_set)
889 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
890 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
891 assert_avoptions(o->g->format_opts);
893 /* apply forced codec ids */
894 for (i = 0; i < ic->nb_streams; i++)
895 choose_decoder(o, ic, ic->streams[i]);
897 /* Set AVCodecContext options for avformat_find_stream_info */
898 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
899 orig_nb_streams = ic->nb_streams;
901 /* If not enough info to get the stream parameters, we decode the
902 first frames to get it. (used in mpeg case for example) */
903 ret = avformat_find_stream_info(ic, opts);
905 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
906 if (ic->nb_streams == 0) {
907 avformat_close_input(&ic);
912 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
913 /* add the stream start time */
914 if (ic->start_time != AV_NOPTS_VALUE)
915 timestamp += ic->start_time;
917 /* if seeking requested, we execute it */
918 if (o->start_time != AV_NOPTS_VALUE) {
919 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
921 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
922 filename, (double)timestamp / AV_TIME_BASE);
926 /* update the current parameters so that they match the one of the input stream */
927 add_input_streams(o, ic);
929 /* dump the file content */
930 av_dump_format(ic, nb_input_files, filename, 0);
932 GROW_ARRAY(input_files, nb_input_files);
933 f = av_mallocz(sizeof(*f));
936 input_files[nb_input_files - 1] = f;
939 f->ist_index = nb_input_streams - ic->nb_streams;
940 f->start_time = o->start_time;
941 f->recording_time = o->recording_time;
942 f->input_ts_offset = o->input_ts_offset;
943 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
944 f->nb_streams = ic->nb_streams;
945 f->rate_emu = o->rate_emu;
946 f->accurate_seek = o->accurate_seek;
948 /* check if all codec options have been used */
949 unused_opts = strip_specifiers(o->g->codec_opts);
950 for (i = f->ist_index; i < nb_input_streams; i++) {
952 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
953 AV_DICT_IGNORE_SUFFIX)))
954 av_dict_set(&unused_opts, e->key, NULL, 0);
958 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
959 const AVClass *class = avcodec_get_class();
960 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
961 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
962 const AVClass *fclass = avformat_get_class();
963 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
964 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
965 if (!option || foption)
969 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
970 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
971 "input file #%d (%s) is not a decoding option.\n", e->key,
972 option->help ? option->help : "", nb_input_files - 1,
977 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
978 "input file #%d (%s) has not been used for any stream. The most "
979 "likely reason is either wrong type (e.g. a video option with "
980 "no video streams) or that it is a private option of some decoder "
981 "which was not actually used for any stream.\n", e->key,
982 option->help ? option->help : "", nb_input_files - 1, filename);
984 av_dict_free(&unused_opts);
986 for (i = 0; i < o->nb_dump_attachment; i++) {
989 for (j = 0; j < ic->nb_streams; j++) {
990 AVStream *st = ic->streams[j];
992 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
993 dump_attachment(st, o->dump_attachment[i].u.str);
997 for (i = 0; i < orig_nb_streams; i++)
998 av_dict_free(&opts[i]);
1004 static uint8_t *get_line(AVIOContext *s)
1010 if (avio_open_dyn_buf(&line) < 0) {
1011 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1015 while ((c = avio_r8(s)) && c != '\n')
1018 avio_close_dyn_buf(line, &buf);
1023 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1026 char filename[1000];
1027 const char *base[3] = { getenv("AVCONV_DATADIR"),
1032 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1036 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1037 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1038 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1041 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1042 i != 1 ? "" : "/.avconv", preset_name);
1043 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1049 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1051 char *codec_name = NULL;
1053 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1055 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1056 NULL, ost->st->codec->codec_type);
1057 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1058 } else if (!strcmp(codec_name, "copy"))
1059 ost->stream_copy = 1;
1061 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1062 ost->st->codec->codec_id = ost->enc->id;
1066 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1069 AVStream *st = avformat_new_stream(oc, NULL);
1070 int idx = oc->nb_streams - 1, ret = 0;
1071 char *bsf = NULL, *next, *codec_tag = NULL;
1072 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1077 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1081 if (oc->nb_streams - 1 < o->nb_streamid_map)
1082 st->id = o->streamid_map[oc->nb_streams - 1];
1084 GROW_ARRAY(output_streams, nb_output_streams);
1085 if (!(ost = av_mallocz(sizeof(*ost))))
1087 output_streams[nb_output_streams - 1] = ost;
1089 ost->file_index = nb_output_files - 1;
1092 st->codec->codec_type = type;
1093 choose_encoder(o, oc, ost);
1095 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1096 if (!ost->enc_ctx) {
1097 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1100 ost->enc_ctx->codec_type = type;
1103 AVIOContext *s = NULL;
1104 char *buf = NULL, *arg = NULL, *preset = NULL;
1106 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1108 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1109 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1112 if (!buf[0] || buf[0] == '#') {
1116 if (!(arg = strchr(buf, '='))) {
1117 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1121 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1123 } while (!s->eof_reached);
1127 av_log(NULL, AV_LOG_FATAL,
1128 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1129 preset, ost->file_index, ost->index);
1133 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1136 ost->max_frames = INT64_MAX;
1137 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1138 for (i = 0; i<o->nb_max_frames; i++) {
1139 char *p = o->max_frames[i].specifier;
1140 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1141 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1146 ost->copy_prior_start = -1;
1147 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1149 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1152 if (next = strchr(bsf, ','))
1154 if (arg = strchr(bsf, '='))
1156 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1157 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1161 bsfc_prev->next = bsfc;
1163 ost->bitstream_filters = bsfc;
1164 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1170 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1172 uint32_t tag = strtol(codec_tag, &next, 0);
1174 tag = AV_RL32(codec_tag);
1175 ost->enc_ctx->codec_tag = tag;
1178 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1180 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1181 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1184 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1185 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1187 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1189 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1190 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1191 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1193 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1195 ost->source_index = source_index;
1196 if (source_index >= 0) {
1197 ost->sync_ist = input_streams[source_index];
1198 input_streams[source_index]->discard = 0;
1199 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1201 ost->last_mux_dts = AV_NOPTS_VALUE;
1206 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1209 const char *p = str;
1216 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1223 /* read file contents into a string */
1224 static uint8_t *read_file(const char *filename)
1226 AVIOContext *pb = NULL;
1227 AVIOContext *dyn_buf = NULL;
1228 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1229 uint8_t buf[1024], *str;
1232 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1236 ret = avio_open_dyn_buf(&dyn_buf);
1241 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1242 avio_write(dyn_buf, buf, ret);
1243 avio_w8(dyn_buf, 0);
1246 ret = avio_close_dyn_buf(dyn_buf, &str);
1252 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1255 AVStream *st = ost->st;
1257 if (ost->filters_script && ost->filters) {
1258 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1259 "output stream #%d:%d.\n", nb_output_files, st->index);
1263 if (ost->filters_script)
1264 return read_file(ost->filters_script);
1265 else if (ost->filters)
1266 return av_strdup(ost->filters);
1268 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1272 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1273 const OutputStream *ost, enum AVMediaType type)
1275 if (ost->filters_script || ost->filters) {
1276 av_log(NULL, AV_LOG_ERROR,
1277 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1278 "Filtering and streamcopy cannot be used together.\n",
1279 ost->filters ? "Filtergraph" : "Filtergraph script",
1280 ost->filters ? ost->filters : ost->filters_script,
1281 av_get_media_type_string(type), ost->file_index, ost->index);
1286 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1290 AVCodecContext *video_enc;
1291 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1293 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1295 video_enc = ost->enc_ctx;
1297 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1298 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1299 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1302 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1303 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1305 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1306 if (frame_aspect_ratio) {
1308 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1309 q.num <= 0 || q.den <= 0) {
1310 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1313 ost->frame_aspect_ratio = q;
1316 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1317 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1319 if (!ost->stream_copy) {
1320 const char *p = NULL;
1321 char *frame_size = NULL;
1322 char *frame_pix_fmt = NULL;
1323 char *intra_matrix = NULL, *inter_matrix = NULL;
1324 char *chroma_intra_matrix = NULL;
1328 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1329 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1330 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1334 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1335 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1336 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1337 ost->keep_pix_fmt = 1;
1338 if (!*++frame_pix_fmt)
1339 frame_pix_fmt = NULL;
1341 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1342 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1345 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1348 video_enc->gop_size = 0;
1349 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1351 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1352 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1355 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1357 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1358 if (chroma_intra_matrix) {
1359 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1361 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1364 av_codec_set_chroma_intra_matrix(video_enc, p);
1365 parse_matrix_coeffs(p, chroma_intra_matrix);
1367 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1369 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1370 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1373 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1376 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1377 for (i = 0; p; i++) {
1379 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1381 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1384 video_enc->rc_override =
1385 av_realloc_array(video_enc->rc_override,
1386 i + 1, sizeof(RcOverride));
1387 if (!video_enc->rc_override)
1389 video_enc->rc_override[i].start_frame = start;
1390 video_enc->rc_override[i].end_frame = end;
1392 video_enc->rc_override[i].qscale = q;
1393 video_enc->rc_override[i].quality_factor = 1.0;
1396 video_enc->rc_override[i].qscale = 0;
1397 video_enc->rc_override[i].quality_factor = -q/100.0;
1402 video_enc->rc_override_count = i;
1405 video_enc->flags|= CODEC_FLAG_PSNR;
1408 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1411 video_enc->flags |= CODEC_FLAG_PASS1;
1412 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1415 video_enc->flags |= CODEC_FLAG_PASS2;
1416 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1420 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1421 if (ost->logfile_prefix &&
1422 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1425 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1426 if (ost->forced_keyframes)
1427 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1429 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1431 ost->top_field_first = -1;
1432 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1435 ost->avfilter = get_ost_filters(o, oc, ost);
1439 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1442 if (ost->stream_copy)
1443 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1448 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1453 AVCodecContext *audio_enc;
1455 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1458 audio_enc = ost->enc_ctx;
1459 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1461 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1462 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1464 if (!ost->stream_copy) {
1465 char *sample_fmt = NULL;
1467 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1469 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1471 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1472 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1476 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1478 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1479 ost->apad = av_strdup(ost->apad);
1481 ost->avfilter = get_ost_filters(o, oc, ost);
1485 /* check for channel mapping for this audio stream */
1486 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1487 AudioChannelMap *map = &o->audio_channel_maps[n];
1488 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1489 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1492 if (map->channel_idx == -1) {
1494 } else if (ost->source_index < 0) {
1495 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1496 ost->file_index, ost->st->index);
1499 ist = input_streams[ost->source_index];
1502 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1503 if (av_reallocp_array(&ost->audio_channels_map,
1504 ost->audio_channels_mapped + 1,
1505 sizeof(*ost->audio_channels_map)
1509 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1515 if (ost->stream_copy)
1516 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1521 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1525 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1526 if (!ost->stream_copy) {
1527 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1534 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1536 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1537 ost->stream_copy = 1;
1542 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1546 AVCodecContext *subtitle_enc;
1548 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1550 subtitle_enc = ost->enc_ctx;
1552 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1554 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1556 if (!ost->stream_copy) {
1557 char *frame_size = NULL;
1559 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1560 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1561 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1569 /* arg format is "output-stream-index:streamid-value". */
1570 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1572 OptionsContext *o = optctx;
1577 av_strlcpy(idx_str, arg, sizeof(idx_str));
1578 p = strchr(idx_str, ':');
1580 av_log(NULL, AV_LOG_FATAL,
1581 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1586 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1587 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1588 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1592 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1594 AVFormatContext *is = ifile->ctx;
1595 AVFormatContext *os = ofile->ctx;
1599 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1601 return AVERROR(ENOMEM);
1604 for (i = 0; i < is->nb_chapters; i++) {
1605 AVChapter *in_ch = is->chapters[i], *out_ch;
1606 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1607 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1608 AV_TIME_BASE_Q, in_ch->time_base);
1609 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1610 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1613 if (in_ch->end < ts_off)
1615 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1618 out_ch = av_mallocz(sizeof(AVChapter));
1620 return AVERROR(ENOMEM);
1622 out_ch->id = in_ch->id;
1623 out_ch->time_base = in_ch->time_base;
1624 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1625 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1628 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1630 os->chapters[os->nb_chapters++] = out_ch;
1635 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1638 AVFormatContext *ic = avformat_alloc_context();
1640 ic->interrupt_callback = int_cb;
1641 err = avformat_open_input(&ic, filename, NULL, NULL);
1644 /* copy stream format */
1645 for(i=0;i<ic->nb_streams;i++) {
1649 const char *enc_config;
1651 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1653 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1654 return AVERROR(EINVAL);
1656 if (codec->type == AVMEDIA_TYPE_AUDIO)
1657 opt_audio_codec(o, "c:a", codec->name);
1658 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1659 opt_video_codec(o, "c:v", codec->name);
1660 ost = new_output_stream(o, s, codec->type, -1);
1663 avcodec_get_context_defaults3(st->codec, codec);
1664 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1666 AVDictionary *opts = NULL;
1667 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1668 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1669 av_dict_free(&opts);
1672 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1673 choose_sample_fmt(st, codec);
1674 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1675 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1676 avcodec_copy_context(ost->enc_ctx, st->codec);
1678 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1681 avformat_close_input(&ic);
1685 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1686 AVFormatContext *oc)
1690 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1691 ofilter->out_tmp->pad_idx)) {
1692 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1693 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1695 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1700 ost->source_index = -1;
1701 ost->filter = ofilter;
1705 if (ost->stream_copy) {
1706 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1707 "which is fed from a complex filtergraph. Filtering and streamcopy "
1708 "cannot be used together.\n", ost->file_index, ost->index);
1712 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1713 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1714 av_log(NULL, AV_LOG_ERROR,
1715 "%s '%s' was specified through the %s option "
1716 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1717 "%s and -filter_complex cannot be used together for the same stream.\n",
1718 ost->filters ? "Filtergraph" : "Filtergraph script",
1719 ost->filters ? ost->filters : ost->filters_script,
1720 opt, ost->file_index, ost->index, opt);
1724 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1725 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1728 avfilter_inout_free(&ofilter->out_tmp);
1731 static int configure_complex_filters(void)
1735 for (i = 0; i < nb_filtergraphs; i++)
1736 if (!filtergraphs[i]->graph &&
1737 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1742 static int open_output_file(OptionsContext *o, const char *filename)
1744 AVFormatContext *oc;
1746 AVOutputFormat *file_oformat;
1750 AVDictionary *unused_opts = NULL;
1751 AVDictionaryEntry *e = NULL;
1753 if (configure_complex_filters() < 0) {
1754 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1758 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1759 o->stop_time = INT64_MAX;
1760 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1763 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1764 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1765 if (o->stop_time <= start_time) {
1766 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1769 o->recording_time = o->stop_time - start_time;
1773 GROW_ARRAY(output_files, nb_output_files);
1774 of = av_mallocz(sizeof(*of));
1777 output_files[nb_output_files - 1] = of;
1779 of->ost_index = nb_output_streams;
1780 of->recording_time = o->recording_time;
1781 of->start_time = o->start_time;
1782 of->limit_filesize = o->limit_filesize;
1783 of->shortest = o->shortest;
1784 av_dict_copy(&of->opts, o->g->format_opts, 0);
1786 if (!strcmp(filename, "-"))
1789 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1791 print_error(filename, err);
1796 if (o->recording_time != INT64_MAX)
1797 oc->duration = o->recording_time;
1799 file_oformat= oc->oformat;
1800 oc->interrupt_callback = int_cb;
1802 /* create streams for all unlabeled output pads */
1803 for (i = 0; i < nb_filtergraphs; i++) {
1804 FilterGraph *fg = filtergraphs[i];
1805 for (j = 0; j < fg->nb_outputs; j++) {
1806 OutputFilter *ofilter = fg->outputs[j];
1808 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1811 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1812 ofilter->out_tmp->pad_idx)) {
1813 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1814 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1815 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1817 init_output_filter(ofilter, o, oc);
1821 /* ffserver seeking with date=... needs a date reference */
1822 if (!strcmp(file_oformat->name, "ffm") &&
1823 av_strstart(filename, "http:", NULL)) {
1824 int err = parse_option(o, "metadata", "creation_time=now", options);
1826 print_error(filename, err);
1831 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1832 av_strstart(filename, "http:", NULL)) {
1834 /* special case for files sent to ffserver: we get the stream
1835 parameters from ffserver */
1836 int err = read_ffserver_streams(o, oc, filename);
1838 print_error(filename, err);
1841 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1842 ost = output_streams[j];
1843 for (i = 0; i < nb_input_streams; i++) {
1844 ist = input_streams[i];
1845 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1847 ost->source_index= i;
1848 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1849 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1851 ist->st->discard = ist->user_set_discard;
1856 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1860 } else if (!o->nb_stream_maps) {
1861 char *subtitle_codec_name = NULL;
1862 /* pick the "best" stream of each type */
1864 /* video: highest resolution */
1865 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1866 int area = 0, idx = -1;
1867 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1868 for (i = 0; i < nb_input_streams; i++) {
1870 ist = input_streams[i];
1871 new_area = ist->st->codec->width * ist->st->codec->height;
1872 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1874 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1876 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1883 new_video_stream(o, oc, idx);
1886 /* audio: most channels */
1887 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1888 int channels = 0, idx = -1;
1889 for (i = 0; i < nb_input_streams; i++) {
1890 ist = input_streams[i];
1891 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1892 ist->st->codec->channels > channels) {
1893 channels = ist->st->codec->channels;
1898 new_audio_stream(o, oc, idx);
1901 /* subtitles: pick first */
1902 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1903 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1904 for (i = 0; i < nb_input_streams; i++)
1905 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1906 AVCodecDescriptor const *input_descriptor =
1907 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1908 AVCodecDescriptor const *output_descriptor = NULL;
1909 AVCodec const *output_codec =
1910 avcodec_find_encoder(oc->oformat->subtitle_codec);
1911 int input_props = 0, output_props = 0;
1913 output_descriptor = avcodec_descriptor_get(output_codec->id);
1914 if (input_descriptor)
1915 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1916 if (output_descriptor)
1917 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1918 if (subtitle_codec_name ||
1919 input_props & output_props ||
1920 // Map dvb teletext which has neither property to any output subtitle encoder
1921 input_descriptor && output_descriptor &&
1922 (!input_descriptor->props ||
1923 !output_descriptor->props)) {
1924 new_subtitle_stream(o, oc, i);
1929 /* do something with data? */
1931 for (i = 0; i < o->nb_stream_maps; i++) {
1932 StreamMap *map = &o->stream_maps[i];
1937 if (map->linklabel) {
1939 OutputFilter *ofilter = NULL;
1942 for (j = 0; j < nb_filtergraphs; j++) {
1943 fg = filtergraphs[j];
1944 for (k = 0; k < fg->nb_outputs; k++) {
1945 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1946 if (out && !strcmp(out->name, map->linklabel)) {
1947 ofilter = fg->outputs[k];
1954 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1955 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1958 init_output_filter(ofilter, o, oc);
1960 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1962 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1963 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1965 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1967 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1969 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1972 switch (ist->st->codec->codec_type) {
1973 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1974 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1975 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1976 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1977 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1979 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1980 map->file_index, map->stream_index);
1987 /* handle attached files */
1988 for (i = 0; i < o->nb_attachments; i++) {
1990 uint8_t *attachment;
1994 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1995 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1999 if ((len = avio_size(pb)) <= 0) {
2000 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2004 if (!(attachment = av_malloc(len))) {
2005 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2009 avio_read(pb, attachment, len);
2011 ost = new_attachment_stream(o, oc, -1);
2012 ost->stream_copy = 0;
2013 ost->attachment_filename = o->attachments[i];
2015 ost->enc_ctx->extradata = attachment;
2016 ost->enc_ctx->extradata_size = len;
2018 p = strrchr(o->attachments[i], '/');
2019 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2023 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2024 AVDictionaryEntry *e;
2025 ost = output_streams[i];
2027 if ((ost->stream_copy || ost->attachment_filename)
2028 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2029 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2030 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2034 /* check if all codec options have been used */
2035 unused_opts = strip_specifiers(o->g->codec_opts);
2036 for (i = of->ost_index; i < nb_output_streams; i++) {
2038 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2039 AV_DICT_IGNORE_SUFFIX)))
2040 av_dict_set(&unused_opts, e->key, NULL, 0);
2044 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2045 const AVClass *class = avcodec_get_class();
2046 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2047 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2048 const AVClass *fclass = avformat_get_class();
2049 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2050 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2051 if (!option || foption)
2055 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2056 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2057 "output file #%d (%s) is not an encoding option.\n", e->key,
2058 option->help ? option->help : "", nb_output_files - 1,
2063 // gop_timecode is injected by generic code but not always used
2064 if (!strcmp(e->key, "gop_timecode"))
2067 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2068 "output file #%d (%s) has not been used for any stream. The most "
2069 "likely reason is either wrong type (e.g. a video option with "
2070 "no video streams) or that it is a private option of some encoder "
2071 "which was not actually used for any stream.\n", e->key,
2072 option->help ? option->help : "", nb_output_files - 1, filename);
2074 av_dict_free(&unused_opts);
2076 /* check filename in case of an image number is expected */
2077 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2078 if (!av_filename_number_test(oc->filename)) {
2079 print_error(oc->filename, AVERROR(EINVAL));
2084 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2085 /* test if it already exists to avoid losing precious files */
2086 assert_file_overwrite(filename);
2089 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2090 &oc->interrupt_callback,
2092 print_error(filename, err);
2095 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2096 assert_file_overwrite(filename);
2098 if (o->mux_preload) {
2099 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2101 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2104 for (i = 0; i < o->nb_metadata_map; i++) {
2106 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2108 if (in_file_index >= nb_input_files) {
2109 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2112 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2113 in_file_index >= 0 ?
2114 input_files[in_file_index]->ctx : NULL, o);
2118 if (o->chapters_input_file >= nb_input_files) {
2119 if (o->chapters_input_file == INT_MAX) {
2120 /* copy chapters from the first input file that has them*/
2121 o->chapters_input_file = -1;
2122 for (i = 0; i < nb_input_files; i++)
2123 if (input_files[i]->ctx->nb_chapters) {
2124 o->chapters_input_file = i;
2128 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2129 o->chapters_input_file);
2133 if (o->chapters_input_file >= 0)
2134 copy_chapters(input_files[o->chapters_input_file], of,
2135 !o->metadata_chapters_manual);
2137 /* copy global metadata by default */
2138 if (!o->metadata_global_manual && nb_input_files){
2139 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2140 AV_DICT_DONT_OVERWRITE);
2141 if(o->recording_time != INT64_MAX)
2142 av_dict_set(&oc->metadata, "duration", NULL, 0);
2143 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2145 if (!o->metadata_streams_manual)
2146 for (i = of->ost_index; i < nb_output_streams; i++) {
2148 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2150 ist = input_streams[output_streams[i]->source_index];
2151 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2152 if (!output_streams[i]->stream_copy)
2153 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2156 /* process manually set metadata */
2157 for (i = 0; i < o->nb_metadata; i++) {
2160 const char *stream_spec;
2161 int index = 0, j, ret = 0;
2163 val = strchr(o->metadata[i].u.str, '=');
2165 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2166 o->metadata[i].u.str);
2171 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2173 for (j = 0; j < oc->nb_streams; j++) {
2174 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2175 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2186 if (index < 0 || index >= oc->nb_chapters) {
2187 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2190 m = &oc->chapters[index]->metadata;
2193 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2196 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2203 static int opt_target(void *optctx, const char *opt, const char *arg)
2205 OptionsContext *o = optctx;
2206 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2207 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2209 if (!strncmp(arg, "pal-", 4)) {
2212 } else if (!strncmp(arg, "ntsc-", 5)) {
2215 } else if (!strncmp(arg, "film-", 5)) {
2219 /* Try to determine PAL/NTSC by peeking in the input files */
2220 if (nb_input_files) {
2222 for (j = 0; j < nb_input_files; j++) {
2223 for (i = 0; i < input_files[j]->nb_streams; i++) {
2224 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2225 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2228 fr = c->time_base.den * 1000 / c->time_base.num;
2232 } else if ((fr == 29970) || (fr == 23976)) {
2237 if (norm != UNKNOWN)
2241 if (norm != UNKNOWN)
2242 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2245 if (norm == UNKNOWN) {
2246 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2247 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2248 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2252 if (!strcmp(arg, "vcd")) {
2253 opt_video_codec(o, "c:v", "mpeg1video");
2254 opt_audio_codec(o, "c:a", "mp2");
2255 parse_option(o, "f", "vcd", options);
2257 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2258 parse_option(o, "r", frame_rates[norm], options);
2259 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2261 opt_default(NULL, "b:v", "1150000");
2262 opt_default(NULL, "maxrate", "1150000");
2263 opt_default(NULL, "minrate", "1150000");
2264 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2266 opt_default(NULL, "b:a", "224000");
2267 parse_option(o, "ar", "44100", options);
2268 parse_option(o, "ac", "2", options);
2270 opt_default(NULL, "packetsize", "2324");
2271 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2273 /* We have to offset the PTS, so that it is consistent with the SCR.
2274 SCR starts at 36000, but the first two packs contain only padding
2275 and the first pack from the other stream, respectively, may also have
2276 been written before.
2277 So the real data starts at SCR 36000+3*1200. */
2278 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2279 } else if (!strcmp(arg, "svcd")) {
2281 opt_video_codec(o, "c:v", "mpeg2video");
2282 opt_audio_codec(o, "c:a", "mp2");
2283 parse_option(o, "f", "svcd", options);
2285 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2286 parse_option(o, "r", frame_rates[norm], options);
2287 parse_option(o, "pix_fmt", "yuv420p", options);
2288 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2290 opt_default(NULL, "b:v", "2040000");
2291 opt_default(NULL, "maxrate", "2516000");
2292 opt_default(NULL, "minrate", "0"); // 1145000;
2293 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2294 opt_default(NULL, "scan_offset", "1");
2296 opt_default(NULL, "b:a", "224000");
2297 parse_option(o, "ar", "44100", options);
2299 opt_default(NULL, "packetsize", "2324");
2301 } else if (!strcmp(arg, "dvd")) {
2303 opt_video_codec(o, "c:v", "mpeg2video");
2304 opt_audio_codec(o, "c:a", "ac3");
2305 parse_option(o, "f", "dvd", options);
2307 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2308 parse_option(o, "r", frame_rates[norm], options);
2309 parse_option(o, "pix_fmt", "yuv420p", options);
2310 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2312 opt_default(NULL, "b:v", "6000000");
2313 opt_default(NULL, "maxrate", "9000000");
2314 opt_default(NULL, "minrate", "0"); // 1500000;
2315 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2317 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2318 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2320 opt_default(NULL, "b:a", "448000");
2321 parse_option(o, "ar", "48000", options);
2323 } else if (!strncmp(arg, "dv", 2)) {
2325 parse_option(o, "f", "dv", options);
2327 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2328 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2329 norm == PAL ? "yuv420p" : "yuv411p", options);
2330 parse_option(o, "r", frame_rates[norm], options);
2332 parse_option(o, "ar", "48000", options);
2333 parse_option(o, "ac", "2", options);
2336 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2337 return AVERROR(EINVAL);
2340 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2341 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2346 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2348 av_free (vstats_filename);
2349 vstats_filename = av_strdup (arg);
2353 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2356 time_t today2 = time(NULL);
2357 struct tm *today = localtime(&today2);
2359 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2361 return opt_vstats_file(NULL, opt, filename);
2364 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2366 OptionsContext *o = optctx;
2367 return parse_option(o, "frames:v", arg, options);
2370 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2372 OptionsContext *o = optctx;
2373 return parse_option(o, "frames:a", arg, options);
2376 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2378 OptionsContext *o = optctx;
2379 return parse_option(o, "frames:d", arg, options);
2382 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2385 AVDictionary *cbak = codec_opts;
2386 AVDictionary *fbak = format_opts;
2390 ret = opt_default(NULL, opt, arg);
2392 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2393 av_dict_copy(&o->g->format_opts, format_opts, 0);
2394 av_dict_free(&codec_opts);
2395 av_dict_free(&format_opts);
2402 static int opt_preset(void *optctx, const char *opt, const char *arg)
2404 OptionsContext *o = optctx;
2406 char filename[1000], line[1000], tmp_line[1000];
2407 const char *codec_name = NULL;
2411 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2413 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2414 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2415 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2417 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2421 while (fgets(line, sizeof(line), f)) {
2422 char *key = tmp_line, *value, *endptr;
2424 if (strcspn(line, "#\n\r") == 0)
2426 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2427 if (!av_strtok(key, "=", &value) ||
2428 !av_strtok(value, "\r\n", &endptr)) {
2429 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2432 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2434 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2435 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2436 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2437 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2438 else if (opt_default_new(o, key, value) < 0) {
2439 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2440 filename, line, key, value);
2450 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2452 OptionsContext *o = optctx;
2453 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2454 int ret = parse_option(o, s, arg, options);
2459 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2461 OptionsContext *o = optctx;
2463 if(!strcmp(opt, "ab")){
2464 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2466 } else if(!strcmp(opt, "b")){
2467 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2468 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2471 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2475 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2477 OptionsContext *o = optctx;
2480 if(!strcmp(opt, "qscale")){
2481 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2482 return parse_option(o, "q:v", arg, options);
2484 s = av_asprintf("q%s", opt + 6);
2485 ret = parse_option(o, s, arg, options);
2490 static int opt_profile(void *optctx, const char *opt, const char *arg)
2492 OptionsContext *o = optctx;
2493 if(!strcmp(opt, "profile")){
2494 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2495 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2498 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2502 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2504 OptionsContext *o = optctx;
2505 return parse_option(o, "filter:v", arg, options);
2508 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2510 OptionsContext *o = optctx;
2511 return parse_option(o, "filter:a", arg, options);
2514 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2516 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2517 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2518 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2519 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2521 if (video_sync_method == VSYNC_AUTO)
2522 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2526 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2528 OptionsContext *o = optctx;
2529 char *tcr = av_asprintf("timecode=%s", arg);
2530 int ret = parse_option(o, "metadata:g", tcr, options);
2532 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2537 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2539 OptionsContext *o = optctx;
2540 char layout_str[32];
2543 int ret, channels, ac_str_size;
2546 layout = av_get_channel_layout(arg);
2548 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2549 return AVERROR(EINVAL);
2551 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2552 ret = opt_default_new(o, opt, layout_str);
2556 /* set 'ac' option based on channel layout */
2557 channels = av_get_channel_layout_nb_channels(layout);
2558 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2559 stream_str = strchr(opt, ':');
2560 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2561 ac_str = av_mallocz(ac_str_size);
2563 return AVERROR(ENOMEM);
2564 av_strlcpy(ac_str, "ac", 3);
2566 av_strlcat(ac_str, stream_str, ac_str_size);
2567 ret = parse_option(o, ac_str, layout_str, options);
2573 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2575 OptionsContext *o = optctx;
2576 return parse_option(o, "q:a", arg, options);
2579 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2581 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2582 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2583 return AVERROR(ENOMEM);
2584 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2585 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2586 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2587 return AVERROR(ENOMEM);
2591 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2593 uint8_t *graph_desc = read_file(arg);
2595 return AVERROR(EINVAL);
2597 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2598 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2599 return AVERROR(ENOMEM);
2600 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2601 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2605 void show_help_default(const char *opt, const char *arg)
2607 /* per-file options have at least one of those set */
2608 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2609 int show_advanced = 0, show_avoptions = 0;
2612 if (!strcmp(opt, "long"))
2614 else if (!strcmp(opt, "full"))
2615 show_advanced = show_avoptions = 1;
2617 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2622 printf("Getting help:\n"
2623 " -h -- print basic options\n"
2624 " -h long -- print more options\n"
2625 " -h full -- print all options (including all format and codec specific options, very long)\n"
2626 " See man %s for detailed description of the options.\n"
2627 "\n", program_name);
2629 show_help_options(options, "Print help / information / capabilities:",
2632 show_help_options(options, "Global options (affect whole program "
2633 "instead of just one file:",
2634 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2636 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2637 per_file | OPT_EXIT, 0);
2639 show_help_options(options, "Per-file main options:", 0,
2640 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2641 OPT_EXIT, per_file);
2643 show_help_options(options, "Advanced per-file options:",
2644 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2646 show_help_options(options, "Video options:",
2647 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2649 show_help_options(options, "Advanced Video options:",
2650 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2652 show_help_options(options, "Audio options:",
2653 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2655 show_help_options(options, "Advanced Audio options:",
2656 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2657 show_help_options(options, "Subtitle options:",
2658 OPT_SUBTITLE, 0, 0);
2661 if (show_avoptions) {
2662 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2663 show_help_children(avcodec_get_class(), flags);
2664 show_help_children(avformat_get_class(), flags);
2666 show_help_children(sws_get_class(), flags);
2668 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2669 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2673 void show_usage(void)
2675 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2676 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2677 av_log(NULL, AV_LOG_INFO, "\n");
2685 static const OptionGroupDef groups[] = {
2686 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2687 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2690 static int open_files(OptionGroupList *l, const char *inout,
2691 int (*open_file)(OptionsContext*, const char*))
2695 for (i = 0; i < l->nb_groups; i++) {
2696 OptionGroup *g = &l->groups[i];
2702 ret = parse_optgroup(&o, g);
2704 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2705 "%s.\n", inout, g->arg);
2709 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2710 ret = open_file(&o, g->arg);
2713 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2717 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2723 int ffmpeg_parse_options(int argc, char **argv)
2725 OptionParseContext octx;
2729 memset(&octx, 0, sizeof(octx));
2731 /* split the commandline into an internal representation */
2732 ret = split_commandline(&octx, argc, argv, options, groups,
2733 FF_ARRAY_ELEMS(groups));
2735 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2739 /* apply global options */
2740 ret = parse_optgroup(NULL, &octx.global_opts);
2742 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2746 /* open input files */
2747 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2749 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2753 /* open output files */
2754 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2756 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2761 uninit_parse_context(&octx);
2763 av_strerror(ret, error, sizeof(error));
2764 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2769 static int opt_progress(void *optctx, const char *opt, const char *arg)
2771 AVIOContext *avio = NULL;
2774 if (!strcmp(arg, "-"))
2776 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2778 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2779 arg, av_err2str(ret));
2782 progress_avio = avio;
2786 #define OFFSET(x) offsetof(OptionsContext, x)
2787 const OptionDef options[] = {
2789 #include "cmdutils_common_opts.h"
2790 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2791 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2792 "force format", "fmt" },
2793 { "y", OPT_BOOL, { &file_overwrite },
2794 "overwrite output files" },
2795 { "n", OPT_BOOL, { &no_file_overwrite },
2796 "never overwrite output files" },
2797 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2798 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2799 "codec name", "codec" },
2800 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2801 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2802 "codec name", "codec" },
2803 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2804 OPT_OUTPUT, { .off = OFFSET(presets) },
2805 "preset name", "preset" },
2806 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2807 OPT_OUTPUT, { .func_arg = opt_map },
2808 "set input stream mapping",
2809 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2810 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2811 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2812 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2813 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2814 "set metadata information of outfile from infile",
2815 "outfile[,metadata]:infile[,metadata]" },
2816 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2817 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2818 "set chapters mapping", "input_file_index" },
2819 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2820 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2821 "record or transcode \"duration\" seconds of audio/video",
2823 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2824 "record or transcode stop time", "time_stop" },
2825 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2826 "set the limit file size in bytes", "limit_size" },
2827 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2828 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2829 "set the start time offset", "time_off" },
2830 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2831 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2832 "enable/disable accurate seeking with -ss" },
2833 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2834 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2835 "set the input ts offset", "time_off" },
2836 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2837 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2838 "set the input ts scale", "scale" },
2839 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2840 "set the recording timestamp ('now' to set the current time)", "time" },
2841 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2842 "add metadata", "string=string" },
2843 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2844 OPT_OUTPUT, { .func_arg = opt_data_frames },
2845 "set the number of data frames to output", "number" },
2846 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2847 "add timings for benchmarking" },
2848 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2849 "add timings for each task" },
2850 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2851 "write program-readable progress information", "url" },
2852 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2853 "enable or disable interaction on standard input" },
2854 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2855 "set max runtime in seconds", "limit" },
2856 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2857 "dump each input packet" },
2858 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2859 "when dumping packets, also dump the payload" },
2860 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2861 OPT_INPUT, { .off = OFFSET(rate_emu) },
2862 "read input at native frame rate", "" },
2863 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2864 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2865 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2866 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2867 "video sync method", "" },
2868 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2869 "audio sync method", "" },
2870 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2871 "audio drift threshold", "threshold" },
2872 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2873 "copy timestamps" },
2874 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2875 "shift input timestamps to start at 0 when using copyts" },
2876 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2877 "copy input stream time base when stream copying", "mode" },
2878 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2879 OPT_OUTPUT, { .off = OFFSET(shortest) },
2880 "finish encoding within shortest input" },
2881 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2882 OPT_OUTPUT, { .off = OFFSET(apad) },
2884 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2885 "timestamp discontinuity delta threshold", "threshold" },
2886 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2887 "timestamp error delta threshold", "threshold" },
2888 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2889 "exit on error", "error" },
2890 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2891 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2892 "copy initial non-keyframes" },
2893 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2894 "copy or discard frames before start time" },
2895 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2896 "set the number of frames to output", "number" },
2897 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2898 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2899 "force codec tag/fourcc", "fourcc/tag" },
2900 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2901 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2902 "use fixed quality scale (VBR)", "q" },
2903 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2904 OPT_OUTPUT, { .func_arg = opt_qscale },
2905 "use fixed quality scale (VBR)", "q" },
2906 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2907 "set profile", "profile" },
2908 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2909 "set stream filtergraph", "filter_graph" },
2910 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2911 "read stream filtergraph description from a file", "filename" },
2912 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2913 "reinit filtergraph on input parameter changes", "" },
2914 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2915 "create a complex filtergraph", "graph_description" },
2916 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2917 "create a complex filtergraph", "graph_description" },
2918 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2919 "read complex filtergraph description from a file", "filename" },
2920 { "stats", OPT_BOOL, { &print_stats },
2921 "print progress report during encoding", },
2922 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2923 OPT_OUTPUT, { .func_arg = opt_attach },
2924 "add an attachment to the output file", "filename" },
2925 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2926 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2927 "extract an attachment into a file", "filename" },
2928 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2929 "print timestamp debugging info" },
2930 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2931 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2932 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2933 OPT_INPUT, { .off = OFFSET(discard) },
2937 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2938 "set the number of video frames to output", "number" },
2939 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2940 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2941 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2942 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2943 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2944 "set frame size (WxH or abbreviation)", "size" },
2945 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2946 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2947 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2948 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2949 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2950 "set pixel format", "format" },
2951 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2952 "set the number of bits per raw sample", "number" },
2953 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2954 "deprecated use -g 1" },
2955 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2957 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2958 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2959 "rate control override for specific intervals", "override" },
2960 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2961 OPT_OUTPUT, { .func_arg = opt_video_codec },
2962 "force video codec ('copy' to copy stream)", "codec" },
2963 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2965 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2967 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2968 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2969 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2970 "select the pass number (1 to 3)", "n" },
2971 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2972 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2973 "select two pass log file name prefix", "prefix" },
2974 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2975 "this option is deprecated, use the yadif filter instead" },
2976 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2977 "calculate PSNR of compressed frames" },
2978 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2979 "dump video coding statistics to file" },
2980 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2981 "dump video coding statistics to file", "file" },
2982 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2983 "set video filters", "filter_graph" },
2984 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2985 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2986 "specify intra matrix coeffs", "matrix" },
2987 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2988 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2989 "specify inter matrix coeffs", "matrix" },
2990 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2991 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2992 "specify intra matrix coeffs", "matrix" },
2993 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2994 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2995 "top=1/bottom=0/auto=-1 field first", "" },
2996 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2997 OPT_OUTPUT, { .func_arg = opt_old2new },
2998 "force video tag/fourcc", "fourcc/tag" },
2999 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3000 "show QP histogram" },
3001 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3002 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3003 "force the selected framerate, disable the best supported framerate selection" },
3004 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3005 OPT_OUTPUT, { .func_arg = opt_streamid },
3006 "set the value of an outfile streamid", "streamIndex:value" },
3007 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3008 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3009 "force key frames at specified timestamps", "timestamps" },
3010 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3011 "audio bitrate (please use -b:a)", "bitrate" },
3012 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3013 "video bitrate (please use -b:v)", "bitrate" },
3014 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3015 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3016 "use HW accelerated decoding", "hwaccel name" },
3017 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3018 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3019 "select a device for HW acceleration" "devicename" },
3021 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3025 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3026 "set the number of audio frames to output", "number" },
3027 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3028 "set audio quality (codec-specific)", "quality", },
3029 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3030 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3031 "set audio sampling rate (in Hz)", "rate" },
3032 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3033 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3034 "set number of audio channels", "channels" },
3035 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3037 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3038 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3039 "force audio codec ('copy' to copy stream)", "codec" },
3040 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3041 OPT_OUTPUT, { .func_arg = opt_old2new },
3042 "force audio tag/fourcc", "fourcc/tag" },
3043 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3044 "change audio volume (256=normal)" , "volume" },
3045 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3046 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3047 "set sample format", "format" },
3048 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3049 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3050 "set channel layout", "layout" },
3051 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3052 "set audio filters", "filter_graph" },
3053 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3054 "set the maximum number of channels to try to guess the channel layout" },
3056 /* subtitle options */
3057 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3058 "disable subtitle" },
3059 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3060 "force subtitle codec ('copy' to copy stream)", "codec" },
3061 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3062 , "force subtitle tag/fourcc", "fourcc/tag" },
3063 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3064 "fix subtitles duration" },
3065 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3066 "set canvas size (WxH or abbreviation)", "size" },
3069 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3070 "deprecated, use -channel", "channel" },
3071 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3072 "deprecated, use -standard", "standard" },
3073 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3076 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3077 "set the maximum demux-decode delay", "seconds" },
3078 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3079 "set the initial demux-decode delay", "seconds" },
3080 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3081 "override the options from ffserver", "" },
3082 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3083 "specify a file in which to print sdp information", "file" },
3085 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3086 "A comma-separated list of bitstream filters", "bitstream_filters" },
3087 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3088 "deprecated", "audio bitstream_filters" },
3089 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3090 "deprecated", "video bitstream_filters" },
3092 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3093 "set the audio options to the indicated preset", "preset" },
3094 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3095 "set the video options to the indicated preset", "preset" },
3096 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3097 "set the subtitle options to the indicated preset", "preset" },
3098 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3099 "set options from indicated preset file", "filename" },
3100 /* data codec support */
3101 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3102 "force data codec ('copy' to copy stream)", "codec" },
3103 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },