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=%Y-%m-%dT%H:%M:%S%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 char * data_codec_name = NULL;
808 int scan_all_pmts_set = 0;
811 if (!(file_iformat = av_find_input_format(o->format))) {
812 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
817 if (!strcmp(filename, "-"))
820 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
821 strcmp(filename, "/dev/stdin");
823 /* get default parameters from command line */
824 ic = avformat_alloc_context();
826 print_error(filename, AVERROR(ENOMEM));
829 if (o->nb_audio_sample_rate) {
830 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
832 if (o->nb_audio_channels) {
833 /* because we set audio_channels based on both the "ac" and
834 * "channel_layout" options, we need to check that the specified
835 * demuxer actually has the "channels" option before setting it */
836 if (file_iformat && file_iformat->priv_class &&
837 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
838 AV_OPT_SEARCH_FAKE_OBJ)) {
839 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
842 if (o->nb_frame_rates) {
843 /* set the format-level framerate option;
844 * this is important for video grabbers, e.g. x11 */
845 if (file_iformat && file_iformat->priv_class &&
846 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
847 AV_OPT_SEARCH_FAKE_OBJ)) {
848 av_dict_set(&o->g->format_opts, "framerate",
849 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
852 if (o->nb_frame_sizes) {
853 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
855 if (o->nb_frame_pix_fmts)
856 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
858 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
859 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
860 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
862 ic->video_codec_id = video_codec_name ?
863 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
864 ic->audio_codec_id = audio_codec_name ?
865 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
866 ic->subtitle_codec_id= subtitle_codec_name ?
867 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
868 ic->data_codec_id = data_codec_name ?
869 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
871 if (video_codec_name)
872 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
873 if (audio_codec_name)
874 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
875 if (subtitle_codec_name)
876 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
878 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
880 ic->flags |= AVFMT_FLAG_NONBLOCK;
881 ic->interrupt_callback = int_cb;
883 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
884 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
885 scan_all_pmts_set = 1;
887 /* open the input file with generic avformat function */
888 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
890 print_error(filename, err);
893 if (scan_all_pmts_set)
894 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
895 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
896 assert_avoptions(o->g->format_opts);
898 /* apply forced codec ids */
899 for (i = 0; i < ic->nb_streams; i++)
900 choose_decoder(o, ic, ic->streams[i]);
902 /* Set AVCodecContext options for avformat_find_stream_info */
903 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
904 orig_nb_streams = ic->nb_streams;
906 /* If not enough info to get the stream parameters, we decode the
907 first frames to get it. (used in mpeg case for example) */
908 ret = avformat_find_stream_info(ic, opts);
910 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
911 if (ic->nb_streams == 0) {
912 avformat_close_input(&ic);
917 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
918 /* add the stream start time */
919 if (ic->start_time != AV_NOPTS_VALUE)
920 timestamp += ic->start_time;
922 /* if seeking requested, we execute it */
923 if (o->start_time != AV_NOPTS_VALUE) {
924 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
926 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
927 filename, (double)timestamp / AV_TIME_BASE);
931 /* update the current parameters so that they match the one of the input stream */
932 add_input_streams(o, ic);
934 /* dump the file content */
935 av_dump_format(ic, nb_input_files, filename, 0);
937 GROW_ARRAY(input_files, nb_input_files);
938 f = av_mallocz(sizeof(*f));
941 input_files[nb_input_files - 1] = f;
944 f->ist_index = nb_input_streams - ic->nb_streams;
945 f->start_time = o->start_time;
946 f->recording_time = o->recording_time;
947 f->input_ts_offset = o->input_ts_offset;
948 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
949 f->nb_streams = ic->nb_streams;
950 f->rate_emu = o->rate_emu;
951 f->accurate_seek = o->accurate_seek;
953 /* check if all codec options have been used */
954 unused_opts = strip_specifiers(o->g->codec_opts);
955 for (i = f->ist_index; i < nb_input_streams; i++) {
957 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
958 AV_DICT_IGNORE_SUFFIX)))
959 av_dict_set(&unused_opts, e->key, NULL, 0);
963 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
964 const AVClass *class = avcodec_get_class();
965 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
966 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
967 const AVClass *fclass = avformat_get_class();
968 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
969 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
970 if (!option || foption)
974 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
975 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
976 "input file #%d (%s) is not a decoding option.\n", e->key,
977 option->help ? option->help : "", nb_input_files - 1,
982 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
983 "input file #%d (%s) has not been used for any stream. The most "
984 "likely reason is either wrong type (e.g. a video option with "
985 "no video streams) or that it is a private option of some decoder "
986 "which was not actually used for any stream.\n", e->key,
987 option->help ? option->help : "", nb_input_files - 1, filename);
989 av_dict_free(&unused_opts);
991 for (i = 0; i < o->nb_dump_attachment; i++) {
994 for (j = 0; j < ic->nb_streams; j++) {
995 AVStream *st = ic->streams[j];
997 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
998 dump_attachment(st, o->dump_attachment[i].u.str);
1002 for (i = 0; i < orig_nb_streams; i++)
1003 av_dict_free(&opts[i]);
1009 static uint8_t *get_line(AVIOContext *s)
1015 if (avio_open_dyn_buf(&line) < 0) {
1016 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1020 while ((c = avio_r8(s)) && c != '\n')
1023 avio_close_dyn_buf(line, &buf);
1028 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1031 char filename[1000];
1032 const char *base[3] = { getenv("AVCONV_DATADIR"),
1037 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1041 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1042 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1043 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1046 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1047 i != 1 ? "" : "/.avconv", preset_name);
1048 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1054 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1056 char *codec_name = NULL;
1058 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1060 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1061 NULL, ost->st->codec->codec_type);
1062 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1063 } else if (!strcmp(codec_name, "copy"))
1064 ost->stream_copy = 1;
1066 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1067 ost->st->codec->codec_id = ost->enc->id;
1071 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1074 AVStream *st = avformat_new_stream(oc, NULL);
1075 int idx = oc->nb_streams - 1, ret = 0;
1076 char *bsf = NULL, *next, *codec_tag = NULL;
1077 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1082 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1086 if (oc->nb_streams - 1 < o->nb_streamid_map)
1087 st->id = o->streamid_map[oc->nb_streams - 1];
1089 GROW_ARRAY(output_streams, nb_output_streams);
1090 if (!(ost = av_mallocz(sizeof(*ost))))
1092 output_streams[nb_output_streams - 1] = ost;
1094 ost->file_index = nb_output_files - 1;
1097 st->codec->codec_type = type;
1098 choose_encoder(o, oc, ost);
1100 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1101 if (!ost->enc_ctx) {
1102 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1105 ost->enc_ctx->codec_type = type;
1108 AVIOContext *s = NULL;
1109 char *buf = NULL, *arg = NULL, *preset = NULL;
1111 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1113 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1114 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1117 if (!buf[0] || buf[0] == '#') {
1121 if (!(arg = strchr(buf, '='))) {
1122 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1126 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1128 } while (!s->eof_reached);
1132 av_log(NULL, AV_LOG_FATAL,
1133 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1134 preset, ost->file_index, ost->index);
1138 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1141 ost->max_frames = INT64_MAX;
1142 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1143 for (i = 0; i<o->nb_max_frames; i++) {
1144 char *p = o->max_frames[i].specifier;
1145 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1146 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1151 ost->copy_prior_start = -1;
1152 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1154 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1157 if (next = strchr(bsf, ','))
1159 if (arg = strchr(bsf, '='))
1161 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1162 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1166 bsfc_prev->next = bsfc;
1168 ost->bitstream_filters = bsfc;
1169 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1175 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1177 uint32_t tag = strtol(codec_tag, &next, 0);
1179 tag = AV_RL32(codec_tag);
1180 ost->enc_ctx->codec_tag = tag;
1183 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1185 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1186 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1189 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1190 ost->disposition = av_strdup(ost->disposition);
1192 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1193 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1195 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1197 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1198 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1199 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1201 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1203 ost->source_index = source_index;
1204 if (source_index >= 0) {
1205 ost->sync_ist = input_streams[source_index];
1206 input_streams[source_index]->discard = 0;
1207 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1209 ost->last_mux_dts = AV_NOPTS_VALUE;
1214 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1217 const char *p = str;
1224 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1231 /* read file contents into a string */
1232 static uint8_t *read_file(const char *filename)
1234 AVIOContext *pb = NULL;
1235 AVIOContext *dyn_buf = NULL;
1236 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1237 uint8_t buf[1024], *str;
1240 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1244 ret = avio_open_dyn_buf(&dyn_buf);
1249 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1250 avio_write(dyn_buf, buf, ret);
1251 avio_w8(dyn_buf, 0);
1254 ret = avio_close_dyn_buf(dyn_buf, &str);
1260 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1263 AVStream *st = ost->st;
1265 if (ost->filters_script && ost->filters) {
1266 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1267 "output stream #%d:%d.\n", nb_output_files, st->index);
1271 if (ost->filters_script)
1272 return read_file(ost->filters_script);
1273 else if (ost->filters)
1274 return av_strdup(ost->filters);
1276 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1280 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1281 const OutputStream *ost, enum AVMediaType type)
1283 if (ost->filters_script || ost->filters) {
1284 av_log(NULL, AV_LOG_ERROR,
1285 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1286 "Filtering and streamcopy cannot be used together.\n",
1287 ost->filters ? "Filtergraph" : "Filtergraph script",
1288 ost->filters ? ost->filters : ost->filters_script,
1289 av_get_media_type_string(type), ost->file_index, ost->index);
1294 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1298 AVCodecContext *video_enc;
1299 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1301 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1303 video_enc = ost->enc_ctx;
1305 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1306 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1307 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1310 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1311 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1313 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1314 if (frame_aspect_ratio) {
1316 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1317 q.num <= 0 || q.den <= 0) {
1318 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1321 ost->frame_aspect_ratio = q;
1324 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1325 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1327 if (!ost->stream_copy) {
1328 const char *p = NULL;
1329 char *frame_size = NULL;
1330 char *frame_pix_fmt = NULL;
1331 char *intra_matrix = NULL, *inter_matrix = NULL;
1332 char *chroma_intra_matrix = NULL;
1336 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1337 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1338 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1342 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1343 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1344 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1345 ost->keep_pix_fmt = 1;
1346 if (!*++frame_pix_fmt)
1347 frame_pix_fmt = NULL;
1349 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1350 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1353 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1356 video_enc->gop_size = 0;
1357 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1359 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1360 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1363 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1365 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1366 if (chroma_intra_matrix) {
1367 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1369 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1372 av_codec_set_chroma_intra_matrix(video_enc, p);
1373 parse_matrix_coeffs(p, chroma_intra_matrix);
1375 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1377 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1378 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1381 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1384 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1385 for (i = 0; p; i++) {
1387 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1389 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1392 video_enc->rc_override =
1393 av_realloc_array(video_enc->rc_override,
1394 i + 1, sizeof(RcOverride));
1395 if (!video_enc->rc_override)
1397 video_enc->rc_override[i].start_frame = start;
1398 video_enc->rc_override[i].end_frame = end;
1400 video_enc->rc_override[i].qscale = q;
1401 video_enc->rc_override[i].quality_factor = 1.0;
1404 video_enc->rc_override[i].qscale = 0;
1405 video_enc->rc_override[i].quality_factor = -q/100.0;
1410 video_enc->rc_override_count = i;
1413 video_enc->flags|= CODEC_FLAG_PSNR;
1416 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1419 video_enc->flags |= CODEC_FLAG_PASS1;
1420 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1423 video_enc->flags |= CODEC_FLAG_PASS2;
1424 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1428 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1429 if (ost->logfile_prefix &&
1430 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1433 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1434 if (ost->forced_keyframes)
1435 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1437 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1439 ost->top_field_first = -1;
1440 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1443 ost->avfilter = get_ost_filters(o, oc, ost);
1447 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1450 if (ost->stream_copy)
1451 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1456 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1461 AVCodecContext *audio_enc;
1463 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1466 audio_enc = ost->enc_ctx;
1467 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1469 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1470 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1472 if (!ost->stream_copy) {
1473 char *sample_fmt = NULL;
1475 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1477 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1479 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1480 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1484 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1486 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1487 ost->apad = av_strdup(ost->apad);
1489 ost->avfilter = get_ost_filters(o, oc, ost);
1493 /* check for channel mapping for this audio stream */
1494 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1495 AudioChannelMap *map = &o->audio_channel_maps[n];
1496 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1497 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1500 if (map->channel_idx == -1) {
1502 } else if (ost->source_index < 0) {
1503 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1504 ost->file_index, ost->st->index);
1507 ist = input_streams[ost->source_index];
1510 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1511 if (av_reallocp_array(&ost->audio_channels_map,
1512 ost->audio_channels_mapped + 1,
1513 sizeof(*ost->audio_channels_map)
1517 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1523 if (ost->stream_copy)
1524 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1529 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1533 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1534 if (!ost->stream_copy) {
1535 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1542 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1544 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1545 ost->stream_copy = 1;
1550 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1554 AVCodecContext *subtitle_enc;
1556 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1558 subtitle_enc = ost->enc_ctx;
1560 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1562 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1564 if (!ost->stream_copy) {
1565 char *frame_size = NULL;
1567 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1568 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1569 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1577 /* arg format is "output-stream-index:streamid-value". */
1578 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1580 OptionsContext *o = optctx;
1585 av_strlcpy(idx_str, arg, sizeof(idx_str));
1586 p = strchr(idx_str, ':');
1588 av_log(NULL, AV_LOG_FATAL,
1589 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1594 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1595 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1596 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1600 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1602 AVFormatContext *is = ifile->ctx;
1603 AVFormatContext *os = ofile->ctx;
1607 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1609 return AVERROR(ENOMEM);
1612 for (i = 0; i < is->nb_chapters; i++) {
1613 AVChapter *in_ch = is->chapters[i], *out_ch;
1614 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1615 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1616 AV_TIME_BASE_Q, in_ch->time_base);
1617 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1618 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1621 if (in_ch->end < ts_off)
1623 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1626 out_ch = av_mallocz(sizeof(AVChapter));
1628 return AVERROR(ENOMEM);
1630 out_ch->id = in_ch->id;
1631 out_ch->time_base = in_ch->time_base;
1632 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1633 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1636 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1638 os->chapters[os->nb_chapters++] = out_ch;
1643 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1646 AVFormatContext *ic = avformat_alloc_context();
1648 ic->interrupt_callback = int_cb;
1649 err = avformat_open_input(&ic, filename, NULL, NULL);
1652 /* copy stream format */
1653 for(i=0;i<ic->nb_streams;i++) {
1657 const char *enc_config;
1659 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1661 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1662 return AVERROR(EINVAL);
1664 if (codec->type == AVMEDIA_TYPE_AUDIO)
1665 opt_audio_codec(o, "c:a", codec->name);
1666 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1667 opt_video_codec(o, "c:v", codec->name);
1668 ost = new_output_stream(o, s, codec->type, -1);
1671 avcodec_get_context_defaults3(st->codec, codec);
1672 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1674 AVDictionary *opts = NULL;
1675 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1676 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1677 av_dict_free(&opts);
1680 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1681 choose_sample_fmt(st, codec);
1682 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1683 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1684 avcodec_copy_context(ost->enc_ctx, st->codec);
1686 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1689 avformat_close_input(&ic);
1693 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1694 AVFormatContext *oc)
1698 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1699 ofilter->out_tmp->pad_idx)) {
1700 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1701 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1703 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1708 ost->source_index = -1;
1709 ost->filter = ofilter;
1713 if (ost->stream_copy) {
1714 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1715 "which is fed from a complex filtergraph. Filtering and streamcopy "
1716 "cannot be used together.\n", ost->file_index, ost->index);
1720 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1721 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1722 av_log(NULL, AV_LOG_ERROR,
1723 "%s '%s' was specified through the %s option "
1724 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1725 "%s and -filter_complex cannot be used together for the same stream.\n",
1726 ost->filters ? "Filtergraph" : "Filtergraph script",
1727 ost->filters ? ost->filters : ost->filters_script,
1728 opt, ost->file_index, ost->index, opt);
1732 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1733 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1736 avfilter_inout_free(&ofilter->out_tmp);
1739 static int configure_complex_filters(void)
1743 for (i = 0; i < nb_filtergraphs; i++)
1744 if (!filtergraphs[i]->graph &&
1745 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1750 static int open_output_file(OptionsContext *o, const char *filename)
1752 AVFormatContext *oc;
1754 AVOutputFormat *file_oformat;
1758 AVDictionary *unused_opts = NULL;
1759 AVDictionaryEntry *e = NULL;
1761 if (configure_complex_filters() < 0) {
1762 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1766 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1767 o->stop_time = INT64_MAX;
1768 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1771 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1772 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1773 if (o->stop_time <= start_time) {
1774 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1777 o->recording_time = o->stop_time - start_time;
1781 GROW_ARRAY(output_files, nb_output_files);
1782 of = av_mallocz(sizeof(*of));
1785 output_files[nb_output_files - 1] = of;
1787 of->ost_index = nb_output_streams;
1788 of->recording_time = o->recording_time;
1789 of->start_time = o->start_time;
1790 of->limit_filesize = o->limit_filesize;
1791 of->shortest = o->shortest;
1792 av_dict_copy(&of->opts, o->g->format_opts, 0);
1794 if (!strcmp(filename, "-"))
1797 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1799 print_error(filename, err);
1804 if (o->recording_time != INT64_MAX)
1805 oc->duration = o->recording_time;
1807 file_oformat= oc->oformat;
1808 oc->interrupt_callback = int_cb;
1810 /* create streams for all unlabeled output pads */
1811 for (i = 0; i < nb_filtergraphs; i++) {
1812 FilterGraph *fg = filtergraphs[i];
1813 for (j = 0; j < fg->nb_outputs; j++) {
1814 OutputFilter *ofilter = fg->outputs[j];
1816 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1819 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1820 ofilter->out_tmp->pad_idx)) {
1821 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1822 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1823 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1825 init_output_filter(ofilter, o, oc);
1829 /* ffserver seeking with date=... needs a date reference */
1830 if (!strcmp(file_oformat->name, "ffm") &&
1831 av_strstart(filename, "http:", NULL)) {
1832 int err = parse_option(o, "metadata", "creation_time=now", options);
1834 print_error(filename, err);
1839 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1840 av_strstart(filename, "http:", NULL)) {
1842 /* special case for files sent to ffserver: we get the stream
1843 parameters from ffserver */
1844 int err = read_ffserver_streams(o, oc, filename);
1846 print_error(filename, err);
1849 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1850 ost = output_streams[j];
1851 for (i = 0; i < nb_input_streams; i++) {
1852 ist = input_streams[i];
1853 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1855 ost->source_index= i;
1856 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1857 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1859 ist->st->discard = ist->user_set_discard;
1864 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));
1868 } else if (!o->nb_stream_maps) {
1869 char *subtitle_codec_name = NULL;
1870 /* pick the "best" stream of each type */
1872 /* video: highest resolution */
1873 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1874 int area = 0, idx = -1;
1875 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1876 for (i = 0; i < nb_input_streams; i++) {
1878 ist = input_streams[i];
1879 new_area = ist->st->codec->width * ist->st->codec->height;
1880 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1882 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1884 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1891 new_video_stream(o, oc, idx);
1894 /* audio: most channels */
1895 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1896 int channels = 0, idx = -1;
1897 for (i = 0; i < nb_input_streams; i++) {
1898 ist = input_streams[i];
1899 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1900 ist->st->codec->channels > channels) {
1901 channels = ist->st->codec->channels;
1906 new_audio_stream(o, oc, idx);
1909 /* subtitles: pick first */
1910 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1911 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1912 for (i = 0; i < nb_input_streams; i++)
1913 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1914 AVCodecDescriptor const *input_descriptor =
1915 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1916 AVCodecDescriptor const *output_descriptor = NULL;
1917 AVCodec const *output_codec =
1918 avcodec_find_encoder(oc->oformat->subtitle_codec);
1919 int input_props = 0, output_props = 0;
1921 output_descriptor = avcodec_descriptor_get(output_codec->id);
1922 if (input_descriptor)
1923 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1924 if (output_descriptor)
1925 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1926 if (subtitle_codec_name ||
1927 input_props & output_props ||
1928 // Map dvb teletext which has neither property to any output subtitle encoder
1929 input_descriptor && output_descriptor &&
1930 (!input_descriptor->props ||
1931 !output_descriptor->props)) {
1932 new_subtitle_stream(o, oc, i);
1937 /* do something with data? */
1939 for (i = 0; i < o->nb_stream_maps; i++) {
1940 StreamMap *map = &o->stream_maps[i];
1945 if (map->linklabel) {
1947 OutputFilter *ofilter = NULL;
1950 for (j = 0; j < nb_filtergraphs; j++) {
1951 fg = filtergraphs[j];
1952 for (k = 0; k < fg->nb_outputs; k++) {
1953 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1954 if (out && !strcmp(out->name, map->linklabel)) {
1955 ofilter = fg->outputs[k];
1962 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1963 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1966 init_output_filter(ofilter, o, oc);
1968 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1970 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1971 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1973 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1975 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1977 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1980 switch (ist->st->codec->codec_type) {
1981 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1982 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1983 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1984 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1985 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1987 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1988 map->file_index, map->stream_index);
1995 /* handle attached files */
1996 for (i = 0; i < o->nb_attachments; i++) {
1998 uint8_t *attachment;
2002 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2003 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2007 if ((len = avio_size(pb)) <= 0) {
2008 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2012 if (!(attachment = av_malloc(len))) {
2013 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2017 avio_read(pb, attachment, len);
2019 ost = new_attachment_stream(o, oc, -1);
2020 ost->stream_copy = 0;
2021 ost->attachment_filename = o->attachments[i];
2023 ost->enc_ctx->extradata = attachment;
2024 ost->enc_ctx->extradata_size = len;
2026 p = strrchr(o->attachments[i], '/');
2027 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2031 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2032 AVDictionaryEntry *e;
2033 ost = output_streams[i];
2035 if ((ost->stream_copy || ost->attachment_filename)
2036 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2037 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2038 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2042 /* check if all codec options have been used */
2043 unused_opts = strip_specifiers(o->g->codec_opts);
2044 for (i = of->ost_index; i < nb_output_streams; i++) {
2046 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2047 AV_DICT_IGNORE_SUFFIX)))
2048 av_dict_set(&unused_opts, e->key, NULL, 0);
2052 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2053 const AVClass *class = avcodec_get_class();
2054 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2055 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2056 const AVClass *fclass = avformat_get_class();
2057 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2058 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2059 if (!option || foption)
2063 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2064 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2065 "output file #%d (%s) is not an encoding option.\n", e->key,
2066 option->help ? option->help : "", nb_output_files - 1,
2071 // gop_timecode is injected by generic code but not always used
2072 if (!strcmp(e->key, "gop_timecode"))
2075 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2076 "output file #%d (%s) has not been used for any stream. The most "
2077 "likely reason is either wrong type (e.g. a video option with "
2078 "no video streams) or that it is a private option of some encoder "
2079 "which was not actually used for any stream.\n", e->key,
2080 option->help ? option->help : "", nb_output_files - 1, filename);
2082 av_dict_free(&unused_opts);
2084 /* check filename in case of an image number is expected */
2085 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2086 if (!av_filename_number_test(oc->filename)) {
2087 print_error(oc->filename, AVERROR(EINVAL));
2092 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2093 /* test if it already exists to avoid losing precious files */
2094 assert_file_overwrite(filename);
2097 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2098 &oc->interrupt_callback,
2100 print_error(filename, err);
2103 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2104 assert_file_overwrite(filename);
2106 if (o->mux_preload) {
2107 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2109 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2112 for (i = 0; i < o->nb_metadata_map; i++) {
2114 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2116 if (in_file_index >= nb_input_files) {
2117 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2120 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2121 in_file_index >= 0 ?
2122 input_files[in_file_index]->ctx : NULL, o);
2126 if (o->chapters_input_file >= nb_input_files) {
2127 if (o->chapters_input_file == INT_MAX) {
2128 /* copy chapters from the first input file that has them*/
2129 o->chapters_input_file = -1;
2130 for (i = 0; i < nb_input_files; i++)
2131 if (input_files[i]->ctx->nb_chapters) {
2132 o->chapters_input_file = i;
2136 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2137 o->chapters_input_file);
2141 if (o->chapters_input_file >= 0)
2142 copy_chapters(input_files[o->chapters_input_file], of,
2143 !o->metadata_chapters_manual);
2145 /* copy global metadata by default */
2146 if (!o->metadata_global_manual && nb_input_files){
2147 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2148 AV_DICT_DONT_OVERWRITE);
2149 if(o->recording_time != INT64_MAX)
2150 av_dict_set(&oc->metadata, "duration", NULL, 0);
2151 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2153 if (!o->metadata_streams_manual)
2154 for (i = of->ost_index; i < nb_output_streams; i++) {
2156 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2158 ist = input_streams[output_streams[i]->source_index];
2159 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2160 if (!output_streams[i]->stream_copy)
2161 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2164 /* process manually set metadata */
2165 for (i = 0; i < o->nb_metadata; i++) {
2168 const char *stream_spec;
2169 int index = 0, j, ret = 0;
2171 val = strchr(o->metadata[i].u.str, '=');
2173 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2174 o->metadata[i].u.str);
2179 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2181 for (j = 0; j < oc->nb_streams; j++) {
2182 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2183 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2194 if (index < 0 || index >= oc->nb_chapters) {
2195 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2198 m = &oc->chapters[index]->metadata;
2201 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2204 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2211 static int opt_target(void *optctx, const char *opt, const char *arg)
2213 OptionsContext *o = optctx;
2214 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2215 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2217 if (!strncmp(arg, "pal-", 4)) {
2220 } else if (!strncmp(arg, "ntsc-", 5)) {
2223 } else if (!strncmp(arg, "film-", 5)) {
2227 /* Try to determine PAL/NTSC by peeking in the input files */
2228 if (nb_input_files) {
2230 for (j = 0; j < nb_input_files; j++) {
2231 for (i = 0; i < input_files[j]->nb_streams; i++) {
2232 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2233 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2236 fr = c->time_base.den * 1000 / c->time_base.num;
2240 } else if ((fr == 29970) || (fr == 23976)) {
2245 if (norm != UNKNOWN)
2249 if (norm != UNKNOWN)
2250 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2253 if (norm == UNKNOWN) {
2254 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2255 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2256 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2260 if (!strcmp(arg, "vcd")) {
2261 opt_video_codec(o, "c:v", "mpeg1video");
2262 opt_audio_codec(o, "c:a", "mp2");
2263 parse_option(o, "f", "vcd", options);
2265 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2266 parse_option(o, "r", frame_rates[norm], options);
2267 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2269 opt_default(NULL, "b:v", "1150000");
2270 opt_default(NULL, "maxrate", "1150000");
2271 opt_default(NULL, "minrate", "1150000");
2272 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2274 opt_default(NULL, "b:a", "224000");
2275 parse_option(o, "ar", "44100", options);
2276 parse_option(o, "ac", "2", options);
2278 opt_default(NULL, "packetsize", "2324");
2279 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2281 /* We have to offset the PTS, so that it is consistent with the SCR.
2282 SCR starts at 36000, but the first two packs contain only padding
2283 and the first pack from the other stream, respectively, may also have
2284 been written before.
2285 So the real data starts at SCR 36000+3*1200. */
2286 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2287 } else if (!strcmp(arg, "svcd")) {
2289 opt_video_codec(o, "c:v", "mpeg2video");
2290 opt_audio_codec(o, "c:a", "mp2");
2291 parse_option(o, "f", "svcd", options);
2293 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2294 parse_option(o, "r", frame_rates[norm], options);
2295 parse_option(o, "pix_fmt", "yuv420p", options);
2296 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2298 opt_default(NULL, "b:v", "2040000");
2299 opt_default(NULL, "maxrate", "2516000");
2300 opt_default(NULL, "minrate", "0"); // 1145000;
2301 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2302 opt_default(NULL, "scan_offset", "1");
2304 opt_default(NULL, "b:a", "224000");
2305 parse_option(o, "ar", "44100", options);
2307 opt_default(NULL, "packetsize", "2324");
2309 } else if (!strcmp(arg, "dvd")) {
2311 opt_video_codec(o, "c:v", "mpeg2video");
2312 opt_audio_codec(o, "c:a", "ac3");
2313 parse_option(o, "f", "dvd", options);
2315 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2316 parse_option(o, "r", frame_rates[norm], options);
2317 parse_option(o, "pix_fmt", "yuv420p", options);
2318 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2320 opt_default(NULL, "b:v", "6000000");
2321 opt_default(NULL, "maxrate", "9000000");
2322 opt_default(NULL, "minrate", "0"); // 1500000;
2323 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2325 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2326 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2328 opt_default(NULL, "b:a", "448000");
2329 parse_option(o, "ar", "48000", options);
2331 } else if (!strncmp(arg, "dv", 2)) {
2333 parse_option(o, "f", "dv", options);
2335 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2336 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2337 norm == PAL ? "yuv420p" : "yuv411p", options);
2338 parse_option(o, "r", frame_rates[norm], options);
2340 parse_option(o, "ar", "48000", options);
2341 parse_option(o, "ac", "2", options);
2344 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2345 return AVERROR(EINVAL);
2348 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2349 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2354 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2356 av_free (vstats_filename);
2357 vstats_filename = av_strdup (arg);
2361 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2364 time_t today2 = time(NULL);
2365 struct tm *today = localtime(&today2);
2367 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2369 return opt_vstats_file(NULL, opt, filename);
2372 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2374 OptionsContext *o = optctx;
2375 return parse_option(o, "frames:v", arg, options);
2378 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2380 OptionsContext *o = optctx;
2381 return parse_option(o, "frames:a", arg, options);
2384 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2386 OptionsContext *o = optctx;
2387 return parse_option(o, "frames:d", arg, options);
2390 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2393 AVDictionary *cbak = codec_opts;
2394 AVDictionary *fbak = format_opts;
2398 ret = opt_default(NULL, opt, arg);
2400 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2401 av_dict_copy(&o->g->format_opts, format_opts, 0);
2402 av_dict_free(&codec_opts);
2403 av_dict_free(&format_opts);
2410 static int opt_preset(void *optctx, const char *opt, const char *arg)
2412 OptionsContext *o = optctx;
2414 char filename[1000], line[1000], tmp_line[1000];
2415 const char *codec_name = NULL;
2419 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2421 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2422 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2423 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2425 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2429 while (fgets(line, sizeof(line), f)) {
2430 char *key = tmp_line, *value, *endptr;
2432 if (strcspn(line, "#\n\r") == 0)
2434 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2435 if (!av_strtok(key, "=", &value) ||
2436 !av_strtok(value, "\r\n", &endptr)) {
2437 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2440 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2442 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2443 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2444 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2445 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2446 else if (opt_default_new(o, key, value) < 0) {
2447 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2448 filename, line, key, value);
2458 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2460 OptionsContext *o = optctx;
2461 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2462 int ret = parse_option(o, s, arg, options);
2467 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2469 OptionsContext *o = optctx;
2471 if(!strcmp(opt, "ab")){
2472 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2474 } else if(!strcmp(opt, "b")){
2475 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2476 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2479 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2483 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2485 OptionsContext *o = optctx;
2488 if(!strcmp(opt, "qscale")){
2489 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2490 return parse_option(o, "q:v", arg, options);
2492 s = av_asprintf("q%s", opt + 6);
2493 ret = parse_option(o, s, arg, options);
2498 static int opt_profile(void *optctx, const char *opt, const char *arg)
2500 OptionsContext *o = optctx;
2501 if(!strcmp(opt, "profile")){
2502 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2503 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2506 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2510 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2512 OptionsContext *o = optctx;
2513 return parse_option(o, "filter:v", arg, options);
2516 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2518 OptionsContext *o = optctx;
2519 return parse_option(o, "filter:a", arg, options);
2522 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2524 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2525 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2526 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2527 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2529 if (video_sync_method == VSYNC_AUTO)
2530 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2534 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2536 OptionsContext *o = optctx;
2537 char *tcr = av_asprintf("timecode=%s", arg);
2538 int ret = parse_option(o, "metadata:g", tcr, options);
2540 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2545 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2547 OptionsContext *o = optctx;
2548 char layout_str[32];
2551 int ret, channels, ac_str_size;
2554 layout = av_get_channel_layout(arg);
2556 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2557 return AVERROR(EINVAL);
2559 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2560 ret = opt_default_new(o, opt, layout_str);
2564 /* set 'ac' option based on channel layout */
2565 channels = av_get_channel_layout_nb_channels(layout);
2566 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2567 stream_str = strchr(opt, ':');
2568 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2569 ac_str = av_mallocz(ac_str_size);
2571 return AVERROR(ENOMEM);
2572 av_strlcpy(ac_str, "ac", 3);
2574 av_strlcat(ac_str, stream_str, ac_str_size);
2575 ret = parse_option(o, ac_str, layout_str, options);
2581 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2583 OptionsContext *o = optctx;
2584 return parse_option(o, "q:a", arg, options);
2587 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2589 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2590 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2591 return AVERROR(ENOMEM);
2592 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2593 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2594 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2595 return AVERROR(ENOMEM);
2599 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2601 uint8_t *graph_desc = read_file(arg);
2603 return AVERROR(EINVAL);
2605 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2606 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2607 return AVERROR(ENOMEM);
2608 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2609 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2613 void show_help_default(const char *opt, const char *arg)
2615 /* per-file options have at least one of those set */
2616 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2617 int show_advanced = 0, show_avoptions = 0;
2620 if (!strcmp(opt, "long"))
2622 else if (!strcmp(opt, "full"))
2623 show_advanced = show_avoptions = 1;
2625 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2630 printf("Getting help:\n"
2631 " -h -- print basic options\n"
2632 " -h long -- print more options\n"
2633 " -h full -- print all options (including all format and codec specific options, very long)\n"
2634 " See man %s for detailed description of the options.\n"
2635 "\n", program_name);
2637 show_help_options(options, "Print help / information / capabilities:",
2640 show_help_options(options, "Global options (affect whole program "
2641 "instead of just one file:",
2642 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2644 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2645 per_file | OPT_EXIT, 0);
2647 show_help_options(options, "Per-file main options:", 0,
2648 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2649 OPT_EXIT, per_file);
2651 show_help_options(options, "Advanced per-file options:",
2652 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2654 show_help_options(options, "Video options:",
2655 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2657 show_help_options(options, "Advanced Video options:",
2658 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2660 show_help_options(options, "Audio options:",
2661 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2663 show_help_options(options, "Advanced Audio options:",
2664 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2665 show_help_options(options, "Subtitle options:",
2666 OPT_SUBTITLE, 0, 0);
2669 if (show_avoptions) {
2670 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2671 show_help_children(avcodec_get_class(), flags);
2672 show_help_children(avformat_get_class(), flags);
2674 show_help_children(sws_get_class(), flags);
2676 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2677 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2681 void show_usage(void)
2683 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2684 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2685 av_log(NULL, AV_LOG_INFO, "\n");
2693 static const OptionGroupDef groups[] = {
2694 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2695 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2698 static int open_files(OptionGroupList *l, const char *inout,
2699 int (*open_file)(OptionsContext*, const char*))
2703 for (i = 0; i < l->nb_groups; i++) {
2704 OptionGroup *g = &l->groups[i];
2710 ret = parse_optgroup(&o, g);
2712 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2713 "%s.\n", inout, g->arg);
2717 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2718 ret = open_file(&o, g->arg);
2721 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2725 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2731 int ffmpeg_parse_options(int argc, char **argv)
2733 OptionParseContext octx;
2737 memset(&octx, 0, sizeof(octx));
2739 /* split the commandline into an internal representation */
2740 ret = split_commandline(&octx, argc, argv, options, groups,
2741 FF_ARRAY_ELEMS(groups));
2743 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2747 /* apply global options */
2748 ret = parse_optgroup(NULL, &octx.global_opts);
2750 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2754 /* open input files */
2755 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2757 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2761 /* open output files */
2762 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2764 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2769 uninit_parse_context(&octx);
2771 av_strerror(ret, error, sizeof(error));
2772 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2777 static int opt_progress(void *optctx, const char *opt, const char *arg)
2779 AVIOContext *avio = NULL;
2782 if (!strcmp(arg, "-"))
2784 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2786 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2787 arg, av_err2str(ret));
2790 progress_avio = avio;
2794 #define OFFSET(x) offsetof(OptionsContext, x)
2795 const OptionDef options[] = {
2797 #include "cmdutils_common_opts.h"
2798 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2799 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2800 "force format", "fmt" },
2801 { "y", OPT_BOOL, { &file_overwrite },
2802 "overwrite output files" },
2803 { "n", OPT_BOOL, { &no_file_overwrite },
2804 "never overwrite output files" },
2805 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2806 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2807 "codec name", "codec" },
2808 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2809 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2810 "codec name", "codec" },
2811 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2812 OPT_OUTPUT, { .off = OFFSET(presets) },
2813 "preset name", "preset" },
2814 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2815 OPT_OUTPUT, { .func_arg = opt_map },
2816 "set input stream mapping",
2817 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2818 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2819 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2820 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2821 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2822 "set metadata information of outfile from infile",
2823 "outfile[,metadata]:infile[,metadata]" },
2824 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2825 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2826 "set chapters mapping", "input_file_index" },
2827 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2828 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2829 "record or transcode \"duration\" seconds of audio/video",
2831 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2832 "record or transcode stop time", "time_stop" },
2833 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2834 "set the limit file size in bytes", "limit_size" },
2835 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2836 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2837 "set the start time offset", "time_off" },
2838 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2839 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2840 "enable/disable accurate seeking with -ss" },
2841 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2842 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2843 "set the input ts offset", "time_off" },
2844 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2845 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2846 "set the input ts scale", "scale" },
2847 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2848 "set the recording timestamp ('now' to set the current time)", "time" },
2849 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2850 "add metadata", "string=string" },
2851 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2852 OPT_OUTPUT, { .func_arg = opt_data_frames },
2853 "set the number of data frames to output", "number" },
2854 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2855 "add timings for benchmarking" },
2856 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2857 "add timings for each task" },
2858 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2859 "write program-readable progress information", "url" },
2860 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2861 "enable or disable interaction on standard input" },
2862 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2863 "set max runtime in seconds", "limit" },
2864 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2865 "dump each input packet" },
2866 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2867 "when dumping packets, also dump the payload" },
2868 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2869 OPT_INPUT, { .off = OFFSET(rate_emu) },
2870 "read input at native frame rate", "" },
2871 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2872 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2873 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2874 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2875 "video sync method", "" },
2876 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2877 "audio sync method", "" },
2878 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2879 "audio drift threshold", "threshold" },
2880 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2881 "copy timestamps" },
2882 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2883 "shift input timestamps to start at 0 when using copyts" },
2884 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2885 "copy input stream time base when stream copying", "mode" },
2886 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2887 OPT_OUTPUT, { .off = OFFSET(shortest) },
2888 "finish encoding within shortest input" },
2889 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2890 OPT_OUTPUT, { .off = OFFSET(apad) },
2892 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2893 "timestamp discontinuity delta threshold", "threshold" },
2894 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2895 "timestamp error delta threshold", "threshold" },
2896 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2897 "exit on error", "error" },
2898 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2899 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2900 "copy initial non-keyframes" },
2901 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2902 "copy or discard frames before start time" },
2903 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2904 "set the number of frames to output", "number" },
2905 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2906 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2907 "force codec tag/fourcc", "fourcc/tag" },
2908 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2909 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2910 "use fixed quality scale (VBR)", "q" },
2911 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2912 OPT_OUTPUT, { .func_arg = opt_qscale },
2913 "use fixed quality scale (VBR)", "q" },
2914 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2915 "set profile", "profile" },
2916 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2917 "set stream filtergraph", "filter_graph" },
2918 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2919 "read stream filtergraph description from a file", "filename" },
2920 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2921 "reinit filtergraph on input parameter changes", "" },
2922 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2923 "create a complex filtergraph", "graph_description" },
2924 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2925 "create a complex filtergraph", "graph_description" },
2926 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2927 "read complex filtergraph description from a file", "filename" },
2928 { "stats", OPT_BOOL, { &print_stats },
2929 "print progress report during encoding", },
2930 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2931 OPT_OUTPUT, { .func_arg = opt_attach },
2932 "add an attachment to the output file", "filename" },
2933 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2934 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2935 "extract an attachment into a file", "filename" },
2936 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2937 "print timestamp debugging info" },
2938 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2939 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2940 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2941 OPT_INPUT, { .off = OFFSET(discard) },
2943 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
2944 OPT_OUTPUT, { .off = OFFSET(disposition) },
2945 "disposition", "" },
2948 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2949 "set the number of video frames to output", "number" },
2950 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2951 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2952 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2953 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2954 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2955 "set frame size (WxH or abbreviation)", "size" },
2956 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2957 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2958 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2959 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2960 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2961 "set pixel format", "format" },
2962 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2963 "set the number of bits per raw sample", "number" },
2964 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2965 "deprecated use -g 1" },
2966 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2968 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2969 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2970 "rate control override for specific intervals", "override" },
2971 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2972 OPT_OUTPUT, { .func_arg = opt_video_codec },
2973 "force video codec ('copy' to copy stream)", "codec" },
2974 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2976 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2978 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2979 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2980 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2981 "select the pass number (1 to 3)", "n" },
2982 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2983 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2984 "select two pass log file name prefix", "prefix" },
2985 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2986 "this option is deprecated, use the yadif filter instead" },
2987 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2988 "calculate PSNR of compressed frames" },
2989 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2990 "dump video coding statistics to file" },
2991 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2992 "dump video coding statistics to file", "file" },
2993 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2994 "set video filters", "filter_graph" },
2995 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2996 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2997 "specify intra matrix coeffs", "matrix" },
2998 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2999 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3000 "specify inter matrix coeffs", "matrix" },
3001 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3002 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3003 "specify intra matrix coeffs", "matrix" },
3004 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3005 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3006 "top=1/bottom=0/auto=-1 field first", "" },
3007 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3008 OPT_OUTPUT, { .func_arg = opt_old2new },
3009 "force video tag/fourcc", "fourcc/tag" },
3010 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3011 "show QP histogram" },
3012 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3013 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3014 "force the selected framerate, disable the best supported framerate selection" },
3015 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3016 OPT_OUTPUT, { .func_arg = opt_streamid },
3017 "set the value of an outfile streamid", "streamIndex:value" },
3018 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3019 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3020 "force key frames at specified timestamps", "timestamps" },
3021 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3022 "audio bitrate (please use -b:a)", "bitrate" },
3023 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3024 "video bitrate (please use -b:v)", "bitrate" },
3025 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3026 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3027 "use HW accelerated decoding", "hwaccel name" },
3028 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3029 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3030 "select a device for HW acceleration" "devicename" },
3032 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3036 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3037 "set the number of audio frames to output", "number" },
3038 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3039 "set audio quality (codec-specific)", "quality", },
3040 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3041 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3042 "set audio sampling rate (in Hz)", "rate" },
3043 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3044 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3045 "set number of audio channels", "channels" },
3046 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3048 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3049 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3050 "force audio codec ('copy' to copy stream)", "codec" },
3051 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3052 OPT_OUTPUT, { .func_arg = opt_old2new },
3053 "force audio tag/fourcc", "fourcc/tag" },
3054 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3055 "change audio volume (256=normal)" , "volume" },
3056 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3057 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3058 "set sample format", "format" },
3059 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3060 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3061 "set channel layout", "layout" },
3062 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3063 "set audio filters", "filter_graph" },
3064 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3065 "set the maximum number of channels to try to guess the channel layout" },
3067 /* subtitle options */
3068 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3069 "disable subtitle" },
3070 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3071 "force subtitle codec ('copy' to copy stream)", "codec" },
3072 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3073 , "force subtitle tag/fourcc", "fourcc/tag" },
3074 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3075 "fix subtitles duration" },
3076 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3077 "set canvas size (WxH or abbreviation)", "size" },
3080 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3081 "deprecated, use -channel", "channel" },
3082 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3083 "deprecated, use -standard", "standard" },
3084 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3087 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3088 "set the maximum demux-decode delay", "seconds" },
3089 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3090 "set the initial demux-decode delay", "seconds" },
3091 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3092 "override the options from ffserver", "" },
3093 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3094 "specify a file in which to print sdp information", "file" },
3096 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3097 "A comma-separated list of bitstream filters", "bitstream_filters" },
3098 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3099 "deprecated", "audio bitstream_filters" },
3100 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3101 "deprecated", "video bitstream_filters" },
3103 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3104 "set the audio options to the indicated preset", "preset" },
3105 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3106 "set the video options to the indicated preset", "preset" },
3107 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3108 "set the subtitle options to the indicated preset", "preset" },
3109 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3110 "set options from indicated preset file", "filename" },
3111 /* data codec support */
3112 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3113 "force data codec ('copy' to copy stream)", "codec" },
3114 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },