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"
43 #include "libavutil/time_internal.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 for (i = 0; i < o->nb_ ## name; i++) {\
61 char *spec = o->name[i].specifier;\
62 if (!strcmp(spec, mediatype))\
63 outvar = o->name[i].u.type;\
67 const HWAccel hwaccels[] = {
69 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
72 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
75 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
80 char *vstats_filename;
83 float audio_drift_threshold = 0.1;
84 float dts_delta_threshold = 10;
85 float dts_error_threshold = 3600*30;
87 int audio_volume = 256;
88 int audio_sync_method = 0;
89 int video_sync_method = VSYNC_AUTO;
90 float frame_drop_threshold = 0;
91 int do_deinterlace = 0;
93 int do_benchmark_all = 0;
97 int start_at_zero = 0;
100 int exit_on_error = 0;
101 int print_stats = -1;
103 int stdin_interaction = 1;
104 int frame_bits_per_raw_sample = 0;
105 float max_error_rate = 2.0/3;
108 static int intra_only = 0;
109 static int file_overwrite = 0;
110 static int no_file_overwrite = 0;
111 static int do_psnr = 0;
112 static int input_sync;
113 static int override_ffserver = 0;
114 static int input_stream_potentially_available = 0;
115 static int ignore_unknown_streams = 0;
116 static int copy_unknown_streams = 0;
118 static void uninit_options(OptionsContext *o)
120 const OptionDef *po = options;
123 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
125 void *dst = (uint8_t*)o + po->u.off;
127 if (po->flags & OPT_SPEC) {
128 SpecifierOpt **so = dst;
129 int i, *count = (int*)(so + 1);
130 for (i = 0; i < *count; i++) {
131 av_freep(&(*so)[i].specifier);
132 if (po->flags & OPT_STRING)
133 av_freep(&(*so)[i].u.str);
137 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
142 for (i = 0; i < o->nb_stream_maps; i++)
143 av_freep(&o->stream_maps[i].linklabel);
144 av_freep(&o->stream_maps);
145 av_freep(&o->audio_channel_maps);
146 av_freep(&o->streamid_map);
147 av_freep(&o->attachments);
150 static void init_options(OptionsContext *o)
152 memset(o, 0, sizeof(*o));
154 o->stop_time = INT64_MAX;
155 o->mux_max_delay = 0.7;
156 o->start_time = AV_NOPTS_VALUE;
157 o->recording_time = INT64_MAX;
158 o->limit_filesize = UINT64_MAX;
159 o->chapters_input_file = INT_MAX;
160 o->accurate_seek = 1;
163 /* return a copy of the input with the stream specifiers removed from the keys */
164 static AVDictionary *strip_specifiers(AVDictionary *dict)
166 AVDictionaryEntry *e = NULL;
167 AVDictionary *ret = NULL;
169 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
170 char *p = strchr(e->key, ':');
174 av_dict_set(&ret, e->key, e->value, 0);
181 static int opt_sameq(void *optctx, const char *opt, const char *arg)
183 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
184 "If you are looking for an option to preserve the quality (which is not "
185 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
187 return AVERROR(EINVAL);
190 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
192 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
193 return opt_default(optctx, "channel", arg);
196 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
198 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
199 return opt_default(optctx, "standard", arg);
202 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
204 OptionsContext *o = optctx;
205 return parse_option(o, "codec:a", arg, options);
208 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
210 OptionsContext *o = optctx;
211 return parse_option(o, "codec:v", arg, options);
214 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
216 OptionsContext *o = optctx;
217 return parse_option(o, "codec:s", arg, options);
220 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
222 OptionsContext *o = optctx;
223 return parse_option(o, "codec:d", arg, options);
226 static int opt_map(void *optctx, const char *opt, const char *arg)
228 OptionsContext *o = optctx;
230 int i, negative = 0, file_idx;
231 int sync_file_idx = -1, sync_stream_idx = 0;
239 map = av_strdup(arg);
241 return AVERROR(ENOMEM);
243 /* parse sync stream first, just pick first matching stream */
244 if (sync = strchr(map, ',')) {
246 sync_file_idx = strtol(sync + 1, &sync, 0);
247 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
248 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
253 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
254 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
255 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
259 if (i == input_files[sync_file_idx]->nb_streams) {
260 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
261 "match any streams.\n", arg);
268 /* this mapping refers to lavfi output */
269 const char *c = map + 1;
270 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
271 m = &o->stream_maps[o->nb_stream_maps - 1];
272 m->linklabel = av_get_token(&c, "]");
274 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
278 file_idx = strtol(map, &p, 0);
279 if (file_idx >= nb_input_files || file_idx < 0) {
280 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
284 /* disable some already defined maps */
285 for (i = 0; i < o->nb_stream_maps; i++) {
286 m = &o->stream_maps[i];
287 if (file_idx == m->file_index &&
288 check_stream_specifier(input_files[m->file_index]->ctx,
289 input_files[m->file_index]->ctx->streams[m->stream_index],
290 *p == ':' ? p + 1 : p) > 0)
294 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
295 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
296 *p == ':' ? p + 1 : p) <= 0)
298 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
299 m = &o->stream_maps[o->nb_stream_maps - 1];
301 m->file_index = file_idx;
304 if (sync_file_idx >= 0) {
305 m->sync_file_index = sync_file_idx;
306 m->sync_stream_index = sync_stream_idx;
308 m->sync_file_index = file_idx;
309 m->sync_stream_index = i;
315 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
323 static int opt_attach(void *optctx, const char *opt, const char *arg)
325 OptionsContext *o = optctx;
326 GROW_ARRAY(o->attachments, o->nb_attachments);
327 o->attachments[o->nb_attachments - 1] = arg;
331 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
333 OptionsContext *o = optctx;
338 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
339 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
341 /* muted channel syntax */
342 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
343 if ((n == 1 || n == 3) && m->channel_idx == -1) {
344 m->file_idx = m->stream_idx = -1;
346 m->ofile_idx = m->ostream_idx = -1;
351 n = sscanf(arg, "%d.%d.%d:%d.%d",
352 &m->file_idx, &m->stream_idx, &m->channel_idx,
353 &m->ofile_idx, &m->ostream_idx);
355 if (n != 3 && n != 5) {
356 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
357 "[file.stream.channel|-1][:syncfile:syncstream]\n");
361 if (n != 5) // only file.stream.channel specified
362 m->ofile_idx = m->ostream_idx = -1;
365 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
366 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
370 if (m->stream_idx < 0 ||
371 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
372 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
373 m->file_idx, m->stream_idx);
376 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
377 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
378 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
379 m->file_idx, m->stream_idx);
382 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
383 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
384 m->file_idx, m->stream_idx, m->channel_idx);
390 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
392 av_free(sdp_filename);
393 sdp_filename = av_strdup(arg);
398 * Parse a metadata specifier passed as 'arg' parameter.
399 * @param arg metadata string to parse
400 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
401 * @param index for type c/p, chapter/program index is written here
402 * @param stream_spec for type s, the stream specifier is written here
404 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
412 if (*(++arg) && *arg != ':') {
413 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
416 *stream_spec = *arg == ':' ? arg + 1 : "";
421 *index = strtol(++arg, NULL, 0);
424 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
431 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
433 AVDictionary **meta_in = NULL;
434 AVDictionary **meta_out = NULL;
436 char type_in, type_out;
437 const char *istream_spec = NULL, *ostream_spec = NULL;
438 int idx_in = 0, idx_out = 0;
440 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
441 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
444 if (type_out == 'g' || !*outspec)
445 o->metadata_global_manual = 1;
446 if (type_out == 's' || !*outspec)
447 o->metadata_streams_manual = 1;
448 if (type_out == 'c' || !*outspec)
449 o->metadata_chapters_manual = 1;
453 if (type_in == 'g' || type_out == 'g')
454 o->metadata_global_manual = 1;
455 if (type_in == 's' || type_out == 's')
456 o->metadata_streams_manual = 1;
457 if (type_in == 'c' || type_out == 'c')
458 o->metadata_chapters_manual = 1;
460 /* ic is NULL when just disabling automatic mappings */
464 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
465 if ((index) < 0 || (index) >= (nb_elems)) {\
466 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
471 #define SET_DICT(type, meta, context, index)\
474 meta = &context->metadata;\
477 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
478 meta = &context->chapters[index]->metadata;\
481 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
482 meta = &context->programs[index]->metadata;\
485 break; /* handled separately below */ \
486 default: av_assert0(0);\
489 SET_DICT(type_in, meta_in, ic, idx_in);
490 SET_DICT(type_out, meta_out, oc, idx_out);
492 /* for input streams choose first matching stream */
493 if (type_in == 's') {
494 for (i = 0; i < ic->nb_streams; i++) {
495 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
496 meta_in = &ic->streams[i]->metadata;
502 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
507 if (type_out == 's') {
508 for (i = 0; i < oc->nb_streams; i++) {
509 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
510 meta_out = &oc->streams[i]->metadata;
511 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
516 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
521 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
523 OptionsContext *o = optctx;
525 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
526 struct tm time = *gmtime((time_t*)&recording_timestamp);
527 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
529 parse_option(o, "metadata", buf, options);
531 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
532 "tag instead.\n", opt);
536 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
538 const AVCodecDescriptor *desc;
539 const char *codec_string = encoder ? "encoder" : "decoder";
543 avcodec_find_encoder_by_name(name) :
544 avcodec_find_decoder_by_name(name);
546 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
547 codec = encoder ? avcodec_find_encoder(desc->id) :
548 avcodec_find_decoder(desc->id);
550 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
551 codec_string, codec->name, desc->name);
555 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
558 if (codec->type != type) {
559 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
565 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
567 char *codec_name = NULL;
569 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
571 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
572 st->codec->codec_id = codec->id;
575 return avcodec_find_decoder(st->codec->codec_id);
578 /* Add all the streams from the given input file to the global
579 * list of input streams. */
580 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
584 for (i = 0; i < ic->nb_streams; i++) {
585 AVStream *st = ic->streams[i];
586 AVCodecContext *dec = st->codec;
587 InputStream *ist = av_mallocz(sizeof(*ist));
588 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
589 char *codec_tag = NULL;
591 char *discard_str = NULL;
592 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
597 GROW_ARRAY(input_streams, nb_input_streams);
598 input_streams[nb_input_streams - 1] = ist;
601 ist->file_index = nb_input_files;
603 st->discard = AVDISCARD_ALL;
606 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
609 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
611 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
613 uint32_t tag = strtol(codec_tag, &next, 0);
615 tag = AV_RL32(codec_tag);
616 st->codec->codec_tag = tag;
619 ist->dec = choose_decoder(o, ic, st);
620 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
622 ist->reinit_filters = -1;
623 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
625 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
626 ist->user_set_discard = AVDISCARD_NONE;
627 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
628 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
633 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
635 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
637 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
641 ret = avcodec_copy_context(ist->dec_ctx, dec);
643 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
647 switch (dec->codec_type) {
648 case AVMEDIA_TYPE_VIDEO:
650 ist->dec = avcodec_find_decoder(dec->codec_id);
651 if (av_codec_get_lowres(dec)) {
652 dec->flags |= CODEC_FLAG_EMU_EDGE;
655 ist->resample_height = ist->dec_ctx->height;
656 ist->resample_width = ist->dec_ctx->width;
657 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
659 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
660 if (framerate && av_parse_video_rate(&ist->framerate,
662 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
667 ist->top_field_first = -1;
668 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
670 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
672 if (!strcmp(hwaccel, "none"))
673 ist->hwaccel_id = HWACCEL_NONE;
674 else if (!strcmp(hwaccel, "auto"))
675 ist->hwaccel_id = HWACCEL_AUTO;
678 for (i = 0; hwaccels[i].name; i++) {
679 if (!strcmp(hwaccels[i].name, hwaccel)) {
680 ist->hwaccel_id = hwaccels[i].id;
685 if (!ist->hwaccel_id) {
686 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
688 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
689 for (i = 0; hwaccels[i].name; i++)
690 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
691 av_log(NULL, AV_LOG_FATAL, "\n");
697 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
698 if (hwaccel_device) {
699 ist->hwaccel_device = av_strdup(hwaccel_device);
700 if (!ist->hwaccel_device)
703 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
706 case AVMEDIA_TYPE_AUDIO:
707 ist->guess_layout_max = INT_MAX;
708 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
709 guess_input_channel_layout(ist);
711 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
712 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
713 ist->resample_channels = ist->dec_ctx->channels;
714 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
717 case AVMEDIA_TYPE_DATA:
718 case AVMEDIA_TYPE_SUBTITLE: {
719 char *canvas_size = NULL;
721 ist->dec = avcodec_find_decoder(dec->codec_id);
722 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
723 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
725 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
726 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
731 case AVMEDIA_TYPE_ATTACHMENT:
732 case AVMEDIA_TYPE_UNKNOWN:
740 static void assert_file_overwrite(const char *filename)
742 if (file_overwrite && no_file_overwrite) {
743 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
747 if (!file_overwrite) {
748 const char *proto_name = avio_find_protocol_name(filename);
749 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
750 if (stdin_interaction && !no_file_overwrite) {
751 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
754 signal(SIGINT, SIG_DFL);
756 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
762 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
769 static void dump_attachment(AVStream *st, const char *filename)
772 AVIOContext *out = NULL;
773 AVDictionaryEntry *e;
775 if (!st->codec->extradata_size) {
776 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
777 nb_input_files - 1, st->index);
780 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
783 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
784 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
788 assert_file_overwrite(filename);
790 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
791 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
796 avio_write(out, st->codec->extradata, st->codec->extradata_size);
801 static int open_input_file(OptionsContext *o, const char *filename)
805 AVInputFormat *file_iformat = NULL;
809 AVDictionary *unused_opts = NULL;
810 AVDictionaryEntry *e = NULL;
811 int orig_nb_streams; // number of streams before avformat_find_stream_info
812 char * video_codec_name = NULL;
813 char * audio_codec_name = NULL;
814 char *subtitle_codec_name = NULL;
815 char * data_codec_name = NULL;
816 int scan_all_pmts_set = 0;
819 if (!(file_iformat = av_find_input_format(o->format))) {
820 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
825 if (!strcmp(filename, "-"))
828 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
829 strcmp(filename, "/dev/stdin");
831 /* get default parameters from command line */
832 ic = avformat_alloc_context();
834 print_error(filename, AVERROR(ENOMEM));
837 if (o->nb_audio_sample_rate) {
838 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
840 if (o->nb_audio_channels) {
841 /* because we set audio_channels based on both the "ac" and
842 * "channel_layout" options, we need to check that the specified
843 * demuxer actually has the "channels" option before setting it */
844 if (file_iformat && file_iformat->priv_class &&
845 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
846 AV_OPT_SEARCH_FAKE_OBJ)) {
847 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
850 if (o->nb_frame_rates) {
851 /* set the format-level framerate option;
852 * this is important for video grabbers, e.g. x11 */
853 if (file_iformat && file_iformat->priv_class &&
854 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
855 AV_OPT_SEARCH_FAKE_OBJ)) {
856 av_dict_set(&o->g->format_opts, "framerate",
857 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
860 if (o->nb_frame_sizes) {
861 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
863 if (o->nb_frame_pix_fmts)
864 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
866 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
867 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
868 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
869 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
871 ic->video_codec_id = video_codec_name ?
872 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
873 ic->audio_codec_id = audio_codec_name ?
874 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
875 ic->subtitle_codec_id= subtitle_codec_name ?
876 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
877 ic->data_codec_id = data_codec_name ?
878 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
880 if (video_codec_name)
881 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
882 if (audio_codec_name)
883 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
884 if (subtitle_codec_name)
885 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
887 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
889 ic->flags |= AVFMT_FLAG_NONBLOCK;
890 ic->interrupt_callback = int_cb;
892 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
893 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
894 scan_all_pmts_set = 1;
896 /* open the input file with generic avformat function */
897 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
899 print_error(filename, err);
902 if (scan_all_pmts_set)
903 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
904 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
905 assert_avoptions(o->g->format_opts);
907 /* apply forced codec ids */
908 for (i = 0; i < ic->nb_streams; i++)
909 choose_decoder(o, ic, ic->streams[i]);
911 /* Set AVCodecContext options for avformat_find_stream_info */
912 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
913 orig_nb_streams = ic->nb_streams;
915 /* If not enough info to get the stream parameters, we decode the
916 first frames to get it. (used in mpeg case for example) */
917 ret = avformat_find_stream_info(ic, opts);
919 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
920 if (ic->nb_streams == 0) {
921 avformat_close_input(&ic);
926 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
927 /* add the stream start time */
928 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
929 timestamp += ic->start_time;
931 /* if seeking requested, we execute it */
932 if (o->start_time != AV_NOPTS_VALUE) {
933 int64_t seek_timestamp = timestamp;
935 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
936 int dts_heuristic = 0;
937 for (i=0; i<ic->nb_streams; i++) {
938 AVCodecContext *avctx = ic->streams[i]->codec;
939 if (avctx->has_b_frames)
943 seek_timestamp -= 3*AV_TIME_BASE / 23;
946 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
948 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
949 filename, (double)timestamp / AV_TIME_BASE);
953 /* update the current parameters so that they match the one of the input stream */
954 add_input_streams(o, ic);
956 /* dump the file content */
957 av_dump_format(ic, nb_input_files, filename, 0);
959 GROW_ARRAY(input_files, nb_input_files);
960 f = av_mallocz(sizeof(*f));
963 input_files[nb_input_files - 1] = f;
966 f->ist_index = nb_input_streams - ic->nb_streams;
967 f->start_time = o->start_time;
968 f->recording_time = o->recording_time;
969 f->input_ts_offset = o->input_ts_offset;
970 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
971 f->nb_streams = ic->nb_streams;
972 f->rate_emu = o->rate_emu;
973 f->accurate_seek = o->accurate_seek;
975 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
978 /* check if all codec options have been used */
979 unused_opts = strip_specifiers(o->g->codec_opts);
980 for (i = f->ist_index; i < nb_input_streams; i++) {
982 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
983 AV_DICT_IGNORE_SUFFIX)))
984 av_dict_set(&unused_opts, e->key, NULL, 0);
988 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
989 const AVClass *class = avcodec_get_class();
990 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
991 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
992 const AVClass *fclass = avformat_get_class();
993 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
994 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
995 if (!option || foption)
999 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1000 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1001 "input file #%d (%s) is not a decoding option.\n", e->key,
1002 option->help ? option->help : "", nb_input_files - 1,
1007 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1008 "input file #%d (%s) has not been used for any stream. The most "
1009 "likely reason is either wrong type (e.g. a video option with "
1010 "no video streams) or that it is a private option of some decoder "
1011 "which was not actually used for any stream.\n", e->key,
1012 option->help ? option->help : "", nb_input_files - 1, filename);
1014 av_dict_free(&unused_opts);
1016 for (i = 0; i < o->nb_dump_attachment; i++) {
1019 for (j = 0; j < ic->nb_streams; j++) {
1020 AVStream *st = ic->streams[j];
1022 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1023 dump_attachment(st, o->dump_attachment[i].u.str);
1027 for (i = 0; i < orig_nb_streams; i++)
1028 av_dict_free(&opts[i]);
1031 input_stream_potentially_available = 1;
1036 static uint8_t *get_line(AVIOContext *s)
1042 if (avio_open_dyn_buf(&line) < 0) {
1043 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1047 while ((c = avio_r8(s)) && c != '\n')
1050 avio_close_dyn_buf(line, &buf);
1055 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1058 char filename[1000];
1059 const char *base[3] = { getenv("AVCONV_DATADIR"),
1064 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1068 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1069 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1070 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1073 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1074 i != 1 ? "" : "/.avconv", preset_name);
1075 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1081 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1083 char *codec_name = NULL;
1085 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1087 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1088 NULL, ost->st->codec->codec_type);
1089 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1090 } else if (!strcmp(codec_name, "copy"))
1091 ost->stream_copy = 1;
1093 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1094 ost->st->codec->codec_id = ost->enc->id;
1098 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1101 AVStream *st = avformat_new_stream(oc, NULL);
1102 int idx = oc->nb_streams - 1, ret = 0;
1103 char *bsf = NULL, *next, *codec_tag = NULL;
1104 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1109 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1113 if (oc->nb_streams - 1 < o->nb_streamid_map)
1114 st->id = o->streamid_map[oc->nb_streams - 1];
1116 GROW_ARRAY(output_streams, nb_output_streams);
1117 if (!(ost = av_mallocz(sizeof(*ost))))
1119 output_streams[nb_output_streams - 1] = ost;
1121 ost->file_index = nb_output_files - 1;
1124 st->codec->codec_type = type;
1125 choose_encoder(o, oc, ost);
1127 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1128 if (!ost->enc_ctx) {
1129 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1132 ost->enc_ctx->codec_type = type;
1135 AVIOContext *s = NULL;
1136 char *buf = NULL, *arg = NULL, *preset = NULL;
1138 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1140 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1141 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1144 if (!buf[0] || buf[0] == '#') {
1148 if (!(arg = strchr(buf, '='))) {
1149 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1153 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1155 } while (!s->eof_reached);
1159 av_log(NULL, AV_LOG_FATAL,
1160 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1161 preset, ost->file_index, ost->index);
1165 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1168 ost->max_frames = INT64_MAX;
1169 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1170 for (i = 0; i<o->nb_max_frames; i++) {
1171 char *p = o->max_frames[i].specifier;
1172 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1173 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1178 ost->copy_prior_start = -1;
1179 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1181 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1184 if (next = strchr(bsf, ','))
1186 if (arg = strchr(bsf, '='))
1188 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1189 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1193 bsfc_prev->next = bsfc;
1195 ost->bitstream_filters = bsfc;
1196 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1202 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1204 uint32_t tag = strtol(codec_tag, &next, 0);
1206 tag = AV_RL32(codec_tag);
1207 ost->enc_ctx->codec_tag = tag;
1210 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1212 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1213 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1216 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1217 ost->disposition = av_strdup(ost->disposition);
1219 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1220 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1222 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1224 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1225 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1226 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1228 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1230 ost->source_index = source_index;
1231 if (source_index >= 0) {
1232 ost->sync_ist = input_streams[source_index];
1233 input_streams[source_index]->discard = 0;
1234 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1236 ost->last_mux_dts = AV_NOPTS_VALUE;
1241 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1244 const char *p = str;
1251 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1258 /* read file contents into a string */
1259 static uint8_t *read_file(const char *filename)
1261 AVIOContext *pb = NULL;
1262 AVIOContext *dyn_buf = NULL;
1263 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1264 uint8_t buf[1024], *str;
1267 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1271 ret = avio_open_dyn_buf(&dyn_buf);
1276 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1277 avio_write(dyn_buf, buf, ret);
1278 avio_w8(dyn_buf, 0);
1281 ret = avio_close_dyn_buf(dyn_buf, &str);
1287 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1290 AVStream *st = ost->st;
1292 if (ost->filters_script && ost->filters) {
1293 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1294 "output stream #%d:%d.\n", nb_output_files, st->index);
1298 if (ost->filters_script)
1299 return read_file(ost->filters_script);
1300 else if (ost->filters)
1301 return av_strdup(ost->filters);
1303 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1307 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1308 const OutputStream *ost, enum AVMediaType type)
1310 if (ost->filters_script || ost->filters) {
1311 av_log(NULL, AV_LOG_ERROR,
1312 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1313 "Filtering and streamcopy cannot be used together.\n",
1314 ost->filters ? "Filtergraph" : "Filtergraph script",
1315 ost->filters ? ost->filters : ost->filters_script,
1316 av_get_media_type_string(type), ost->file_index, ost->index);
1321 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1325 AVCodecContext *video_enc;
1326 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1328 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1330 video_enc = ost->enc_ctx;
1332 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1333 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1334 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1337 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1338 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1340 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1341 if (frame_aspect_ratio) {
1343 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1344 q.num <= 0 || q.den <= 0) {
1345 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1348 ost->frame_aspect_ratio = q;
1351 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1352 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1354 if (!ost->stream_copy) {
1355 const char *p = NULL;
1356 char *frame_size = NULL;
1357 char *frame_pix_fmt = NULL;
1358 char *intra_matrix = NULL, *inter_matrix = NULL;
1359 char *chroma_intra_matrix = NULL;
1363 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1364 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1365 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1369 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1370 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1371 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1372 ost->keep_pix_fmt = 1;
1373 if (!*++frame_pix_fmt)
1374 frame_pix_fmt = NULL;
1376 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1377 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1380 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1383 video_enc->gop_size = 0;
1384 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1386 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1387 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1390 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1392 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1393 if (chroma_intra_matrix) {
1394 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1396 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1399 av_codec_set_chroma_intra_matrix(video_enc, p);
1400 parse_matrix_coeffs(p, chroma_intra_matrix);
1402 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1404 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1405 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1408 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1411 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1412 for (i = 0; p; i++) {
1414 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1416 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1419 video_enc->rc_override =
1420 av_realloc_array(video_enc->rc_override,
1421 i + 1, sizeof(RcOverride));
1422 if (!video_enc->rc_override) {
1423 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1426 video_enc->rc_override[i].start_frame = start;
1427 video_enc->rc_override[i].end_frame = end;
1429 video_enc->rc_override[i].qscale = q;
1430 video_enc->rc_override[i].quality_factor = 1.0;
1433 video_enc->rc_override[i].qscale = 0;
1434 video_enc->rc_override[i].quality_factor = -q/100.0;
1439 video_enc->rc_override_count = i;
1442 video_enc->flags|= CODEC_FLAG_PSNR;
1445 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1448 video_enc->flags |= CODEC_FLAG_PASS1;
1449 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1452 video_enc->flags |= CODEC_FLAG_PASS2;
1453 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1457 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1458 if (ost->logfile_prefix &&
1459 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1462 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1463 if (ost->forced_keyframes)
1464 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1466 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1468 ost->top_field_first = -1;
1469 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1472 ost->avfilter = get_ost_filters(o, oc, ost);
1476 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1479 if (ost->stream_copy)
1480 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1485 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1490 AVCodecContext *audio_enc;
1492 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1495 audio_enc = ost->enc_ctx;
1496 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1498 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1499 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1501 if (!ost->stream_copy) {
1502 char *sample_fmt = NULL;
1504 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1506 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1508 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1509 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1513 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1515 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1516 ost->apad = av_strdup(ost->apad);
1518 ost->avfilter = get_ost_filters(o, oc, ost);
1522 /* check for channel mapping for this audio stream */
1523 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1524 AudioChannelMap *map = &o->audio_channel_maps[n];
1525 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1526 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1529 if (map->channel_idx == -1) {
1531 } else if (ost->source_index < 0) {
1532 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1533 ost->file_index, ost->st->index);
1536 ist = input_streams[ost->source_index];
1539 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1540 if (av_reallocp_array(&ost->audio_channels_map,
1541 ost->audio_channels_mapped + 1,
1542 sizeof(*ost->audio_channels_map)
1546 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1552 if (ost->stream_copy)
1553 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1558 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1562 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1563 if (!ost->stream_copy) {
1564 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1571 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1575 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1576 if (!ost->stream_copy) {
1577 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1584 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1586 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1587 ost->stream_copy = 1;
1592 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1596 AVCodecContext *subtitle_enc;
1598 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1600 subtitle_enc = ost->enc_ctx;
1602 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1604 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1606 if (!ost->stream_copy) {
1607 char *frame_size = NULL;
1609 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1610 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1611 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1619 /* arg format is "output-stream-index:streamid-value". */
1620 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1622 OptionsContext *o = optctx;
1627 av_strlcpy(idx_str, arg, sizeof(idx_str));
1628 p = strchr(idx_str, ':');
1630 av_log(NULL, AV_LOG_FATAL,
1631 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1636 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1637 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1638 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1642 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1644 AVFormatContext *is = ifile->ctx;
1645 AVFormatContext *os = ofile->ctx;
1649 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1651 return AVERROR(ENOMEM);
1654 for (i = 0; i < is->nb_chapters; i++) {
1655 AVChapter *in_ch = is->chapters[i], *out_ch;
1656 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1657 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1658 AV_TIME_BASE_Q, in_ch->time_base);
1659 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1660 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1663 if (in_ch->end < ts_off)
1665 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1668 out_ch = av_mallocz(sizeof(AVChapter));
1670 return AVERROR(ENOMEM);
1672 out_ch->id = in_ch->id;
1673 out_ch->time_base = in_ch->time_base;
1674 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1675 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1678 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1680 os->chapters[os->nb_chapters++] = out_ch;
1685 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1688 AVFormatContext *ic = avformat_alloc_context();
1690 ic->interrupt_callback = int_cb;
1691 err = avformat_open_input(&ic, filename, NULL, NULL);
1694 /* copy stream format */
1695 for(i=0;i<ic->nb_streams;i++) {
1699 const char *enc_config;
1701 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1703 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1704 return AVERROR(EINVAL);
1706 if (codec->type == AVMEDIA_TYPE_AUDIO)
1707 opt_audio_codec(o, "c:a", codec->name);
1708 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1709 opt_video_codec(o, "c:v", codec->name);
1710 ost = new_output_stream(o, s, codec->type, -1);
1713 avcodec_get_context_defaults3(st->codec, codec);
1714 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1716 AVDictionary *opts = NULL;
1717 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1718 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1719 av_dict_free(&opts);
1722 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1723 choose_sample_fmt(st, codec);
1724 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1725 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1726 avcodec_copy_context(ost->enc_ctx, st->codec);
1728 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1731 avformat_close_input(&ic);
1735 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1736 AVFormatContext *oc)
1740 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1741 ofilter->out_tmp->pad_idx)) {
1742 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1743 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1745 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1750 ost->source_index = -1;
1751 ost->filter = ofilter;
1755 if (ost->stream_copy) {
1756 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1757 "which is fed from a complex filtergraph. Filtering and streamcopy "
1758 "cannot be used together.\n", ost->file_index, ost->index);
1762 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1763 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1764 av_log(NULL, AV_LOG_ERROR,
1765 "%s '%s' was specified through the %s option "
1766 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1767 "%s and -filter_complex cannot be used together for the same stream.\n",
1768 ost->filters ? "Filtergraph" : "Filtergraph script",
1769 ost->filters ? ost->filters : ost->filters_script,
1770 opt, ost->file_index, ost->index, opt);
1774 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1775 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1778 avfilter_inout_free(&ofilter->out_tmp);
1781 static int configure_complex_filters(void)
1785 for (i = 0; i < nb_filtergraphs; i++)
1786 if (!filtergraphs[i]->graph &&
1787 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1792 static int open_output_file(OptionsContext *o, const char *filename)
1794 AVFormatContext *oc;
1796 AVOutputFormat *file_oformat;
1800 AVDictionary *unused_opts = NULL;
1801 AVDictionaryEntry *e = NULL;
1803 if (configure_complex_filters() < 0) {
1804 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1808 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1809 o->stop_time = INT64_MAX;
1810 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1813 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1814 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1815 if (o->stop_time <= start_time) {
1816 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1819 o->recording_time = o->stop_time - start_time;
1823 GROW_ARRAY(output_files, nb_output_files);
1824 of = av_mallocz(sizeof(*of));
1827 output_files[nb_output_files - 1] = of;
1829 of->ost_index = nb_output_streams;
1830 of->recording_time = o->recording_time;
1831 of->start_time = o->start_time;
1832 of->limit_filesize = o->limit_filesize;
1833 of->shortest = o->shortest;
1834 av_dict_copy(&of->opts, o->g->format_opts, 0);
1836 if (!strcmp(filename, "-"))
1839 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1841 print_error(filename, err);
1846 if (o->recording_time != INT64_MAX)
1847 oc->duration = o->recording_time;
1849 file_oformat= oc->oformat;
1850 oc->interrupt_callback = int_cb;
1852 /* create streams for all unlabeled output pads */
1853 for (i = 0; i < nb_filtergraphs; i++) {
1854 FilterGraph *fg = filtergraphs[i];
1855 for (j = 0; j < fg->nb_outputs; j++) {
1856 OutputFilter *ofilter = fg->outputs[j];
1858 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1861 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1862 ofilter->out_tmp->pad_idx)) {
1863 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1864 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1865 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1867 init_output_filter(ofilter, o, oc);
1871 /* ffserver seeking with date=... needs a date reference */
1872 if (!strcmp(file_oformat->name, "ffm") &&
1873 av_strstart(filename, "http:", NULL)) {
1874 int err = parse_option(o, "metadata", "creation_time=now", options);
1876 print_error(filename, err);
1881 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1882 av_strstart(filename, "http:", NULL)) {
1884 /* special case for files sent to ffserver: we get the stream
1885 parameters from ffserver */
1886 int err = read_ffserver_streams(o, oc, filename);
1888 print_error(filename, err);
1891 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1892 ost = output_streams[j];
1893 for (i = 0; i < nb_input_streams; i++) {
1894 ist = input_streams[i];
1895 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1897 ost->source_index= i;
1898 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1899 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1901 ist->st->discard = ist->user_set_discard;
1906 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));
1910 } else if (!o->nb_stream_maps) {
1911 char *subtitle_codec_name = NULL;
1912 /* pick the "best" stream of each type */
1914 /* video: highest resolution */
1915 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1916 int area = 0, idx = -1;
1917 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1918 for (i = 0; i < nb_input_streams; i++) {
1920 ist = input_streams[i];
1921 new_area = ist->st->codec->width * ist->st->codec->height;
1922 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1924 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1926 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1933 new_video_stream(o, oc, idx);
1936 /* audio: most channels */
1937 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1938 int channels = 0, idx = -1;
1939 for (i = 0; i < nb_input_streams; i++) {
1940 ist = input_streams[i];
1941 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1942 ist->st->codec->channels > channels) {
1943 channels = ist->st->codec->channels;
1948 new_audio_stream(o, oc, idx);
1951 /* subtitles: pick first */
1952 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1953 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1954 for (i = 0; i < nb_input_streams; i++)
1955 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1956 AVCodecDescriptor const *input_descriptor =
1957 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1958 AVCodecDescriptor const *output_descriptor = NULL;
1959 AVCodec const *output_codec =
1960 avcodec_find_encoder(oc->oformat->subtitle_codec);
1961 int input_props = 0, output_props = 0;
1963 output_descriptor = avcodec_descriptor_get(output_codec->id);
1964 if (input_descriptor)
1965 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1966 if (output_descriptor)
1967 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1968 if (subtitle_codec_name ||
1969 input_props & output_props ||
1970 // Map dvb teletext which has neither property to any output subtitle encoder
1971 input_descriptor && output_descriptor &&
1972 (!input_descriptor->props ||
1973 !output_descriptor->props)) {
1974 new_subtitle_stream(o, oc, i);
1979 /* Data only if codec id match */
1980 if (!o->data_disable ) {
1981 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
1982 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1983 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1984 && input_streams[i]->st->codec->codec_id == codec_id )
1985 new_data_stream(o, oc, i);
1989 for (i = 0; i < o->nb_stream_maps; i++) {
1990 StreamMap *map = &o->stream_maps[i];
1995 if (map->linklabel) {
1997 OutputFilter *ofilter = NULL;
2000 for (j = 0; j < nb_filtergraphs; j++) {
2001 fg = filtergraphs[j];
2002 for (k = 0; k < fg->nb_outputs; k++) {
2003 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2004 if (out && !strcmp(out->name, map->linklabel)) {
2005 ofilter = fg->outputs[k];
2012 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2013 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2016 init_output_filter(ofilter, o, oc);
2018 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2020 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2021 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2023 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2025 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2027 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2030 switch (ist->st->codec->codec_type) {
2031 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2032 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2033 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2034 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2035 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2036 case AVMEDIA_TYPE_UNKNOWN:
2037 if (copy_unknown_streams) {
2038 ost = new_unknown_stream (o, oc, src_idx);
2042 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2043 "Cannot map stream #%d:%d - unsupported type.\n",
2044 map->file_index, map->stream_index);
2045 if (!ignore_unknown_streams) {
2046 av_log(NULL, AV_LOG_FATAL,
2047 "If you want unsupported types ignored instead "
2048 "of failing, please use the -ignore_unknown option\n"
2049 "If you want them copied, please use -copy_unknown\n");
2057 /* handle attached files */
2058 for (i = 0; i < o->nb_attachments; i++) {
2060 uint8_t *attachment;
2064 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2065 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2069 if ((len = avio_size(pb)) <= 0) {
2070 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2074 if (!(attachment = av_malloc(len))) {
2075 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2079 avio_read(pb, attachment, len);
2081 ost = new_attachment_stream(o, oc, -1);
2082 ost->stream_copy = 0;
2083 ost->attachment_filename = o->attachments[i];
2085 ost->st->codec->extradata = attachment;
2086 ost->st->codec->extradata_size = len;
2088 p = strrchr(o->attachments[i], '/');
2089 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2093 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2094 AVDictionaryEntry *e;
2095 ost = output_streams[i];
2097 if ((ost->stream_copy || ost->attachment_filename)
2098 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2099 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2100 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2104 /* check if all codec options have been used */
2105 unused_opts = strip_specifiers(o->g->codec_opts);
2106 for (i = of->ost_index; i < nb_output_streams; i++) {
2108 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2109 AV_DICT_IGNORE_SUFFIX)))
2110 av_dict_set(&unused_opts, e->key, NULL, 0);
2114 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2115 const AVClass *class = avcodec_get_class();
2116 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2117 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2118 const AVClass *fclass = avformat_get_class();
2119 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2120 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2121 if (!option || foption)
2125 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2126 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2127 "output file #%d (%s) is not an encoding option.\n", e->key,
2128 option->help ? option->help : "", nb_output_files - 1,
2133 // gop_timecode is injected by generic code but not always used
2134 if (!strcmp(e->key, "gop_timecode"))
2137 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2138 "output file #%d (%s) has not been used for any stream. The most "
2139 "likely reason is either wrong type (e.g. a video option with "
2140 "no video streams) or that it is a private option of some encoder "
2141 "which was not actually used for any stream.\n", e->key,
2142 option->help ? option->help : "", nb_output_files - 1, filename);
2144 av_dict_free(&unused_opts);
2146 /* check filename in case of an image number is expected */
2147 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2148 if (!av_filename_number_test(oc->filename)) {
2149 print_error(oc->filename, AVERROR(EINVAL));
2154 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2155 av_log(NULL, AV_LOG_ERROR,
2156 "No input streams but output needs an input stream\n");
2160 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2161 /* test if it already exists to avoid losing precious files */
2162 assert_file_overwrite(filename);
2165 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2166 &oc->interrupt_callback,
2168 print_error(filename, err);
2171 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2172 assert_file_overwrite(filename);
2174 if (o->mux_preload) {
2175 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2177 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2180 for (i = 0; i < o->nb_metadata_map; i++) {
2182 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2184 if (in_file_index >= nb_input_files) {
2185 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2188 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2189 in_file_index >= 0 ?
2190 input_files[in_file_index]->ctx : NULL, o);
2194 if (o->chapters_input_file >= nb_input_files) {
2195 if (o->chapters_input_file == INT_MAX) {
2196 /* copy chapters from the first input file that has them*/
2197 o->chapters_input_file = -1;
2198 for (i = 0; i < nb_input_files; i++)
2199 if (input_files[i]->ctx->nb_chapters) {
2200 o->chapters_input_file = i;
2204 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2205 o->chapters_input_file);
2209 if (o->chapters_input_file >= 0)
2210 copy_chapters(input_files[o->chapters_input_file], of,
2211 !o->metadata_chapters_manual);
2213 /* copy global metadata by default */
2214 if (!o->metadata_global_manual && nb_input_files){
2215 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2216 AV_DICT_DONT_OVERWRITE);
2217 if(o->recording_time != INT64_MAX)
2218 av_dict_set(&oc->metadata, "duration", NULL, 0);
2219 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2221 if (!o->metadata_streams_manual)
2222 for (i = of->ost_index; i < nb_output_streams; i++) {
2224 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2226 ist = input_streams[output_streams[i]->source_index];
2227 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2228 if (!output_streams[i]->stream_copy) {
2229 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2230 if (ist->autorotate)
2231 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2235 /* process manually set metadata */
2236 for (i = 0; i < o->nb_metadata; i++) {
2239 const char *stream_spec;
2240 int index = 0, j, ret = 0;
2243 val = strchr(o->metadata[i].u.str, '=');
2245 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2246 o->metadata[i].u.str);
2251 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2252 !strcmp(val, "now")) {
2253 time_t now = time(0);
2254 struct tm *ptm, tmbuf;
2255 ptm = localtime_r(&now, &tmbuf);
2257 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2262 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2264 for (j = 0; j < oc->nb_streams; j++) {
2265 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2266 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2267 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2268 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2269 ost->rotate_overridden = 1;
2281 if (index < 0 || index >= oc->nb_chapters) {
2282 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2285 m = &oc->chapters[index]->metadata;
2288 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2291 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2298 static int opt_target(void *optctx, const char *opt, const char *arg)
2300 OptionsContext *o = optctx;
2301 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2302 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2304 if (!strncmp(arg, "pal-", 4)) {
2307 } else if (!strncmp(arg, "ntsc-", 5)) {
2310 } else if (!strncmp(arg, "film-", 5)) {
2314 /* Try to determine PAL/NTSC by peeking in the input files */
2315 if (nb_input_files) {
2317 for (j = 0; j < nb_input_files; j++) {
2318 for (i = 0; i < input_files[j]->nb_streams; i++) {
2319 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2320 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2323 fr = c->time_base.den * 1000 / c->time_base.num;
2327 } else if ((fr == 29970) || (fr == 23976)) {
2332 if (norm != UNKNOWN)
2336 if (norm != UNKNOWN)
2337 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2340 if (norm == UNKNOWN) {
2341 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2342 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2343 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2347 if (!strcmp(arg, "vcd")) {
2348 opt_video_codec(o, "c:v", "mpeg1video");
2349 opt_audio_codec(o, "c:a", "mp2");
2350 parse_option(o, "f", "vcd", options);
2352 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2353 parse_option(o, "r", frame_rates[norm], options);
2354 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2356 opt_default(NULL, "b:v", "1150000");
2357 opt_default(NULL, "maxrate:v", "1150000");
2358 opt_default(NULL, "minrate:v", "1150000");
2359 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2361 opt_default(NULL, "b:a", "224000");
2362 parse_option(o, "ar", "44100", options);
2363 parse_option(o, "ac", "2", options);
2365 opt_default(NULL, "packetsize", "2324");
2366 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2368 /* We have to offset the PTS, so that it is consistent with the SCR.
2369 SCR starts at 36000, but the first two packs contain only padding
2370 and the first pack from the other stream, respectively, may also have
2371 been written before.
2372 So the real data starts at SCR 36000+3*1200. */
2373 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2374 } else if (!strcmp(arg, "svcd")) {
2376 opt_video_codec(o, "c:v", "mpeg2video");
2377 opt_audio_codec(o, "c:a", "mp2");
2378 parse_option(o, "f", "svcd", options);
2380 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2381 parse_option(o, "r", frame_rates[norm], options);
2382 parse_option(o, "pix_fmt", "yuv420p", options);
2383 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2385 opt_default(NULL, "b:v", "2040000");
2386 opt_default(NULL, "maxrate:v", "2516000");
2387 opt_default(NULL, "minrate:v", "0"); // 1145000;
2388 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2389 opt_default(NULL, "scan_offset", "1");
2391 opt_default(NULL, "b:a", "224000");
2392 parse_option(o, "ar", "44100", options);
2394 opt_default(NULL, "packetsize", "2324");
2396 } else if (!strcmp(arg, "dvd")) {
2398 opt_video_codec(o, "c:v", "mpeg2video");
2399 opt_audio_codec(o, "c:a", "ac3");
2400 parse_option(o, "f", "dvd", options);
2402 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2403 parse_option(o, "r", frame_rates[norm], options);
2404 parse_option(o, "pix_fmt", "yuv420p", options);
2405 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2407 opt_default(NULL, "b:v", "6000000");
2408 opt_default(NULL, "maxrate:v", "9000000");
2409 opt_default(NULL, "minrate:v", "0"); // 1500000;
2410 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2412 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2413 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2415 opt_default(NULL, "b:a", "448000");
2416 parse_option(o, "ar", "48000", options);
2418 } else if (!strncmp(arg, "dv", 2)) {
2420 parse_option(o, "f", "dv", options);
2422 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2423 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2424 norm == PAL ? "yuv420p" : "yuv411p", options);
2425 parse_option(o, "r", frame_rates[norm], options);
2427 parse_option(o, "ar", "48000", options);
2428 parse_option(o, "ac", "2", options);
2431 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2432 return AVERROR(EINVAL);
2435 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2436 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2441 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2443 av_free (vstats_filename);
2444 vstats_filename = av_strdup (arg);
2448 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2451 time_t today2 = time(NULL);
2452 struct tm *today = localtime(&today2);
2454 if (!today) { // maybe tomorrow
2455 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2459 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2461 return opt_vstats_file(NULL, opt, filename);
2464 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2466 OptionsContext *o = optctx;
2467 return parse_option(o, "frames:v", arg, options);
2470 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2472 OptionsContext *o = optctx;
2473 return parse_option(o, "frames:a", arg, options);
2476 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2478 OptionsContext *o = optctx;
2479 return parse_option(o, "frames:d", arg, options);
2482 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2485 AVDictionary *cbak = codec_opts;
2486 AVDictionary *fbak = format_opts;
2490 ret = opt_default(NULL, opt, arg);
2492 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2493 av_dict_copy(&o->g->format_opts, format_opts, 0);
2494 av_dict_free(&codec_opts);
2495 av_dict_free(&format_opts);
2502 static int opt_preset(void *optctx, const char *opt, const char *arg)
2504 OptionsContext *o = optctx;
2506 char filename[1000], line[1000], tmp_line[1000];
2507 const char *codec_name = NULL;
2511 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2513 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2514 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2515 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2517 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2521 while (fgets(line, sizeof(line), f)) {
2522 char *key = tmp_line, *value, *endptr;
2524 if (strcspn(line, "#\n\r") == 0)
2526 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2527 if (!av_strtok(key, "=", &value) ||
2528 !av_strtok(value, "\r\n", &endptr)) {
2529 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2532 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2534 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2535 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2536 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2537 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2538 else if (opt_default_new(o, key, value) < 0) {
2539 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2540 filename, line, key, value);
2550 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2552 OptionsContext *o = optctx;
2553 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2554 int ret = parse_option(o, s, arg, options);
2559 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2561 OptionsContext *o = optctx;
2563 if(!strcmp(opt, "ab")){
2564 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2566 } else if(!strcmp(opt, "b")){
2567 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2568 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2571 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2575 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2577 OptionsContext *o = optctx;
2580 if(!strcmp(opt, "qscale")){
2581 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2582 return parse_option(o, "q:v", arg, options);
2584 s = av_asprintf("q%s", opt + 6);
2585 ret = parse_option(o, s, arg, options);
2590 static int opt_profile(void *optctx, const char *opt, const char *arg)
2592 OptionsContext *o = optctx;
2593 if(!strcmp(opt, "profile")){
2594 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2595 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2598 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2602 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2604 OptionsContext *o = optctx;
2605 return parse_option(o, "filter:v", arg, options);
2608 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2610 OptionsContext *o = optctx;
2611 return parse_option(o, "filter:a", arg, options);
2614 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2616 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2617 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2618 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2619 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2621 if (video_sync_method == VSYNC_AUTO)
2622 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2626 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2628 OptionsContext *o = optctx;
2629 char *tcr = av_asprintf("timecode=%s", arg);
2630 int ret = parse_option(o, "metadata:g", tcr, options);
2632 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2637 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2639 OptionsContext *o = optctx;
2640 char layout_str[32];
2643 int ret, channels, ac_str_size;
2646 layout = av_get_channel_layout(arg);
2648 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2649 return AVERROR(EINVAL);
2651 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2652 ret = opt_default_new(o, opt, layout_str);
2656 /* set 'ac' option based on channel layout */
2657 channels = av_get_channel_layout_nb_channels(layout);
2658 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2659 stream_str = strchr(opt, ':');
2660 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2661 ac_str = av_mallocz(ac_str_size);
2663 return AVERROR(ENOMEM);
2664 av_strlcpy(ac_str, "ac", 3);
2666 av_strlcat(ac_str, stream_str, ac_str_size);
2667 ret = parse_option(o, ac_str, layout_str, options);
2673 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2675 OptionsContext *o = optctx;
2676 return parse_option(o, "q:a", arg, options);
2679 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2681 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2682 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2683 return AVERROR(ENOMEM);
2684 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2685 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2686 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2687 return AVERROR(ENOMEM);
2689 input_stream_potentially_available = 1;
2694 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2696 uint8_t *graph_desc = read_file(arg);
2698 return AVERROR(EINVAL);
2700 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2701 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2702 return AVERROR(ENOMEM);
2703 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2704 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2706 input_stream_potentially_available = 1;
2711 void show_help_default(const char *opt, const char *arg)
2713 /* per-file options have at least one of those set */
2714 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2715 int show_advanced = 0, show_avoptions = 0;
2718 if (!strcmp(opt, "long"))
2720 else if (!strcmp(opt, "full"))
2721 show_advanced = show_avoptions = 1;
2723 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2728 printf("Getting help:\n"
2729 " -h -- print basic options\n"
2730 " -h long -- print more options\n"
2731 " -h full -- print all options (including all format and codec specific options, very long)\n"
2732 " See man %s for detailed description of the options.\n"
2733 "\n", program_name);
2735 show_help_options(options, "Print help / information / capabilities:",
2738 show_help_options(options, "Global options (affect whole program "
2739 "instead of just one file:",
2740 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2742 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2743 per_file | OPT_EXIT, 0);
2745 show_help_options(options, "Per-file main options:", 0,
2746 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2747 OPT_EXIT, per_file);
2749 show_help_options(options, "Advanced per-file options:",
2750 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2752 show_help_options(options, "Video options:",
2753 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2755 show_help_options(options, "Advanced Video options:",
2756 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2758 show_help_options(options, "Audio options:",
2759 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2761 show_help_options(options, "Advanced Audio options:",
2762 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2763 show_help_options(options, "Subtitle options:",
2764 OPT_SUBTITLE, 0, 0);
2767 if (show_avoptions) {
2768 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2769 show_help_children(avcodec_get_class(), flags);
2770 show_help_children(avformat_get_class(), flags);
2772 show_help_children(sws_get_class(), flags);
2774 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2775 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2779 void show_usage(void)
2781 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2782 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2783 av_log(NULL, AV_LOG_INFO, "\n");
2791 static const OptionGroupDef groups[] = {
2792 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2793 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2796 static int open_files(OptionGroupList *l, const char *inout,
2797 int (*open_file)(OptionsContext*, const char*))
2801 for (i = 0; i < l->nb_groups; i++) {
2802 OptionGroup *g = &l->groups[i];
2808 ret = parse_optgroup(&o, g);
2810 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2811 "%s.\n", inout, g->arg);
2815 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2816 ret = open_file(&o, g->arg);
2819 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2823 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2829 int ffmpeg_parse_options(int argc, char **argv)
2831 OptionParseContext octx;
2835 memset(&octx, 0, sizeof(octx));
2837 /* split the commandline into an internal representation */
2838 ret = split_commandline(&octx, argc, argv, options, groups,
2839 FF_ARRAY_ELEMS(groups));
2841 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2845 /* apply global options */
2846 ret = parse_optgroup(NULL, &octx.global_opts);
2848 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2852 /* open input files */
2853 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2855 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2859 /* open output files */
2860 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2862 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2867 uninit_parse_context(&octx);
2869 av_strerror(ret, error, sizeof(error));
2870 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2875 static int opt_progress(void *optctx, const char *opt, const char *arg)
2877 AVIOContext *avio = NULL;
2880 if (!strcmp(arg, "-"))
2882 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2884 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2885 arg, av_err2str(ret));
2888 progress_avio = avio;
2892 #define OFFSET(x) offsetof(OptionsContext, x)
2893 const OptionDef options[] = {
2895 #include "cmdutils_common_opts.h"
2896 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2897 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2898 "force format", "fmt" },
2899 { "y", OPT_BOOL, { &file_overwrite },
2900 "overwrite output files" },
2901 { "n", OPT_BOOL, { &no_file_overwrite },
2902 "never overwrite output files" },
2903 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
2904 "Ignore unknown stream types" },
2905 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
2906 "Copy unknown stream types" },
2907 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2908 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2909 "codec name", "codec" },
2910 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2911 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2912 "codec name", "codec" },
2913 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2914 OPT_OUTPUT, { .off = OFFSET(presets) },
2915 "preset name", "preset" },
2916 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2917 OPT_OUTPUT, { .func_arg = opt_map },
2918 "set input stream mapping",
2919 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2920 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2921 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2922 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2923 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2924 "set metadata information of outfile from infile",
2925 "outfile[,metadata]:infile[,metadata]" },
2926 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2927 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2928 "set chapters mapping", "input_file_index" },
2929 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2930 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2931 "record or transcode \"duration\" seconds of audio/video",
2933 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2934 "record or transcode stop time", "time_stop" },
2935 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2936 "set the limit file size in bytes", "limit_size" },
2937 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2938 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2939 "set the start time offset", "time_off" },
2940 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
2941 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
2942 "enable/disable seeking by timestamp with -ss" },
2943 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2944 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2945 "enable/disable accurate seeking with -ss" },
2946 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2947 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2948 "set the input ts offset", "time_off" },
2949 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2950 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2951 "set the input ts scale", "scale" },
2952 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
2953 "set the recording timestamp ('now' to set the current time)", "time" },
2954 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2955 "add metadata", "string=string" },
2956 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2957 OPT_OUTPUT, { .func_arg = opt_data_frames },
2958 "set the number of data frames to output", "number" },
2959 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2960 "add timings for benchmarking" },
2961 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2962 "add timings for each task" },
2963 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2964 "write program-readable progress information", "url" },
2965 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2966 "enable or disable interaction on standard input" },
2967 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2968 "set max runtime in seconds", "limit" },
2969 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2970 "dump each input packet" },
2971 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2972 "when dumping packets, also dump the payload" },
2973 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2974 OPT_INPUT, { .off = OFFSET(rate_emu) },
2975 "read input at native frame rate", "" },
2976 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2977 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2978 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2979 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2980 "video sync method", "" },
2981 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2982 "frame drop threshold", "" },
2983 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2984 "audio sync method", "" },
2985 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2986 "audio drift threshold", "threshold" },
2987 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2988 "copy timestamps" },
2989 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2990 "shift input timestamps to start at 0 when using copyts" },
2991 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2992 "copy input stream time base when stream copying", "mode" },
2993 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2994 OPT_OUTPUT, { .off = OFFSET(shortest) },
2995 "finish encoding within shortest input" },
2996 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2997 OPT_OUTPUT, { .off = OFFSET(apad) },
2999 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3000 "timestamp discontinuity delta threshold", "threshold" },
3001 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3002 "timestamp error delta threshold", "threshold" },
3003 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3004 "exit on error", "error" },
3005 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3006 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3007 "copy initial non-keyframes" },
3008 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3009 "copy or discard frames before start time" },
3010 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3011 "set the number of frames to output", "number" },
3012 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3013 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3014 "force codec tag/fourcc", "fourcc/tag" },
3015 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3016 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3017 "use fixed quality scale (VBR)", "q" },
3018 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3019 OPT_OUTPUT, { .func_arg = opt_qscale },
3020 "use fixed quality scale (VBR)", "q" },
3021 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3022 "set profile", "profile" },
3023 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3024 "set stream filtergraph", "filter_graph" },
3025 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3026 "read stream filtergraph description from a file", "filename" },
3027 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3028 "reinit filtergraph on input parameter changes", "" },
3029 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3030 "create a complex filtergraph", "graph_description" },
3031 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3032 "create a complex filtergraph", "graph_description" },
3033 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3034 "read complex filtergraph description from a file", "filename" },
3035 { "stats", OPT_BOOL, { &print_stats },
3036 "print progress report during encoding", },
3037 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3038 OPT_OUTPUT, { .func_arg = opt_attach },
3039 "add an attachment to the output file", "filename" },
3040 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3041 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3042 "extract an attachment into a file", "filename" },
3043 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3044 "print timestamp debugging info" },
3045 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3046 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3047 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3048 OPT_INPUT, { .off = OFFSET(discard) },
3050 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3051 OPT_OUTPUT, { .off = OFFSET(disposition) },
3052 "disposition", "" },
3053 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3054 { .off = OFFSET(thread_queue_size) },
3055 "set the maximum number of queued packets from the demuxer" },
3058 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3059 "set the number of video frames to output", "number" },
3060 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3061 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3062 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3063 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3064 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3065 "set frame size (WxH or abbreviation)", "size" },
3066 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3067 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3068 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3069 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3070 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3071 "set pixel format", "format" },
3072 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3073 "set the number of bits per raw sample", "number" },
3074 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3075 "deprecated use -g 1" },
3076 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3078 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3079 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3080 "rate control override for specific intervals", "override" },
3081 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3082 OPT_OUTPUT, { .func_arg = opt_video_codec },
3083 "force video codec ('copy' to copy stream)", "codec" },
3084 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3086 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3088 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3089 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3090 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3091 "select the pass number (1 to 3)", "n" },
3092 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3093 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3094 "select two pass log file name prefix", "prefix" },
3095 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3096 "this option is deprecated, use the yadif filter instead" },
3097 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3098 "calculate PSNR of compressed frames" },
3099 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3100 "dump video coding statistics to file" },
3101 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3102 "dump video coding statistics to file", "file" },
3103 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3104 "set video filters", "filter_graph" },
3105 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3106 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3107 "specify intra matrix coeffs", "matrix" },
3108 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3109 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3110 "specify inter matrix coeffs", "matrix" },
3111 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3112 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3113 "specify intra matrix coeffs", "matrix" },
3114 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3115 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3116 "top=1/bottom=0/auto=-1 field first", "" },
3117 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3118 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3119 "force video tag/fourcc", "fourcc/tag" },
3120 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3121 "show QP histogram" },
3122 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3123 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3124 "force the selected framerate, disable the best supported framerate selection" },
3125 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3126 OPT_OUTPUT, { .func_arg = opt_streamid },
3127 "set the value of an outfile streamid", "streamIndex:value" },
3128 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3129 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3130 "force key frames at specified timestamps", "timestamps" },
3131 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3132 "audio bitrate (please use -b:a)", "bitrate" },
3133 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3134 "video bitrate (please use -b:v)", "bitrate" },
3135 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3136 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3137 "use HW accelerated decoding", "hwaccel name" },
3138 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3139 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3140 "select a device for HW acceleration" "devicename" },
3142 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3144 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3145 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3146 "automatically insert correct rotate filters" },
3149 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3150 "set the number of audio frames to output", "number" },
3151 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3152 "set audio quality (codec-specific)", "quality", },
3153 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3154 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3155 "set audio sampling rate (in Hz)", "rate" },
3156 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3157 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3158 "set number of audio channels", "channels" },
3159 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3161 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3162 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3163 "force audio codec ('copy' to copy stream)", "codec" },
3164 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3165 OPT_OUTPUT, { .func_arg = opt_old2new },
3166 "force audio tag/fourcc", "fourcc/tag" },
3167 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3168 "change audio volume (256=normal)" , "volume" },
3169 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3170 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3171 "set sample format", "format" },
3172 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3173 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3174 "set channel layout", "layout" },
3175 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3176 "set audio filters", "filter_graph" },
3177 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3178 "set the maximum number of channels to try to guess the channel layout" },
3180 /* subtitle options */
3181 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3182 "disable subtitle" },
3183 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3184 "force subtitle codec ('copy' to copy stream)", "codec" },
3185 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3186 , "force subtitle tag/fourcc", "fourcc/tag" },
3187 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3188 "fix subtitles duration" },
3189 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3190 "set canvas size (WxH or abbreviation)", "size" },
3193 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3194 "deprecated, use -channel", "channel" },
3195 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3196 "deprecated, use -standard", "standard" },
3197 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3200 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3201 "set the maximum demux-decode delay", "seconds" },
3202 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3203 "set the initial demux-decode delay", "seconds" },
3204 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3205 "override the options from ffserver", "" },
3206 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3207 "specify a file in which to print sdp information", "file" },
3209 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3210 "A comma-separated list of bitstream filters", "bitstream_filters" },
3211 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3212 "deprecated", "audio bitstream_filters" },
3213 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3214 "deprecated", "video bitstream_filters" },
3216 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3217 "set the audio options to the indicated preset", "preset" },
3218 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3219 "set the video options to the indicated preset", "preset" },
3220 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3221 "set the subtitle options to the indicated preset", "preset" },
3222 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3223 "set options from indicated preset file", "filename" },
3224 /* data codec support */
3225 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3226 "force data codec ('copy' to copy stream)", "codec" },
3227 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },