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;
240 map = av_strdup(arg);
242 return AVERROR(ENOMEM);
244 /* parse sync stream first, just pick first matching stream */
245 if (sync = strchr(map, ',')) {
247 sync_file_idx = strtol(sync + 1, &sync, 0);
248 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
249 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
254 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
255 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
256 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
260 if (i == input_files[sync_file_idx]->nb_streams) {
261 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
262 "match any streams.\n", arg);
269 /* this mapping refers to lavfi output */
270 const char *c = map + 1;
271 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
272 m = &o->stream_maps[o->nb_stream_maps - 1];
273 m->linklabel = av_get_token(&c, "]");
275 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
279 if (allow_unused = strchr(map, '?'))
281 file_idx = strtol(map, &p, 0);
282 if (file_idx >= nb_input_files || file_idx < 0) {
283 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
287 /* disable some already defined maps */
288 for (i = 0; i < o->nb_stream_maps; i++) {
289 m = &o->stream_maps[i];
290 if (file_idx == m->file_index &&
291 check_stream_specifier(input_files[m->file_index]->ctx,
292 input_files[m->file_index]->ctx->streams[m->stream_index],
293 *p == ':' ? p + 1 : p) > 0)
297 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
298 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
299 *p == ':' ? p + 1 : p) <= 0)
301 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
302 m = &o->stream_maps[o->nb_stream_maps - 1];
304 m->file_index = file_idx;
307 if (sync_file_idx >= 0) {
308 m->sync_file_index = sync_file_idx;
309 m->sync_stream_index = sync_stream_idx;
311 m->sync_file_index = file_idx;
312 m->sync_stream_index = i;
319 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
321 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
322 "To ignore this, add a trailing '?' to the map.\n", arg);
331 static int opt_attach(void *optctx, const char *opt, const char *arg)
333 OptionsContext *o = optctx;
334 GROW_ARRAY(o->attachments, o->nb_attachments);
335 o->attachments[o->nb_attachments - 1] = arg;
339 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
341 OptionsContext *o = optctx;
346 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
347 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
349 /* muted channel syntax */
350 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
351 if ((n == 1 || n == 3) && m->channel_idx == -1) {
352 m->file_idx = m->stream_idx = -1;
354 m->ofile_idx = m->ostream_idx = -1;
359 n = sscanf(arg, "%d.%d.%d:%d.%d",
360 &m->file_idx, &m->stream_idx, &m->channel_idx,
361 &m->ofile_idx, &m->ostream_idx);
363 if (n != 3 && n != 5) {
364 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
365 "[file.stream.channel|-1][:syncfile:syncstream]\n");
369 if (n != 5) // only file.stream.channel specified
370 m->ofile_idx = m->ostream_idx = -1;
373 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
374 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
378 if (m->stream_idx < 0 ||
379 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
380 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
381 m->file_idx, m->stream_idx);
384 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
385 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
386 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
387 m->file_idx, m->stream_idx);
390 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
391 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
392 m->file_idx, m->stream_idx, m->channel_idx);
398 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
400 av_free(sdp_filename);
401 sdp_filename = av_strdup(arg);
406 * Parse a metadata specifier passed as 'arg' parameter.
407 * @param arg metadata string to parse
408 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
409 * @param index for type c/p, chapter/program index is written here
410 * @param stream_spec for type s, the stream specifier is written here
412 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
420 if (*(++arg) && *arg != ':') {
421 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
424 *stream_spec = *arg == ':' ? arg + 1 : "";
429 *index = strtol(++arg, NULL, 0);
432 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
439 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
441 AVDictionary **meta_in = NULL;
442 AVDictionary **meta_out = NULL;
444 char type_in, type_out;
445 const char *istream_spec = NULL, *ostream_spec = NULL;
446 int idx_in = 0, idx_out = 0;
448 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
449 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
452 if (type_out == 'g' || !*outspec)
453 o->metadata_global_manual = 1;
454 if (type_out == 's' || !*outspec)
455 o->metadata_streams_manual = 1;
456 if (type_out == 'c' || !*outspec)
457 o->metadata_chapters_manual = 1;
461 if (type_in == 'g' || type_out == 'g')
462 o->metadata_global_manual = 1;
463 if (type_in == 's' || type_out == 's')
464 o->metadata_streams_manual = 1;
465 if (type_in == 'c' || type_out == 'c')
466 o->metadata_chapters_manual = 1;
468 /* ic is NULL when just disabling automatic mappings */
472 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
473 if ((index) < 0 || (index) >= (nb_elems)) {\
474 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
479 #define SET_DICT(type, meta, context, index)\
482 meta = &context->metadata;\
485 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
486 meta = &context->chapters[index]->metadata;\
489 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
490 meta = &context->programs[index]->metadata;\
493 break; /* handled separately below */ \
494 default: av_assert0(0);\
497 SET_DICT(type_in, meta_in, ic, idx_in);
498 SET_DICT(type_out, meta_out, oc, idx_out);
500 /* for input streams choose first matching stream */
501 if (type_in == 's') {
502 for (i = 0; i < ic->nb_streams; i++) {
503 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
504 meta_in = &ic->streams[i]->metadata;
510 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
515 if (type_out == 's') {
516 for (i = 0; i < oc->nb_streams; i++) {
517 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
518 meta_out = &oc->streams[i]->metadata;
519 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
524 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
529 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
531 OptionsContext *o = optctx;
533 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
534 struct tm time = *gmtime((time_t*)&recording_timestamp);
535 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
537 parse_option(o, "metadata", buf, options);
539 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
540 "tag instead.\n", opt);
544 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
546 const AVCodecDescriptor *desc;
547 const char *codec_string = encoder ? "encoder" : "decoder";
551 avcodec_find_encoder_by_name(name) :
552 avcodec_find_decoder_by_name(name);
554 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
555 codec = encoder ? avcodec_find_encoder(desc->id) :
556 avcodec_find_decoder(desc->id);
558 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
559 codec_string, codec->name, desc->name);
563 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
566 if (codec->type != type) {
567 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
573 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
575 char *codec_name = NULL;
577 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
579 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
580 st->codec->codec_id = codec->id;
583 return avcodec_find_decoder(st->codec->codec_id);
586 /* Add all the streams from the given input file to the global
587 * list of input streams. */
588 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
592 for (i = 0; i < ic->nb_streams; i++) {
593 AVStream *st = ic->streams[i];
594 AVCodecContext *dec = st->codec;
595 InputStream *ist = av_mallocz(sizeof(*ist));
596 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
597 char *codec_tag = NULL;
599 char *discard_str = NULL;
600 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
605 GROW_ARRAY(input_streams, nb_input_streams);
606 input_streams[nb_input_streams - 1] = ist;
609 ist->file_index = nb_input_files;
611 st->discard = AVDISCARD_ALL;
614 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
617 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
619 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
621 uint32_t tag = strtol(codec_tag, &next, 0);
623 tag = AV_RL32(codec_tag);
624 st->codec->codec_tag = tag;
627 ist->dec = choose_decoder(o, ic, st);
628 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
630 ist->reinit_filters = -1;
631 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
633 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
634 ist->user_set_discard = AVDISCARD_NONE;
635 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
636 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
641 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
643 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
645 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
649 ret = avcodec_copy_context(ist->dec_ctx, dec);
651 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
655 switch (dec->codec_type) {
656 case AVMEDIA_TYPE_VIDEO:
658 ist->dec = avcodec_find_decoder(dec->codec_id);
659 if (av_codec_get_lowres(dec)) {
660 dec->flags |= CODEC_FLAG_EMU_EDGE;
663 ist->resample_height = ist->dec_ctx->height;
664 ist->resample_width = ist->dec_ctx->width;
665 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
667 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
668 if (framerate && av_parse_video_rate(&ist->framerate,
670 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
675 ist->top_field_first = -1;
676 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
678 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
680 if (!strcmp(hwaccel, "none"))
681 ist->hwaccel_id = HWACCEL_NONE;
682 else if (!strcmp(hwaccel, "auto"))
683 ist->hwaccel_id = HWACCEL_AUTO;
686 for (i = 0; hwaccels[i].name; i++) {
687 if (!strcmp(hwaccels[i].name, hwaccel)) {
688 ist->hwaccel_id = hwaccels[i].id;
693 if (!ist->hwaccel_id) {
694 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
696 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
697 for (i = 0; hwaccels[i].name; i++)
698 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
699 av_log(NULL, AV_LOG_FATAL, "\n");
705 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
706 if (hwaccel_device) {
707 ist->hwaccel_device = av_strdup(hwaccel_device);
708 if (!ist->hwaccel_device)
711 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
714 case AVMEDIA_TYPE_AUDIO:
715 ist->guess_layout_max = INT_MAX;
716 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
717 guess_input_channel_layout(ist);
719 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
720 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
721 ist->resample_channels = ist->dec_ctx->channels;
722 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
725 case AVMEDIA_TYPE_DATA:
726 case AVMEDIA_TYPE_SUBTITLE: {
727 char *canvas_size = NULL;
729 ist->dec = avcodec_find_decoder(dec->codec_id);
730 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
731 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
733 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
734 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
739 case AVMEDIA_TYPE_ATTACHMENT:
740 case AVMEDIA_TYPE_UNKNOWN:
748 static void assert_file_overwrite(const char *filename)
750 if (file_overwrite && no_file_overwrite) {
751 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
755 if (!file_overwrite) {
756 const char *proto_name = avio_find_protocol_name(filename);
757 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
758 if (stdin_interaction && !no_file_overwrite) {
759 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
762 signal(SIGINT, SIG_DFL);
764 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
770 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
777 static void dump_attachment(AVStream *st, const char *filename)
780 AVIOContext *out = NULL;
781 AVDictionaryEntry *e;
783 if (!st->codec->extradata_size) {
784 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
785 nb_input_files - 1, st->index);
788 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
791 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
792 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
796 assert_file_overwrite(filename);
798 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
799 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
804 avio_write(out, st->codec->extradata, st->codec->extradata_size);
809 static int open_input_file(OptionsContext *o, const char *filename)
813 AVInputFormat *file_iformat = NULL;
817 AVDictionary *unused_opts = NULL;
818 AVDictionaryEntry *e = NULL;
819 int orig_nb_streams; // number of streams before avformat_find_stream_info
820 char * video_codec_name = NULL;
821 char * audio_codec_name = NULL;
822 char *subtitle_codec_name = NULL;
823 char * data_codec_name = NULL;
824 int scan_all_pmts_set = 0;
827 if (!(file_iformat = av_find_input_format(o->format))) {
828 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
833 if (!strcmp(filename, "-"))
836 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
837 strcmp(filename, "/dev/stdin");
839 /* get default parameters from command line */
840 ic = avformat_alloc_context();
842 print_error(filename, AVERROR(ENOMEM));
845 if (o->nb_audio_sample_rate) {
846 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
848 if (o->nb_audio_channels) {
849 /* because we set audio_channels based on both the "ac" and
850 * "channel_layout" options, we need to check that the specified
851 * demuxer actually has the "channels" option before setting it */
852 if (file_iformat && file_iformat->priv_class &&
853 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
854 AV_OPT_SEARCH_FAKE_OBJ)) {
855 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
858 if (o->nb_frame_rates) {
859 /* set the format-level framerate option;
860 * this is important for video grabbers, e.g. x11 */
861 if (file_iformat && file_iformat->priv_class &&
862 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
863 AV_OPT_SEARCH_FAKE_OBJ)) {
864 av_dict_set(&o->g->format_opts, "framerate",
865 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
868 if (o->nb_frame_sizes) {
869 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
871 if (o->nb_frame_pix_fmts)
872 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
874 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
875 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
876 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
877 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
879 ic->video_codec_id = video_codec_name ?
880 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
881 ic->audio_codec_id = audio_codec_name ?
882 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
883 ic->subtitle_codec_id= subtitle_codec_name ?
884 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
885 ic->data_codec_id = data_codec_name ?
886 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
888 if (video_codec_name)
889 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
890 if (audio_codec_name)
891 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
892 if (subtitle_codec_name)
893 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
895 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
897 ic->flags |= AVFMT_FLAG_NONBLOCK;
898 ic->interrupt_callback = int_cb;
900 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
901 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
902 scan_all_pmts_set = 1;
904 /* open the input file with generic avformat function */
905 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
907 print_error(filename, err);
910 if (scan_all_pmts_set)
911 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
912 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
913 assert_avoptions(o->g->format_opts);
915 /* apply forced codec ids */
916 for (i = 0; i < ic->nb_streams; i++)
917 choose_decoder(o, ic, ic->streams[i]);
919 /* Set AVCodecContext options for avformat_find_stream_info */
920 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
921 orig_nb_streams = ic->nb_streams;
923 /* If not enough info to get the stream parameters, we decode the
924 first frames to get it. (used in mpeg case for example) */
925 ret = avformat_find_stream_info(ic, opts);
927 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
928 if (ic->nb_streams == 0) {
929 avformat_close_input(&ic);
934 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
935 /* add the stream start time */
936 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
937 timestamp += ic->start_time;
939 /* if seeking requested, we execute it */
940 if (o->start_time != AV_NOPTS_VALUE) {
941 int64_t seek_timestamp = timestamp;
943 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
944 int dts_heuristic = 0;
945 for (i=0; i<ic->nb_streams; i++) {
946 AVCodecContext *avctx = ic->streams[i]->codec;
947 if (avctx->has_b_frames)
951 seek_timestamp -= 3*AV_TIME_BASE / 23;
954 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
956 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
957 filename, (double)timestamp / AV_TIME_BASE);
961 /* update the current parameters so that they match the one of the input stream */
962 add_input_streams(o, ic);
964 /* dump the file content */
965 av_dump_format(ic, nb_input_files, filename, 0);
967 GROW_ARRAY(input_files, nb_input_files);
968 f = av_mallocz(sizeof(*f));
971 input_files[nb_input_files - 1] = f;
974 f->ist_index = nb_input_streams - ic->nb_streams;
975 f->start_time = o->start_time;
976 f->recording_time = o->recording_time;
977 f->input_ts_offset = o->input_ts_offset;
978 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
979 f->nb_streams = ic->nb_streams;
980 f->rate_emu = o->rate_emu;
981 f->accurate_seek = o->accurate_seek;
983 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
986 /* check if all codec options have been used */
987 unused_opts = strip_specifiers(o->g->codec_opts);
988 for (i = f->ist_index; i < nb_input_streams; i++) {
990 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
991 AV_DICT_IGNORE_SUFFIX)))
992 av_dict_set(&unused_opts, e->key, NULL, 0);
996 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
997 const AVClass *class = avcodec_get_class();
998 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
999 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1000 const AVClass *fclass = avformat_get_class();
1001 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1002 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1003 if (!option || foption)
1007 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1008 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1009 "input file #%d (%s) is not a decoding option.\n", e->key,
1010 option->help ? option->help : "", nb_input_files - 1,
1015 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1016 "input file #%d (%s) has not been used for any stream. The most "
1017 "likely reason is either wrong type (e.g. a video option with "
1018 "no video streams) or that it is a private option of some decoder "
1019 "which was not actually used for any stream.\n", e->key,
1020 option->help ? option->help : "", nb_input_files - 1, filename);
1022 av_dict_free(&unused_opts);
1024 for (i = 0; i < o->nb_dump_attachment; i++) {
1027 for (j = 0; j < ic->nb_streams; j++) {
1028 AVStream *st = ic->streams[j];
1030 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1031 dump_attachment(st, o->dump_attachment[i].u.str);
1035 for (i = 0; i < orig_nb_streams; i++)
1036 av_dict_free(&opts[i]);
1039 input_stream_potentially_available = 1;
1044 static uint8_t *get_line(AVIOContext *s)
1050 if (avio_open_dyn_buf(&line) < 0) {
1051 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1055 while ((c = avio_r8(s)) && c != '\n')
1058 avio_close_dyn_buf(line, &buf);
1063 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1066 char filename[1000];
1067 const char *base[3] = { getenv("AVCONV_DATADIR"),
1072 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1076 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1077 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1078 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1081 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1082 i != 1 ? "" : "/.avconv", preset_name);
1083 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1089 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1091 char *codec_name = NULL;
1093 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1095 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1096 NULL, ost->st->codec->codec_type);
1097 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1098 } else if (!strcmp(codec_name, "copy"))
1099 ost->stream_copy = 1;
1101 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1102 ost->st->codec->codec_id = ost->enc->id;
1106 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1109 AVStream *st = avformat_new_stream(oc, NULL);
1110 int idx = oc->nb_streams - 1, ret = 0;
1111 char *bsf = NULL, *next, *codec_tag = NULL;
1112 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1117 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1121 if (oc->nb_streams - 1 < o->nb_streamid_map)
1122 st->id = o->streamid_map[oc->nb_streams - 1];
1124 GROW_ARRAY(output_streams, nb_output_streams);
1125 if (!(ost = av_mallocz(sizeof(*ost))))
1127 output_streams[nb_output_streams - 1] = ost;
1129 ost->file_index = nb_output_files - 1;
1132 st->codec->codec_type = type;
1133 choose_encoder(o, oc, ost);
1135 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1136 if (!ost->enc_ctx) {
1137 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1140 ost->enc_ctx->codec_type = type;
1143 AVIOContext *s = NULL;
1144 char *buf = NULL, *arg = NULL, *preset = NULL;
1146 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1148 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1149 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1152 if (!buf[0] || buf[0] == '#') {
1156 if (!(arg = strchr(buf, '='))) {
1157 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1161 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1163 } while (!s->eof_reached);
1167 av_log(NULL, AV_LOG_FATAL,
1168 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1169 preset, ost->file_index, ost->index);
1173 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1176 ost->max_frames = INT64_MAX;
1177 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1178 for (i = 0; i<o->nb_max_frames; i++) {
1179 char *p = o->max_frames[i].specifier;
1180 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1181 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1186 ost->copy_prior_start = -1;
1187 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1189 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1192 if (next = strchr(bsf, ','))
1194 if (arg = strchr(bsf, '='))
1196 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1197 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1201 bsfc_prev->next = bsfc;
1203 ost->bitstream_filters = bsfc;
1204 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1210 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1212 uint32_t tag = strtol(codec_tag, &next, 0);
1214 tag = AV_RL32(codec_tag);
1215 ost->st->codec->codec_tag =
1216 ost->enc_ctx->codec_tag = tag;
1219 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1221 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1222 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1225 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1226 ost->disposition = av_strdup(ost->disposition);
1228 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1229 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1231 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1233 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1234 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1235 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1237 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1239 ost->source_index = source_index;
1240 if (source_index >= 0) {
1241 ost->sync_ist = input_streams[source_index];
1242 input_streams[source_index]->discard = 0;
1243 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1245 ost->last_mux_dts = AV_NOPTS_VALUE;
1250 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1253 const char *p = str;
1260 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1267 /* read file contents into a string */
1268 static uint8_t *read_file(const char *filename)
1270 AVIOContext *pb = NULL;
1271 AVIOContext *dyn_buf = NULL;
1272 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1273 uint8_t buf[1024], *str;
1276 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1280 ret = avio_open_dyn_buf(&dyn_buf);
1285 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1286 avio_write(dyn_buf, buf, ret);
1287 avio_w8(dyn_buf, 0);
1290 ret = avio_close_dyn_buf(dyn_buf, &str);
1296 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1299 AVStream *st = ost->st;
1301 if (ost->filters_script && ost->filters) {
1302 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1303 "output stream #%d:%d.\n", nb_output_files, st->index);
1307 if (ost->filters_script)
1308 return read_file(ost->filters_script);
1309 else if (ost->filters)
1310 return av_strdup(ost->filters);
1312 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1316 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1317 const OutputStream *ost, enum AVMediaType type)
1319 if (ost->filters_script || ost->filters) {
1320 av_log(NULL, AV_LOG_ERROR,
1321 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1322 "Filtering and streamcopy cannot be used together.\n",
1323 ost->filters ? "Filtergraph" : "Filtergraph script",
1324 ost->filters ? ost->filters : ost->filters_script,
1325 av_get_media_type_string(type), ost->file_index, ost->index);
1330 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1334 AVCodecContext *video_enc;
1335 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1337 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1339 video_enc = ost->enc_ctx;
1341 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1342 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1343 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1346 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1347 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1349 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1350 if (frame_aspect_ratio) {
1352 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1353 q.num <= 0 || q.den <= 0) {
1354 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1357 ost->frame_aspect_ratio = q;
1360 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1361 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1363 if (!ost->stream_copy) {
1364 const char *p = NULL;
1365 char *frame_size = NULL;
1366 char *frame_pix_fmt = NULL;
1367 char *intra_matrix = NULL, *inter_matrix = NULL;
1368 char *chroma_intra_matrix = NULL;
1372 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1373 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1374 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1378 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1379 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1380 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1381 ost->keep_pix_fmt = 1;
1382 if (!*++frame_pix_fmt)
1383 frame_pix_fmt = NULL;
1385 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1386 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1389 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1392 video_enc->gop_size = 0;
1393 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1395 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1396 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1399 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1401 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1402 if (chroma_intra_matrix) {
1403 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1405 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1408 av_codec_set_chroma_intra_matrix(video_enc, p);
1409 parse_matrix_coeffs(p, chroma_intra_matrix);
1411 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1413 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1414 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1417 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1420 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1421 for (i = 0; p; i++) {
1423 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1425 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1428 video_enc->rc_override =
1429 av_realloc_array(video_enc->rc_override,
1430 i + 1, sizeof(RcOverride));
1431 if (!video_enc->rc_override) {
1432 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1435 video_enc->rc_override[i].start_frame = start;
1436 video_enc->rc_override[i].end_frame = end;
1438 video_enc->rc_override[i].qscale = q;
1439 video_enc->rc_override[i].quality_factor = 1.0;
1442 video_enc->rc_override[i].qscale = 0;
1443 video_enc->rc_override[i].quality_factor = -q/100.0;
1448 video_enc->rc_override_count = i;
1451 video_enc->flags|= CODEC_FLAG_PSNR;
1454 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1457 video_enc->flags |= CODEC_FLAG_PASS1;
1458 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1461 video_enc->flags |= CODEC_FLAG_PASS2;
1462 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1466 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1467 if (ost->logfile_prefix &&
1468 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1471 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1472 if (ost->forced_keyframes)
1473 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1475 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1477 ost->top_field_first = -1;
1478 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1481 ost->avfilter = get_ost_filters(o, oc, ost);
1485 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1488 if (ost->stream_copy)
1489 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1494 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1499 AVCodecContext *audio_enc;
1501 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1504 audio_enc = ost->enc_ctx;
1505 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1507 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1508 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1510 if (!ost->stream_copy) {
1511 char *sample_fmt = NULL;
1513 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1515 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1517 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1518 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1522 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1524 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1525 ost->apad = av_strdup(ost->apad);
1527 ost->avfilter = get_ost_filters(o, oc, ost);
1531 /* check for channel mapping for this audio stream */
1532 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1533 AudioChannelMap *map = &o->audio_channel_maps[n];
1534 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1535 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1538 if (map->channel_idx == -1) {
1540 } else if (ost->source_index < 0) {
1541 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1542 ost->file_index, ost->st->index);
1545 ist = input_streams[ost->source_index];
1548 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1549 if (av_reallocp_array(&ost->audio_channels_map,
1550 ost->audio_channels_mapped + 1,
1551 sizeof(*ost->audio_channels_map)
1555 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1561 if (ost->stream_copy)
1562 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1567 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1571 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1572 if (!ost->stream_copy) {
1573 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1580 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1584 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1585 if (!ost->stream_copy) {
1586 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1593 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1595 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1596 ost->stream_copy = 1;
1601 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1605 AVCodecContext *subtitle_enc;
1607 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1609 subtitle_enc = ost->enc_ctx;
1611 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1613 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1615 if (!ost->stream_copy) {
1616 char *frame_size = NULL;
1618 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1619 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1620 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1628 /* arg format is "output-stream-index:streamid-value". */
1629 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1631 OptionsContext *o = optctx;
1636 av_strlcpy(idx_str, arg, sizeof(idx_str));
1637 p = strchr(idx_str, ':');
1639 av_log(NULL, AV_LOG_FATAL,
1640 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1645 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1646 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1647 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1651 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1653 AVFormatContext *is = ifile->ctx;
1654 AVFormatContext *os = ofile->ctx;
1658 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1660 return AVERROR(ENOMEM);
1663 for (i = 0; i < is->nb_chapters; i++) {
1664 AVChapter *in_ch = is->chapters[i], *out_ch;
1665 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1666 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1667 AV_TIME_BASE_Q, in_ch->time_base);
1668 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1669 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1672 if (in_ch->end < ts_off)
1674 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1677 out_ch = av_mallocz(sizeof(AVChapter));
1679 return AVERROR(ENOMEM);
1681 out_ch->id = in_ch->id;
1682 out_ch->time_base = in_ch->time_base;
1683 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1684 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1687 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1689 os->chapters[os->nb_chapters++] = out_ch;
1694 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1697 AVFormatContext *ic = avformat_alloc_context();
1699 ic->interrupt_callback = int_cb;
1700 err = avformat_open_input(&ic, filename, NULL, NULL);
1703 /* copy stream format */
1704 for(i=0;i<ic->nb_streams;i++) {
1708 const char *enc_config;
1710 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1712 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1713 return AVERROR(EINVAL);
1715 if (codec->type == AVMEDIA_TYPE_AUDIO)
1716 opt_audio_codec(o, "c:a", codec->name);
1717 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1718 opt_video_codec(o, "c:v", codec->name);
1719 ost = new_output_stream(o, s, codec->type, -1);
1722 avcodec_get_context_defaults3(st->codec, codec);
1723 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1725 AVDictionary *opts = NULL;
1726 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1727 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1728 av_dict_free(&opts);
1731 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1732 choose_sample_fmt(st, codec);
1733 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1734 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1735 avcodec_copy_context(ost->enc_ctx, st->codec);
1737 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1740 avformat_close_input(&ic);
1744 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1745 AVFormatContext *oc)
1749 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1750 ofilter->out_tmp->pad_idx)) {
1751 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1752 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1754 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1759 ost->source_index = -1;
1760 ost->filter = ofilter;
1764 if (ost->stream_copy) {
1765 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1766 "which is fed from a complex filtergraph. Filtering and streamcopy "
1767 "cannot be used together.\n", ost->file_index, ost->index);
1771 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1772 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1773 av_log(NULL, AV_LOG_ERROR,
1774 "%s '%s' was specified through the %s option "
1775 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1776 "%s and -filter_complex cannot be used together for the same stream.\n",
1777 ost->filters ? "Filtergraph" : "Filtergraph script",
1778 ost->filters ? ost->filters : ost->filters_script,
1779 opt, ost->file_index, ost->index, opt);
1783 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1784 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1787 avfilter_inout_free(&ofilter->out_tmp);
1790 static int configure_complex_filters(void)
1794 for (i = 0; i < nb_filtergraphs; i++)
1795 if (!filtergraphs[i]->graph &&
1796 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1801 static int open_output_file(OptionsContext *o, const char *filename)
1803 AVFormatContext *oc;
1805 AVOutputFormat *file_oformat;
1809 AVDictionary *unused_opts = NULL;
1810 AVDictionaryEntry *e = NULL;
1812 if (configure_complex_filters() < 0) {
1813 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1817 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1818 o->stop_time = INT64_MAX;
1819 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1822 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1823 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1824 if (o->stop_time <= start_time) {
1825 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1828 o->recording_time = o->stop_time - start_time;
1832 GROW_ARRAY(output_files, nb_output_files);
1833 of = av_mallocz(sizeof(*of));
1836 output_files[nb_output_files - 1] = of;
1838 of->ost_index = nb_output_streams;
1839 of->recording_time = o->recording_time;
1840 of->start_time = o->start_time;
1841 of->limit_filesize = o->limit_filesize;
1842 of->shortest = o->shortest;
1843 av_dict_copy(&of->opts, o->g->format_opts, 0);
1845 if (!strcmp(filename, "-"))
1848 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1850 print_error(filename, err);
1855 if (o->recording_time != INT64_MAX)
1856 oc->duration = o->recording_time;
1858 file_oformat= oc->oformat;
1859 oc->interrupt_callback = int_cb;
1861 /* create streams for all unlabeled output pads */
1862 for (i = 0; i < nb_filtergraphs; i++) {
1863 FilterGraph *fg = filtergraphs[i];
1864 for (j = 0; j < fg->nb_outputs; j++) {
1865 OutputFilter *ofilter = fg->outputs[j];
1867 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1870 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1871 ofilter->out_tmp->pad_idx)) {
1872 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1873 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1874 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1876 init_output_filter(ofilter, o, oc);
1880 /* ffserver seeking with date=... needs a date reference */
1881 if (!strcmp(file_oformat->name, "ffm") &&
1882 av_strstart(filename, "http:", NULL)) {
1883 int err = parse_option(o, "metadata", "creation_time=now", options);
1885 print_error(filename, err);
1890 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1891 av_strstart(filename, "http:", NULL)) {
1893 /* special case for files sent to ffserver: we get the stream
1894 parameters from ffserver */
1895 int err = read_ffserver_streams(o, oc, filename);
1897 print_error(filename, err);
1900 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1901 ost = output_streams[j];
1902 for (i = 0; i < nb_input_streams; i++) {
1903 ist = input_streams[i];
1904 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1906 ost->source_index= i;
1907 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1908 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1910 ist->st->discard = ist->user_set_discard;
1915 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));
1919 } else if (!o->nb_stream_maps) {
1920 char *subtitle_codec_name = NULL;
1921 /* pick the "best" stream of each type */
1923 /* video: highest resolution */
1924 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1925 int area = 0, idx = -1;
1926 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1927 for (i = 0; i < nb_input_streams; i++) {
1929 ist = input_streams[i];
1930 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
1931 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1933 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1935 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1942 new_video_stream(o, oc, idx);
1945 /* audio: most channels */
1946 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1947 int channels = 0, idx = -1;
1948 for (i = 0; i < nb_input_streams; i++) {
1949 ist = input_streams[i];
1950 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1951 ist->st->codec->channels > channels) {
1952 channels = ist->st->codec->channels;
1957 new_audio_stream(o, oc, idx);
1960 /* subtitles: pick first */
1961 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1962 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1963 for (i = 0; i < nb_input_streams; i++)
1964 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1965 AVCodecDescriptor const *input_descriptor =
1966 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
1967 AVCodecDescriptor const *output_descriptor = NULL;
1968 AVCodec const *output_codec =
1969 avcodec_find_encoder(oc->oformat->subtitle_codec);
1970 int input_props = 0, output_props = 0;
1972 output_descriptor = avcodec_descriptor_get(output_codec->id);
1973 if (input_descriptor)
1974 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1975 if (output_descriptor)
1976 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
1977 if (subtitle_codec_name ||
1978 input_props & output_props ||
1979 // Map dvb teletext which has neither property to any output subtitle encoder
1980 input_descriptor && output_descriptor &&
1981 (!input_descriptor->props ||
1982 !output_descriptor->props)) {
1983 new_subtitle_stream(o, oc, i);
1988 /* Data only if codec id match */
1989 if (!o->data_disable ) {
1990 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
1991 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
1992 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
1993 && input_streams[i]->st->codec->codec_id == codec_id )
1994 new_data_stream(o, oc, i);
1998 for (i = 0; i < o->nb_stream_maps; i++) {
1999 StreamMap *map = &o->stream_maps[i];
2004 if (map->linklabel) {
2006 OutputFilter *ofilter = NULL;
2009 for (j = 0; j < nb_filtergraphs; j++) {
2010 fg = filtergraphs[j];
2011 for (k = 0; k < fg->nb_outputs; k++) {
2012 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2013 if (out && !strcmp(out->name, map->linklabel)) {
2014 ofilter = fg->outputs[k];
2021 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2022 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2025 init_output_filter(ofilter, o, oc);
2027 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2029 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2030 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2032 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2034 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2036 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2040 switch (ist->st->codec->codec_type) {
2041 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2042 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2043 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2044 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2045 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2046 case AVMEDIA_TYPE_UNKNOWN:
2047 if (copy_unknown_streams) {
2048 ost = new_unknown_stream (o, oc, src_idx);
2052 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2053 "Cannot map stream #%d:%d - unsupported type.\n",
2054 map->file_index, map->stream_index);
2055 if (!ignore_unknown_streams) {
2056 av_log(NULL, AV_LOG_FATAL,
2057 "If you want unsupported types ignored instead "
2058 "of failing, please use the -ignore_unknown option\n"
2059 "If you want them copied, please use -copy_unknown\n");
2064 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2065 + map->sync_stream_index];
2070 /* handle attached files */
2071 for (i = 0; i < o->nb_attachments; i++) {
2073 uint8_t *attachment;
2077 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2078 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2082 if ((len = avio_size(pb)) <= 0) {
2083 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2087 if (!(attachment = av_malloc(len))) {
2088 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2092 avio_read(pb, attachment, len);
2094 ost = new_attachment_stream(o, oc, -1);
2095 ost->stream_copy = 0;
2096 ost->attachment_filename = o->attachments[i];
2098 ost->st->codec->extradata = attachment;
2099 ost->st->codec->extradata_size = len;
2101 p = strrchr(o->attachments[i], '/');
2102 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2106 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2107 AVDictionaryEntry *e;
2108 ost = output_streams[i];
2110 if ((ost->stream_copy || ost->attachment_filename)
2111 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2112 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2113 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2117 /* check if all codec options have been used */
2118 unused_opts = strip_specifiers(o->g->codec_opts);
2119 for (i = of->ost_index; i < nb_output_streams; i++) {
2121 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2122 AV_DICT_IGNORE_SUFFIX)))
2123 av_dict_set(&unused_opts, e->key, NULL, 0);
2127 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2128 const AVClass *class = avcodec_get_class();
2129 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2130 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2131 const AVClass *fclass = avformat_get_class();
2132 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2133 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2134 if (!option || foption)
2138 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2139 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2140 "output file #%d (%s) is not an encoding option.\n", e->key,
2141 option->help ? option->help : "", nb_output_files - 1,
2146 // gop_timecode is injected by generic code but not always used
2147 if (!strcmp(e->key, "gop_timecode"))
2150 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2151 "output file #%d (%s) has not been used for any stream. The most "
2152 "likely reason is either wrong type (e.g. a video option with "
2153 "no video streams) or that it is a private option of some encoder "
2154 "which was not actually used for any stream.\n", e->key,
2155 option->help ? option->help : "", nb_output_files - 1, filename);
2157 av_dict_free(&unused_opts);
2159 /* check filename in case of an image number is expected */
2160 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2161 if (!av_filename_number_test(oc->filename)) {
2162 print_error(oc->filename, AVERROR(EINVAL));
2167 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2168 av_log(NULL, AV_LOG_ERROR,
2169 "No input streams but output needs an input stream\n");
2173 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2174 /* test if it already exists to avoid losing precious files */
2175 assert_file_overwrite(filename);
2178 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2179 &oc->interrupt_callback,
2181 print_error(filename, err);
2184 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2185 assert_file_overwrite(filename);
2187 if (o->mux_preload) {
2188 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2190 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2193 for (i = 0; i < o->nb_metadata_map; i++) {
2195 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2197 if (in_file_index >= nb_input_files) {
2198 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2201 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2202 in_file_index >= 0 ?
2203 input_files[in_file_index]->ctx : NULL, o);
2207 if (o->chapters_input_file >= nb_input_files) {
2208 if (o->chapters_input_file == INT_MAX) {
2209 /* copy chapters from the first input file that has them*/
2210 o->chapters_input_file = -1;
2211 for (i = 0; i < nb_input_files; i++)
2212 if (input_files[i]->ctx->nb_chapters) {
2213 o->chapters_input_file = i;
2217 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2218 o->chapters_input_file);
2222 if (o->chapters_input_file >= 0)
2223 copy_chapters(input_files[o->chapters_input_file], of,
2224 !o->metadata_chapters_manual);
2226 /* copy global metadata by default */
2227 if (!o->metadata_global_manual && nb_input_files){
2228 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2229 AV_DICT_DONT_OVERWRITE);
2230 if(o->recording_time != INT64_MAX)
2231 av_dict_set(&oc->metadata, "duration", NULL, 0);
2232 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2234 if (!o->metadata_streams_manual)
2235 for (i = of->ost_index; i < nb_output_streams; i++) {
2237 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2239 ist = input_streams[output_streams[i]->source_index];
2240 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2241 if (!output_streams[i]->stream_copy) {
2242 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2243 if (ist->autorotate)
2244 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2248 /* process manually set metadata */
2249 for (i = 0; i < o->nb_metadata; i++) {
2252 const char *stream_spec;
2253 int index = 0, j, ret = 0;
2256 val = strchr(o->metadata[i].u.str, '=');
2258 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2259 o->metadata[i].u.str);
2264 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2265 !strcmp(val, "now")) {
2266 time_t now = time(0);
2267 struct tm *ptm, tmbuf;
2268 ptm = localtime_r(&now, &tmbuf);
2270 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2275 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2277 for (j = 0; j < oc->nb_streams; j++) {
2278 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2279 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2280 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2281 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2282 ost->rotate_overridden = 1;
2294 if (index < 0 || index >= oc->nb_chapters) {
2295 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2298 m = &oc->chapters[index]->metadata;
2301 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2304 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2311 static int opt_target(void *optctx, const char *opt, const char *arg)
2313 OptionsContext *o = optctx;
2314 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2315 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2317 if (!strncmp(arg, "pal-", 4)) {
2320 } else if (!strncmp(arg, "ntsc-", 5)) {
2323 } else if (!strncmp(arg, "film-", 5)) {
2327 /* Try to determine PAL/NTSC by peeking in the input files */
2328 if (nb_input_files) {
2330 for (j = 0; j < nb_input_files; j++) {
2331 for (i = 0; i < input_files[j]->nb_streams; i++) {
2332 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2333 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2336 fr = c->time_base.den * 1000 / c->time_base.num;
2340 } else if ((fr == 29970) || (fr == 23976)) {
2345 if (norm != UNKNOWN)
2349 if (norm != UNKNOWN)
2350 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2353 if (norm == UNKNOWN) {
2354 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2355 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2356 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2360 if (!strcmp(arg, "vcd")) {
2361 opt_video_codec(o, "c:v", "mpeg1video");
2362 opt_audio_codec(o, "c:a", "mp2");
2363 parse_option(o, "f", "vcd", options);
2365 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2366 parse_option(o, "r", frame_rates[norm], options);
2367 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2369 opt_default(NULL, "b:v", "1150000");
2370 opt_default(NULL, "maxrate:v", "1150000");
2371 opt_default(NULL, "minrate:v", "1150000");
2372 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2374 opt_default(NULL, "b:a", "224000");
2375 parse_option(o, "ar", "44100", options);
2376 parse_option(o, "ac", "2", options);
2378 opt_default(NULL, "packetsize", "2324");
2379 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2381 /* We have to offset the PTS, so that it is consistent with the SCR.
2382 SCR starts at 36000, but the first two packs contain only padding
2383 and the first pack from the other stream, respectively, may also have
2384 been written before.
2385 So the real data starts at SCR 36000+3*1200. */
2386 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2387 } else if (!strcmp(arg, "svcd")) {
2389 opt_video_codec(o, "c:v", "mpeg2video");
2390 opt_audio_codec(o, "c:a", "mp2");
2391 parse_option(o, "f", "svcd", options);
2393 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2394 parse_option(o, "r", frame_rates[norm], options);
2395 parse_option(o, "pix_fmt", "yuv420p", options);
2396 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2398 opt_default(NULL, "b:v", "2040000");
2399 opt_default(NULL, "maxrate:v", "2516000");
2400 opt_default(NULL, "minrate:v", "0"); // 1145000;
2401 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2402 opt_default(NULL, "scan_offset", "1");
2404 opt_default(NULL, "b:a", "224000");
2405 parse_option(o, "ar", "44100", options);
2407 opt_default(NULL, "packetsize", "2324");
2409 } else if (!strcmp(arg, "dvd")) {
2411 opt_video_codec(o, "c:v", "mpeg2video");
2412 opt_audio_codec(o, "c:a", "ac3");
2413 parse_option(o, "f", "dvd", options);
2415 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2416 parse_option(o, "r", frame_rates[norm], options);
2417 parse_option(o, "pix_fmt", "yuv420p", options);
2418 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2420 opt_default(NULL, "b:v", "6000000");
2421 opt_default(NULL, "maxrate:v", "9000000");
2422 opt_default(NULL, "minrate:v", "0"); // 1500000;
2423 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2425 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2426 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2428 opt_default(NULL, "b:a", "448000");
2429 parse_option(o, "ar", "48000", options);
2431 } else if (!strncmp(arg, "dv", 2)) {
2433 parse_option(o, "f", "dv", options);
2435 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2436 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2437 norm == PAL ? "yuv420p" : "yuv411p", options);
2438 parse_option(o, "r", frame_rates[norm], options);
2440 parse_option(o, "ar", "48000", options);
2441 parse_option(o, "ac", "2", options);
2444 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2445 return AVERROR(EINVAL);
2448 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2449 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2454 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2456 av_free (vstats_filename);
2457 vstats_filename = av_strdup (arg);
2461 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2464 time_t today2 = time(NULL);
2465 struct tm *today = localtime(&today2);
2467 if (!today) { // maybe tomorrow
2468 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2472 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2474 return opt_vstats_file(NULL, opt, filename);
2477 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2479 OptionsContext *o = optctx;
2480 return parse_option(o, "frames:v", arg, options);
2483 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2485 OptionsContext *o = optctx;
2486 return parse_option(o, "frames:a", arg, options);
2489 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2491 OptionsContext *o = optctx;
2492 return parse_option(o, "frames:d", arg, options);
2495 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2498 AVDictionary *cbak = codec_opts;
2499 AVDictionary *fbak = format_opts;
2503 ret = opt_default(NULL, opt, arg);
2505 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2506 av_dict_copy(&o->g->format_opts, format_opts, 0);
2507 av_dict_free(&codec_opts);
2508 av_dict_free(&format_opts);
2515 static int opt_preset(void *optctx, const char *opt, const char *arg)
2517 OptionsContext *o = optctx;
2519 char filename[1000], line[1000], tmp_line[1000];
2520 const char *codec_name = NULL;
2524 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2526 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2527 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2528 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2530 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2534 while (fgets(line, sizeof(line), f)) {
2535 char *key = tmp_line, *value, *endptr;
2537 if (strcspn(line, "#\n\r") == 0)
2539 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2540 if (!av_strtok(key, "=", &value) ||
2541 !av_strtok(value, "\r\n", &endptr)) {
2542 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2545 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2547 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2548 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2549 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2550 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2551 else if (opt_default_new(o, key, value) < 0) {
2552 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2553 filename, line, key, value);
2563 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2565 OptionsContext *o = optctx;
2566 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2567 int ret = parse_option(o, s, arg, options);
2572 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2574 OptionsContext *o = optctx;
2576 if(!strcmp(opt, "ab")){
2577 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2579 } else if(!strcmp(opt, "b")){
2580 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2581 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2584 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2588 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2590 OptionsContext *o = optctx;
2593 if(!strcmp(opt, "qscale")){
2594 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2595 return parse_option(o, "q:v", arg, options);
2597 s = av_asprintf("q%s", opt + 6);
2598 ret = parse_option(o, s, arg, options);
2603 static int opt_profile(void *optctx, const char *opt, const char *arg)
2605 OptionsContext *o = optctx;
2606 if(!strcmp(opt, "profile")){
2607 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2608 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2611 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2615 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2617 OptionsContext *o = optctx;
2618 return parse_option(o, "filter:v", arg, options);
2621 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2623 OptionsContext *o = optctx;
2624 return parse_option(o, "filter:a", arg, options);
2627 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2629 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2630 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2631 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2632 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2634 if (video_sync_method == VSYNC_AUTO)
2635 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2639 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2641 OptionsContext *o = optctx;
2642 char *tcr = av_asprintf("timecode=%s", arg);
2643 int ret = parse_option(o, "metadata:g", tcr, options);
2645 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2650 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2652 OptionsContext *o = optctx;
2653 char layout_str[32];
2656 int ret, channels, ac_str_size;
2659 layout = av_get_channel_layout(arg);
2661 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2662 return AVERROR(EINVAL);
2664 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2665 ret = opt_default_new(o, opt, layout_str);
2669 /* set 'ac' option based on channel layout */
2670 channels = av_get_channel_layout_nb_channels(layout);
2671 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2672 stream_str = strchr(opt, ':');
2673 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2674 ac_str = av_mallocz(ac_str_size);
2676 return AVERROR(ENOMEM);
2677 av_strlcpy(ac_str, "ac", 3);
2679 av_strlcat(ac_str, stream_str, ac_str_size);
2680 ret = parse_option(o, ac_str, layout_str, options);
2686 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2688 OptionsContext *o = optctx;
2689 return parse_option(o, "q:a", arg, options);
2692 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2694 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2695 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2696 return AVERROR(ENOMEM);
2697 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2698 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2699 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2700 return AVERROR(ENOMEM);
2702 input_stream_potentially_available = 1;
2707 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2709 uint8_t *graph_desc = read_file(arg);
2711 return AVERROR(EINVAL);
2713 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2714 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2715 return AVERROR(ENOMEM);
2716 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2717 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2719 input_stream_potentially_available = 1;
2724 void show_help_default(const char *opt, const char *arg)
2726 /* per-file options have at least one of those set */
2727 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2728 int show_advanced = 0, show_avoptions = 0;
2731 if (!strcmp(opt, "long"))
2733 else if (!strcmp(opt, "full"))
2734 show_advanced = show_avoptions = 1;
2736 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2741 printf("Getting help:\n"
2742 " -h -- print basic options\n"
2743 " -h long -- print more options\n"
2744 " -h full -- print all options (including all format and codec specific options, very long)\n"
2745 " See man %s for detailed description of the options.\n"
2746 "\n", program_name);
2748 show_help_options(options, "Print help / information / capabilities:",
2751 show_help_options(options, "Global options (affect whole program "
2752 "instead of just one file:",
2753 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2755 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2756 per_file | OPT_EXIT, 0);
2758 show_help_options(options, "Per-file main options:", 0,
2759 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2760 OPT_EXIT, per_file);
2762 show_help_options(options, "Advanced per-file options:",
2763 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2765 show_help_options(options, "Video options:",
2766 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2768 show_help_options(options, "Advanced Video options:",
2769 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2771 show_help_options(options, "Audio options:",
2772 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2774 show_help_options(options, "Advanced Audio options:",
2775 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2776 show_help_options(options, "Subtitle options:",
2777 OPT_SUBTITLE, 0, 0);
2780 if (show_avoptions) {
2781 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2782 show_help_children(avcodec_get_class(), flags);
2783 show_help_children(avformat_get_class(), flags);
2785 show_help_children(sws_get_class(), flags);
2787 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2788 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2792 void show_usage(void)
2794 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2795 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2796 av_log(NULL, AV_LOG_INFO, "\n");
2804 static const OptionGroupDef groups[] = {
2805 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2806 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2809 static int open_files(OptionGroupList *l, const char *inout,
2810 int (*open_file)(OptionsContext*, const char*))
2814 for (i = 0; i < l->nb_groups; i++) {
2815 OptionGroup *g = &l->groups[i];
2821 ret = parse_optgroup(&o, g);
2823 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2824 "%s.\n", inout, g->arg);
2828 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2829 ret = open_file(&o, g->arg);
2832 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2836 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2842 int ffmpeg_parse_options(int argc, char **argv)
2844 OptionParseContext octx;
2848 memset(&octx, 0, sizeof(octx));
2850 /* split the commandline into an internal representation */
2851 ret = split_commandline(&octx, argc, argv, options, groups,
2852 FF_ARRAY_ELEMS(groups));
2854 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2858 /* apply global options */
2859 ret = parse_optgroup(NULL, &octx.global_opts);
2861 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2865 /* open input files */
2866 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2868 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2872 /* open output files */
2873 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2875 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2880 uninit_parse_context(&octx);
2882 av_strerror(ret, error, sizeof(error));
2883 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2888 static int opt_progress(void *optctx, const char *opt, const char *arg)
2890 AVIOContext *avio = NULL;
2893 if (!strcmp(arg, "-"))
2895 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2897 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2898 arg, av_err2str(ret));
2901 progress_avio = avio;
2905 #define OFFSET(x) offsetof(OptionsContext, x)
2906 const OptionDef options[] = {
2908 #include "cmdutils_common_opts.h"
2909 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2910 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2911 "force format", "fmt" },
2912 { "y", OPT_BOOL, { &file_overwrite },
2913 "overwrite output files" },
2914 { "n", OPT_BOOL, { &no_file_overwrite },
2915 "never overwrite output files" },
2916 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
2917 "Ignore unknown stream types" },
2918 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
2919 "Copy unknown stream types" },
2920 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2921 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2922 "codec name", "codec" },
2923 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2924 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2925 "codec name", "codec" },
2926 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2927 OPT_OUTPUT, { .off = OFFSET(presets) },
2928 "preset name", "preset" },
2929 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2930 OPT_OUTPUT, { .func_arg = opt_map },
2931 "set input stream mapping",
2932 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2933 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2934 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2935 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2936 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2937 "set metadata information of outfile from infile",
2938 "outfile[,metadata]:infile[,metadata]" },
2939 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2940 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2941 "set chapters mapping", "input_file_index" },
2942 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2943 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2944 "record or transcode \"duration\" seconds of audio/video",
2946 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2947 "record or transcode stop time", "time_stop" },
2948 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2949 "set the limit file size in bytes", "limit_size" },
2950 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2951 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2952 "set the start time offset", "time_off" },
2953 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
2954 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
2955 "enable/disable seeking by timestamp with -ss" },
2956 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2957 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2958 "enable/disable accurate seeking with -ss" },
2959 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2960 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2961 "set the input ts offset", "time_off" },
2962 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2963 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2964 "set the input ts scale", "scale" },
2965 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
2966 "set the recording timestamp ('now' to set the current time)", "time" },
2967 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2968 "add metadata", "string=string" },
2969 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2970 OPT_OUTPUT, { .func_arg = opt_data_frames },
2971 "set the number of data frames to output", "number" },
2972 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2973 "add timings for benchmarking" },
2974 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2975 "add timings for each task" },
2976 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2977 "write program-readable progress information", "url" },
2978 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2979 "enable or disable interaction on standard input" },
2980 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2981 "set max runtime in seconds", "limit" },
2982 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2983 "dump each input packet" },
2984 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2985 "when dumping packets, also dump the payload" },
2986 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2987 OPT_INPUT, { .off = OFFSET(rate_emu) },
2988 "read input at native frame rate", "" },
2989 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2990 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2991 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2992 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2993 "video sync method", "" },
2994 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
2995 "frame drop threshold", "" },
2996 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2997 "audio sync method", "" },
2998 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2999 "audio drift threshold", "threshold" },
3000 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3001 "copy timestamps" },
3002 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3003 "shift input timestamps to start at 0 when using copyts" },
3004 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3005 "copy input stream time base when stream copying", "mode" },
3006 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3007 OPT_OUTPUT, { .off = OFFSET(shortest) },
3008 "finish encoding within shortest input" },
3009 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3010 OPT_OUTPUT, { .off = OFFSET(apad) },
3012 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3013 "timestamp discontinuity delta threshold", "threshold" },
3014 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3015 "timestamp error delta threshold", "threshold" },
3016 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3017 "exit on error", "error" },
3018 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3019 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3020 "copy initial non-keyframes" },
3021 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3022 "copy or discard frames before start time" },
3023 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3024 "set the number of frames to output", "number" },
3025 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3026 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3027 "force codec tag/fourcc", "fourcc/tag" },
3028 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3029 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3030 "use fixed quality scale (VBR)", "q" },
3031 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3032 OPT_OUTPUT, { .func_arg = opt_qscale },
3033 "use fixed quality scale (VBR)", "q" },
3034 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3035 "set profile", "profile" },
3036 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3037 "set stream filtergraph", "filter_graph" },
3038 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3039 "read stream filtergraph description from a file", "filename" },
3040 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3041 "reinit filtergraph on input parameter changes", "" },
3042 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3043 "create a complex filtergraph", "graph_description" },
3044 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3045 "create a complex filtergraph", "graph_description" },
3046 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3047 "read complex filtergraph description from a file", "filename" },
3048 { "stats", OPT_BOOL, { &print_stats },
3049 "print progress report during encoding", },
3050 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3051 OPT_OUTPUT, { .func_arg = opt_attach },
3052 "add an attachment to the output file", "filename" },
3053 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3054 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3055 "extract an attachment into a file", "filename" },
3056 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3057 "print timestamp debugging info" },
3058 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3059 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3060 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3061 OPT_INPUT, { .off = OFFSET(discard) },
3063 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3064 OPT_OUTPUT, { .off = OFFSET(disposition) },
3065 "disposition", "" },
3066 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3067 { .off = OFFSET(thread_queue_size) },
3068 "set the maximum number of queued packets from the demuxer" },
3071 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3072 "set the number of video frames to output", "number" },
3073 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3074 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3075 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3076 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3077 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3078 "set frame size (WxH or abbreviation)", "size" },
3079 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3080 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3081 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3082 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3083 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3084 "set pixel format", "format" },
3085 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3086 "set the number of bits per raw sample", "number" },
3087 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3088 "deprecated use -g 1" },
3089 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3091 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3092 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3093 "rate control override for specific intervals", "override" },
3094 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3095 OPT_OUTPUT, { .func_arg = opt_video_codec },
3096 "force video codec ('copy' to copy stream)", "codec" },
3097 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3099 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3101 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3102 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3103 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3104 "select the pass number (1 to 3)", "n" },
3105 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3106 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3107 "select two pass log file name prefix", "prefix" },
3108 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3109 "this option is deprecated, use the yadif filter instead" },
3110 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3111 "calculate PSNR of compressed frames" },
3112 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3113 "dump video coding statistics to file" },
3114 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3115 "dump video coding statistics to file", "file" },
3116 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3117 "set video filters", "filter_graph" },
3118 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3119 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3120 "specify intra matrix coeffs", "matrix" },
3121 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3122 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3123 "specify inter matrix coeffs", "matrix" },
3124 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3125 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3126 "specify intra matrix coeffs", "matrix" },
3127 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3128 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3129 "top=1/bottom=0/auto=-1 field first", "" },
3130 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3131 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3132 "force video tag/fourcc", "fourcc/tag" },
3133 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3134 "show QP histogram" },
3135 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3136 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3137 "force the selected framerate, disable the best supported framerate selection" },
3138 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3139 OPT_OUTPUT, { .func_arg = opt_streamid },
3140 "set the value of an outfile streamid", "streamIndex:value" },
3141 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3142 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3143 "force key frames at specified timestamps", "timestamps" },
3144 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3145 "audio bitrate (please use -b:a)", "bitrate" },
3146 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3147 "video bitrate (please use -b:v)", "bitrate" },
3148 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3149 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3150 "use HW accelerated decoding", "hwaccel name" },
3151 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3152 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3153 "select a device for HW acceleration" "devicename" },
3155 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3157 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3158 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3159 "automatically insert correct rotate filters" },
3162 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3163 "set the number of audio frames to output", "number" },
3164 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3165 "set audio quality (codec-specific)", "quality", },
3166 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3167 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3168 "set audio sampling rate (in Hz)", "rate" },
3169 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3170 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3171 "set number of audio channels", "channels" },
3172 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3174 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3175 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3176 "force audio codec ('copy' to copy stream)", "codec" },
3177 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3178 OPT_OUTPUT, { .func_arg = opt_old2new },
3179 "force audio tag/fourcc", "fourcc/tag" },
3180 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3181 "change audio volume (256=normal)" , "volume" },
3182 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3183 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3184 "set sample format", "format" },
3185 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3186 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3187 "set channel layout", "layout" },
3188 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3189 "set audio filters", "filter_graph" },
3190 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3191 "set the maximum number of channels to try to guess the channel layout" },
3193 /* subtitle options */
3194 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3195 "disable subtitle" },
3196 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3197 "force subtitle codec ('copy' to copy stream)", "codec" },
3198 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3199 , "force subtitle tag/fourcc", "fourcc/tag" },
3200 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3201 "fix subtitles duration" },
3202 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3203 "set canvas size (WxH or abbreviation)", "size" },
3206 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3207 "deprecated, use -channel", "channel" },
3208 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3209 "deprecated, use -standard", "standard" },
3210 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3213 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3214 "set the maximum demux-decode delay", "seconds" },
3215 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3216 "set the initial demux-decode delay", "seconds" },
3217 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3218 "override the options from ffserver", "" },
3219 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3220 "specify a file in which to print sdp information", "file" },
3222 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3223 "A comma-separated list of bitstream filters", "bitstream_filters" },
3224 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3225 "deprecated", "audio bitstream_filters" },
3226 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3227 "deprecated", "video bitstream_filters" },
3229 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3230 "set the audio options to the indicated preset", "preset" },
3231 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3232 "set the video options to the indicated preset", "preset" },
3233 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3234 "set the subtitle options to the indicated preset", "preset" },
3235 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3236 "set options from indicated preset file", "filename" },
3237 /* data codec support */
3238 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3239 "force data codec ('copy' to copy stream)", "codec" },
3240 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },