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)
2031 switch (ist->st->codec->codec_type) {
2032 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2033 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2034 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2035 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2036 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2037 case AVMEDIA_TYPE_UNKNOWN:
2038 if (copy_unknown_streams) {
2039 ost = new_unknown_stream (o, oc, src_idx);
2043 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2044 "Cannot map stream #%d:%d - unsupported type.\n",
2045 map->file_index, map->stream_index);
2046 if (!ignore_unknown_streams) {
2047 av_log(NULL, AV_LOG_FATAL,
2048 "If you want unsupported types ignored instead "
2049 "of failing, please use the -ignore_unknown option\n"
2050 "If you want them copied, please use -copy_unknown\n");
2055 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2056 + map->sync_stream_index];
2061 /* handle attached files */
2062 for (i = 0; i < o->nb_attachments; i++) {
2064 uint8_t *attachment;
2068 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2069 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2073 if ((len = avio_size(pb)) <= 0) {
2074 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2078 if (!(attachment = av_malloc(len))) {
2079 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2083 avio_read(pb, attachment, len);
2085 ost = new_attachment_stream(o, oc, -1);
2086 ost->stream_copy = 0;
2087 ost->attachment_filename = o->attachments[i];
2089 ost->st->codec->extradata = attachment;
2090 ost->st->codec->extradata_size = len;
2092 p = strrchr(o->attachments[i], '/');
2093 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2097 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2098 AVDictionaryEntry *e;
2099 ost = output_streams[i];
2101 if ((ost->stream_copy || ost->attachment_filename)
2102 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2103 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2104 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2108 /* check if all codec options have been used */
2109 unused_opts = strip_specifiers(o->g->codec_opts);
2110 for (i = of->ost_index; i < nb_output_streams; i++) {
2112 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2113 AV_DICT_IGNORE_SUFFIX)))
2114 av_dict_set(&unused_opts, e->key, NULL, 0);
2118 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2119 const AVClass *class = avcodec_get_class();
2120 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2121 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2122 const AVClass *fclass = avformat_get_class();
2123 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2124 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2125 if (!option || foption)
2129 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2130 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2131 "output file #%d (%s) is not an encoding option.\n", e->key,
2132 option->help ? option->help : "", nb_output_files - 1,
2137 // gop_timecode is injected by generic code but not always used
2138 if (!strcmp(e->key, "gop_timecode"))
2141 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2142 "output file #%d (%s) has not been used for any stream. The most "
2143 "likely reason is either wrong type (e.g. a video option with "
2144 "no video streams) or that it is a private option of some encoder "
2145 "which was not actually used for any stream.\n", e->key,
2146 option->help ? option->help : "", nb_output_files - 1, filename);
2148 av_dict_free(&unused_opts);
2150 /* check filename in case of an image number is expected */
2151 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2152 if (!av_filename_number_test(oc->filename)) {
2153 print_error(oc->filename, AVERROR(EINVAL));
2158 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2159 av_log(NULL, AV_LOG_ERROR,
2160 "No input streams but output needs an input stream\n");
2164 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2165 /* test if it already exists to avoid losing precious files */
2166 assert_file_overwrite(filename);
2169 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2170 &oc->interrupt_callback,
2172 print_error(filename, err);
2175 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2176 assert_file_overwrite(filename);
2178 if (o->mux_preload) {
2179 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2181 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2184 for (i = 0; i < o->nb_metadata_map; i++) {
2186 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2188 if (in_file_index >= nb_input_files) {
2189 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2192 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2193 in_file_index >= 0 ?
2194 input_files[in_file_index]->ctx : NULL, o);
2198 if (o->chapters_input_file >= nb_input_files) {
2199 if (o->chapters_input_file == INT_MAX) {
2200 /* copy chapters from the first input file that has them*/
2201 o->chapters_input_file = -1;
2202 for (i = 0; i < nb_input_files; i++)
2203 if (input_files[i]->ctx->nb_chapters) {
2204 o->chapters_input_file = i;
2208 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2209 o->chapters_input_file);
2213 if (o->chapters_input_file >= 0)
2214 copy_chapters(input_files[o->chapters_input_file], of,
2215 !o->metadata_chapters_manual);
2217 /* copy global metadata by default */
2218 if (!o->metadata_global_manual && nb_input_files){
2219 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2220 AV_DICT_DONT_OVERWRITE);
2221 if(o->recording_time != INT64_MAX)
2222 av_dict_set(&oc->metadata, "duration", NULL, 0);
2223 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2225 if (!o->metadata_streams_manual)
2226 for (i = of->ost_index; i < nb_output_streams; i++) {
2228 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2230 ist = input_streams[output_streams[i]->source_index];
2231 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2232 if (!output_streams[i]->stream_copy) {
2233 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2234 if (ist->autorotate)
2235 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2239 /* process manually set metadata */
2240 for (i = 0; i < o->nb_metadata; i++) {
2243 const char *stream_spec;
2244 int index = 0, j, ret = 0;
2247 val = strchr(o->metadata[i].u.str, '=');
2249 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2250 o->metadata[i].u.str);
2255 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2256 !strcmp(val, "now")) {
2257 time_t now = time(0);
2258 struct tm *ptm, tmbuf;
2259 ptm = localtime_r(&now, &tmbuf);
2261 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2266 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2268 for (j = 0; j < oc->nb_streams; j++) {
2269 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2270 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2271 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2272 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2273 ost->rotate_overridden = 1;
2285 if (index < 0 || index >= oc->nb_chapters) {
2286 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2289 m = &oc->chapters[index]->metadata;
2292 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2295 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2302 static int opt_target(void *optctx, const char *opt, const char *arg)
2304 OptionsContext *o = optctx;
2305 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2306 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2308 if (!strncmp(arg, "pal-", 4)) {
2311 } else if (!strncmp(arg, "ntsc-", 5)) {
2314 } else if (!strncmp(arg, "film-", 5)) {
2318 /* Try to determine PAL/NTSC by peeking in the input files */
2319 if (nb_input_files) {
2321 for (j = 0; j < nb_input_files; j++) {
2322 for (i = 0; i < input_files[j]->nb_streams; i++) {
2323 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2324 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2327 fr = c->time_base.den * 1000 / c->time_base.num;
2331 } else if ((fr == 29970) || (fr == 23976)) {
2336 if (norm != UNKNOWN)
2340 if (norm != UNKNOWN)
2341 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2344 if (norm == UNKNOWN) {
2345 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2346 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2347 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2351 if (!strcmp(arg, "vcd")) {
2352 opt_video_codec(o, "c:v", "mpeg1video");
2353 opt_audio_codec(o, "c:a", "mp2");
2354 parse_option(o, "f", "vcd", options);
2356 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2357 parse_option(o, "r", frame_rates[norm], options);
2358 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2360 opt_default(NULL, "b:v", "1150000");
2361 opt_default(NULL, "maxrate:v", "1150000");
2362 opt_default(NULL, "minrate:v", "1150000");
2363 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2365 opt_default(NULL, "b:a", "224000");
2366 parse_option(o, "ar", "44100", options);
2367 parse_option(o, "ac", "2", options);
2369 opt_default(NULL, "packetsize", "2324");
2370 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2372 /* We have to offset the PTS, so that it is consistent with the SCR.
2373 SCR starts at 36000, but the first two packs contain only padding
2374 and the first pack from the other stream, respectively, may also have
2375 been written before.
2376 So the real data starts at SCR 36000+3*1200. */
2377 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2378 } else if (!strcmp(arg, "svcd")) {
2380 opt_video_codec(o, "c:v", "mpeg2video");
2381 opt_audio_codec(o, "c:a", "mp2");
2382 parse_option(o, "f", "svcd", options);
2384 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2385 parse_option(o, "r", frame_rates[norm], options);
2386 parse_option(o, "pix_fmt", "yuv420p", options);
2387 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2389 opt_default(NULL, "b:v", "2040000");
2390 opt_default(NULL, "maxrate:v", "2516000");
2391 opt_default(NULL, "minrate:v", "0"); // 1145000;
2392 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2393 opt_default(NULL, "scan_offset", "1");
2395 opt_default(NULL, "b:a", "224000");
2396 parse_option(o, "ar", "44100", options);
2398 opt_default(NULL, "packetsize", "2324");
2400 } else if (!strcmp(arg, "dvd")) {
2402 opt_video_codec(o, "c:v", "mpeg2video");
2403 opt_audio_codec(o, "c:a", "ac3");
2404 parse_option(o, "f", "dvd", options);
2406 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2407 parse_option(o, "r", frame_rates[norm], options);
2408 parse_option(o, "pix_fmt", "yuv420p", options);
2409 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2411 opt_default(NULL, "b:v", "6000000");
2412 opt_default(NULL, "maxrate:v", "9000000");
2413 opt_default(NULL, "minrate:v", "0"); // 1500000;
2414 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2416 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2417 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2419 opt_default(NULL, "b:a", "448000");
2420 parse_option(o, "ar", "48000", options);
2422 } else if (!strncmp(arg, "dv", 2)) {
2424 parse_option(o, "f", "dv", options);
2426 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2427 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2428 norm == PAL ? "yuv420p" : "yuv411p", options);
2429 parse_option(o, "r", frame_rates[norm], options);
2431 parse_option(o, "ar", "48000", options);
2432 parse_option(o, "ac", "2", options);
2435 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2436 return AVERROR(EINVAL);
2439 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2440 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2445 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2447 av_free (vstats_filename);
2448 vstats_filename = av_strdup (arg);
2452 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2455 time_t today2 = time(NULL);
2456 struct tm *today = localtime(&today2);
2458 if (!today) { // maybe tomorrow
2459 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2463 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2465 return opt_vstats_file(NULL, opt, filename);
2468 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2470 OptionsContext *o = optctx;
2471 return parse_option(o, "frames:v", arg, options);
2474 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2476 OptionsContext *o = optctx;
2477 return parse_option(o, "frames:a", arg, options);
2480 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2482 OptionsContext *o = optctx;
2483 return parse_option(o, "frames:d", arg, options);
2486 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2489 AVDictionary *cbak = codec_opts;
2490 AVDictionary *fbak = format_opts;
2494 ret = opt_default(NULL, opt, arg);
2496 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2497 av_dict_copy(&o->g->format_opts, format_opts, 0);
2498 av_dict_free(&codec_opts);
2499 av_dict_free(&format_opts);
2506 static int opt_preset(void *optctx, const char *opt, const char *arg)
2508 OptionsContext *o = optctx;
2510 char filename[1000], line[1000], tmp_line[1000];
2511 const char *codec_name = NULL;
2515 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2517 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2518 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2519 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2521 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2525 while (fgets(line, sizeof(line), f)) {
2526 char *key = tmp_line, *value, *endptr;
2528 if (strcspn(line, "#\n\r") == 0)
2530 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2531 if (!av_strtok(key, "=", &value) ||
2532 !av_strtok(value, "\r\n", &endptr)) {
2533 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2536 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2538 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2539 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2540 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2541 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2542 else if (opt_default_new(o, key, value) < 0) {
2543 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2544 filename, line, key, value);
2554 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2556 OptionsContext *o = optctx;
2557 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2558 int ret = parse_option(o, s, arg, options);
2563 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2565 OptionsContext *o = optctx;
2567 if(!strcmp(opt, "ab")){
2568 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2570 } else if(!strcmp(opt, "b")){
2571 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2572 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2575 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2579 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2581 OptionsContext *o = optctx;
2584 if(!strcmp(opt, "qscale")){
2585 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2586 return parse_option(o, "q:v", arg, options);
2588 s = av_asprintf("q%s", opt + 6);
2589 ret = parse_option(o, s, arg, options);
2594 static int opt_profile(void *optctx, const char *opt, const char *arg)
2596 OptionsContext *o = optctx;
2597 if(!strcmp(opt, "profile")){
2598 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2599 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2602 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2606 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2608 OptionsContext *o = optctx;
2609 return parse_option(o, "filter:v", arg, options);
2612 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2614 OptionsContext *o = optctx;
2615 return parse_option(o, "filter:a", arg, options);
2618 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2620 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2621 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2622 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2623 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2625 if (video_sync_method == VSYNC_AUTO)
2626 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2630 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2632 OptionsContext *o = optctx;
2633 char *tcr = av_asprintf("timecode=%s", arg);
2634 int ret = parse_option(o, "metadata:g", tcr, options);
2636 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2641 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2643 OptionsContext *o = optctx;
2644 char layout_str[32];
2647 int ret, channels, ac_str_size;
2650 layout = av_get_channel_layout(arg);
2652 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2653 return AVERROR(EINVAL);
2655 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2656 ret = opt_default_new(o, opt, layout_str);
2660 /* set 'ac' option based on channel layout */
2661 channels = av_get_channel_layout_nb_channels(layout);
2662 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2663 stream_str = strchr(opt, ':');
2664 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2665 ac_str = av_mallocz(ac_str_size);
2667 return AVERROR(ENOMEM);
2668 av_strlcpy(ac_str, "ac", 3);
2670 av_strlcat(ac_str, stream_str, ac_str_size);
2671 ret = parse_option(o, ac_str, layout_str, options);
2677 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2679 OptionsContext *o = optctx;
2680 return parse_option(o, "q:a", arg, options);
2683 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2685 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2686 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2687 return AVERROR(ENOMEM);
2688 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2689 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2690 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2691 return AVERROR(ENOMEM);
2693 input_stream_potentially_available = 1;
2698 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2700 uint8_t *graph_desc = read_file(arg);
2702 return AVERROR(EINVAL);
2704 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2705 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2706 return AVERROR(ENOMEM);
2707 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2708 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2710 input_stream_potentially_available = 1;
2715 void show_help_default(const char *opt, const char *arg)
2717 /* per-file options have at least one of those set */
2718 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2719 int show_advanced = 0, show_avoptions = 0;
2722 if (!strcmp(opt, "long"))
2724 else if (!strcmp(opt, "full"))
2725 show_advanced = show_avoptions = 1;
2727 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2732 printf("Getting help:\n"
2733 " -h -- print basic options\n"
2734 " -h long -- print more options\n"
2735 " -h full -- print all options (including all format and codec specific options, very long)\n"
2736 " See man %s for detailed description of the options.\n"
2737 "\n", program_name);
2739 show_help_options(options, "Print help / information / capabilities:",
2742 show_help_options(options, "Global options (affect whole program "
2743 "instead of just one file:",
2744 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2746 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2747 per_file | OPT_EXIT, 0);
2749 show_help_options(options, "Per-file main options:", 0,
2750 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2751 OPT_EXIT, per_file);
2753 show_help_options(options, "Advanced per-file options:",
2754 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2756 show_help_options(options, "Video options:",
2757 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2759 show_help_options(options, "Advanced Video options:",
2760 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2762 show_help_options(options, "Audio options:",
2763 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2765 show_help_options(options, "Advanced Audio options:",
2766 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2767 show_help_options(options, "Subtitle options:",
2768 OPT_SUBTITLE, 0, 0);
2771 if (show_avoptions) {
2772 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2773 show_help_children(avcodec_get_class(), flags);
2774 show_help_children(avformat_get_class(), flags);
2776 show_help_children(sws_get_class(), flags);
2778 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2779 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2783 void show_usage(void)
2785 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2786 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2787 av_log(NULL, AV_LOG_INFO, "\n");
2795 static const OptionGroupDef groups[] = {
2796 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2797 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2800 static int open_files(OptionGroupList *l, const char *inout,
2801 int (*open_file)(OptionsContext*, const char*))
2805 for (i = 0; i < l->nb_groups; i++) {
2806 OptionGroup *g = &l->groups[i];
2812 ret = parse_optgroup(&o, g);
2814 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2815 "%s.\n", inout, g->arg);
2819 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2820 ret = open_file(&o, g->arg);
2823 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2827 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2833 int ffmpeg_parse_options(int argc, char **argv)
2835 OptionParseContext octx;
2839 memset(&octx, 0, sizeof(octx));
2841 /* split the commandline into an internal representation */
2842 ret = split_commandline(&octx, argc, argv, options, groups,
2843 FF_ARRAY_ELEMS(groups));
2845 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2849 /* apply global options */
2850 ret = parse_optgroup(NULL, &octx.global_opts);
2852 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2856 /* open input files */
2857 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2859 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2863 /* open output files */
2864 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2866 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2871 uninit_parse_context(&octx);
2873 av_strerror(ret, error, sizeof(error));
2874 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2879 static int opt_progress(void *optctx, const char *opt, const char *arg)
2881 AVIOContext *avio = NULL;
2884 if (!strcmp(arg, "-"))
2886 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2888 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2889 arg, av_err2str(ret));
2892 progress_avio = avio;
2896 #define OFFSET(x) offsetof(OptionsContext, x)
2897 const OptionDef options[] = {
2899 #include "cmdutils_common_opts.h"
2900 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2901 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2902 "force format", "fmt" },
2903 { "y", OPT_BOOL, { &file_overwrite },
2904 "overwrite output files" },
2905 { "n", OPT_BOOL, { &no_file_overwrite },
2906 "never overwrite output files" },
2907 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
2908 "Ignore unknown stream types" },
2909 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
2910 "Copy unknown stream types" },
2911 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2912 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2913 "codec name", "codec" },
2914 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2915 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2916 "codec name", "codec" },
2917 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2918 OPT_OUTPUT, { .off = OFFSET(presets) },
2919 "preset name", "preset" },
2920 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2921 OPT_OUTPUT, { .func_arg = opt_map },
2922 "set input stream mapping",
2923 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2924 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2925 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2926 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2927 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2928 "set metadata information of outfile from infile",
2929 "outfile[,metadata]:infile[,metadata]" },
2930 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2931 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2932 "set chapters mapping", "input_file_index" },
2933 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2934 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2935 "record or transcode \"duration\" seconds of audio/video",
2937 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2938 "record or transcode stop time", "time_stop" },
2939 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2940 "set the limit file size in bytes", "limit_size" },
2941 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2942 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2943 "set the start time offset", "time_off" },
2944 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
2945 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
2946 "enable/disable seeking by timestamp with -ss" },
2947 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2948 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2949 "enable/disable accurate seeking with -ss" },
2950 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2951 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2952 "set the input ts offset", "time_off" },
2953 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2954 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2955 "set the input ts scale", "scale" },
2956 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
2957 "set the recording timestamp ('now' to set the current time)", "time" },
2958 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2959 "add metadata", "string=string" },
2960 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2961 OPT_OUTPUT, { .func_arg = opt_data_frames },
2962 "set the number of data frames to output", "number" },
2963 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2964 "add timings for benchmarking" },
2965 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2966 "add timings for each task" },
2967 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2968 "write program-readable progress information", "url" },
2969 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2970 "enable or disable interaction on standard input" },
2971 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2972 "set max runtime in seconds", "limit" },
2973 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2974 "dump each input packet" },
2975 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2976 "when dumping packets, also dump the payload" },
2977 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2978 OPT_INPUT, { .off = OFFSET(rate_emu) },
2979 "read input at native frame rate", "" },
2980 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2981 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2982 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2983 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2984 "video sync method", "" },
2985 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2986 "frame drop threshold", "" },
2987 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2988 "audio sync method", "" },
2989 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2990 "audio drift threshold", "threshold" },
2991 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2992 "copy timestamps" },
2993 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
2994 "shift input timestamps to start at 0 when using copyts" },
2995 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2996 "copy input stream time base when stream copying", "mode" },
2997 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2998 OPT_OUTPUT, { .off = OFFSET(shortest) },
2999 "finish encoding within shortest input" },
3000 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3001 OPT_OUTPUT, { .off = OFFSET(apad) },
3003 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3004 "timestamp discontinuity delta threshold", "threshold" },
3005 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3006 "timestamp error delta threshold", "threshold" },
3007 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3008 "exit on error", "error" },
3009 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3010 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3011 "copy initial non-keyframes" },
3012 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3013 "copy or discard frames before start time" },
3014 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3015 "set the number of frames to output", "number" },
3016 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3017 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3018 "force codec tag/fourcc", "fourcc/tag" },
3019 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3020 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3021 "use fixed quality scale (VBR)", "q" },
3022 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3023 OPT_OUTPUT, { .func_arg = opt_qscale },
3024 "use fixed quality scale (VBR)", "q" },
3025 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3026 "set profile", "profile" },
3027 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3028 "set stream filtergraph", "filter_graph" },
3029 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3030 "read stream filtergraph description from a file", "filename" },
3031 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3032 "reinit filtergraph on input parameter changes", "" },
3033 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3034 "create a complex filtergraph", "graph_description" },
3035 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3036 "create a complex filtergraph", "graph_description" },
3037 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3038 "read complex filtergraph description from a file", "filename" },
3039 { "stats", OPT_BOOL, { &print_stats },
3040 "print progress report during encoding", },
3041 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3042 OPT_OUTPUT, { .func_arg = opt_attach },
3043 "add an attachment to the output file", "filename" },
3044 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3045 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3046 "extract an attachment into a file", "filename" },
3047 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3048 "print timestamp debugging info" },
3049 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3050 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3051 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3052 OPT_INPUT, { .off = OFFSET(discard) },
3054 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3055 OPT_OUTPUT, { .off = OFFSET(disposition) },
3056 "disposition", "" },
3057 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3058 { .off = OFFSET(thread_queue_size) },
3059 "set the maximum number of queued packets from the demuxer" },
3062 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3063 "set the number of video frames to output", "number" },
3064 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3065 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3066 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3067 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3068 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3069 "set frame size (WxH or abbreviation)", "size" },
3070 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3071 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3072 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3073 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3074 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3075 "set pixel format", "format" },
3076 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3077 "set the number of bits per raw sample", "number" },
3078 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3079 "deprecated use -g 1" },
3080 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3082 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3083 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3084 "rate control override for specific intervals", "override" },
3085 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3086 OPT_OUTPUT, { .func_arg = opt_video_codec },
3087 "force video codec ('copy' to copy stream)", "codec" },
3088 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3090 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3092 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3093 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3094 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3095 "select the pass number (1 to 3)", "n" },
3096 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3097 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3098 "select two pass log file name prefix", "prefix" },
3099 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3100 "this option is deprecated, use the yadif filter instead" },
3101 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3102 "calculate PSNR of compressed frames" },
3103 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3104 "dump video coding statistics to file" },
3105 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3106 "dump video coding statistics to file", "file" },
3107 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3108 "set video filters", "filter_graph" },
3109 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3110 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3111 "specify intra matrix coeffs", "matrix" },
3112 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3113 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3114 "specify inter matrix coeffs", "matrix" },
3115 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3116 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3117 "specify intra matrix coeffs", "matrix" },
3118 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3119 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3120 "top=1/bottom=0/auto=-1 field first", "" },
3121 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3122 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3123 "force video tag/fourcc", "fourcc/tag" },
3124 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3125 "show QP histogram" },
3126 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3127 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3128 "force the selected framerate, disable the best supported framerate selection" },
3129 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3130 OPT_OUTPUT, { .func_arg = opt_streamid },
3131 "set the value of an outfile streamid", "streamIndex:value" },
3132 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3133 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3134 "force key frames at specified timestamps", "timestamps" },
3135 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3136 "audio bitrate (please use -b:a)", "bitrate" },
3137 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3138 "video bitrate (please use -b:v)", "bitrate" },
3139 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3140 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3141 "use HW accelerated decoding", "hwaccel name" },
3142 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3143 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3144 "select a device for HW acceleration" "devicename" },
3146 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3148 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3149 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3150 "automatically insert correct rotate filters" },
3153 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3154 "set the number of audio frames to output", "number" },
3155 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3156 "set audio quality (codec-specific)", "quality", },
3157 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3158 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3159 "set audio sampling rate (in Hz)", "rate" },
3160 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3161 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3162 "set number of audio channels", "channels" },
3163 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3165 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3166 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3167 "force audio codec ('copy' to copy stream)", "codec" },
3168 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3169 OPT_OUTPUT, { .func_arg = opt_old2new },
3170 "force audio tag/fourcc", "fourcc/tag" },
3171 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3172 "change audio volume (256=normal)" , "volume" },
3173 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3174 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3175 "set sample format", "format" },
3176 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3177 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3178 "set channel layout", "layout" },
3179 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3180 "set audio filters", "filter_graph" },
3181 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3182 "set the maximum number of channels to try to guess the channel layout" },
3184 /* subtitle options */
3185 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3186 "disable subtitle" },
3187 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3188 "force subtitle codec ('copy' to copy stream)", "codec" },
3189 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3190 , "force subtitle tag/fourcc", "fourcc/tag" },
3191 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3192 "fix subtitles duration" },
3193 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3194 "set canvas size (WxH or abbreviation)", "size" },
3197 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3198 "deprecated, use -channel", "channel" },
3199 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3200 "deprecated, use -standard", "standard" },
3201 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3204 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3205 "set the maximum demux-decode delay", "seconds" },
3206 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3207 "set the initial demux-decode delay", "seconds" },
3208 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3209 "override the options from ffserver", "" },
3210 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3211 "specify a file in which to print sdp information", "file" },
3213 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3214 "A comma-separated list of bitstream filters", "bitstream_filters" },
3215 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3216 "deprecated", "audio bitstream_filters" },
3217 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3218 "deprecated", "video bitstream_filters" },
3220 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3221 "set the audio options to the indicated preset", "preset" },
3222 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3223 "set the video options to the indicated preset", "preset" },
3224 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3225 "set the subtitle options to the indicated preset", "preset" },
3226 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3227 "set options from indicated preset file", "filename" },
3228 /* data codec support */
3229 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3230 "force data codec ('copy' to copy stream)", "codec" },
3231 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },