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 float frame_drop_threshold = 0;
90 int do_deinterlace = 0;
92 int do_benchmark_all = 0;
96 int start_at_zero = 0;
99 int exit_on_error = 0;
100 int print_stats = -1;
102 int stdin_interaction = 1;
103 int frame_bits_per_raw_sample = 0;
104 float max_error_rate = 2.0/3;
107 static int intra_only = 0;
108 static int file_overwrite = 0;
109 static int no_file_overwrite = 0;
110 static int do_psnr = 0;
111 static int input_sync;
112 static int override_ffserver = 0;
114 static void uninit_options(OptionsContext *o)
116 const OptionDef *po = options;
119 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
121 void *dst = (uint8_t*)o + po->u.off;
123 if (po->flags & OPT_SPEC) {
124 SpecifierOpt **so = dst;
125 int i, *count = (int*)(so + 1);
126 for (i = 0; i < *count; i++) {
127 av_freep(&(*so)[i].specifier);
128 if (po->flags & OPT_STRING)
129 av_freep(&(*so)[i].u.str);
133 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
138 for (i = 0; i < o->nb_stream_maps; i++)
139 av_freep(&o->stream_maps[i].linklabel);
140 av_freep(&o->stream_maps);
141 av_freep(&o->audio_channel_maps);
142 av_freep(&o->streamid_map);
143 av_freep(&o->attachments);
146 static void init_options(OptionsContext *o)
148 memset(o, 0, sizeof(*o));
150 o->stop_time = INT64_MAX;
151 o->mux_max_delay = 0.7;
152 o->start_time = AV_NOPTS_VALUE;
153 o->recording_time = INT64_MAX;
154 o->limit_filesize = UINT64_MAX;
155 o->chapters_input_file = INT_MAX;
156 o->accurate_seek = 1;
159 /* return a copy of the input with the stream specifiers removed from the keys */
160 static AVDictionary *strip_specifiers(AVDictionary *dict)
162 AVDictionaryEntry *e = NULL;
163 AVDictionary *ret = NULL;
165 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
166 char *p = strchr(e->key, ':');
170 av_dict_set(&ret, e->key, e->value, 0);
177 static int opt_sameq(void *optctx, const char *opt, const char *arg)
179 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
180 "If you are looking for an option to preserve the quality (which is not "
181 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
183 return AVERROR(EINVAL);
186 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
188 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
189 return opt_default(optctx, "channel", arg);
192 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
194 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
195 return opt_default(optctx, "standard", arg);
198 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
200 OptionsContext *o = optctx;
201 return parse_option(o, "codec:a", arg, options);
204 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
206 OptionsContext *o = optctx;
207 return parse_option(o, "codec:v", arg, options);
210 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
212 OptionsContext *o = optctx;
213 return parse_option(o, "codec:s", arg, options);
216 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
218 OptionsContext *o = optctx;
219 return parse_option(o, "codec:d", arg, options);
222 static int opt_map(void *optctx, const char *opt, const char *arg)
224 OptionsContext *o = optctx;
226 int i, negative = 0, file_idx;
227 int sync_file_idx = -1, sync_stream_idx = 0;
235 map = av_strdup(arg);
237 return AVERROR(ENOMEM);
239 /* parse sync stream first, just pick first matching stream */
240 if (sync = strchr(map, ',')) {
242 sync_file_idx = strtol(sync + 1, &sync, 0);
243 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
244 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
249 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
250 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
251 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
255 if (i == input_files[sync_file_idx]->nb_streams) {
256 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
257 "match any streams.\n", arg);
264 /* this mapping refers to lavfi output */
265 const char *c = map + 1;
266 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
267 m = &o->stream_maps[o->nb_stream_maps - 1];
268 m->linklabel = av_get_token(&c, "]");
270 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
274 file_idx = strtol(map, &p, 0);
275 if (file_idx >= nb_input_files || file_idx < 0) {
276 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
280 /* disable some already defined maps */
281 for (i = 0; i < o->nb_stream_maps; i++) {
282 m = &o->stream_maps[i];
283 if (file_idx == m->file_index &&
284 check_stream_specifier(input_files[m->file_index]->ctx,
285 input_files[m->file_index]->ctx->streams[m->stream_index],
286 *p == ':' ? p + 1 : p) > 0)
290 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
291 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
292 *p == ':' ? p + 1 : p) <= 0)
294 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
295 m = &o->stream_maps[o->nb_stream_maps - 1];
297 m->file_index = file_idx;
300 if (sync_file_idx >= 0) {
301 m->sync_file_index = sync_file_idx;
302 m->sync_stream_index = sync_stream_idx;
304 m->sync_file_index = file_idx;
305 m->sync_stream_index = i;
311 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
319 static int opt_attach(void *optctx, const char *opt, const char *arg)
321 OptionsContext *o = optctx;
322 GROW_ARRAY(o->attachments, o->nb_attachments);
323 o->attachments[o->nb_attachments - 1] = arg;
327 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
329 OptionsContext *o = optctx;
334 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
335 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
337 /* muted channel syntax */
338 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
339 if ((n == 1 || n == 3) && m->channel_idx == -1) {
340 m->file_idx = m->stream_idx = -1;
342 m->ofile_idx = m->ostream_idx = -1;
347 n = sscanf(arg, "%d.%d.%d:%d.%d",
348 &m->file_idx, &m->stream_idx, &m->channel_idx,
349 &m->ofile_idx, &m->ostream_idx);
351 if (n != 3 && n != 5) {
352 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
353 "[file.stream.channel|-1][:syncfile:syncstream]\n");
357 if (n != 5) // only file.stream.channel specified
358 m->ofile_idx = m->ostream_idx = -1;
361 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
362 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
366 if (m->stream_idx < 0 ||
367 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
368 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
369 m->file_idx, m->stream_idx);
372 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
373 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
374 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
375 m->file_idx, m->stream_idx);
378 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
379 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
380 m->file_idx, m->stream_idx, m->channel_idx);
386 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
388 av_free(sdp_filename);
389 sdp_filename = av_strdup(arg);
394 * Parse a metadata specifier passed as 'arg' parameter.
395 * @param arg metadata string to parse
396 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
397 * @param index for type c/p, chapter/program index is written here
398 * @param stream_spec for type s, the stream specifier is written here
400 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
408 if (*(++arg) && *arg != ':') {
409 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
412 *stream_spec = *arg == ':' ? arg + 1 : "";
417 *index = strtol(++arg, NULL, 0);
420 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
427 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
429 AVDictionary **meta_in = NULL;
430 AVDictionary **meta_out = NULL;
432 char type_in, type_out;
433 const char *istream_spec = NULL, *ostream_spec = NULL;
434 int idx_in = 0, idx_out = 0;
436 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
437 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
440 if (type_out == 'g' || !*outspec)
441 o->metadata_global_manual = 1;
442 if (type_out == 's' || !*outspec)
443 o->metadata_streams_manual = 1;
444 if (type_out == 'c' || !*outspec)
445 o->metadata_chapters_manual = 1;
449 if (type_in == 'g' || type_out == 'g')
450 o->metadata_global_manual = 1;
451 if (type_in == 's' || type_out == 's')
452 o->metadata_streams_manual = 1;
453 if (type_in == 'c' || type_out == 'c')
454 o->metadata_chapters_manual = 1;
456 /* ic is NULL when just disabling automatic mappings */
460 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
461 if ((index) < 0 || (index) >= (nb_elems)) {\
462 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
467 #define SET_DICT(type, meta, context, index)\
470 meta = &context->metadata;\
473 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
474 meta = &context->chapters[index]->metadata;\
477 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
478 meta = &context->programs[index]->metadata;\
481 break; /* handled separately below */ \
482 default: av_assert0(0);\
485 SET_DICT(type_in, meta_in, ic, idx_in);
486 SET_DICT(type_out, meta_out, oc, idx_out);
488 /* for input streams choose first matching stream */
489 if (type_in == 's') {
490 for (i = 0; i < ic->nb_streams; i++) {
491 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
492 meta_in = &ic->streams[i]->metadata;
498 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
503 if (type_out == 's') {
504 for (i = 0; i < oc->nb_streams; i++) {
505 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
506 meta_out = &oc->streams[i]->metadata;
507 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
512 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
517 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
519 OptionsContext *o = optctx;
521 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
522 struct tm time = *gmtime((time_t*)&recording_timestamp);
523 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
525 parse_option(o, "metadata", buf, options);
527 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
528 "tag instead.\n", opt);
532 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
534 const AVCodecDescriptor *desc;
535 const char *codec_string = encoder ? "encoder" : "decoder";
539 avcodec_find_encoder_by_name(name) :
540 avcodec_find_decoder_by_name(name);
542 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
543 codec = encoder ? avcodec_find_encoder(desc->id) :
544 avcodec_find_decoder(desc->id);
546 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
547 codec_string, codec->name, desc->name);
551 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
554 if (codec->type != type) {
555 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
561 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
563 char *codec_name = NULL;
565 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
567 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
568 st->codec->codec_id = codec->id;
571 return avcodec_find_decoder(st->codec->codec_id);
574 /* Add all the streams from the given input file to the global
575 * list of input streams. */
576 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
580 for (i = 0; i < ic->nb_streams; i++) {
581 AVStream *st = ic->streams[i];
582 AVCodecContext *dec = st->codec;
583 InputStream *ist = av_mallocz(sizeof(*ist));
584 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
585 char *codec_tag = NULL;
587 char *discard_str = NULL;
588 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
593 GROW_ARRAY(input_streams, nb_input_streams);
594 input_streams[nb_input_streams - 1] = ist;
597 ist->file_index = nb_input_files;
599 st->discard = AVDISCARD_ALL;
602 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
604 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
606 uint32_t tag = strtol(codec_tag, &next, 0);
608 tag = AV_RL32(codec_tag);
609 st->codec->codec_tag = tag;
612 ist->dec = choose_decoder(o, ic, st);
613 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
615 ist->reinit_filters = -1;
616 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
618 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
619 ist->user_set_discard = AVDISCARD_NONE;
620 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
621 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
626 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
628 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
630 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
634 ret = avcodec_copy_context(ist->dec_ctx, dec);
636 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
640 switch (dec->codec_type) {
641 case AVMEDIA_TYPE_VIDEO:
643 ist->dec = avcodec_find_decoder(dec->codec_id);
644 if (av_codec_get_lowres(dec)) {
645 dec->flags |= CODEC_FLAG_EMU_EDGE;
648 ist->resample_height = ist->dec_ctx->height;
649 ist->resample_width = ist->dec_ctx->width;
650 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
652 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
653 if (framerate && av_parse_video_rate(&ist->framerate,
655 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
660 ist->top_field_first = -1;
661 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
663 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
665 if (!strcmp(hwaccel, "none"))
666 ist->hwaccel_id = HWACCEL_NONE;
667 else if (!strcmp(hwaccel, "auto"))
668 ist->hwaccel_id = HWACCEL_AUTO;
671 for (i = 0; hwaccels[i].name; i++) {
672 if (!strcmp(hwaccels[i].name, hwaccel)) {
673 ist->hwaccel_id = hwaccels[i].id;
678 if (!ist->hwaccel_id) {
679 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
681 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
682 for (i = 0; hwaccels[i].name; i++)
683 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
684 av_log(NULL, AV_LOG_FATAL, "\n");
690 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
691 if (hwaccel_device) {
692 ist->hwaccel_device = av_strdup(hwaccel_device);
693 if (!ist->hwaccel_device)
696 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
699 case AVMEDIA_TYPE_AUDIO:
700 ist->guess_layout_max = INT_MAX;
701 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
702 guess_input_channel_layout(ist);
704 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
705 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
706 ist->resample_channels = ist->dec_ctx->channels;
707 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
710 case AVMEDIA_TYPE_DATA:
711 case AVMEDIA_TYPE_SUBTITLE: {
712 char *canvas_size = NULL;
714 ist->dec = avcodec_find_decoder(dec->codec_id);
715 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
716 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
718 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
719 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
724 case AVMEDIA_TYPE_ATTACHMENT:
725 case AVMEDIA_TYPE_UNKNOWN:
733 static void assert_file_overwrite(const char *filename)
735 if (file_overwrite && no_file_overwrite) {
736 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
740 if (!file_overwrite) {
741 const char *proto_name = avio_find_protocol_name(filename);
742 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
743 if (stdin_interaction && !no_file_overwrite) {
744 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
747 signal(SIGINT, SIG_DFL);
749 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
755 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
762 static void dump_attachment(AVStream *st, const char *filename)
765 AVIOContext *out = NULL;
766 AVDictionaryEntry *e;
768 if (!st->codec->extradata_size) {
769 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
770 nb_input_files - 1, st->index);
773 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
776 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
777 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
781 assert_file_overwrite(filename);
783 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
784 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
789 avio_write(out, st->codec->extradata, st->codec->extradata_size);
794 static int open_input_file(OptionsContext *o, const char *filename)
798 AVInputFormat *file_iformat = NULL;
802 AVDictionary *unused_opts = NULL;
803 AVDictionaryEntry *e = NULL;
804 int orig_nb_streams; // number of streams before avformat_find_stream_info
805 char * video_codec_name = NULL;
806 char * audio_codec_name = NULL;
807 char *subtitle_codec_name = NULL;
808 char * data_codec_name = NULL;
809 int scan_all_pmts_set = 0;
812 if (!(file_iformat = av_find_input_format(o->format))) {
813 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
818 if (!strcmp(filename, "-"))
821 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
822 strcmp(filename, "/dev/stdin");
824 /* get default parameters from command line */
825 ic = avformat_alloc_context();
827 print_error(filename, AVERROR(ENOMEM));
830 if (o->nb_audio_sample_rate) {
831 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
833 if (o->nb_audio_channels) {
834 /* because we set audio_channels based on both the "ac" and
835 * "channel_layout" options, we need to check that the specified
836 * demuxer actually has the "channels" option before setting it */
837 if (file_iformat && file_iformat->priv_class &&
838 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
839 AV_OPT_SEARCH_FAKE_OBJ)) {
840 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
843 if (o->nb_frame_rates) {
844 /* set the format-level framerate option;
845 * this is important for video grabbers, e.g. x11 */
846 if (file_iformat && file_iformat->priv_class &&
847 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
848 AV_OPT_SEARCH_FAKE_OBJ)) {
849 av_dict_set(&o->g->format_opts, "framerate",
850 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
853 if (o->nb_frame_sizes) {
854 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
856 if (o->nb_frame_pix_fmts)
857 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
859 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
860 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
861 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
862 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
864 ic->video_codec_id = video_codec_name ?
865 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
866 ic->audio_codec_id = audio_codec_name ?
867 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
868 ic->subtitle_codec_id= subtitle_codec_name ?
869 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
870 ic->data_codec_id = data_codec_name ?
871 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
873 if (video_codec_name)
874 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
875 if (audio_codec_name)
876 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
877 if (subtitle_codec_name)
878 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
880 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
882 ic->flags |= AVFMT_FLAG_NONBLOCK;
883 ic->interrupt_callback = int_cb;
885 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
886 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
887 scan_all_pmts_set = 1;
889 /* open the input file with generic avformat function */
890 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
892 print_error(filename, err);
895 if (scan_all_pmts_set)
896 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
897 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
898 assert_avoptions(o->g->format_opts);
900 /* apply forced codec ids */
901 for (i = 0; i < ic->nb_streams; i++)
902 choose_decoder(o, ic, ic->streams[i]);
904 /* Set AVCodecContext options for avformat_find_stream_info */
905 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
906 orig_nb_streams = ic->nb_streams;
908 /* If not enough info to get the stream parameters, we decode the
909 first frames to get it. (used in mpeg case for example) */
910 ret = avformat_find_stream_info(ic, opts);
912 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
913 if (ic->nb_streams == 0) {
914 avformat_close_input(&ic);
919 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
920 /* add the stream start time */
921 if (ic->start_time != AV_NOPTS_VALUE)
922 timestamp += ic->start_time;
924 /* if seeking requested, we execute it */
925 if (o->start_time != AV_NOPTS_VALUE) {
926 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
928 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
929 filename, (double)timestamp / AV_TIME_BASE);
933 /* update the current parameters so that they match the one of the input stream */
934 add_input_streams(o, ic);
936 /* dump the file content */
937 av_dump_format(ic, nb_input_files, filename, 0);
939 GROW_ARRAY(input_files, nb_input_files);
940 f = av_mallocz(sizeof(*f));
943 input_files[nb_input_files - 1] = f;
946 f->ist_index = nb_input_streams - ic->nb_streams;
947 f->start_time = o->start_time;
948 f->recording_time = o->recording_time;
949 f->input_ts_offset = o->input_ts_offset;
950 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
951 f->nb_streams = ic->nb_streams;
952 f->rate_emu = o->rate_emu;
953 f->accurate_seek = o->accurate_seek;
955 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
958 /* check if all codec options have been used */
959 unused_opts = strip_specifiers(o->g->codec_opts);
960 for (i = f->ist_index; i < nb_input_streams; i++) {
962 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
963 AV_DICT_IGNORE_SUFFIX)))
964 av_dict_set(&unused_opts, e->key, NULL, 0);
968 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
969 const AVClass *class = avcodec_get_class();
970 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
971 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
972 const AVClass *fclass = avformat_get_class();
973 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
974 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
975 if (!option || foption)
979 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
980 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
981 "input file #%d (%s) is not a decoding option.\n", e->key,
982 option->help ? option->help : "", nb_input_files - 1,
987 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
988 "input file #%d (%s) has not been used for any stream. The most "
989 "likely reason is either wrong type (e.g. a video option with "
990 "no video streams) or that it is a private option of some decoder "
991 "which was not actually used for any stream.\n", e->key,
992 option->help ? option->help : "", nb_input_files - 1, filename);
994 av_dict_free(&unused_opts);
996 for (i = 0; i < o->nb_dump_attachment; i++) {
999 for (j = 0; j < ic->nb_streams; j++) {
1000 AVStream *st = ic->streams[j];
1002 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1003 dump_attachment(st, o->dump_attachment[i].u.str);
1007 for (i = 0; i < orig_nb_streams; i++)
1008 av_dict_free(&opts[i]);
1014 static uint8_t *get_line(AVIOContext *s)
1020 if (avio_open_dyn_buf(&line) < 0) {
1021 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1025 while ((c = avio_r8(s)) && c != '\n')
1028 avio_close_dyn_buf(line, &buf);
1033 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1036 char filename[1000];
1037 const char *base[3] = { getenv("AVCONV_DATADIR"),
1042 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1046 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1047 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1048 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1051 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1052 i != 1 ? "" : "/.avconv", preset_name);
1053 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1059 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1061 char *codec_name = NULL;
1063 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1065 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1066 NULL, ost->st->codec->codec_type);
1067 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1068 } else if (!strcmp(codec_name, "copy"))
1069 ost->stream_copy = 1;
1071 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1072 ost->st->codec->codec_id = ost->enc->id;
1076 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1079 AVStream *st = avformat_new_stream(oc, NULL);
1080 int idx = oc->nb_streams - 1, ret = 0;
1081 char *bsf = NULL, *next, *codec_tag = NULL;
1082 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1087 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1091 if (oc->nb_streams - 1 < o->nb_streamid_map)
1092 st->id = o->streamid_map[oc->nb_streams - 1];
1094 GROW_ARRAY(output_streams, nb_output_streams);
1095 if (!(ost = av_mallocz(sizeof(*ost))))
1097 output_streams[nb_output_streams - 1] = ost;
1099 ost->file_index = nb_output_files - 1;
1102 st->codec->codec_type = type;
1103 choose_encoder(o, oc, ost);
1105 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1106 if (!ost->enc_ctx) {
1107 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1110 ost->enc_ctx->codec_type = type;
1113 AVIOContext *s = NULL;
1114 char *buf = NULL, *arg = NULL, *preset = NULL;
1116 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1118 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1119 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1122 if (!buf[0] || buf[0] == '#') {
1126 if (!(arg = strchr(buf, '='))) {
1127 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1131 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1133 } while (!s->eof_reached);
1137 av_log(NULL, AV_LOG_FATAL,
1138 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1139 preset, ost->file_index, ost->index);
1143 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1146 ost->max_frames = INT64_MAX;
1147 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1148 for (i = 0; i<o->nb_max_frames; i++) {
1149 char *p = o->max_frames[i].specifier;
1150 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1151 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1156 ost->copy_prior_start = -1;
1157 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1159 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1162 if (next = strchr(bsf, ','))
1164 if (arg = strchr(bsf, '='))
1166 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1167 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1171 bsfc_prev->next = bsfc;
1173 ost->bitstream_filters = bsfc;
1174 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1180 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1182 uint32_t tag = strtol(codec_tag, &next, 0);
1184 tag = AV_RL32(codec_tag);
1185 ost->enc_ctx->codec_tag = tag;
1188 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1190 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1191 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1194 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1195 ost->disposition = av_strdup(ost->disposition);
1197 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1198 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1200 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1202 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1203 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1204 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1206 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1208 ost->source_index = source_index;
1209 if (source_index >= 0) {
1210 ost->sync_ist = input_streams[source_index];
1211 input_streams[source_index]->discard = 0;
1212 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1214 ost->last_mux_dts = AV_NOPTS_VALUE;
1219 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1222 const char *p = str;
1229 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1236 /* read file contents into a string */
1237 static uint8_t *read_file(const char *filename)
1239 AVIOContext *pb = NULL;
1240 AVIOContext *dyn_buf = NULL;
1241 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1242 uint8_t buf[1024], *str;
1245 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1249 ret = avio_open_dyn_buf(&dyn_buf);
1254 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1255 avio_write(dyn_buf, buf, ret);
1256 avio_w8(dyn_buf, 0);
1259 ret = avio_close_dyn_buf(dyn_buf, &str);
1265 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1268 AVStream *st = ost->st;
1270 if (ost->filters_script && ost->filters) {
1271 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1272 "output stream #%d:%d.\n", nb_output_files, st->index);
1276 if (ost->filters_script)
1277 return read_file(ost->filters_script);
1278 else if (ost->filters)
1279 return av_strdup(ost->filters);
1281 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1285 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1286 const OutputStream *ost, enum AVMediaType type)
1288 if (ost->filters_script || ost->filters) {
1289 av_log(NULL, AV_LOG_ERROR,
1290 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1291 "Filtering and streamcopy cannot be used together.\n",
1292 ost->filters ? "Filtergraph" : "Filtergraph script",
1293 ost->filters ? ost->filters : ost->filters_script,
1294 av_get_media_type_string(type), ost->file_index, ost->index);
1299 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1303 AVCodecContext *video_enc;
1304 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1306 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1308 video_enc = ost->enc_ctx;
1310 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1311 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1312 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1315 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1316 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1318 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1319 if (frame_aspect_ratio) {
1321 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1322 q.num <= 0 || q.den <= 0) {
1323 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1326 ost->frame_aspect_ratio = q;
1329 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1330 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1332 if (!ost->stream_copy) {
1333 const char *p = NULL;
1334 char *frame_size = NULL;
1335 char *frame_pix_fmt = NULL;
1336 char *intra_matrix = NULL, *inter_matrix = NULL;
1337 char *chroma_intra_matrix = NULL;
1341 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1342 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1343 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1347 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1348 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1349 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1350 ost->keep_pix_fmt = 1;
1351 if (!*++frame_pix_fmt)
1352 frame_pix_fmt = NULL;
1354 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1355 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1358 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1361 video_enc->gop_size = 0;
1362 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1364 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1365 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1368 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1370 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1371 if (chroma_intra_matrix) {
1372 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1374 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1377 av_codec_set_chroma_intra_matrix(video_enc, p);
1378 parse_matrix_coeffs(p, chroma_intra_matrix);
1380 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1382 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1383 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1386 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1389 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1390 for (i = 0; p; i++) {
1392 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1394 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1397 video_enc->rc_override =
1398 av_realloc_array(video_enc->rc_override,
1399 i + 1, sizeof(RcOverride));
1400 if (!video_enc->rc_override) {
1401 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1404 video_enc->rc_override[i].start_frame = start;
1405 video_enc->rc_override[i].end_frame = end;
1407 video_enc->rc_override[i].qscale = q;
1408 video_enc->rc_override[i].quality_factor = 1.0;
1411 video_enc->rc_override[i].qscale = 0;
1412 video_enc->rc_override[i].quality_factor = -q/100.0;
1417 video_enc->rc_override_count = i;
1420 video_enc->flags|= CODEC_FLAG_PSNR;
1423 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1426 video_enc->flags |= CODEC_FLAG_PASS1;
1427 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1430 video_enc->flags |= CODEC_FLAG_PASS2;
1431 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1435 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1436 if (ost->logfile_prefix &&
1437 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1440 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1441 if (ost->forced_keyframes)
1442 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1444 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1446 ost->top_field_first = -1;
1447 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1450 ost->avfilter = get_ost_filters(o, oc, ost);
1454 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1457 if (ost->stream_copy)
1458 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1463 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1468 AVCodecContext *audio_enc;
1470 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1473 audio_enc = ost->enc_ctx;
1474 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1476 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1477 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1479 if (!ost->stream_copy) {
1480 char *sample_fmt = NULL;
1482 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1484 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1486 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1487 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1491 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1493 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1494 ost->apad = av_strdup(ost->apad);
1496 ost->avfilter = get_ost_filters(o, oc, ost);
1500 /* check for channel mapping for this audio stream */
1501 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1502 AudioChannelMap *map = &o->audio_channel_maps[n];
1503 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1504 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1507 if (map->channel_idx == -1) {
1509 } else if (ost->source_index < 0) {
1510 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1511 ost->file_index, ost->st->index);
1514 ist = input_streams[ost->source_index];
1517 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1518 if (av_reallocp_array(&ost->audio_channels_map,
1519 ost->audio_channels_mapped + 1,
1520 sizeof(*ost->audio_channels_map)
1524 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1530 if (ost->stream_copy)
1531 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1536 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1540 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1541 if (!ost->stream_copy) {
1542 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1549 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1551 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1552 ost->stream_copy = 1;
1557 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1561 AVCodecContext *subtitle_enc;
1563 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1565 subtitle_enc = ost->enc_ctx;
1567 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1569 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1571 if (!ost->stream_copy) {
1572 char *frame_size = NULL;
1574 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1575 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1576 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1584 /* arg format is "output-stream-index:streamid-value". */
1585 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1587 OptionsContext *o = optctx;
1592 av_strlcpy(idx_str, arg, sizeof(idx_str));
1593 p = strchr(idx_str, ':');
1595 av_log(NULL, AV_LOG_FATAL,
1596 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1601 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1602 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1603 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1607 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1609 AVFormatContext *is = ifile->ctx;
1610 AVFormatContext *os = ofile->ctx;
1614 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1616 return AVERROR(ENOMEM);
1619 for (i = 0; i < is->nb_chapters; i++) {
1620 AVChapter *in_ch = is->chapters[i], *out_ch;
1621 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1622 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1623 AV_TIME_BASE_Q, in_ch->time_base);
1624 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1625 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1628 if (in_ch->end < ts_off)
1630 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1633 out_ch = av_mallocz(sizeof(AVChapter));
1635 return AVERROR(ENOMEM);
1637 out_ch->id = in_ch->id;
1638 out_ch->time_base = in_ch->time_base;
1639 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1640 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1643 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1645 os->chapters[os->nb_chapters++] = out_ch;
1650 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1653 AVFormatContext *ic = avformat_alloc_context();
1655 ic->interrupt_callback = int_cb;
1656 err = avformat_open_input(&ic, filename, NULL, NULL);
1659 /* copy stream format */
1660 for(i=0;i<ic->nb_streams;i++) {
1664 const char *enc_config;
1666 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1668 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1669 return AVERROR(EINVAL);
1671 if (codec->type == AVMEDIA_TYPE_AUDIO)
1672 opt_audio_codec(o, "c:a", codec->name);
1673 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1674 opt_video_codec(o, "c:v", codec->name);
1675 ost = new_output_stream(o, s, codec->type, -1);
1678 avcodec_get_context_defaults3(st->codec, codec);
1679 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1681 AVDictionary *opts = NULL;
1682 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1683 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1684 av_dict_free(&opts);
1687 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1688 choose_sample_fmt(st, codec);
1689 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1690 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1691 avcodec_copy_context(ost->enc_ctx, st->codec);
1693 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1696 avformat_close_input(&ic);
1700 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1701 AVFormatContext *oc)
1705 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1706 ofilter->out_tmp->pad_idx)) {
1707 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1708 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1710 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1715 ost->source_index = -1;
1716 ost->filter = ofilter;
1720 if (ost->stream_copy) {
1721 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1722 "which is fed from a complex filtergraph. Filtering and streamcopy "
1723 "cannot be used together.\n", ost->file_index, ost->index);
1727 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1728 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1729 av_log(NULL, AV_LOG_ERROR,
1730 "%s '%s' was specified through the %s option "
1731 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1732 "%s and -filter_complex cannot be used together for the same stream.\n",
1733 ost->filters ? "Filtergraph" : "Filtergraph script",
1734 ost->filters ? ost->filters : ost->filters_script,
1735 opt, ost->file_index, ost->index, opt);
1739 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1740 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1743 avfilter_inout_free(&ofilter->out_tmp);
1746 static int configure_complex_filters(void)
1750 for (i = 0; i < nb_filtergraphs; i++)
1751 if (!filtergraphs[i]->graph &&
1752 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1757 static int open_output_file(OptionsContext *o, const char *filename)
1759 AVFormatContext *oc;
1761 AVOutputFormat *file_oformat;
1765 AVDictionary *unused_opts = NULL;
1766 AVDictionaryEntry *e = NULL;
1768 if (configure_complex_filters() < 0) {
1769 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1773 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1774 o->stop_time = INT64_MAX;
1775 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1778 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1779 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1780 if (o->stop_time <= start_time) {
1781 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1784 o->recording_time = o->stop_time - start_time;
1788 GROW_ARRAY(output_files, nb_output_files);
1789 of = av_mallocz(sizeof(*of));
1792 output_files[nb_output_files - 1] = of;
1794 of->ost_index = nb_output_streams;
1795 of->recording_time = o->recording_time;
1796 of->start_time = o->start_time;
1797 of->limit_filesize = o->limit_filesize;
1798 of->shortest = o->shortest;
1799 av_dict_copy(&of->opts, o->g->format_opts, 0);
1801 if (!strcmp(filename, "-"))
1804 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1806 print_error(filename, err);
1811 if (o->recording_time != INT64_MAX)
1812 oc->duration = o->recording_time;
1814 file_oformat= oc->oformat;
1815 oc->interrupt_callback = int_cb;
1817 /* create streams for all unlabeled output pads */
1818 for (i = 0; i < nb_filtergraphs; i++) {
1819 FilterGraph *fg = filtergraphs[i];
1820 for (j = 0; j < fg->nb_outputs; j++) {
1821 OutputFilter *ofilter = fg->outputs[j];
1823 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1826 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1827 ofilter->out_tmp->pad_idx)) {
1828 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1829 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1830 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1832 init_output_filter(ofilter, o, oc);
1836 /* ffserver seeking with date=... needs a date reference */
1837 if (!strcmp(file_oformat->name, "ffm") &&
1838 av_strstart(filename, "http:", NULL)) {
1839 int err = parse_option(o, "metadata", "creation_time=now", options);
1841 print_error(filename, err);
1846 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1847 av_strstart(filename, "http:", NULL)) {
1849 /* special case for files sent to ffserver: we get the stream
1850 parameters from ffserver */
1851 int err = read_ffserver_streams(o, oc, filename);
1853 print_error(filename, err);
1856 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1857 ost = output_streams[j];
1858 for (i = 0; i < nb_input_streams; i++) {
1859 ist = input_streams[i];
1860 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1862 ost->source_index= i;
1863 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1864 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1866 ist->st->discard = ist->user_set_discard;
1871 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));
1875 } else if (!o->nb_stream_maps) {
1876 char *subtitle_codec_name = NULL;
1877 /* pick the "best" stream of each type */
1879 /* video: highest resolution */
1880 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1881 int area = 0, idx = -1;
1882 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1883 for (i = 0; i < nb_input_streams; i++) {
1885 ist = input_streams[i];
1886 new_area = ist->st->codec->width * ist->st->codec->height;
1887 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1889 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1891 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1898 new_video_stream(o, oc, idx);
1901 /* audio: most channels */
1902 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1903 int channels = 0, idx = -1;
1904 for (i = 0; i < nb_input_streams; i++) {
1905 ist = input_streams[i];
1906 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1907 ist->st->codec->channels > channels) {
1908 channels = ist->st->codec->channels;
1913 new_audio_stream(o, oc, idx);
1916 /* subtitles: pick first */
1917 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1918 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1919 for (i = 0; i < nb_input_streams; i++)
1920 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1921 AVCodecDescriptor const *input_descriptor =
1922 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1923 AVCodecDescriptor const *output_descriptor = NULL;
1924 AVCodec const *output_codec =
1925 avcodec_find_encoder(oc->oformat->subtitle_codec);
1926 int input_props = 0, output_props = 0;
1928 output_descriptor = avcodec_descriptor_get(output_codec->id);
1929 if (input_descriptor)
1930 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1931 if (output_descriptor)
1932 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1933 if (subtitle_codec_name ||
1934 input_props & output_props ||
1935 // Map dvb teletext which has neither property to any output subtitle encoder
1936 input_descriptor && output_descriptor &&
1937 (!input_descriptor->props ||
1938 !output_descriptor->props)) {
1939 new_subtitle_stream(o, oc, i);
1944 /* Data only if codec id match */
1945 if (!o->data_disable ) {
1946 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
1947 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1948 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1949 && input_streams[i]->st->codec->codec_id == codec_id )
1950 new_data_stream(o, oc, i);
1954 for (i = 0; i < o->nb_stream_maps; i++) {
1955 StreamMap *map = &o->stream_maps[i];
1960 if (map->linklabel) {
1962 OutputFilter *ofilter = NULL;
1965 for (j = 0; j < nb_filtergraphs; j++) {
1966 fg = filtergraphs[j];
1967 for (k = 0; k < fg->nb_outputs; k++) {
1968 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1969 if (out && !strcmp(out->name, map->linklabel)) {
1970 ofilter = fg->outputs[k];
1977 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1978 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1981 init_output_filter(ofilter, o, oc);
1983 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1985 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1986 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1988 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1990 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1992 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1995 switch (ist->st->codec->codec_type) {
1996 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1997 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1998 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1999 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2000 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2002 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
2003 map->file_index, map->stream_index);
2010 /* handle attached files */
2011 for (i = 0; i < o->nb_attachments; i++) {
2013 uint8_t *attachment;
2017 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2018 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2022 if ((len = avio_size(pb)) <= 0) {
2023 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2027 if (!(attachment = av_malloc(len))) {
2028 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2032 avio_read(pb, attachment, len);
2034 ost = new_attachment_stream(o, oc, -1);
2035 ost->stream_copy = 0;
2036 ost->attachment_filename = o->attachments[i];
2038 ost->enc_ctx->extradata = attachment;
2039 ost->enc_ctx->extradata_size = len;
2041 p = strrchr(o->attachments[i], '/');
2042 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2046 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2047 AVDictionaryEntry *e;
2048 ost = output_streams[i];
2050 if ((ost->stream_copy || ost->attachment_filename)
2051 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2052 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2053 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2057 /* check if all codec options have been used */
2058 unused_opts = strip_specifiers(o->g->codec_opts);
2059 for (i = of->ost_index; i < nb_output_streams; i++) {
2061 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2062 AV_DICT_IGNORE_SUFFIX)))
2063 av_dict_set(&unused_opts, e->key, NULL, 0);
2067 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2068 const AVClass *class = avcodec_get_class();
2069 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2070 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2071 const AVClass *fclass = avformat_get_class();
2072 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2073 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2074 if (!option || foption)
2078 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2079 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2080 "output file #%d (%s) is not an encoding option.\n", e->key,
2081 option->help ? option->help : "", nb_output_files - 1,
2086 // gop_timecode is injected by generic code but not always used
2087 if (!strcmp(e->key, "gop_timecode"))
2090 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2091 "output file #%d (%s) has not been used for any stream. The most "
2092 "likely reason is either wrong type (e.g. a video option with "
2093 "no video streams) or that it is a private option of some encoder "
2094 "which was not actually used for any stream.\n", e->key,
2095 option->help ? option->help : "", nb_output_files - 1, filename);
2097 av_dict_free(&unused_opts);
2099 /* check filename in case of an image number is expected */
2100 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2101 if (!av_filename_number_test(oc->filename)) {
2102 print_error(oc->filename, AVERROR(EINVAL));
2107 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2108 /* test if it already exists to avoid losing precious files */
2109 assert_file_overwrite(filename);
2112 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2113 &oc->interrupt_callback,
2115 print_error(filename, err);
2118 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2119 assert_file_overwrite(filename);
2121 if (o->mux_preload) {
2122 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2124 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2127 for (i = 0; i < o->nb_metadata_map; i++) {
2129 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2131 if (in_file_index >= nb_input_files) {
2132 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2135 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2136 in_file_index >= 0 ?
2137 input_files[in_file_index]->ctx : NULL, o);
2141 if (o->chapters_input_file >= nb_input_files) {
2142 if (o->chapters_input_file == INT_MAX) {
2143 /* copy chapters from the first input file that has them*/
2144 o->chapters_input_file = -1;
2145 for (i = 0; i < nb_input_files; i++)
2146 if (input_files[i]->ctx->nb_chapters) {
2147 o->chapters_input_file = i;
2151 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2152 o->chapters_input_file);
2156 if (o->chapters_input_file >= 0)
2157 copy_chapters(input_files[o->chapters_input_file], of,
2158 !o->metadata_chapters_manual);
2160 /* copy global metadata by default */
2161 if (!o->metadata_global_manual && nb_input_files){
2162 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2163 AV_DICT_DONT_OVERWRITE);
2164 if(o->recording_time != INT64_MAX)
2165 av_dict_set(&oc->metadata, "duration", NULL, 0);
2166 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2168 if (!o->metadata_streams_manual)
2169 for (i = of->ost_index; i < nb_output_streams; i++) {
2171 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2173 ist = input_streams[output_streams[i]->source_index];
2174 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2175 if (!output_streams[i]->stream_copy)
2176 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2179 /* process manually set metadata */
2180 for (i = 0; i < o->nb_metadata; i++) {
2183 const char *stream_spec;
2184 int index = 0, j, ret = 0;
2186 val = strchr(o->metadata[i].u.str, '=');
2188 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2189 o->metadata[i].u.str);
2194 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2196 for (j = 0; j < oc->nb_streams; j++) {
2197 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2198 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2209 if (index < 0 || index >= oc->nb_chapters) {
2210 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2213 m = &oc->chapters[index]->metadata;
2216 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2219 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2226 static int opt_target(void *optctx, const char *opt, const char *arg)
2228 OptionsContext *o = optctx;
2229 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2230 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2232 if (!strncmp(arg, "pal-", 4)) {
2235 } else if (!strncmp(arg, "ntsc-", 5)) {
2238 } else if (!strncmp(arg, "film-", 5)) {
2242 /* Try to determine PAL/NTSC by peeking in the input files */
2243 if (nb_input_files) {
2245 for (j = 0; j < nb_input_files; j++) {
2246 for (i = 0; i < input_files[j]->nb_streams; i++) {
2247 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2248 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2251 fr = c->time_base.den * 1000 / c->time_base.num;
2255 } else if ((fr == 29970) || (fr == 23976)) {
2260 if (norm != UNKNOWN)
2264 if (norm != UNKNOWN)
2265 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2268 if (norm == UNKNOWN) {
2269 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2270 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2271 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2275 if (!strcmp(arg, "vcd")) {
2276 opt_video_codec(o, "c:v", "mpeg1video");
2277 opt_audio_codec(o, "c:a", "mp2");
2278 parse_option(o, "f", "vcd", options);
2280 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2281 parse_option(o, "r", frame_rates[norm], options);
2282 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2284 opt_default(NULL, "b:v", "1150000");
2285 opt_default(NULL, "maxrate", "1150000");
2286 opt_default(NULL, "minrate", "1150000");
2287 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2289 opt_default(NULL, "b:a", "224000");
2290 parse_option(o, "ar", "44100", options);
2291 parse_option(o, "ac", "2", options);
2293 opt_default(NULL, "packetsize", "2324");
2294 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2296 /* We have to offset the PTS, so that it is consistent with the SCR.
2297 SCR starts at 36000, but the first two packs contain only padding
2298 and the first pack from the other stream, respectively, may also have
2299 been written before.
2300 So the real data starts at SCR 36000+3*1200. */
2301 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2302 } else if (!strcmp(arg, "svcd")) {
2304 opt_video_codec(o, "c:v", "mpeg2video");
2305 opt_audio_codec(o, "c:a", "mp2");
2306 parse_option(o, "f", "svcd", options);
2308 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2309 parse_option(o, "r", frame_rates[norm], options);
2310 parse_option(o, "pix_fmt", "yuv420p", options);
2311 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2313 opt_default(NULL, "b:v", "2040000");
2314 opt_default(NULL, "maxrate", "2516000");
2315 opt_default(NULL, "minrate", "0"); // 1145000;
2316 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2317 opt_default(NULL, "scan_offset", "1");
2319 opt_default(NULL, "b:a", "224000");
2320 parse_option(o, "ar", "44100", options);
2322 opt_default(NULL, "packetsize", "2324");
2324 } else if (!strcmp(arg, "dvd")) {
2326 opt_video_codec(o, "c:v", "mpeg2video");
2327 opt_audio_codec(o, "c:a", "ac3");
2328 parse_option(o, "f", "dvd", options);
2330 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2331 parse_option(o, "r", frame_rates[norm], options);
2332 parse_option(o, "pix_fmt", "yuv420p", options);
2333 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2335 opt_default(NULL, "b:v", "6000000");
2336 opt_default(NULL, "maxrate", "9000000");
2337 opt_default(NULL, "minrate", "0"); // 1500000;
2338 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2340 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2341 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2343 opt_default(NULL, "b:a", "448000");
2344 parse_option(o, "ar", "48000", options);
2346 } else if (!strncmp(arg, "dv", 2)) {
2348 parse_option(o, "f", "dv", options);
2350 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2351 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2352 norm == PAL ? "yuv420p" : "yuv411p", options);
2353 parse_option(o, "r", frame_rates[norm], options);
2355 parse_option(o, "ar", "48000", options);
2356 parse_option(o, "ac", "2", options);
2359 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2360 return AVERROR(EINVAL);
2363 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2364 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2369 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2371 av_free (vstats_filename);
2372 vstats_filename = av_strdup (arg);
2376 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2379 time_t today2 = time(NULL);
2380 struct tm *today = localtime(&today2);
2382 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2384 return opt_vstats_file(NULL, opt, filename);
2387 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2389 OptionsContext *o = optctx;
2390 return parse_option(o, "frames:v", arg, options);
2393 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2395 OptionsContext *o = optctx;
2396 return parse_option(o, "frames:a", arg, options);
2399 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2401 OptionsContext *o = optctx;
2402 return parse_option(o, "frames:d", arg, options);
2405 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2408 AVDictionary *cbak = codec_opts;
2409 AVDictionary *fbak = format_opts;
2413 ret = opt_default(NULL, opt, arg);
2415 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2416 av_dict_copy(&o->g->format_opts, format_opts, 0);
2417 av_dict_free(&codec_opts);
2418 av_dict_free(&format_opts);
2425 static int opt_preset(void *optctx, const char *opt, const char *arg)
2427 OptionsContext *o = optctx;
2429 char filename[1000], line[1000], tmp_line[1000];
2430 const char *codec_name = NULL;
2434 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2436 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2437 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2438 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2440 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2444 while (fgets(line, sizeof(line), f)) {
2445 char *key = tmp_line, *value, *endptr;
2447 if (strcspn(line, "#\n\r") == 0)
2449 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2450 if (!av_strtok(key, "=", &value) ||
2451 !av_strtok(value, "\r\n", &endptr)) {
2452 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2455 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2457 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2458 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2459 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2460 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2461 else if (opt_default_new(o, key, value) < 0) {
2462 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2463 filename, line, key, value);
2473 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2475 OptionsContext *o = optctx;
2476 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2477 int ret = parse_option(o, s, arg, options);
2482 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2484 OptionsContext *o = optctx;
2486 if(!strcmp(opt, "ab")){
2487 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2489 } else if(!strcmp(opt, "b")){
2490 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2491 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2494 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2498 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2500 OptionsContext *o = optctx;
2503 if(!strcmp(opt, "qscale")){
2504 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2505 return parse_option(o, "q:v", arg, options);
2507 s = av_asprintf("q%s", opt + 6);
2508 ret = parse_option(o, s, arg, options);
2513 static int opt_profile(void *optctx, const char *opt, const char *arg)
2515 OptionsContext *o = optctx;
2516 if(!strcmp(opt, "profile")){
2517 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2518 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2521 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2525 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2527 OptionsContext *o = optctx;
2528 return parse_option(o, "filter:v", arg, options);
2531 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2533 OptionsContext *o = optctx;
2534 return parse_option(o, "filter:a", arg, options);
2537 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2539 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2540 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2541 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2542 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2544 if (video_sync_method == VSYNC_AUTO)
2545 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2549 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2551 OptionsContext *o = optctx;
2552 char *tcr = av_asprintf("timecode=%s", arg);
2553 int ret = parse_option(o, "metadata:g", tcr, options);
2555 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2560 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2562 OptionsContext *o = optctx;
2563 char layout_str[32];
2566 int ret, channels, ac_str_size;
2569 layout = av_get_channel_layout(arg);
2571 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2572 return AVERROR(EINVAL);
2574 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2575 ret = opt_default_new(o, opt, layout_str);
2579 /* set 'ac' option based on channel layout */
2580 channels = av_get_channel_layout_nb_channels(layout);
2581 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2582 stream_str = strchr(opt, ':');
2583 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2584 ac_str = av_mallocz(ac_str_size);
2586 return AVERROR(ENOMEM);
2587 av_strlcpy(ac_str, "ac", 3);
2589 av_strlcat(ac_str, stream_str, ac_str_size);
2590 ret = parse_option(o, ac_str, layout_str, options);
2596 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2598 OptionsContext *o = optctx;
2599 return parse_option(o, "q:a", arg, options);
2602 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2604 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2605 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2606 return AVERROR(ENOMEM);
2607 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2608 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2609 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2610 return AVERROR(ENOMEM);
2614 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2616 uint8_t *graph_desc = read_file(arg);
2618 return AVERROR(EINVAL);
2620 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2621 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2622 return AVERROR(ENOMEM);
2623 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2624 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2628 void show_help_default(const char *opt, const char *arg)
2630 /* per-file options have at least one of those set */
2631 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2632 int show_advanced = 0, show_avoptions = 0;
2635 if (!strcmp(opt, "long"))
2637 else if (!strcmp(opt, "full"))
2638 show_advanced = show_avoptions = 1;
2640 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2645 printf("Getting help:\n"
2646 " -h -- print basic options\n"
2647 " -h long -- print more options\n"
2648 " -h full -- print all options (including all format and codec specific options, very long)\n"
2649 " See man %s for detailed description of the options.\n"
2650 "\n", program_name);
2652 show_help_options(options, "Print help / information / capabilities:",
2655 show_help_options(options, "Global options (affect whole program "
2656 "instead of just one file:",
2657 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2659 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2660 per_file | OPT_EXIT, 0);
2662 show_help_options(options, "Per-file main options:", 0,
2663 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2664 OPT_EXIT, per_file);
2666 show_help_options(options, "Advanced per-file options:",
2667 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2669 show_help_options(options, "Video options:",
2670 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2672 show_help_options(options, "Advanced Video options:",
2673 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2675 show_help_options(options, "Audio options:",
2676 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2678 show_help_options(options, "Advanced Audio options:",
2679 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2680 show_help_options(options, "Subtitle options:",
2681 OPT_SUBTITLE, 0, 0);
2684 if (show_avoptions) {
2685 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2686 show_help_children(avcodec_get_class(), flags);
2687 show_help_children(avformat_get_class(), flags);
2689 show_help_children(sws_get_class(), flags);
2691 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2692 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2696 void show_usage(void)
2698 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2699 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2700 av_log(NULL, AV_LOG_INFO, "\n");
2708 static const OptionGroupDef groups[] = {
2709 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2710 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2713 static int open_files(OptionGroupList *l, const char *inout,
2714 int (*open_file)(OptionsContext*, const char*))
2718 for (i = 0; i < l->nb_groups; i++) {
2719 OptionGroup *g = &l->groups[i];
2725 ret = parse_optgroup(&o, g);
2727 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2728 "%s.\n", inout, g->arg);
2732 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2733 ret = open_file(&o, g->arg);
2736 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2740 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2746 int ffmpeg_parse_options(int argc, char **argv)
2748 OptionParseContext octx;
2752 memset(&octx, 0, sizeof(octx));
2754 /* split the commandline into an internal representation */
2755 ret = split_commandline(&octx, argc, argv, options, groups,
2756 FF_ARRAY_ELEMS(groups));
2758 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2762 /* apply global options */
2763 ret = parse_optgroup(NULL, &octx.global_opts);
2765 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2769 /* open input files */
2770 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2772 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2776 /* open output files */
2777 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2779 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2784 uninit_parse_context(&octx);
2786 av_strerror(ret, error, sizeof(error));
2787 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2792 static int opt_progress(void *optctx, const char *opt, const char *arg)
2794 AVIOContext *avio = NULL;
2797 if (!strcmp(arg, "-"))
2799 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2801 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2802 arg, av_err2str(ret));
2805 progress_avio = avio;
2809 #define OFFSET(x) offsetof(OptionsContext, x)
2810 const OptionDef options[] = {
2812 #include "cmdutils_common_opts.h"
2813 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2814 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2815 "force format", "fmt" },
2816 { "y", OPT_BOOL, { &file_overwrite },
2817 "overwrite output files" },
2818 { "n", OPT_BOOL, { &no_file_overwrite },
2819 "never overwrite output files" },
2820 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2821 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2822 "codec name", "codec" },
2823 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2824 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2825 "codec name", "codec" },
2826 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2827 OPT_OUTPUT, { .off = OFFSET(presets) },
2828 "preset name", "preset" },
2829 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2830 OPT_OUTPUT, { .func_arg = opt_map },
2831 "set input stream mapping",
2832 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2833 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2834 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2835 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2836 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2837 "set metadata information of outfile from infile",
2838 "outfile[,metadata]:infile[,metadata]" },
2839 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2840 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2841 "set chapters mapping", "input_file_index" },
2842 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2843 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2844 "record or transcode \"duration\" seconds of audio/video",
2846 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2847 "record or transcode stop time", "time_stop" },
2848 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2849 "set the limit file size in bytes", "limit_size" },
2850 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2851 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2852 "set the start time offset", "time_off" },
2853 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2854 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2855 "enable/disable accurate seeking with -ss" },
2856 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2857 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2858 "set the input ts offset", "time_off" },
2859 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2860 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2861 "set the input ts scale", "scale" },
2862 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2863 "set the recording timestamp ('now' to set the current time)", "time" },
2864 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2865 "add metadata", "string=string" },
2866 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2867 OPT_OUTPUT, { .func_arg = opt_data_frames },
2868 "set the number of data frames to output", "number" },
2869 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2870 "add timings for benchmarking" },
2871 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2872 "add timings for each task" },
2873 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2874 "write program-readable progress information", "url" },
2875 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2876 "enable or disable interaction on standard input" },
2877 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2878 "set max runtime in seconds", "limit" },
2879 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2880 "dump each input packet" },
2881 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2882 "when dumping packets, also dump the payload" },
2883 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2884 OPT_INPUT, { .off = OFFSET(rate_emu) },
2885 "read input at native frame rate", "" },
2886 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2887 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2888 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2889 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2890 "video sync method", "" },
2891 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2892 "frame drop threshold", "" },
2893 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2894 "audio sync method", "" },
2895 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2896 "audio drift threshold", "threshold" },
2897 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2898 "copy timestamps" },
2899 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2900 "shift input timestamps to start at 0 when using copyts" },
2901 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2902 "copy input stream time base when stream copying", "mode" },
2903 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2904 OPT_OUTPUT, { .off = OFFSET(shortest) },
2905 "finish encoding within shortest input" },
2906 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2907 OPT_OUTPUT, { .off = OFFSET(apad) },
2909 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2910 "timestamp discontinuity delta threshold", "threshold" },
2911 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2912 "timestamp error delta threshold", "threshold" },
2913 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2914 "exit on error", "error" },
2915 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2916 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2917 "copy initial non-keyframes" },
2918 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2919 "copy or discard frames before start time" },
2920 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2921 "set the number of frames to output", "number" },
2922 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2923 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2924 "force codec tag/fourcc", "fourcc/tag" },
2925 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2926 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2927 "use fixed quality scale (VBR)", "q" },
2928 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2929 OPT_OUTPUT, { .func_arg = opt_qscale },
2930 "use fixed quality scale (VBR)", "q" },
2931 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2932 "set profile", "profile" },
2933 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2934 "set stream filtergraph", "filter_graph" },
2935 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2936 "read stream filtergraph description from a file", "filename" },
2937 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2938 "reinit filtergraph on input parameter changes", "" },
2939 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2940 "create a complex filtergraph", "graph_description" },
2941 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2942 "create a complex filtergraph", "graph_description" },
2943 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2944 "read complex filtergraph description from a file", "filename" },
2945 { "stats", OPT_BOOL, { &print_stats },
2946 "print progress report during encoding", },
2947 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2948 OPT_OUTPUT, { .func_arg = opt_attach },
2949 "add an attachment to the output file", "filename" },
2950 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2951 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2952 "extract an attachment into a file", "filename" },
2953 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2954 "print timestamp debugging info" },
2955 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2956 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2957 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2958 OPT_INPUT, { .off = OFFSET(discard) },
2960 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
2961 OPT_OUTPUT, { .off = OFFSET(disposition) },
2962 "disposition", "" },
2963 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
2964 { .off = OFFSET(thread_queue_size) },
2965 "set the maximum number of queued packets from the demuxer" },
2968 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2969 "set the number of video frames to output", "number" },
2970 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2971 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2972 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2973 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2974 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2975 "set frame size (WxH or abbreviation)", "size" },
2976 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2977 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2978 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2979 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2980 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2981 "set pixel format", "format" },
2982 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2983 "set the number of bits per raw sample", "number" },
2984 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2985 "deprecated use -g 1" },
2986 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2988 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2989 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2990 "rate control override for specific intervals", "override" },
2991 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2992 OPT_OUTPUT, { .func_arg = opt_video_codec },
2993 "force video codec ('copy' to copy stream)", "codec" },
2994 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2996 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2998 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2999 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3000 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3001 "select the pass number (1 to 3)", "n" },
3002 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3003 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3004 "select two pass log file name prefix", "prefix" },
3005 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3006 "this option is deprecated, use the yadif filter instead" },
3007 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3008 "calculate PSNR of compressed frames" },
3009 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3010 "dump video coding statistics to file" },
3011 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3012 "dump video coding statistics to file", "file" },
3013 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3014 "set video filters", "filter_graph" },
3015 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3016 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3017 "specify intra matrix coeffs", "matrix" },
3018 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3019 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3020 "specify inter matrix coeffs", "matrix" },
3021 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3022 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3023 "specify intra matrix coeffs", "matrix" },
3024 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3025 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3026 "top=1/bottom=0/auto=-1 field first", "" },
3027 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3028 OPT_OUTPUT, { .func_arg = opt_old2new },
3029 "force video tag/fourcc", "fourcc/tag" },
3030 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3031 "show QP histogram" },
3032 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3033 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3034 "force the selected framerate, disable the best supported framerate selection" },
3035 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3036 OPT_OUTPUT, { .func_arg = opt_streamid },
3037 "set the value of an outfile streamid", "streamIndex:value" },
3038 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3039 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3040 "force key frames at specified timestamps", "timestamps" },
3041 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3042 "audio bitrate (please use -b:a)", "bitrate" },
3043 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3044 "video bitrate (please use -b:v)", "bitrate" },
3045 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3046 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3047 "use HW accelerated decoding", "hwaccel name" },
3048 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3049 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3050 "select a device for HW acceleration" "devicename" },
3052 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3056 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3057 "set the number of audio frames to output", "number" },
3058 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3059 "set audio quality (codec-specific)", "quality", },
3060 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3061 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3062 "set audio sampling rate (in Hz)", "rate" },
3063 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3064 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3065 "set number of audio channels", "channels" },
3066 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3068 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3069 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3070 "force audio codec ('copy' to copy stream)", "codec" },
3071 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3072 OPT_OUTPUT, { .func_arg = opt_old2new },
3073 "force audio tag/fourcc", "fourcc/tag" },
3074 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3075 "change audio volume (256=normal)" , "volume" },
3076 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3077 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3078 "set sample format", "format" },
3079 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3080 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3081 "set channel layout", "layout" },
3082 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3083 "set audio filters", "filter_graph" },
3084 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3085 "set the maximum number of channels to try to guess the channel layout" },
3087 /* subtitle options */
3088 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3089 "disable subtitle" },
3090 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3091 "force subtitle codec ('copy' to copy stream)", "codec" },
3092 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3093 , "force subtitle tag/fourcc", "fourcc/tag" },
3094 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3095 "fix subtitles duration" },
3096 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3097 "set canvas size (WxH or abbreviation)", "size" },
3100 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3101 "deprecated, use -channel", "channel" },
3102 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3103 "deprecated, use -standard", "standard" },
3104 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3107 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3108 "set the maximum demux-decode delay", "seconds" },
3109 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3110 "set the initial demux-decode delay", "seconds" },
3111 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3112 "override the options from ffserver", "" },
3113 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3114 "specify a file in which to print sdp information", "file" },
3116 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3117 "A comma-separated list of bitstream filters", "bitstream_filters" },
3118 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3119 "deprecated", "audio bitstream_filters" },
3120 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3121 "deprecated", "video bitstream_filters" },
3123 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3124 "set the audio options to the indicated preset", "preset" },
3125 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3126 "set the video options to the indicated preset", "preset" },
3127 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3128 "set the subtitle options to the indicated preset", "preset" },
3129 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3130 "set options from indicated preset file", "filename" },
3131 /* data codec support */
3132 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3133 "force data codec ('copy' to copy stream)", "codec" },
3134 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },