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 DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
47 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
50 for (i = 0; i < o->nb_ ## name; i++) {\
51 char *spec = o->name[i].specifier;\
52 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
53 outvar = o->name[i].u.type;\
59 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
62 for (i = 0; i < o->nb_ ## name; i++) {\
63 char *spec = o->name[i].specifier;\
64 if (!strcmp(spec, mediatype))\
65 outvar = o->name[i].u.type;\
69 const HWAccel hwaccels[] = {
71 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
74 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
77 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 #if CONFIG_VIDEOTOOLBOX
80 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
85 char *vstats_filename;
88 float audio_drift_threshold = 0.1;
89 float dts_delta_threshold = 10;
90 float dts_error_threshold = 3600*30;
92 int audio_volume = 256;
93 int audio_sync_method = 0;
94 int video_sync_method = VSYNC_AUTO;
95 float frame_drop_threshold = 0;
96 int do_deinterlace = 0;
98 int do_benchmark_all = 0;
102 int start_at_zero = 0;
105 int exit_on_error = 0;
106 int print_stats = -1;
108 int stdin_interaction = 1;
109 int frame_bits_per_raw_sample = 0;
110 float max_error_rate = 2.0/3;
113 static int intra_only = 0;
114 static int file_overwrite = 0;
115 static int no_file_overwrite = 0;
116 static int do_psnr = 0;
117 static int input_sync;
118 static int override_ffserver = 0;
119 static int input_stream_potentially_available = 0;
120 static int ignore_unknown_streams = 0;
121 static int copy_unknown_streams = 0;
123 static void uninit_options(OptionsContext *o)
125 const OptionDef *po = options;
128 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
130 void *dst = (uint8_t*)o + po->u.off;
132 if (po->flags & OPT_SPEC) {
133 SpecifierOpt **so = dst;
134 int i, *count = (int*)(so + 1);
135 for (i = 0; i < *count; i++) {
136 av_freep(&(*so)[i].specifier);
137 if (po->flags & OPT_STRING)
138 av_freep(&(*so)[i].u.str);
142 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
147 for (i = 0; i < o->nb_stream_maps; i++)
148 av_freep(&o->stream_maps[i].linklabel);
149 av_freep(&o->stream_maps);
150 av_freep(&o->audio_channel_maps);
151 av_freep(&o->streamid_map);
152 av_freep(&o->attachments);
155 static void init_options(OptionsContext *o)
157 memset(o, 0, sizeof(*o));
159 o->stop_time = INT64_MAX;
160 o->mux_max_delay = 0.7;
161 o->start_time = AV_NOPTS_VALUE;
162 o->start_time_eof = AV_NOPTS_VALUE;
163 o->recording_time = INT64_MAX;
164 o->limit_filesize = UINT64_MAX;
165 o->chapters_input_file = INT_MAX;
166 o->accurate_seek = 1;
169 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
173 printf("Hardware acceleration methods:\n");
174 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
175 printf("%s\n", hwaccels[i].name);
181 /* return a copy of the input with the stream specifiers removed from the keys */
182 static AVDictionary *strip_specifiers(AVDictionary *dict)
184 AVDictionaryEntry *e = NULL;
185 AVDictionary *ret = NULL;
187 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
188 char *p = strchr(e->key, ':');
192 av_dict_set(&ret, e->key, e->value, 0);
199 static int opt_sameq(void *optctx, const char *opt, const char *arg)
201 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
202 "If you are looking for an option to preserve the quality (which is not "
203 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
205 return AVERROR(EINVAL);
208 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
210 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
211 return opt_default(optctx, "channel", arg);
214 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
216 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
217 return opt_default(optctx, "standard", arg);
220 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
222 OptionsContext *o = optctx;
223 return parse_option(o, "codec:a", arg, options);
226 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
228 OptionsContext *o = optctx;
229 return parse_option(o, "codec:v", arg, options);
232 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
234 OptionsContext *o = optctx;
235 return parse_option(o, "codec:s", arg, options);
238 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
240 OptionsContext *o = optctx;
241 return parse_option(o, "codec:d", arg, options);
244 static int opt_map(void *optctx, const char *opt, const char *arg)
246 OptionsContext *o = optctx;
248 int i, negative = 0, file_idx;
249 int sync_file_idx = -1, sync_stream_idx = 0;
258 map = av_strdup(arg);
260 return AVERROR(ENOMEM);
262 /* parse sync stream first, just pick first matching stream */
263 if (sync = strchr(map, ',')) {
265 sync_file_idx = strtol(sync + 1, &sync, 0);
266 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
267 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
272 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
273 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
274 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
278 if (i == input_files[sync_file_idx]->nb_streams) {
279 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
280 "match any streams.\n", arg);
287 /* this mapping refers to lavfi output */
288 const char *c = map + 1;
289 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
290 m = &o->stream_maps[o->nb_stream_maps - 1];
291 m->linklabel = av_get_token(&c, "]");
293 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
297 if (allow_unused = strchr(map, '?'))
299 file_idx = strtol(map, &p, 0);
300 if (file_idx >= nb_input_files || file_idx < 0) {
301 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
305 /* disable some already defined maps */
306 for (i = 0; i < o->nb_stream_maps; i++) {
307 m = &o->stream_maps[i];
308 if (file_idx == m->file_index &&
309 check_stream_specifier(input_files[m->file_index]->ctx,
310 input_files[m->file_index]->ctx->streams[m->stream_index],
311 *p == ':' ? p + 1 : p) > 0)
315 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
316 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
317 *p == ':' ? p + 1 : p) <= 0)
319 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
320 m = &o->stream_maps[o->nb_stream_maps - 1];
322 m->file_index = file_idx;
325 if (sync_file_idx >= 0) {
326 m->sync_file_index = sync_file_idx;
327 m->sync_stream_index = sync_stream_idx;
329 m->sync_file_index = file_idx;
330 m->sync_stream_index = i;
337 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
339 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
340 "To ignore this, add a trailing '?' to the map.\n", arg);
349 static int opt_attach(void *optctx, const char *opt, const char *arg)
351 OptionsContext *o = optctx;
352 GROW_ARRAY(o->attachments, o->nb_attachments);
353 o->attachments[o->nb_attachments - 1] = arg;
357 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
359 OptionsContext *o = optctx;
364 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
365 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
367 /* muted channel syntax */
368 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
369 if ((n == 1 || n == 3) && m->channel_idx == -1) {
370 m->file_idx = m->stream_idx = -1;
372 m->ofile_idx = m->ostream_idx = -1;
377 n = sscanf(arg, "%d.%d.%d:%d.%d",
378 &m->file_idx, &m->stream_idx, &m->channel_idx,
379 &m->ofile_idx, &m->ostream_idx);
381 if (n != 3 && n != 5) {
382 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
383 "[file.stream.channel|-1][:syncfile:syncstream]\n");
387 if (n != 5) // only file.stream.channel specified
388 m->ofile_idx = m->ostream_idx = -1;
391 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
392 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
396 if (m->stream_idx < 0 ||
397 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
398 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
399 m->file_idx, m->stream_idx);
402 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
403 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
404 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
405 m->file_idx, m->stream_idx);
408 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
409 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
410 m->file_idx, m->stream_idx, m->channel_idx);
416 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
418 av_free(sdp_filename);
419 sdp_filename = av_strdup(arg);
424 * Parse a metadata specifier passed as 'arg' parameter.
425 * @param arg metadata string to parse
426 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
427 * @param index for type c/p, chapter/program index is written here
428 * @param stream_spec for type s, the stream specifier is written here
430 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
438 if (*(++arg) && *arg != ':') {
439 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
442 *stream_spec = *arg == ':' ? arg + 1 : "";
447 *index = strtol(++arg, NULL, 0);
450 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
457 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
459 AVDictionary **meta_in = NULL;
460 AVDictionary **meta_out = NULL;
462 char type_in, type_out;
463 const char *istream_spec = NULL, *ostream_spec = NULL;
464 int idx_in = 0, idx_out = 0;
466 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
467 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
470 if (type_out == 'g' || !*outspec)
471 o->metadata_global_manual = 1;
472 if (type_out == 's' || !*outspec)
473 o->metadata_streams_manual = 1;
474 if (type_out == 'c' || !*outspec)
475 o->metadata_chapters_manual = 1;
479 if (type_in == 'g' || type_out == 'g')
480 o->metadata_global_manual = 1;
481 if (type_in == 's' || type_out == 's')
482 o->metadata_streams_manual = 1;
483 if (type_in == 'c' || type_out == 'c')
484 o->metadata_chapters_manual = 1;
486 /* ic is NULL when just disabling automatic mappings */
490 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
491 if ((index) < 0 || (index) >= (nb_elems)) {\
492 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
497 #define SET_DICT(type, meta, context, index)\
500 meta = &context->metadata;\
503 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
504 meta = &context->chapters[index]->metadata;\
507 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
508 meta = &context->programs[index]->metadata;\
511 break; /* handled separately below */ \
512 default: av_assert0(0);\
515 SET_DICT(type_in, meta_in, ic, idx_in);
516 SET_DICT(type_out, meta_out, oc, idx_out);
518 /* for input streams choose first matching stream */
519 if (type_in == 's') {
520 for (i = 0; i < ic->nb_streams; i++) {
521 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
522 meta_in = &ic->streams[i]->metadata;
528 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
533 if (type_out == 's') {
534 for (i = 0; i < oc->nb_streams; i++) {
535 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
536 meta_out = &oc->streams[i]->metadata;
537 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
542 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
547 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
549 OptionsContext *o = optctx;
551 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
552 struct tm time = *gmtime((time_t*)&recording_timestamp);
553 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
555 parse_option(o, "metadata", buf, options);
557 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
558 "tag instead.\n", opt);
562 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
564 const AVCodecDescriptor *desc;
565 const char *codec_string = encoder ? "encoder" : "decoder";
569 avcodec_find_encoder_by_name(name) :
570 avcodec_find_decoder_by_name(name);
572 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
573 codec = encoder ? avcodec_find_encoder(desc->id) :
574 avcodec_find_decoder(desc->id);
576 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
577 codec_string, codec->name, desc->name);
581 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
584 if (codec->type != type) {
585 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
591 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
593 char *codec_name = NULL;
595 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
597 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
598 st->codec->codec_id = codec->id;
601 return avcodec_find_decoder(st->codec->codec_id);
604 /* Add all the streams from the given input file to the global
605 * list of input streams. */
606 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
610 for (i = 0; i < ic->nb_streams; i++) {
611 AVStream *st = ic->streams[i];
612 AVCodecContext *dec = st->codec;
613 InputStream *ist = av_mallocz(sizeof(*ist));
614 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
615 char *codec_tag = NULL;
617 char *discard_str = NULL;
618 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
623 GROW_ARRAY(input_streams, nb_input_streams);
624 input_streams[nb_input_streams - 1] = ist;
627 ist->file_index = nb_input_files;
629 st->discard = AVDISCARD_ALL;
631 ist->min_pts = INT64_MAX;
632 ist->max_pts = INT64_MIN;
635 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
638 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
640 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
642 uint32_t tag = strtol(codec_tag, &next, 0);
644 tag = AV_RL32(codec_tag);
645 st->codec->codec_tag = tag;
648 ist->dec = choose_decoder(o, ic, st);
649 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
651 ist->reinit_filters = -1;
652 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
654 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
655 ist->user_set_discard = AVDISCARD_NONE;
656 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
657 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
662 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
664 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
666 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
670 ret = avcodec_copy_context(ist->dec_ctx, dec);
672 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
676 switch (dec->codec_type) {
677 case AVMEDIA_TYPE_VIDEO:
679 ist->dec = avcodec_find_decoder(dec->codec_id);
681 if (av_codec_get_lowres(dec)) {
682 dec->flags |= CODEC_FLAG_EMU_EDGE;
686 ist->resample_height = ist->dec_ctx->height;
687 ist->resample_width = ist->dec_ctx->width;
688 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
690 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
691 if (framerate && av_parse_video_rate(&ist->framerate,
693 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
698 ist->top_field_first = -1;
699 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
701 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
703 if (!strcmp(hwaccel, "none"))
704 ist->hwaccel_id = HWACCEL_NONE;
705 else if (!strcmp(hwaccel, "auto"))
706 ist->hwaccel_id = HWACCEL_AUTO;
709 for (i = 0; hwaccels[i].name; i++) {
710 if (!strcmp(hwaccels[i].name, hwaccel)) {
711 ist->hwaccel_id = hwaccels[i].id;
716 if (!ist->hwaccel_id) {
717 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
719 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
720 for (i = 0; hwaccels[i].name; i++)
721 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
722 av_log(NULL, AV_LOG_FATAL, "\n");
728 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
729 if (hwaccel_device) {
730 ist->hwaccel_device = av_strdup(hwaccel_device);
731 if (!ist->hwaccel_device)
734 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
737 case AVMEDIA_TYPE_AUDIO:
738 ist->guess_layout_max = INT_MAX;
739 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
740 guess_input_channel_layout(ist);
742 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
743 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
744 ist->resample_channels = ist->dec_ctx->channels;
745 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
748 case AVMEDIA_TYPE_DATA:
749 case AVMEDIA_TYPE_SUBTITLE: {
750 char *canvas_size = NULL;
752 ist->dec = avcodec_find_decoder(dec->codec_id);
753 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
754 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
756 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
757 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
762 case AVMEDIA_TYPE_ATTACHMENT:
763 case AVMEDIA_TYPE_UNKNOWN:
771 static void assert_file_overwrite(const char *filename)
773 if (file_overwrite && no_file_overwrite) {
774 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
778 if (!file_overwrite) {
779 const char *proto_name = avio_find_protocol_name(filename);
780 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
781 if (stdin_interaction && !no_file_overwrite) {
782 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
785 signal(SIGINT, SIG_DFL);
787 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
793 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
800 static void dump_attachment(AVStream *st, const char *filename)
803 AVIOContext *out = NULL;
804 AVDictionaryEntry *e;
806 if (!st->codec->extradata_size) {
807 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
808 nb_input_files - 1, st->index);
811 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
814 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
815 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
819 assert_file_overwrite(filename);
821 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
822 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
827 avio_write(out, st->codec->extradata, st->codec->extradata_size);
832 static int open_input_file(OptionsContext *o, const char *filename)
836 AVInputFormat *file_iformat = NULL;
840 AVDictionary *unused_opts = NULL;
841 AVDictionaryEntry *e = NULL;
842 int orig_nb_streams; // number of streams before avformat_find_stream_info
843 char * video_codec_name = NULL;
844 char * audio_codec_name = NULL;
845 char *subtitle_codec_name = NULL;
846 char * data_codec_name = NULL;
847 int scan_all_pmts_set = 0;
850 if (!(file_iformat = av_find_input_format(o->format))) {
851 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
856 if (!strcmp(filename, "-"))
859 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
860 strcmp(filename, "/dev/stdin");
862 /* get default parameters from command line */
863 ic = avformat_alloc_context();
865 print_error(filename, AVERROR(ENOMEM));
868 if (o->nb_audio_sample_rate) {
869 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
871 if (o->nb_audio_channels) {
872 /* because we set audio_channels based on both the "ac" and
873 * "channel_layout" options, we need to check that the specified
874 * demuxer actually has the "channels" option before setting it */
875 if (file_iformat && file_iformat->priv_class &&
876 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
877 AV_OPT_SEARCH_FAKE_OBJ)) {
878 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
881 if (o->nb_frame_rates) {
882 /* set the format-level framerate option;
883 * this is important for video grabbers, e.g. x11 */
884 if (file_iformat && file_iformat->priv_class &&
885 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
886 AV_OPT_SEARCH_FAKE_OBJ)) {
887 av_dict_set(&o->g->format_opts, "framerate",
888 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
891 if (o->nb_frame_sizes) {
892 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
894 if (o->nb_frame_pix_fmts)
895 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
897 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
898 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
899 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
900 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
902 ic->video_codec_id = video_codec_name ?
903 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
904 ic->audio_codec_id = audio_codec_name ?
905 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
906 ic->subtitle_codec_id= subtitle_codec_name ?
907 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
908 ic->data_codec_id = data_codec_name ?
909 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
911 if (video_codec_name)
912 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
913 if (audio_codec_name)
914 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
915 if (subtitle_codec_name)
916 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
918 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
920 ic->flags |= AVFMT_FLAG_NONBLOCK;
921 ic->interrupt_callback = int_cb;
923 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
924 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
925 scan_all_pmts_set = 1;
927 /* open the input file with generic avformat function */
928 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
930 print_error(filename, err);
933 if (scan_all_pmts_set)
934 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
935 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
936 assert_avoptions(o->g->format_opts);
938 /* apply forced codec ids */
939 for (i = 0; i < ic->nb_streams; i++)
940 choose_decoder(o, ic, ic->streams[i]);
942 /* Set AVCodecContext options for avformat_find_stream_info */
943 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
944 orig_nb_streams = ic->nb_streams;
946 /* If not enough info to get the stream parameters, we decode the
947 first frames to get it. (used in mpeg case for example) */
948 ret = avformat_find_stream_info(ic, opts);
950 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
951 if (ic->nb_streams == 0) {
952 avformat_close_input(&ic);
957 if (o->start_time_eof != AV_NOPTS_VALUE) {
958 if (ic->duration>0) {
959 o->start_time = o->start_time_eof + ic->duration;
961 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
963 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
964 /* add the stream start time */
965 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
966 timestamp += ic->start_time;
968 /* if seeking requested, we execute it */
969 if (o->start_time != AV_NOPTS_VALUE) {
970 int64_t seek_timestamp = timestamp;
972 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
973 int dts_heuristic = 0;
974 for (i=0; i<ic->nb_streams; i++) {
975 AVCodecContext *avctx = ic->streams[i]->codec;
976 if (avctx->has_b_frames)
980 seek_timestamp -= 3*AV_TIME_BASE / 23;
983 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
985 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
986 filename, (double)timestamp / AV_TIME_BASE);
990 /* update the current parameters so that they match the one of the input stream */
991 add_input_streams(o, ic);
993 /* dump the file content */
994 av_dump_format(ic, nb_input_files, filename, 0);
996 GROW_ARRAY(input_files, nb_input_files);
997 f = av_mallocz(sizeof(*f));
1000 input_files[nb_input_files - 1] = f;
1003 f->ist_index = nb_input_streams - ic->nb_streams;
1004 f->start_time = o->start_time;
1005 f->recording_time = o->recording_time;
1006 f->input_ts_offset = o->input_ts_offset;
1007 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1008 f->nb_streams = ic->nb_streams;
1009 f->rate_emu = o->rate_emu;
1010 f->accurate_seek = o->accurate_seek;
1013 f->time_base = (AVRational){ 1, 1 };
1015 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1018 /* check if all codec options have been used */
1019 unused_opts = strip_specifiers(o->g->codec_opts);
1020 for (i = f->ist_index; i < nb_input_streams; i++) {
1022 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1023 AV_DICT_IGNORE_SUFFIX)))
1024 av_dict_set(&unused_opts, e->key, NULL, 0);
1028 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1029 const AVClass *class = avcodec_get_class();
1030 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1031 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1032 const AVClass *fclass = avformat_get_class();
1033 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1034 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1035 if (!option || foption)
1039 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1040 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1041 "input file #%d (%s) is not a decoding option.\n", e->key,
1042 option->help ? option->help : "", nb_input_files - 1,
1047 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1048 "input file #%d (%s) has not been used for any stream. The most "
1049 "likely reason is either wrong type (e.g. a video option with "
1050 "no video streams) or that it is a private option of some decoder "
1051 "which was not actually used for any stream.\n", e->key,
1052 option->help ? option->help : "", nb_input_files - 1, filename);
1054 av_dict_free(&unused_opts);
1056 for (i = 0; i < o->nb_dump_attachment; i++) {
1059 for (j = 0; j < ic->nb_streams; j++) {
1060 AVStream *st = ic->streams[j];
1062 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1063 dump_attachment(st, o->dump_attachment[i].u.str);
1067 for (i = 0; i < orig_nb_streams; i++)
1068 av_dict_free(&opts[i]);
1071 input_stream_potentially_available = 1;
1076 static uint8_t *get_line(AVIOContext *s)
1082 if (avio_open_dyn_buf(&line) < 0) {
1083 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1087 while ((c = avio_r8(s)) && c != '\n')
1090 avio_close_dyn_buf(line, &buf);
1095 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1098 char filename[1000];
1099 const char *base[3] = { getenv("AVCONV_DATADIR"),
1104 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1108 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1109 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1110 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1113 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1114 i != 1 ? "" : "/.avconv", preset_name);
1115 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1121 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1123 char *codec_name = NULL;
1125 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1127 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1128 NULL, ost->st->codec->codec_type);
1129 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1130 } else if (!strcmp(codec_name, "copy"))
1131 ost->stream_copy = 1;
1133 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1134 ost->st->codec->codec_id = ost->enc->id;
1138 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1141 AVStream *st = avformat_new_stream(oc, NULL);
1142 int idx = oc->nb_streams - 1, ret = 0;
1143 char *bsf = NULL, *next, *codec_tag = NULL;
1144 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1149 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1153 if (oc->nb_streams - 1 < o->nb_streamid_map)
1154 st->id = o->streamid_map[oc->nb_streams - 1];
1156 GROW_ARRAY(output_streams, nb_output_streams);
1157 if (!(ost = av_mallocz(sizeof(*ost))))
1159 output_streams[nb_output_streams - 1] = ost;
1161 ost->file_index = nb_output_files - 1;
1164 st->codec->codec_type = type;
1165 choose_encoder(o, oc, ost);
1167 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1168 if (!ost->enc_ctx) {
1169 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1172 ost->enc_ctx->codec_type = type;
1175 AVIOContext *s = NULL;
1176 char *buf = NULL, *arg = NULL, *preset = NULL;
1178 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1180 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1181 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1184 if (!buf[0] || buf[0] == '#') {
1188 if (!(arg = strchr(buf, '='))) {
1189 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1193 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1195 } while (!s->eof_reached);
1199 av_log(NULL, AV_LOG_FATAL,
1200 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1201 preset, ost->file_index, ost->index);
1205 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1208 ost->max_frames = INT64_MAX;
1209 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1210 for (i = 0; i<o->nb_max_frames; i++) {
1211 char *p = o->max_frames[i].specifier;
1212 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1213 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1218 ost->copy_prior_start = -1;
1219 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1221 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1224 if (next = strchr(bsf, ','))
1226 if (arg = strchr(bsf, '='))
1228 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1229 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1233 bsfc_prev->next = bsfc;
1235 ost->bitstream_filters = bsfc;
1236 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1242 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1244 uint32_t tag = strtol(codec_tag, &next, 0);
1246 tag = AV_RL32(codec_tag);
1247 ost->st->codec->codec_tag =
1248 ost->enc_ctx->codec_tag = tag;
1251 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1253 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1254 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1257 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1258 ost->disposition = av_strdup(ost->disposition);
1260 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1261 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1263 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1265 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1266 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1267 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1269 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1271 ost->source_index = source_index;
1272 if (source_index >= 0) {
1273 ost->sync_ist = input_streams[source_index];
1274 input_streams[source_index]->discard = 0;
1275 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1277 ost->last_mux_dts = AV_NOPTS_VALUE;
1282 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1285 const char *p = str;
1292 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1299 /* read file contents into a string */
1300 static uint8_t *read_file(const char *filename)
1302 AVIOContext *pb = NULL;
1303 AVIOContext *dyn_buf = NULL;
1304 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1305 uint8_t buf[1024], *str;
1308 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1312 ret = avio_open_dyn_buf(&dyn_buf);
1317 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1318 avio_write(dyn_buf, buf, ret);
1319 avio_w8(dyn_buf, 0);
1322 ret = avio_close_dyn_buf(dyn_buf, &str);
1328 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1331 AVStream *st = ost->st;
1333 if (ost->filters_script && ost->filters) {
1334 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1335 "output stream #%d:%d.\n", nb_output_files, st->index);
1339 if (ost->filters_script)
1340 return read_file(ost->filters_script);
1341 else if (ost->filters)
1342 return av_strdup(ost->filters);
1344 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1348 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1349 const OutputStream *ost, enum AVMediaType type)
1351 if (ost->filters_script || ost->filters) {
1352 av_log(NULL, AV_LOG_ERROR,
1353 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1354 "Filtering and streamcopy cannot be used together.\n",
1355 ost->filters ? "Filtergraph" : "Filtergraph script",
1356 ost->filters ? ost->filters : ost->filters_script,
1357 av_get_media_type_string(type), ost->file_index, ost->index);
1362 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1366 AVCodecContext *video_enc;
1367 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1369 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1371 video_enc = ost->enc_ctx;
1373 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1374 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1375 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1378 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1379 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1381 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1382 if (frame_aspect_ratio) {
1384 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1385 q.num <= 0 || q.den <= 0) {
1386 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1389 ost->frame_aspect_ratio = q;
1392 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1393 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1395 if (!ost->stream_copy) {
1396 const char *p = NULL;
1397 char *frame_size = NULL;
1398 char *frame_pix_fmt = NULL;
1399 char *intra_matrix = NULL, *inter_matrix = NULL;
1400 char *chroma_intra_matrix = NULL;
1404 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1405 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1406 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1410 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1411 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1412 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1413 ost->keep_pix_fmt = 1;
1414 if (!*++frame_pix_fmt)
1415 frame_pix_fmt = NULL;
1417 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1418 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1421 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1424 video_enc->gop_size = 0;
1425 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1427 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1428 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1431 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1433 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1434 if (chroma_intra_matrix) {
1435 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1437 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1440 av_codec_set_chroma_intra_matrix(video_enc, p);
1441 parse_matrix_coeffs(p, chroma_intra_matrix);
1443 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1445 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1446 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1449 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1452 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1453 for (i = 0; p; i++) {
1455 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1457 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1460 video_enc->rc_override =
1461 av_realloc_array(video_enc->rc_override,
1462 i + 1, sizeof(RcOverride));
1463 if (!video_enc->rc_override) {
1464 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1467 video_enc->rc_override[i].start_frame = start;
1468 video_enc->rc_override[i].end_frame = end;
1470 video_enc->rc_override[i].qscale = q;
1471 video_enc->rc_override[i].quality_factor = 1.0;
1474 video_enc->rc_override[i].qscale = 0;
1475 video_enc->rc_override[i].quality_factor = -q/100.0;
1480 video_enc->rc_override_count = i;
1483 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1486 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1489 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1490 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1493 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1494 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1498 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1499 if (ost->logfile_prefix &&
1500 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1504 char logfilename[1024];
1507 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1508 ost->logfile_prefix ? ost->logfile_prefix :
1509 DEFAULT_PASS_LOGFILENAME_PREFIX,
1511 if (!strcmp(ost->enc->name, "libx264")) {
1512 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1514 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1515 char *logbuffer = read_file(logfilename);
1518 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1522 video_enc->stats_in = logbuffer;
1524 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1525 f = av_fopen_utf8(logfilename, "wb");
1527 av_log(NULL, AV_LOG_FATAL,
1528 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1529 logfilename, strerror(errno));
1537 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1538 if (ost->forced_keyframes)
1539 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1541 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1543 ost->top_field_first = -1;
1544 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1547 ost->avfilter = get_ost_filters(o, oc, ost);
1551 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1554 if (ost->stream_copy)
1555 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1560 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1565 AVCodecContext *audio_enc;
1567 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1570 audio_enc = ost->enc_ctx;
1571 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1573 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1574 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1576 if (!ost->stream_copy) {
1577 char *sample_fmt = NULL;
1579 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1581 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1583 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1584 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1588 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1590 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1591 ost->apad = av_strdup(ost->apad);
1593 ost->avfilter = get_ost_filters(o, oc, ost);
1597 /* check for channel mapping for this audio stream */
1598 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1599 AudioChannelMap *map = &o->audio_channel_maps[n];
1600 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1601 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1604 if (map->channel_idx == -1) {
1606 } else if (ost->source_index < 0) {
1607 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1608 ost->file_index, ost->st->index);
1611 ist = input_streams[ost->source_index];
1614 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1615 if (av_reallocp_array(&ost->audio_channels_map,
1616 ost->audio_channels_mapped + 1,
1617 sizeof(*ost->audio_channels_map)
1621 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1627 if (ost->stream_copy)
1628 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1633 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1637 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1638 if (!ost->stream_copy) {
1639 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1646 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1650 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1651 if (!ost->stream_copy) {
1652 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1659 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1661 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1662 ost->stream_copy = 1;
1667 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1671 AVCodecContext *subtitle_enc;
1673 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1675 subtitle_enc = ost->enc_ctx;
1677 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1679 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1681 if (!ost->stream_copy) {
1682 char *frame_size = NULL;
1684 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1685 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1686 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1694 /* arg format is "output-stream-index:streamid-value". */
1695 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1697 OptionsContext *o = optctx;
1702 av_strlcpy(idx_str, arg, sizeof(idx_str));
1703 p = strchr(idx_str, ':');
1705 av_log(NULL, AV_LOG_FATAL,
1706 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1711 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1712 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1713 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1717 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1719 AVFormatContext *is = ifile->ctx;
1720 AVFormatContext *os = ofile->ctx;
1724 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1726 return AVERROR(ENOMEM);
1729 for (i = 0; i < is->nb_chapters; i++) {
1730 AVChapter *in_ch = is->chapters[i], *out_ch;
1731 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1732 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1733 AV_TIME_BASE_Q, in_ch->time_base);
1734 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1735 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1738 if (in_ch->end < ts_off)
1740 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1743 out_ch = av_mallocz(sizeof(AVChapter));
1745 return AVERROR(ENOMEM);
1747 out_ch->id = in_ch->id;
1748 out_ch->time_base = in_ch->time_base;
1749 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1750 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1753 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1755 os->chapters[os->nb_chapters++] = out_ch;
1760 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1763 AVFormatContext *ic = avformat_alloc_context();
1765 ic->interrupt_callback = int_cb;
1766 err = avformat_open_input(&ic, filename, NULL, NULL);
1769 /* copy stream format */
1770 for(i=0;i<ic->nb_streams;i++) {
1774 const char *enc_config;
1776 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1778 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1779 return AVERROR(EINVAL);
1781 if (codec->type == AVMEDIA_TYPE_AUDIO)
1782 opt_audio_codec(o, "c:a", codec->name);
1783 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1784 opt_video_codec(o, "c:v", codec->name);
1785 ost = new_output_stream(o, s, codec->type, -1);
1788 avcodec_get_context_defaults3(st->codec, codec);
1789 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1791 AVDictionary *opts = NULL;
1792 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1793 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1794 av_dict_free(&opts);
1797 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1798 choose_sample_fmt(st, codec);
1799 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1800 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1801 avcodec_copy_context(ost->enc_ctx, st->codec);
1803 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1806 avformat_close_input(&ic);
1810 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1811 AVFormatContext *oc)
1815 switch (ofilter->type) {
1816 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1817 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1819 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1824 ost->source_index = -1;
1825 ost->filter = ofilter;
1829 if (ost->stream_copy) {
1830 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1831 "which is fed from a complex filtergraph. Filtering and streamcopy "
1832 "cannot be used together.\n", ost->file_index, ost->index);
1836 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1837 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1838 av_log(NULL, AV_LOG_ERROR,
1839 "%s '%s' was specified through the %s option "
1840 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1841 "%s and -filter_complex cannot be used together for the same stream.\n",
1842 ost->filters ? "Filtergraph" : "Filtergraph script",
1843 ost->filters ? ost->filters : ost->filters_script,
1844 opt, ost->file_index, ost->index, opt);
1848 avfilter_inout_free(&ofilter->out_tmp);
1851 static int init_complex_filters(void)
1855 for (i = 0; i < nb_filtergraphs; i++) {
1856 ret = init_complex_filtergraph(filtergraphs[i]);
1863 static int configure_complex_filters(void)
1867 for (i = 0; i < nb_filtergraphs; i++)
1868 if (!filtergraphs[i]->graph &&
1869 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1874 static int open_output_file(OptionsContext *o, const char *filename)
1876 AVFormatContext *oc;
1878 AVOutputFormat *file_oformat;
1882 AVDictionary *unused_opts = NULL;
1883 AVDictionaryEntry *e = NULL;
1886 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1887 o->stop_time = INT64_MAX;
1888 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1891 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1892 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1893 if (o->stop_time <= start_time) {
1894 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1897 o->recording_time = o->stop_time - start_time;
1901 GROW_ARRAY(output_files, nb_output_files);
1902 of = av_mallocz(sizeof(*of));
1905 output_files[nb_output_files - 1] = of;
1907 of->ost_index = nb_output_streams;
1908 of->recording_time = o->recording_time;
1909 of->start_time = o->start_time;
1910 of->limit_filesize = o->limit_filesize;
1911 of->shortest = o->shortest;
1912 av_dict_copy(&of->opts, o->g->format_opts, 0);
1914 if (!strcmp(filename, "-"))
1917 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1919 print_error(filename, err);
1924 if (o->recording_time != INT64_MAX)
1925 oc->duration = o->recording_time;
1927 file_oformat= oc->oformat;
1928 oc->interrupt_callback = int_cb;
1930 /* create streams for all unlabeled output pads */
1931 for (i = 0; i < nb_filtergraphs; i++) {
1932 FilterGraph *fg = filtergraphs[i];
1933 for (j = 0; j < fg->nb_outputs; j++) {
1934 OutputFilter *ofilter = fg->outputs[j];
1936 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1939 switch (ofilter->type) {
1940 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1941 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1942 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1944 init_output_filter(ofilter, o, oc);
1948 /* ffserver seeking with date=... needs a date reference */
1949 if (!strcmp(file_oformat->name, "ffm") &&
1950 av_strstart(filename, "http:", NULL)) {
1951 int err = parse_option(o, "metadata", "creation_time=now", options);
1953 print_error(filename, err);
1958 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1959 av_strstart(filename, "http:", NULL)) {
1961 /* special case for files sent to ffserver: we get the stream
1962 parameters from ffserver */
1963 int err = read_ffserver_streams(o, oc, filename);
1965 print_error(filename, err);
1968 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1969 ost = output_streams[j];
1970 for (i = 0; i < nb_input_streams; i++) {
1971 ist = input_streams[i];
1972 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1974 ost->source_index= i;
1975 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1976 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1978 ist->st->discard = ist->user_set_discard;
1983 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));
1987 } else if (!o->nb_stream_maps) {
1988 char *subtitle_codec_name = NULL;
1989 /* pick the "best" stream of each type */
1991 /* video: highest resolution */
1992 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1993 int area = 0, idx = -1;
1994 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1995 for (i = 0; i < nb_input_streams; i++) {
1997 ist = input_streams[i];
1998 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
1999 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2001 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2003 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2010 new_video_stream(o, oc, idx);
2013 /* audio: most channels */
2014 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2015 int best_score = 0, idx = -1;
2016 for (i = 0; i < nb_input_streams; i++) {
2018 ist = input_streams[i];
2019 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2020 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2021 score > best_score) {
2027 new_audio_stream(o, oc, idx);
2030 /* subtitles: pick first */
2031 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2032 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2033 for (i = 0; i < nb_input_streams; i++)
2034 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2035 AVCodecDescriptor const *input_descriptor =
2036 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2037 AVCodecDescriptor const *output_descriptor = NULL;
2038 AVCodec const *output_codec =
2039 avcodec_find_encoder(oc->oformat->subtitle_codec);
2040 int input_props = 0, output_props = 0;
2042 output_descriptor = avcodec_descriptor_get(output_codec->id);
2043 if (input_descriptor)
2044 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2045 if (output_descriptor)
2046 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2047 if (subtitle_codec_name ||
2048 input_props & output_props ||
2049 // Map dvb teletext which has neither property to any output subtitle encoder
2050 input_descriptor && output_descriptor &&
2051 (!input_descriptor->props ||
2052 !output_descriptor->props)) {
2053 new_subtitle_stream(o, oc, i);
2058 /* Data only if codec id match */
2059 if (!o->data_disable ) {
2060 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2061 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2062 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2063 && input_streams[i]->st->codec->codec_id == codec_id )
2064 new_data_stream(o, oc, i);
2068 for (i = 0; i < o->nb_stream_maps; i++) {
2069 StreamMap *map = &o->stream_maps[i];
2074 if (map->linklabel) {
2076 OutputFilter *ofilter = NULL;
2079 for (j = 0; j < nb_filtergraphs; j++) {
2080 fg = filtergraphs[j];
2081 for (k = 0; k < fg->nb_outputs; k++) {
2082 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2083 if (out && !strcmp(out->name, map->linklabel)) {
2084 ofilter = fg->outputs[k];
2091 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2092 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2095 init_output_filter(ofilter, o, oc);
2097 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2099 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2100 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2102 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2104 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2106 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2110 switch (ist->st->codec->codec_type) {
2111 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2112 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2113 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2114 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2115 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2116 case AVMEDIA_TYPE_UNKNOWN:
2117 if (copy_unknown_streams) {
2118 ost = new_unknown_stream (o, oc, src_idx);
2122 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2123 "Cannot map stream #%d:%d - unsupported type.\n",
2124 map->file_index, map->stream_index);
2125 if (!ignore_unknown_streams) {
2126 av_log(NULL, AV_LOG_FATAL,
2127 "If you want unsupported types ignored instead "
2128 "of failing, please use the -ignore_unknown option\n"
2129 "If you want them copied, please use -copy_unknown\n");
2134 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2135 + map->sync_stream_index];
2140 /* handle attached files */
2141 for (i = 0; i < o->nb_attachments; i++) {
2143 uint8_t *attachment;
2147 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2148 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2152 if ((len = avio_size(pb)) <= 0) {
2153 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2157 if (!(attachment = av_malloc(len))) {
2158 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2162 avio_read(pb, attachment, len);
2164 ost = new_attachment_stream(o, oc, -1);
2165 ost->stream_copy = 1;
2166 ost->attachment_filename = o->attachments[i];
2168 ost->st->codec->extradata = attachment;
2169 ost->st->codec->extradata_size = len;
2171 p = strrchr(o->attachments[i], '/');
2172 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2176 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2177 AVDictionaryEntry *e;
2178 ost = output_streams[i];
2180 if ((ost->stream_copy || ost->attachment_filename)
2181 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2182 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2183 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2187 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2188 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2189 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2193 /* check if all codec options have been used */
2194 unused_opts = strip_specifiers(o->g->codec_opts);
2195 for (i = of->ost_index; i < nb_output_streams; i++) {
2197 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2198 AV_DICT_IGNORE_SUFFIX)))
2199 av_dict_set(&unused_opts, e->key, NULL, 0);
2203 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2204 const AVClass *class = avcodec_get_class();
2205 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2206 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2207 const AVClass *fclass = avformat_get_class();
2208 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2209 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2210 if (!option || foption)
2214 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2215 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2216 "output file #%d (%s) is not an encoding option.\n", e->key,
2217 option->help ? option->help : "", nb_output_files - 1,
2222 // gop_timecode is injected by generic code but not always used
2223 if (!strcmp(e->key, "gop_timecode"))
2226 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2227 "output file #%d (%s) has not been used for any stream. The most "
2228 "likely reason is either wrong type (e.g. a video option with "
2229 "no video streams) or that it is a private option of some encoder "
2230 "which was not actually used for any stream.\n", e->key,
2231 option->help ? option->help : "", nb_output_files - 1, filename);
2233 av_dict_free(&unused_opts);
2235 /* set the encoding/decoding_needed flags */
2236 for (i = of->ost_index; i < nb_output_streams; i++) {
2237 OutputStream *ost = output_streams[i];
2239 ost->encoding_needed = !ost->stream_copy;
2240 if (ost->encoding_needed && ost->source_index >= 0) {
2241 InputStream *ist = input_streams[ost->source_index];
2242 ist->decoding_needed |= DECODING_FOR_OST;
2246 /* check filename in case of an image number is expected */
2247 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2248 if (!av_filename_number_test(oc->filename)) {
2249 print_error(oc->filename, AVERROR(EINVAL));
2254 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2255 av_log(NULL, AV_LOG_ERROR,
2256 "No input streams but output needs an input stream\n");
2260 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2261 /* test if it already exists to avoid losing precious files */
2262 assert_file_overwrite(filename);
2265 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2266 &oc->interrupt_callback,
2268 print_error(filename, err);
2271 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2272 assert_file_overwrite(filename);
2274 if (o->mux_preload) {
2275 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2277 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2280 for (i = 0; i < o->nb_metadata_map; i++) {
2282 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2284 if (in_file_index >= nb_input_files) {
2285 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2288 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2289 in_file_index >= 0 ?
2290 input_files[in_file_index]->ctx : NULL, o);
2294 if (o->chapters_input_file >= nb_input_files) {
2295 if (o->chapters_input_file == INT_MAX) {
2296 /* copy chapters from the first input file that has them*/
2297 o->chapters_input_file = -1;
2298 for (i = 0; i < nb_input_files; i++)
2299 if (input_files[i]->ctx->nb_chapters) {
2300 o->chapters_input_file = i;
2304 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2305 o->chapters_input_file);
2309 if (o->chapters_input_file >= 0)
2310 copy_chapters(input_files[o->chapters_input_file], of,
2311 !o->metadata_chapters_manual);
2313 /* copy global metadata by default */
2314 if (!o->metadata_global_manual && nb_input_files){
2315 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2316 AV_DICT_DONT_OVERWRITE);
2317 if(o->recording_time != INT64_MAX)
2318 av_dict_set(&oc->metadata, "duration", NULL, 0);
2319 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2321 if (!o->metadata_streams_manual)
2322 for (i = of->ost_index; i < nb_output_streams; i++) {
2324 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2326 ist = input_streams[output_streams[i]->source_index];
2327 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2328 if (!output_streams[i]->stream_copy) {
2329 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2330 if (ist->autorotate)
2331 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2335 /* process manually set metadata */
2336 for (i = 0; i < o->nb_metadata; i++) {
2339 const char *stream_spec;
2340 int index = 0, j, ret = 0;
2343 val = strchr(o->metadata[i].u.str, '=');
2345 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2346 o->metadata[i].u.str);
2351 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2352 !strcmp(val, "now")) {
2353 time_t now = time(0);
2354 struct tm *ptm, tmbuf;
2355 ptm = localtime_r(&now, &tmbuf);
2357 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2362 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2364 for (j = 0; j < oc->nb_streams; j++) {
2365 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2366 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2367 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2368 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2369 ost->rotate_overridden = 1;
2381 if (index < 0 || index >= oc->nb_chapters) {
2382 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2385 m = &oc->chapters[index]->metadata;
2388 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2391 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2398 static int opt_target(void *optctx, const char *opt, const char *arg)
2400 OptionsContext *o = optctx;
2401 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2402 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2404 if (!strncmp(arg, "pal-", 4)) {
2407 } else if (!strncmp(arg, "ntsc-", 5)) {
2410 } else if (!strncmp(arg, "film-", 5)) {
2414 /* Try to determine PAL/NTSC by peeking in the input files */
2415 if (nb_input_files) {
2417 for (j = 0; j < nb_input_files; j++) {
2418 for (i = 0; i < input_files[j]->nb_streams; i++) {
2419 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2420 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2423 fr = c->time_base.den * 1000 / c->time_base.num;
2427 } else if ((fr == 29970) || (fr == 23976)) {
2432 if (norm != UNKNOWN)
2436 if (norm != UNKNOWN)
2437 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2440 if (norm == UNKNOWN) {
2441 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2442 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2443 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2447 if (!strcmp(arg, "vcd")) {
2448 opt_video_codec(o, "c:v", "mpeg1video");
2449 opt_audio_codec(o, "c:a", "mp2");
2450 parse_option(o, "f", "vcd", options);
2452 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2453 parse_option(o, "r", frame_rates[norm], options);
2454 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2456 opt_default(NULL, "b:v", "1150000");
2457 opt_default(NULL, "maxrate:v", "1150000");
2458 opt_default(NULL, "minrate:v", "1150000");
2459 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2461 opt_default(NULL, "b:a", "224000");
2462 parse_option(o, "ar", "44100", options);
2463 parse_option(o, "ac", "2", options);
2465 opt_default(NULL, "packetsize", "2324");
2466 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2468 /* We have to offset the PTS, so that it is consistent with the SCR.
2469 SCR starts at 36000, but the first two packs contain only padding
2470 and the first pack from the other stream, respectively, may also have
2471 been written before.
2472 So the real data starts at SCR 36000+3*1200. */
2473 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2474 } else if (!strcmp(arg, "svcd")) {
2476 opt_video_codec(o, "c:v", "mpeg2video");
2477 opt_audio_codec(o, "c:a", "mp2");
2478 parse_option(o, "f", "svcd", options);
2480 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2481 parse_option(o, "r", frame_rates[norm], options);
2482 parse_option(o, "pix_fmt", "yuv420p", options);
2483 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2485 opt_default(NULL, "b:v", "2040000");
2486 opt_default(NULL, "maxrate:v", "2516000");
2487 opt_default(NULL, "minrate:v", "0"); // 1145000;
2488 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2489 opt_default(NULL, "scan_offset", "1");
2491 opt_default(NULL, "b:a", "224000");
2492 parse_option(o, "ar", "44100", options);
2494 opt_default(NULL, "packetsize", "2324");
2496 } else if (!strcmp(arg, "dvd")) {
2498 opt_video_codec(o, "c:v", "mpeg2video");
2499 opt_audio_codec(o, "c:a", "ac3");
2500 parse_option(o, "f", "dvd", options);
2502 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2503 parse_option(o, "r", frame_rates[norm], options);
2504 parse_option(o, "pix_fmt", "yuv420p", options);
2505 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2507 opt_default(NULL, "b:v", "6000000");
2508 opt_default(NULL, "maxrate:v", "9000000");
2509 opt_default(NULL, "minrate:v", "0"); // 1500000;
2510 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2512 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2513 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2515 opt_default(NULL, "b:a", "448000");
2516 parse_option(o, "ar", "48000", options);
2518 } else if (!strncmp(arg, "dv", 2)) {
2520 parse_option(o, "f", "dv", options);
2522 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2523 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2524 norm == PAL ? "yuv420p" : "yuv411p", options);
2525 parse_option(o, "r", frame_rates[norm], options);
2527 parse_option(o, "ar", "48000", options);
2528 parse_option(o, "ac", "2", options);
2531 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2532 return AVERROR(EINVAL);
2535 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2536 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2541 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2543 av_free (vstats_filename);
2544 vstats_filename = av_strdup (arg);
2548 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2551 time_t today2 = time(NULL);
2552 struct tm *today = localtime(&today2);
2554 if (!today) { // maybe tomorrow
2555 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2559 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2561 return opt_vstats_file(NULL, opt, filename);
2564 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2566 OptionsContext *o = optctx;
2567 return parse_option(o, "frames:v", arg, options);
2570 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2572 OptionsContext *o = optctx;
2573 return parse_option(o, "frames:a", arg, options);
2576 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2578 OptionsContext *o = optctx;
2579 return parse_option(o, "frames:d", arg, options);
2582 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2585 AVDictionary *cbak = codec_opts;
2586 AVDictionary *fbak = format_opts;
2590 ret = opt_default(NULL, opt, arg);
2592 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2593 av_dict_copy(&o->g->format_opts, format_opts, 0);
2594 av_dict_free(&codec_opts);
2595 av_dict_free(&format_opts);
2602 static int opt_preset(void *optctx, const char *opt, const char *arg)
2604 OptionsContext *o = optctx;
2606 char filename[1000], line[1000], tmp_line[1000];
2607 const char *codec_name = NULL;
2611 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2613 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2614 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2615 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2617 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2621 while (fgets(line, sizeof(line), f)) {
2622 char *key = tmp_line, *value, *endptr;
2624 if (strcspn(line, "#\n\r") == 0)
2626 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2627 if (!av_strtok(key, "=", &value) ||
2628 !av_strtok(value, "\r\n", &endptr)) {
2629 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2632 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2634 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2635 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2636 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2637 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2638 else if (opt_default_new(o, key, value) < 0) {
2639 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2640 filename, line, key, value);
2650 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2652 OptionsContext *o = optctx;
2653 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2654 int ret = parse_option(o, s, arg, options);
2659 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2661 OptionsContext *o = optctx;
2663 if(!strcmp(opt, "ab")){
2664 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2666 } else if(!strcmp(opt, "b")){
2667 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2668 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2671 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2675 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2677 OptionsContext *o = optctx;
2680 if(!strcmp(opt, "qscale")){
2681 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2682 return parse_option(o, "q:v", arg, options);
2684 s = av_asprintf("q%s", opt + 6);
2685 ret = parse_option(o, s, arg, options);
2690 static int opt_profile(void *optctx, const char *opt, const char *arg)
2692 OptionsContext *o = optctx;
2693 if(!strcmp(opt, "profile")){
2694 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2695 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2698 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2702 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2704 OptionsContext *o = optctx;
2705 return parse_option(o, "filter:v", arg, options);
2708 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2710 OptionsContext *o = optctx;
2711 return parse_option(o, "filter:a", arg, options);
2714 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2716 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2717 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2718 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2719 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2721 if (video_sync_method == VSYNC_AUTO)
2722 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2726 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2728 OptionsContext *o = optctx;
2729 char *tcr = av_asprintf("timecode=%s", arg);
2730 int ret = parse_option(o, "metadata:g", tcr, options);
2732 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2737 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2739 OptionsContext *o = optctx;
2740 char layout_str[32];
2743 int ret, channels, ac_str_size;
2746 layout = av_get_channel_layout(arg);
2748 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2749 return AVERROR(EINVAL);
2751 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2752 ret = opt_default_new(o, opt, layout_str);
2756 /* set 'ac' option based on channel layout */
2757 channels = av_get_channel_layout_nb_channels(layout);
2758 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2759 stream_str = strchr(opt, ':');
2760 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2761 ac_str = av_mallocz(ac_str_size);
2763 return AVERROR(ENOMEM);
2764 av_strlcpy(ac_str, "ac", 3);
2766 av_strlcat(ac_str, stream_str, ac_str_size);
2767 ret = parse_option(o, ac_str, layout_str, options);
2773 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2775 OptionsContext *o = optctx;
2776 return parse_option(o, "q:a", arg, options);
2779 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2781 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2782 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2783 return AVERROR(ENOMEM);
2784 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2785 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2786 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2787 return AVERROR(ENOMEM);
2789 input_stream_potentially_available = 1;
2794 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2796 uint8_t *graph_desc = read_file(arg);
2798 return AVERROR(EINVAL);
2800 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2801 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2802 return AVERROR(ENOMEM);
2803 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2804 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2806 input_stream_potentially_available = 1;
2811 void show_help_default(const char *opt, const char *arg)
2813 /* per-file options have at least one of those set */
2814 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2815 int show_advanced = 0, show_avoptions = 0;
2818 if (!strcmp(opt, "long"))
2820 else if (!strcmp(opt, "full"))
2821 show_advanced = show_avoptions = 1;
2823 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2828 printf("Getting help:\n"
2829 " -h -- print basic options\n"
2830 " -h long -- print more options\n"
2831 " -h full -- print all options (including all format and codec specific options, very long)\n"
2832 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2833 " See man %s for detailed description of the options.\n"
2834 "\n", program_name);
2836 show_help_options(options, "Print help / information / capabilities:",
2839 show_help_options(options, "Global options (affect whole program "
2840 "instead of just one file:",
2841 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2843 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2844 per_file | OPT_EXIT, 0);
2846 show_help_options(options, "Per-file main options:", 0,
2847 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2848 OPT_EXIT, per_file);
2850 show_help_options(options, "Advanced per-file options:",
2851 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2853 show_help_options(options, "Video options:",
2854 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2856 show_help_options(options, "Advanced Video options:",
2857 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2859 show_help_options(options, "Audio options:",
2860 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2862 show_help_options(options, "Advanced Audio options:",
2863 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2864 show_help_options(options, "Subtitle options:",
2865 OPT_SUBTITLE, 0, 0);
2868 if (show_avoptions) {
2869 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2870 show_help_children(avcodec_get_class(), flags);
2871 show_help_children(avformat_get_class(), flags);
2873 show_help_children(sws_get_class(), flags);
2875 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2876 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2880 void show_usage(void)
2882 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2883 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2884 av_log(NULL, AV_LOG_INFO, "\n");
2892 static const OptionGroupDef groups[] = {
2893 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2894 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2897 static int open_files(OptionGroupList *l, const char *inout,
2898 int (*open_file)(OptionsContext*, const char*))
2902 for (i = 0; i < l->nb_groups; i++) {
2903 OptionGroup *g = &l->groups[i];
2909 ret = parse_optgroup(&o, g);
2911 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2912 "%s.\n", inout, g->arg);
2916 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2917 ret = open_file(&o, g->arg);
2920 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2924 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2930 int ffmpeg_parse_options(int argc, char **argv)
2932 OptionParseContext octx;
2936 memset(&octx, 0, sizeof(octx));
2938 /* split the commandline into an internal representation */
2939 ret = split_commandline(&octx, argc, argv, options, groups,
2940 FF_ARRAY_ELEMS(groups));
2942 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2946 /* apply global options */
2947 ret = parse_optgroup(NULL, &octx.global_opts);
2949 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2953 /* open input files */
2954 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2956 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2960 /* create the complex filtergraphs */
2961 ret = init_complex_filters();
2963 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2967 /* open output files */
2968 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2970 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2974 /* configure the complex filtergraphs */
2975 ret = configure_complex_filters();
2977 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2982 uninit_parse_context(&octx);
2984 av_strerror(ret, error, sizeof(error));
2985 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2990 static int opt_progress(void *optctx, const char *opt, const char *arg)
2992 AVIOContext *avio = NULL;
2995 if (!strcmp(arg, "-"))
2997 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2999 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3000 arg, av_err2str(ret));
3003 progress_avio = avio;
3007 #define OFFSET(x) offsetof(OptionsContext, x)
3008 const OptionDef options[] = {
3010 #include "cmdutils_common_opts.h"
3011 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3012 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3013 "force format", "fmt" },
3014 { "y", OPT_BOOL, { &file_overwrite },
3015 "overwrite output files" },
3016 { "n", OPT_BOOL, { &no_file_overwrite },
3017 "never overwrite output files" },
3018 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3019 "Ignore unknown stream types" },
3020 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3021 "Copy unknown stream types" },
3022 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3023 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3024 "codec name", "codec" },
3025 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3026 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3027 "codec name", "codec" },
3028 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3029 OPT_OUTPUT, { .off = OFFSET(presets) },
3030 "preset name", "preset" },
3031 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3032 OPT_OUTPUT, { .func_arg = opt_map },
3033 "set input stream mapping",
3034 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3035 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3036 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3037 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3038 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3039 "set metadata information of outfile from infile",
3040 "outfile[,metadata]:infile[,metadata]" },
3041 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3042 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3043 "set chapters mapping", "input_file_index" },
3044 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3045 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3046 "record or transcode \"duration\" seconds of audio/video",
3048 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3049 "record or transcode stop time", "time_stop" },
3050 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3051 "set the limit file size in bytes", "limit_size" },
3052 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3053 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3054 "set the start time offset", "time_off" },
3055 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3056 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3057 "set the start time offset relative to EOF", "time_off" },
3058 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3059 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3060 "enable/disable seeking by timestamp with -ss" },
3061 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3062 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3063 "enable/disable accurate seeking with -ss" },
3064 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3065 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3066 "set the input ts offset", "time_off" },
3067 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3068 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3069 "set the input ts scale", "scale" },
3070 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3071 "set the recording timestamp ('now' to set the current time)", "time" },
3072 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3073 "add metadata", "string=string" },
3074 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3075 OPT_OUTPUT, { .func_arg = opt_data_frames },
3076 "set the number of data frames to output", "number" },
3077 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3078 "add timings for benchmarking" },
3079 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3080 "add timings for each task" },
3081 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3082 "write program-readable progress information", "url" },
3083 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3084 "enable or disable interaction on standard input" },
3085 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3086 "set max runtime in seconds", "limit" },
3087 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3088 "dump each input packet" },
3089 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3090 "when dumping packets, also dump the payload" },
3091 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3092 OPT_INPUT, { .off = OFFSET(rate_emu) },
3093 "read input at native frame rate", "" },
3094 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3095 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3096 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3097 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
3098 "video sync method", "" },
3099 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3100 "frame drop threshold", "" },
3101 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3102 "audio sync method", "" },
3103 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3104 "audio drift threshold", "threshold" },
3105 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3106 "copy timestamps" },
3107 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3108 "shift input timestamps to start at 0 when using copyts" },
3109 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3110 "copy input stream time base when stream copying", "mode" },
3111 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3112 OPT_OUTPUT, { .off = OFFSET(shortest) },
3113 "finish encoding within shortest input" },
3114 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3115 OPT_OUTPUT, { .off = OFFSET(apad) },
3117 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3118 "timestamp discontinuity delta threshold", "threshold" },
3119 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3120 "timestamp error delta threshold", "threshold" },
3121 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3122 "exit on error", "error" },
3123 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3124 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3125 "copy initial non-keyframes" },
3126 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3127 "copy or discard frames before start time" },
3128 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3129 "set the number of frames to output", "number" },
3130 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3131 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3132 "force codec tag/fourcc", "fourcc/tag" },
3133 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3134 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3135 "use fixed quality scale (VBR)", "q" },
3136 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3137 OPT_OUTPUT, { .func_arg = opt_qscale },
3138 "use fixed quality scale (VBR)", "q" },
3139 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3140 "set profile", "profile" },
3141 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3142 "set stream filtergraph", "filter_graph" },
3143 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3144 "read stream filtergraph description from a file", "filename" },
3145 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3146 "reinit filtergraph on input parameter changes", "" },
3147 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3148 "create a complex filtergraph", "graph_description" },
3149 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3150 "create a complex filtergraph", "graph_description" },
3151 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3152 "read complex filtergraph description from a file", "filename" },
3153 { "stats", OPT_BOOL, { &print_stats },
3154 "print progress report during encoding", },
3155 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3156 OPT_OUTPUT, { .func_arg = opt_attach },
3157 "add an attachment to the output file", "filename" },
3158 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3159 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3160 "extract an attachment into a file", "filename" },
3161 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3162 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3163 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3164 "print timestamp debugging info" },
3165 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3166 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3167 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3168 OPT_INPUT, { .off = OFFSET(discard) },
3170 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3171 OPT_OUTPUT, { .off = OFFSET(disposition) },
3172 "disposition", "" },
3173 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3174 { .off = OFFSET(thread_queue_size) },
3175 "set the maximum number of queued packets from the demuxer" },
3178 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3179 "set the number of video frames to output", "number" },
3180 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3181 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3182 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3183 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3184 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3185 "set frame size (WxH or abbreviation)", "size" },
3186 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3187 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3188 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3189 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3190 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3191 "set pixel format", "format" },
3192 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3193 "set the number of bits per raw sample", "number" },
3194 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3195 "deprecated use -g 1" },
3196 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3198 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3199 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3200 "rate control override for specific intervals", "override" },
3201 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3202 OPT_OUTPUT, { .func_arg = opt_video_codec },
3203 "force video codec ('copy' to copy stream)", "codec" },
3204 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3206 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3208 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3209 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3210 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3211 "select the pass number (1 to 3)", "n" },
3212 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3213 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3214 "select two pass log file name prefix", "prefix" },
3215 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3216 "this option is deprecated, use the yadif filter instead" },
3217 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3218 "calculate PSNR of compressed frames" },
3219 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3220 "dump video coding statistics to file" },
3221 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3222 "dump video coding statistics to file", "file" },
3223 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3224 "set video filters", "filter_graph" },
3225 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3226 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3227 "specify intra matrix coeffs", "matrix" },
3228 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3229 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3230 "specify inter matrix coeffs", "matrix" },
3231 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3232 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3233 "specify intra matrix coeffs", "matrix" },
3234 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3235 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3236 "top=1/bottom=0/auto=-1 field first", "" },
3237 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3238 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3239 "force video tag/fourcc", "fourcc/tag" },
3240 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3241 "show QP histogram" },
3242 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3243 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3244 "force the selected framerate, disable the best supported framerate selection" },
3245 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3246 OPT_OUTPUT, { .func_arg = opt_streamid },
3247 "set the value of an outfile streamid", "streamIndex:value" },
3248 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3249 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3250 "force key frames at specified timestamps", "timestamps" },
3251 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3252 "audio bitrate (please use -b:a)", "bitrate" },
3253 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3254 "video bitrate (please use -b:v)", "bitrate" },
3255 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3256 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3257 "use HW accelerated decoding", "hwaccel name" },
3258 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3259 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3260 "select a device for HW acceleration", "devicename" },
3262 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3264 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3265 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3267 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3268 "show available HW acceleration methods" },
3269 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3270 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3271 "automatically insert correct rotate filters" },
3274 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3275 "set the number of audio frames to output", "number" },
3276 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3277 "set audio quality (codec-specific)", "quality", },
3278 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3279 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3280 "set audio sampling rate (in Hz)", "rate" },
3281 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3282 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3283 "set number of audio channels", "channels" },
3284 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3286 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3287 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3288 "force audio codec ('copy' to copy stream)", "codec" },
3289 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3290 OPT_OUTPUT, { .func_arg = opt_old2new },
3291 "force audio tag/fourcc", "fourcc/tag" },
3292 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3293 "change audio volume (256=normal)" , "volume" },
3294 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3295 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3296 "set sample format", "format" },
3297 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3298 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3299 "set channel layout", "layout" },
3300 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3301 "set audio filters", "filter_graph" },
3302 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3303 "set the maximum number of channels to try to guess the channel layout" },
3305 /* subtitle options */
3306 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3307 "disable subtitle" },
3308 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3309 "force subtitle codec ('copy' to copy stream)", "codec" },
3310 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3311 , "force subtitle tag/fourcc", "fourcc/tag" },
3312 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3313 "fix subtitles duration" },
3314 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3315 "set canvas size (WxH or abbreviation)", "size" },
3318 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3319 "deprecated, use -channel", "channel" },
3320 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3321 "deprecated, use -standard", "standard" },
3322 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3325 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3326 "set the maximum demux-decode delay", "seconds" },
3327 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3328 "set the initial demux-decode delay", "seconds" },
3329 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3330 "override the options from ffserver", "" },
3331 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3332 "specify a file in which to print sdp information", "file" },
3334 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3335 "A comma-separated list of bitstream filters", "bitstream_filters" },
3336 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3337 "deprecated", "audio bitstream_filters" },
3338 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3339 "deprecated", "video bitstream_filters" },
3341 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3342 "set the audio options to the indicated preset", "preset" },
3343 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3344 "set the video options to the indicated preset", "preset" },
3345 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3346 "set the subtitle options to the indicated preset", "preset" },
3347 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3348 "set options from indicated preset file", "filename" },
3349 /* data codec support */
3350 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3351 "force data codec ('copy' to copy stream)", "codec" },
3352 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },