2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
70 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
73 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
76 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
78 #if CONFIG_VIDEOTOOLBOX
79 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
82 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
87 char *vstats_filename;
90 float audio_drift_threshold = 0.1;
91 float dts_delta_threshold = 10;
92 float dts_error_threshold = 3600*30;
94 int audio_volume = 256;
95 int audio_sync_method = 0;
96 int video_sync_method = VSYNC_AUTO;
97 float frame_drop_threshold = 0;
98 int do_deinterlace = 0;
100 int do_benchmark_all = 0;
104 int start_at_zero = 0;
107 int exit_on_error = 0;
108 int abort_on_flags = 0;
109 int print_stats = -1;
111 int stdin_interaction = 1;
112 int frame_bits_per_raw_sample = 0;
113 float max_error_rate = 2.0/3;
116 static int intra_only = 0;
117 static int file_overwrite = 0;
118 static int no_file_overwrite = 0;
119 static int do_psnr = 0;
120 static int input_sync;
121 static int override_ffserver = 0;
122 static int input_stream_potentially_available = 0;
123 static int ignore_unknown_streams = 0;
124 static int copy_unknown_streams = 0;
126 static void uninit_options(OptionsContext *o)
128 const OptionDef *po = options;
131 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
133 void *dst = (uint8_t*)o + po->u.off;
135 if (po->flags & OPT_SPEC) {
136 SpecifierOpt **so = dst;
137 int i, *count = (int*)(so + 1);
138 for (i = 0; i < *count; i++) {
139 av_freep(&(*so)[i].specifier);
140 if (po->flags & OPT_STRING)
141 av_freep(&(*so)[i].u.str);
145 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
150 for (i = 0; i < o->nb_stream_maps; i++)
151 av_freep(&o->stream_maps[i].linklabel);
152 av_freep(&o->stream_maps);
153 av_freep(&o->audio_channel_maps);
154 av_freep(&o->streamid_map);
155 av_freep(&o->attachments);
158 static void init_options(OptionsContext *o)
160 memset(o, 0, sizeof(*o));
162 o->stop_time = INT64_MAX;
163 o->mux_max_delay = 0.7;
164 o->start_time = AV_NOPTS_VALUE;
165 o->start_time_eof = AV_NOPTS_VALUE;
166 o->recording_time = INT64_MAX;
167 o->limit_filesize = UINT64_MAX;
168 o->chapters_input_file = INT_MAX;
169 o->accurate_seek = 1;
172 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
176 printf("Hardware acceleration methods:\n");
177 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
178 printf("%s\n", hwaccels[i].name);
184 /* return a copy of the input with the stream specifiers removed from the keys */
185 static AVDictionary *strip_specifiers(AVDictionary *dict)
187 AVDictionaryEntry *e = NULL;
188 AVDictionary *ret = NULL;
190 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
191 char *p = strchr(e->key, ':');
195 av_dict_set(&ret, e->key, e->value, 0);
202 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
204 static const AVOption opts[] = {
205 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
206 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
209 static const AVClass class = {
211 .item_name = av_default_item_name,
213 .version = LIBAVUTIL_VERSION_INT,
215 const AVClass *pclass = &class;
217 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
220 static int opt_sameq(void *optctx, const char *opt, const char *arg)
222 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
223 "If you are looking for an option to preserve the quality (which is not "
224 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
226 return AVERROR(EINVAL);
229 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
231 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
232 return opt_default(optctx, "channel", arg);
235 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
237 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
238 return opt_default(optctx, "standard", arg);
241 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
243 OptionsContext *o = optctx;
244 return parse_option(o, "codec:a", arg, options);
247 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
249 OptionsContext *o = optctx;
250 return parse_option(o, "codec:v", arg, options);
253 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
255 OptionsContext *o = optctx;
256 return parse_option(o, "codec:s", arg, options);
259 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
261 OptionsContext *o = optctx;
262 return parse_option(o, "codec:d", arg, options);
265 static int opt_map(void *optctx, const char *opt, const char *arg)
267 OptionsContext *o = optctx;
269 int i, negative = 0, file_idx;
270 int sync_file_idx = -1, sync_stream_idx = 0;
279 map = av_strdup(arg);
281 return AVERROR(ENOMEM);
283 /* parse sync stream first, just pick first matching stream */
284 if (sync = strchr(map, ',')) {
286 sync_file_idx = strtol(sync + 1, &sync, 0);
287 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
288 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
293 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
294 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
295 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
299 if (i == input_files[sync_file_idx]->nb_streams) {
300 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
301 "match any streams.\n", arg);
308 /* this mapping refers to lavfi output */
309 const char *c = map + 1;
310 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
311 m = &o->stream_maps[o->nb_stream_maps - 1];
312 m->linklabel = av_get_token(&c, "]");
314 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
318 if (allow_unused = strchr(map, '?'))
320 file_idx = strtol(map, &p, 0);
321 if (file_idx >= nb_input_files || file_idx < 0) {
322 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
326 /* disable some already defined maps */
327 for (i = 0; i < o->nb_stream_maps; i++) {
328 m = &o->stream_maps[i];
329 if (file_idx == m->file_index &&
330 check_stream_specifier(input_files[m->file_index]->ctx,
331 input_files[m->file_index]->ctx->streams[m->stream_index],
332 *p == ':' ? p + 1 : p) > 0)
336 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
337 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
338 *p == ':' ? p + 1 : p) <= 0)
340 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
341 m = &o->stream_maps[o->nb_stream_maps - 1];
343 m->file_index = file_idx;
346 if (sync_file_idx >= 0) {
347 m->sync_file_index = sync_file_idx;
348 m->sync_stream_index = sync_stream_idx;
350 m->sync_file_index = file_idx;
351 m->sync_stream_index = i;
358 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
360 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
361 "To ignore this, add a trailing '?' to the map.\n", arg);
370 static int opt_attach(void *optctx, const char *opt, const char *arg)
372 OptionsContext *o = optctx;
373 GROW_ARRAY(o->attachments, o->nb_attachments);
374 o->attachments[o->nb_attachments - 1] = arg;
378 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
380 OptionsContext *o = optctx;
385 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
386 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
388 /* muted channel syntax */
389 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
390 if ((n == 1 || n == 3) && m->channel_idx == -1) {
391 m->file_idx = m->stream_idx = -1;
393 m->ofile_idx = m->ostream_idx = -1;
398 n = sscanf(arg, "%d.%d.%d:%d.%d",
399 &m->file_idx, &m->stream_idx, &m->channel_idx,
400 &m->ofile_idx, &m->ostream_idx);
402 if (n != 3 && n != 5) {
403 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
404 "[file.stream.channel|-1][:syncfile:syncstream]\n");
408 if (n != 5) // only file.stream.channel specified
409 m->ofile_idx = m->ostream_idx = -1;
412 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
413 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
417 if (m->stream_idx < 0 ||
418 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
419 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
420 m->file_idx, m->stream_idx);
423 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
424 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
425 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
426 m->file_idx, m->stream_idx);
429 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
430 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
431 m->file_idx, m->stream_idx, m->channel_idx);
437 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
439 av_free(sdp_filename);
440 sdp_filename = av_strdup(arg);
445 * Parse a metadata specifier passed as 'arg' parameter.
446 * @param arg metadata string to parse
447 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
448 * @param index for type c/p, chapter/program index is written here
449 * @param stream_spec for type s, the stream specifier is written here
451 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
459 if (*(++arg) && *arg != ':') {
460 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
463 *stream_spec = *arg == ':' ? arg + 1 : "";
468 *index = strtol(++arg, NULL, 0);
471 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
478 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
480 AVDictionary **meta_in = NULL;
481 AVDictionary **meta_out = NULL;
483 char type_in, type_out;
484 const char *istream_spec = NULL, *ostream_spec = NULL;
485 int idx_in = 0, idx_out = 0;
487 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
488 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
491 if (type_out == 'g' || !*outspec)
492 o->metadata_global_manual = 1;
493 if (type_out == 's' || !*outspec)
494 o->metadata_streams_manual = 1;
495 if (type_out == 'c' || !*outspec)
496 o->metadata_chapters_manual = 1;
500 if (type_in == 'g' || type_out == 'g')
501 o->metadata_global_manual = 1;
502 if (type_in == 's' || type_out == 's')
503 o->metadata_streams_manual = 1;
504 if (type_in == 'c' || type_out == 'c')
505 o->metadata_chapters_manual = 1;
507 /* ic is NULL when just disabling automatic mappings */
511 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
512 if ((index) < 0 || (index) >= (nb_elems)) {\
513 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
518 #define SET_DICT(type, meta, context, index)\
521 meta = &context->metadata;\
524 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
525 meta = &context->chapters[index]->metadata;\
528 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
529 meta = &context->programs[index]->metadata;\
532 break; /* handled separately below */ \
533 default: av_assert0(0);\
536 SET_DICT(type_in, meta_in, ic, idx_in);
537 SET_DICT(type_out, meta_out, oc, idx_out);
539 /* for input streams choose first matching stream */
540 if (type_in == 's') {
541 for (i = 0; i < ic->nb_streams; i++) {
542 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
543 meta_in = &ic->streams[i]->metadata;
549 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
554 if (type_out == 's') {
555 for (i = 0; i < oc->nb_streams; i++) {
556 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
557 meta_out = &oc->streams[i]->metadata;
558 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
563 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
568 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
570 OptionsContext *o = optctx;
572 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
573 struct tm time = *gmtime((time_t*)&recording_timestamp);
574 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
576 parse_option(o, "metadata", buf, options);
578 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
579 "tag instead.\n", opt);
583 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
585 const AVCodecDescriptor *desc;
586 const char *codec_string = encoder ? "encoder" : "decoder";
590 avcodec_find_encoder_by_name(name) :
591 avcodec_find_decoder_by_name(name);
593 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
594 codec = encoder ? avcodec_find_encoder(desc->id) :
595 avcodec_find_decoder(desc->id);
597 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
598 codec_string, codec->name, desc->name);
602 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
605 if (codec->type != type) {
606 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
612 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
614 char *codec_name = NULL;
616 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
618 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
619 st->codec->codec_id = codec->id;
622 return avcodec_find_decoder(st->codec->codec_id);
625 /* Add all the streams from the given input file to the global
626 * list of input streams. */
627 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
631 for (i = 0; i < ic->nb_streams; i++) {
632 AVStream *st = ic->streams[i];
633 AVCodecContext *dec = st->codec;
634 InputStream *ist = av_mallocz(sizeof(*ist));
635 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
636 char *codec_tag = NULL;
638 char *discard_str = NULL;
639 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
644 GROW_ARRAY(input_streams, nb_input_streams);
645 input_streams[nb_input_streams - 1] = ist;
648 ist->file_index = nb_input_files;
650 st->discard = AVDISCARD_ALL;
652 ist->min_pts = INT64_MAX;
653 ist->max_pts = INT64_MIN;
656 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
659 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
661 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
663 uint32_t tag = strtol(codec_tag, &next, 0);
665 tag = AV_RL32(codec_tag);
666 st->codec->codec_tag = tag;
669 ist->dec = choose_decoder(o, ic, st);
670 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
672 ist->reinit_filters = -1;
673 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
675 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
676 ist->user_set_discard = AVDISCARD_NONE;
677 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
678 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
683 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
685 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
687 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
691 ret = avcodec_copy_context(ist->dec_ctx, dec);
693 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
697 switch (dec->codec_type) {
698 case AVMEDIA_TYPE_VIDEO:
700 ist->dec = avcodec_find_decoder(dec->codec_id);
702 if (av_codec_get_lowres(dec)) {
703 dec->flags |= CODEC_FLAG_EMU_EDGE;
707 ist->resample_height = ist->dec_ctx->height;
708 ist->resample_width = ist->dec_ctx->width;
709 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
711 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
712 if (framerate && av_parse_video_rate(&ist->framerate,
714 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
719 ist->top_field_first = -1;
720 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
722 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
724 if (!strcmp(hwaccel, "none"))
725 ist->hwaccel_id = HWACCEL_NONE;
726 else if (!strcmp(hwaccel, "auto"))
727 ist->hwaccel_id = HWACCEL_AUTO;
730 for (i = 0; hwaccels[i].name; i++) {
731 if (!strcmp(hwaccels[i].name, hwaccel)) {
732 ist->hwaccel_id = hwaccels[i].id;
737 if (!ist->hwaccel_id) {
738 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
740 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
741 for (i = 0; hwaccels[i].name; i++)
742 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
743 av_log(NULL, AV_LOG_FATAL, "\n");
749 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
750 if (hwaccel_device) {
751 ist->hwaccel_device = av_strdup(hwaccel_device);
752 if (!ist->hwaccel_device)
755 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
758 case AVMEDIA_TYPE_AUDIO:
759 ist->guess_layout_max = INT_MAX;
760 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
761 guess_input_channel_layout(ist);
763 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
764 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
765 ist->resample_channels = ist->dec_ctx->channels;
766 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
769 case AVMEDIA_TYPE_DATA:
770 case AVMEDIA_TYPE_SUBTITLE: {
771 char *canvas_size = NULL;
773 ist->dec = avcodec_find_decoder(dec->codec_id);
774 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
775 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
777 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
778 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
783 case AVMEDIA_TYPE_ATTACHMENT:
784 case AVMEDIA_TYPE_UNKNOWN:
792 static void assert_file_overwrite(const char *filename)
794 if (file_overwrite && no_file_overwrite) {
795 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
799 if (!file_overwrite) {
800 const char *proto_name = avio_find_protocol_name(filename);
801 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
802 if (stdin_interaction && !no_file_overwrite) {
803 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
806 signal(SIGINT, SIG_DFL);
808 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
814 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
821 static void dump_attachment(AVStream *st, const char *filename)
824 AVIOContext *out = NULL;
825 AVDictionaryEntry *e;
827 if (!st->codec->extradata_size) {
828 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
829 nb_input_files - 1, st->index);
832 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
835 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
836 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
840 assert_file_overwrite(filename);
842 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
843 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
848 avio_write(out, st->codec->extradata, st->codec->extradata_size);
853 static int open_input_file(OptionsContext *o, const char *filename)
857 AVInputFormat *file_iformat = NULL;
861 AVDictionary *unused_opts = NULL;
862 AVDictionaryEntry *e = NULL;
863 int orig_nb_streams; // number of streams before avformat_find_stream_info
864 char * video_codec_name = NULL;
865 char * audio_codec_name = NULL;
866 char *subtitle_codec_name = NULL;
867 char * data_codec_name = NULL;
868 int scan_all_pmts_set = 0;
871 if (!(file_iformat = av_find_input_format(o->format))) {
872 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
877 if (!strcmp(filename, "-"))
880 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
881 strcmp(filename, "/dev/stdin");
883 /* get default parameters from command line */
884 ic = avformat_alloc_context();
886 print_error(filename, AVERROR(ENOMEM));
889 if (o->nb_audio_sample_rate) {
890 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
892 if (o->nb_audio_channels) {
893 /* because we set audio_channels based on both the "ac" and
894 * "channel_layout" options, we need to check that the specified
895 * demuxer actually has the "channels" option before setting it */
896 if (file_iformat && file_iformat->priv_class &&
897 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
898 AV_OPT_SEARCH_FAKE_OBJ)) {
899 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
902 if (o->nb_frame_rates) {
903 /* set the format-level framerate option;
904 * this is important for video grabbers, e.g. x11 */
905 if (file_iformat && file_iformat->priv_class &&
906 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
907 AV_OPT_SEARCH_FAKE_OBJ)) {
908 av_dict_set(&o->g->format_opts, "framerate",
909 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
912 if (o->nb_frame_sizes) {
913 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
915 if (o->nb_frame_pix_fmts)
916 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
918 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
919 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
920 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
921 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
923 ic->video_codec_id = video_codec_name ?
924 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
925 ic->audio_codec_id = audio_codec_name ?
926 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
927 ic->subtitle_codec_id= subtitle_codec_name ?
928 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
929 ic->data_codec_id = data_codec_name ?
930 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
932 if (video_codec_name)
933 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
934 if (audio_codec_name)
935 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
936 if (subtitle_codec_name)
937 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
939 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
941 ic->flags |= AVFMT_FLAG_NONBLOCK;
942 ic->interrupt_callback = int_cb;
944 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
945 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
946 scan_all_pmts_set = 1;
948 /* open the input file with generic avformat function */
949 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
951 print_error(filename, err);
954 if (scan_all_pmts_set)
955 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
956 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
957 assert_avoptions(o->g->format_opts);
959 /* apply forced codec ids */
960 for (i = 0; i < ic->nb_streams; i++)
961 choose_decoder(o, ic, ic->streams[i]);
963 /* Set AVCodecContext options for avformat_find_stream_info */
964 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
965 orig_nb_streams = ic->nb_streams;
967 /* If not enough info to get the stream parameters, we decode the
968 first frames to get it. (used in mpeg case for example) */
969 ret = avformat_find_stream_info(ic, opts);
971 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
972 if (ic->nb_streams == 0) {
973 avformat_close_input(&ic);
978 if (o->start_time_eof != AV_NOPTS_VALUE) {
979 if (ic->duration>0) {
980 o->start_time = o->start_time_eof + ic->duration;
982 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
984 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
985 /* add the stream start time */
986 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
987 timestamp += ic->start_time;
989 /* if seeking requested, we execute it */
990 if (o->start_time != AV_NOPTS_VALUE) {
991 int64_t seek_timestamp = timestamp;
993 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
994 int dts_heuristic = 0;
995 for (i=0; i<ic->nb_streams; i++) {
996 AVCodecContext *avctx = ic->streams[i]->codec;
997 if (avctx->has_b_frames)
1000 if (dts_heuristic) {
1001 seek_timestamp -= 3*AV_TIME_BASE / 23;
1004 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1006 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1007 filename, (double)timestamp / AV_TIME_BASE);
1011 /* update the current parameters so that they match the one of the input stream */
1012 add_input_streams(o, ic);
1014 /* dump the file content */
1015 av_dump_format(ic, nb_input_files, filename, 0);
1017 GROW_ARRAY(input_files, nb_input_files);
1018 f = av_mallocz(sizeof(*f));
1021 input_files[nb_input_files - 1] = f;
1024 f->ist_index = nb_input_streams - ic->nb_streams;
1025 f->start_time = o->start_time;
1026 f->recording_time = o->recording_time;
1027 f->input_ts_offset = o->input_ts_offset;
1028 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1029 f->nb_streams = ic->nb_streams;
1030 f->rate_emu = o->rate_emu;
1031 f->accurate_seek = o->accurate_seek;
1034 f->time_base = (AVRational){ 1, 1 };
1036 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1039 /* check if all codec options have been used */
1040 unused_opts = strip_specifiers(o->g->codec_opts);
1041 for (i = f->ist_index; i < nb_input_streams; i++) {
1043 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1044 AV_DICT_IGNORE_SUFFIX)))
1045 av_dict_set(&unused_opts, e->key, NULL, 0);
1049 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1050 const AVClass *class = avcodec_get_class();
1051 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1052 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1053 const AVClass *fclass = avformat_get_class();
1054 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1055 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1056 if (!option || foption)
1060 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1061 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1062 "input file #%d (%s) is not a decoding option.\n", e->key,
1063 option->help ? option->help : "", nb_input_files - 1,
1068 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1069 "input file #%d (%s) has not been used for any stream. The most "
1070 "likely reason is either wrong type (e.g. a video option with "
1071 "no video streams) or that it is a private option of some decoder "
1072 "which was not actually used for any stream.\n", e->key,
1073 option->help ? option->help : "", nb_input_files - 1, filename);
1075 av_dict_free(&unused_opts);
1077 for (i = 0; i < o->nb_dump_attachment; i++) {
1080 for (j = 0; j < ic->nb_streams; j++) {
1081 AVStream *st = ic->streams[j];
1083 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1084 dump_attachment(st, o->dump_attachment[i].u.str);
1088 for (i = 0; i < orig_nb_streams; i++)
1089 av_dict_free(&opts[i]);
1092 input_stream_potentially_available = 1;
1097 static uint8_t *get_line(AVIOContext *s)
1103 if (avio_open_dyn_buf(&line) < 0) {
1104 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1108 while ((c = avio_r8(s)) && c != '\n')
1111 avio_close_dyn_buf(line, &buf);
1116 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1119 char filename[1000];
1120 const char *base[3] = { getenv("AVCONV_DATADIR"),
1125 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1129 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1130 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1131 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1134 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1135 i != 1 ? "" : "/.avconv", preset_name);
1136 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1142 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1144 char *codec_name = NULL;
1146 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1148 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1149 NULL, ost->st->codec->codec_type);
1150 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1151 } else if (!strcmp(codec_name, "copy"))
1152 ost->stream_copy = 1;
1154 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1155 ost->st->codec->codec_id = ost->enc->id;
1159 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1162 AVStream *st = avformat_new_stream(oc, NULL);
1163 int idx = oc->nb_streams - 1, ret = 0;
1164 char *bsf = NULL, *next, *codec_tag = NULL;
1165 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1170 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1174 if (oc->nb_streams - 1 < o->nb_streamid_map)
1175 st->id = o->streamid_map[oc->nb_streams - 1];
1177 GROW_ARRAY(output_streams, nb_output_streams);
1178 if (!(ost = av_mallocz(sizeof(*ost))))
1180 output_streams[nb_output_streams - 1] = ost;
1182 ost->file_index = nb_output_files - 1;
1185 st->codec->codec_type = type;
1186 choose_encoder(o, oc, ost);
1188 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1189 if (!ost->enc_ctx) {
1190 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1193 ost->enc_ctx->codec_type = type;
1196 AVIOContext *s = NULL;
1197 char *buf = NULL, *arg = NULL, *preset = NULL;
1199 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1201 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1202 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1205 if (!buf[0] || buf[0] == '#') {
1209 if (!(arg = strchr(buf, '='))) {
1210 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1214 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1216 } while (!s->eof_reached);
1220 av_log(NULL, AV_LOG_FATAL,
1221 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1222 preset, ost->file_index, ost->index);
1226 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1229 ost->max_frames = INT64_MAX;
1230 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1231 for (i = 0; i<o->nb_max_frames; i++) {
1232 char *p = o->max_frames[i].specifier;
1233 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1234 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1239 ost->copy_prior_start = -1;
1240 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1242 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1245 if (next = strchr(bsf, ','))
1247 if (arg = strchr(bsf, '='))
1249 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1250 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1254 bsfc_prev->next = bsfc;
1256 ost->bitstream_filters = bsfc;
1258 if (!(bsfc->args = av_strdup(arg))) {
1259 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1267 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1269 uint32_t tag = strtol(codec_tag, &next, 0);
1271 tag = AV_RL32(codec_tag);
1272 ost->st->codec->codec_tag =
1273 ost->enc_ctx->codec_tag = tag;
1276 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1278 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1279 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1282 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1283 ost->disposition = av_strdup(ost->disposition);
1285 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1286 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1288 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1290 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1291 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1292 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1294 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1296 ost->source_index = source_index;
1297 if (source_index >= 0) {
1298 ost->sync_ist = input_streams[source_index];
1299 input_streams[source_index]->discard = 0;
1300 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1302 ost->last_mux_dts = AV_NOPTS_VALUE;
1307 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1310 const char *p = str;
1317 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1324 /* read file contents into a string */
1325 static uint8_t *read_file(const char *filename)
1327 AVIOContext *pb = NULL;
1328 AVIOContext *dyn_buf = NULL;
1329 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1330 uint8_t buf[1024], *str;
1333 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1337 ret = avio_open_dyn_buf(&dyn_buf);
1342 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1343 avio_write(dyn_buf, buf, ret);
1344 avio_w8(dyn_buf, 0);
1347 ret = avio_close_dyn_buf(dyn_buf, &str);
1353 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1356 AVStream *st = ost->st;
1358 if (ost->filters_script && ost->filters) {
1359 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1360 "output stream #%d:%d.\n", nb_output_files, st->index);
1364 if (ost->filters_script)
1365 return read_file(ost->filters_script);
1366 else if (ost->filters)
1367 return av_strdup(ost->filters);
1369 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1373 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1374 const OutputStream *ost, enum AVMediaType type)
1376 if (ost->filters_script || ost->filters) {
1377 av_log(NULL, AV_LOG_ERROR,
1378 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1379 "Filtering and streamcopy cannot be used together.\n",
1380 ost->filters ? "Filtergraph" : "Filtergraph script",
1381 ost->filters ? ost->filters : ost->filters_script,
1382 av_get_media_type_string(type), ost->file_index, ost->index);
1387 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1391 AVCodecContext *video_enc;
1392 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1394 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1396 video_enc = ost->enc_ctx;
1398 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1399 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1400 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1403 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1404 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1406 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1407 if (frame_aspect_ratio) {
1409 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1410 q.num <= 0 || q.den <= 0) {
1411 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1414 ost->frame_aspect_ratio = q;
1417 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1418 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1420 if (!ost->stream_copy) {
1421 const char *p = NULL;
1422 char *frame_size = NULL;
1423 char *frame_pix_fmt = NULL;
1424 char *intra_matrix = NULL, *inter_matrix = NULL;
1425 char *chroma_intra_matrix = NULL;
1429 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1430 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1431 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1435 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1436 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1437 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1438 ost->keep_pix_fmt = 1;
1439 if (!*++frame_pix_fmt)
1440 frame_pix_fmt = NULL;
1442 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1443 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1446 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1449 video_enc->gop_size = 0;
1450 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1452 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1453 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1456 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1458 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1459 if (chroma_intra_matrix) {
1460 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1462 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1465 av_codec_set_chroma_intra_matrix(video_enc, p);
1466 parse_matrix_coeffs(p, chroma_intra_matrix);
1468 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1470 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1471 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1474 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1477 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1478 for (i = 0; p; i++) {
1480 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1482 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1485 video_enc->rc_override =
1486 av_realloc_array(video_enc->rc_override,
1487 i + 1, sizeof(RcOverride));
1488 if (!video_enc->rc_override) {
1489 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1492 video_enc->rc_override[i].start_frame = start;
1493 video_enc->rc_override[i].end_frame = end;
1495 video_enc->rc_override[i].qscale = q;
1496 video_enc->rc_override[i].quality_factor = 1.0;
1499 video_enc->rc_override[i].qscale = 0;
1500 video_enc->rc_override[i].quality_factor = -q/100.0;
1505 video_enc->rc_override_count = i;
1508 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1511 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1514 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1515 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1518 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1519 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1523 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1524 if (ost->logfile_prefix &&
1525 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1529 char logfilename[1024];
1532 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1533 ost->logfile_prefix ? ost->logfile_prefix :
1534 DEFAULT_PASS_LOGFILENAME_PREFIX,
1536 if (!strcmp(ost->enc->name, "libx264")) {
1537 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1539 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1540 char *logbuffer = read_file(logfilename);
1543 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1547 video_enc->stats_in = logbuffer;
1549 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1550 f = av_fopen_utf8(logfilename, "wb");
1552 av_log(NULL, AV_LOG_FATAL,
1553 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1554 logfilename, strerror(errno));
1562 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1563 if (ost->forced_keyframes)
1564 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1566 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1568 ost->top_field_first = -1;
1569 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1572 ost->avfilter = get_ost_filters(o, oc, ost);
1576 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1579 if (ost->stream_copy)
1580 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1585 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1590 AVCodecContext *audio_enc;
1592 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1595 audio_enc = ost->enc_ctx;
1596 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1598 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1599 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1601 if (!ost->stream_copy) {
1602 char *sample_fmt = NULL;
1604 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1606 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1608 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1609 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1613 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1615 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1616 ost->apad = av_strdup(ost->apad);
1618 ost->avfilter = get_ost_filters(o, oc, ost);
1622 /* check for channel mapping for this audio stream */
1623 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1624 AudioChannelMap *map = &o->audio_channel_maps[n];
1625 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1626 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1629 if (map->channel_idx == -1) {
1631 } else if (ost->source_index < 0) {
1632 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1633 ost->file_index, ost->st->index);
1636 ist = input_streams[ost->source_index];
1639 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1640 if (av_reallocp_array(&ost->audio_channels_map,
1641 ost->audio_channels_mapped + 1,
1642 sizeof(*ost->audio_channels_map)
1646 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1652 if (ost->stream_copy)
1653 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1658 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1662 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1663 if (!ost->stream_copy) {
1664 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1671 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1675 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1676 if (!ost->stream_copy) {
1677 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1684 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1686 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1687 ost->stream_copy = 1;
1692 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1696 AVCodecContext *subtitle_enc;
1698 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1700 subtitle_enc = ost->enc_ctx;
1702 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1704 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1706 if (!ost->stream_copy) {
1707 char *frame_size = NULL;
1709 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1710 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1711 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1719 /* arg format is "output-stream-index:streamid-value". */
1720 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1722 OptionsContext *o = optctx;
1727 av_strlcpy(idx_str, arg, sizeof(idx_str));
1728 p = strchr(idx_str, ':');
1730 av_log(NULL, AV_LOG_FATAL,
1731 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1736 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1737 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1738 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1742 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1744 AVFormatContext *is = ifile->ctx;
1745 AVFormatContext *os = ofile->ctx;
1749 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1751 return AVERROR(ENOMEM);
1754 for (i = 0; i < is->nb_chapters; i++) {
1755 AVChapter *in_ch = is->chapters[i], *out_ch;
1756 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1757 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1758 AV_TIME_BASE_Q, in_ch->time_base);
1759 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1760 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1763 if (in_ch->end < ts_off)
1765 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1768 out_ch = av_mallocz(sizeof(AVChapter));
1770 return AVERROR(ENOMEM);
1772 out_ch->id = in_ch->id;
1773 out_ch->time_base = in_ch->time_base;
1774 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1775 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1778 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1780 os->chapters[os->nb_chapters++] = out_ch;
1785 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1788 AVFormatContext *ic = avformat_alloc_context();
1790 ic->interrupt_callback = int_cb;
1791 err = avformat_open_input(&ic, filename, NULL, NULL);
1794 /* copy stream format */
1795 for(i=0;i<ic->nb_streams;i++) {
1799 const char *enc_config;
1801 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1803 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1804 return AVERROR(EINVAL);
1806 if (codec->type == AVMEDIA_TYPE_AUDIO)
1807 opt_audio_codec(o, "c:a", codec->name);
1808 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1809 opt_video_codec(o, "c:v", codec->name);
1810 ost = new_output_stream(o, s, codec->type, -1);
1813 avcodec_get_context_defaults3(st->codec, codec);
1814 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1816 AVDictionary *opts = NULL;
1817 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1818 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1819 av_dict_free(&opts);
1822 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1823 choose_sample_fmt(st, codec);
1824 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1825 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1826 avcodec_copy_context(ost->enc_ctx, st->codec);
1828 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1831 avformat_close_input(&ic);
1835 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1836 AVFormatContext *oc)
1840 switch (ofilter->type) {
1841 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1842 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1844 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1849 ost->source_index = -1;
1850 ost->filter = ofilter;
1854 if (ost->stream_copy) {
1855 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1856 "which is fed from a complex filtergraph. Filtering and streamcopy "
1857 "cannot be used together.\n", ost->file_index, ost->index);
1861 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1862 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1863 av_log(NULL, AV_LOG_ERROR,
1864 "%s '%s' was specified through the %s option "
1865 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1866 "%s and -filter_complex cannot be used together for the same stream.\n",
1867 ost->filters ? "Filtergraph" : "Filtergraph script",
1868 ost->filters ? ost->filters : ost->filters_script,
1869 opt, ost->file_index, ost->index, opt);
1873 avfilter_inout_free(&ofilter->out_tmp);
1876 static int init_complex_filters(void)
1880 for (i = 0; i < nb_filtergraphs; i++) {
1881 ret = init_complex_filtergraph(filtergraphs[i]);
1888 static int configure_complex_filters(void)
1892 for (i = 0; i < nb_filtergraphs; i++)
1893 if (!filtergraphs[i]->graph &&
1894 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1899 static int open_output_file(OptionsContext *o, const char *filename)
1901 AVFormatContext *oc;
1903 AVOutputFormat *file_oformat;
1907 AVDictionary *unused_opts = NULL;
1908 AVDictionaryEntry *e = NULL;
1911 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1912 o->stop_time = INT64_MAX;
1913 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1916 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1917 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1918 if (o->stop_time <= start_time) {
1919 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1922 o->recording_time = o->stop_time - start_time;
1926 GROW_ARRAY(output_files, nb_output_files);
1927 of = av_mallocz(sizeof(*of));
1930 output_files[nb_output_files - 1] = of;
1932 of->ost_index = nb_output_streams;
1933 of->recording_time = o->recording_time;
1934 of->start_time = o->start_time;
1935 of->limit_filesize = o->limit_filesize;
1936 of->shortest = o->shortest;
1937 av_dict_copy(&of->opts, o->g->format_opts, 0);
1939 if (!strcmp(filename, "-"))
1942 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1944 print_error(filename, err);
1949 if (o->recording_time != INT64_MAX)
1950 oc->duration = o->recording_time;
1952 file_oformat= oc->oformat;
1953 oc->interrupt_callback = int_cb;
1955 /* create streams for all unlabeled output pads */
1956 for (i = 0; i < nb_filtergraphs; i++) {
1957 FilterGraph *fg = filtergraphs[i];
1958 for (j = 0; j < fg->nb_outputs; j++) {
1959 OutputFilter *ofilter = fg->outputs[j];
1961 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1964 switch (ofilter->type) {
1965 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1966 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1967 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1969 init_output_filter(ofilter, o, oc);
1973 /* ffserver seeking with date=... needs a date reference */
1974 if (!strcmp(file_oformat->name, "ffm") &&
1975 av_strstart(filename, "http:", NULL)) {
1976 int err = parse_option(o, "metadata", "creation_time=now", options);
1978 print_error(filename, err);
1983 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1984 av_strstart(filename, "http:", NULL)) {
1986 /* special case for files sent to ffserver: we get the stream
1987 parameters from ffserver */
1988 int err = read_ffserver_streams(o, oc, filename);
1990 print_error(filename, err);
1993 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1994 ost = output_streams[j];
1995 for (i = 0; i < nb_input_streams; i++) {
1996 ist = input_streams[i];
1997 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1999 ost->source_index= i;
2000 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2001 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2003 ist->st->discard = ist->user_set_discard;
2008 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));
2012 } else if (!o->nb_stream_maps) {
2013 char *subtitle_codec_name = NULL;
2014 /* pick the "best" stream of each type */
2016 /* video: highest resolution */
2017 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2018 int area = 0, idx = -1;
2019 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2020 for (i = 0; i < nb_input_streams; i++) {
2022 ist = input_streams[i];
2023 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
2024 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2026 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2028 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2035 new_video_stream(o, oc, idx);
2038 /* audio: most channels */
2039 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2040 int best_score = 0, idx = -1;
2041 for (i = 0; i < nb_input_streams; i++) {
2043 ist = input_streams[i];
2044 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2045 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2046 score > best_score) {
2052 new_audio_stream(o, oc, idx);
2055 /* subtitles: pick first */
2056 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2057 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2058 for (i = 0; i < nb_input_streams; i++)
2059 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2060 AVCodecDescriptor const *input_descriptor =
2061 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2062 AVCodecDescriptor const *output_descriptor = NULL;
2063 AVCodec const *output_codec =
2064 avcodec_find_encoder(oc->oformat->subtitle_codec);
2065 int input_props = 0, output_props = 0;
2067 output_descriptor = avcodec_descriptor_get(output_codec->id);
2068 if (input_descriptor)
2069 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2070 if (output_descriptor)
2071 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2072 if (subtitle_codec_name ||
2073 input_props & output_props ||
2074 // Map dvb teletext which has neither property to any output subtitle encoder
2075 input_descriptor && output_descriptor &&
2076 (!input_descriptor->props ||
2077 !output_descriptor->props)) {
2078 new_subtitle_stream(o, oc, i);
2083 /* Data only if codec id match */
2084 if (!o->data_disable ) {
2085 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2086 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2087 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2088 && input_streams[i]->st->codec->codec_id == codec_id )
2089 new_data_stream(o, oc, i);
2093 for (i = 0; i < o->nb_stream_maps; i++) {
2094 StreamMap *map = &o->stream_maps[i];
2099 if (map->linklabel) {
2101 OutputFilter *ofilter = NULL;
2104 for (j = 0; j < nb_filtergraphs; j++) {
2105 fg = filtergraphs[j];
2106 for (k = 0; k < fg->nb_outputs; k++) {
2107 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2108 if (out && !strcmp(out->name, map->linklabel)) {
2109 ofilter = fg->outputs[k];
2116 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2117 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2120 init_output_filter(ofilter, o, oc);
2122 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2124 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2125 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2127 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2129 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2131 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2135 switch (ist->st->codec->codec_type) {
2136 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2137 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2138 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2139 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2140 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2141 case AVMEDIA_TYPE_UNKNOWN:
2142 if (copy_unknown_streams) {
2143 ost = new_unknown_stream (o, oc, src_idx);
2147 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2148 "Cannot map stream #%d:%d - unsupported type.\n",
2149 map->file_index, map->stream_index);
2150 if (!ignore_unknown_streams) {
2151 av_log(NULL, AV_LOG_FATAL,
2152 "If you want unsupported types ignored instead "
2153 "of failing, please use the -ignore_unknown option\n"
2154 "If you want them copied, please use -copy_unknown\n");
2159 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2160 + map->sync_stream_index];
2165 /* handle attached files */
2166 for (i = 0; i < o->nb_attachments; i++) {
2168 uint8_t *attachment;
2172 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2173 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2177 if ((len = avio_size(pb)) <= 0) {
2178 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2182 if (!(attachment = av_malloc(len))) {
2183 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2187 avio_read(pb, attachment, len);
2189 ost = new_attachment_stream(o, oc, -1);
2190 ost->stream_copy = 1;
2191 ost->attachment_filename = o->attachments[i];
2193 ost->st->codec->extradata = attachment;
2194 ost->st->codec->extradata_size = len;
2196 p = strrchr(o->attachments[i], '/');
2197 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2201 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2202 AVDictionaryEntry *e;
2203 ost = output_streams[i];
2205 if ((ost->stream_copy || ost->attachment_filename)
2206 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2207 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2208 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2212 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2213 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2214 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2218 /* check if all codec options have been used */
2219 unused_opts = strip_specifiers(o->g->codec_opts);
2220 for (i = of->ost_index; i < nb_output_streams; i++) {
2222 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2223 AV_DICT_IGNORE_SUFFIX)))
2224 av_dict_set(&unused_opts, e->key, NULL, 0);
2228 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2229 const AVClass *class = avcodec_get_class();
2230 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2231 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2232 const AVClass *fclass = avformat_get_class();
2233 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2234 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2235 if (!option || foption)
2239 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2240 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2241 "output file #%d (%s) is not an encoding option.\n", e->key,
2242 option->help ? option->help : "", nb_output_files - 1,
2247 // gop_timecode is injected by generic code but not always used
2248 if (!strcmp(e->key, "gop_timecode"))
2251 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2252 "output file #%d (%s) has not been used for any stream. The most "
2253 "likely reason is either wrong type (e.g. a video option with "
2254 "no video streams) or that it is a private option of some encoder "
2255 "which was not actually used for any stream.\n", e->key,
2256 option->help ? option->help : "", nb_output_files - 1, filename);
2258 av_dict_free(&unused_opts);
2260 /* set the encoding/decoding_needed flags */
2261 for (i = of->ost_index; i < nb_output_streams; i++) {
2262 OutputStream *ost = output_streams[i];
2264 ost->encoding_needed = !ost->stream_copy;
2265 if (ost->encoding_needed && ost->source_index >= 0) {
2266 InputStream *ist = input_streams[ost->source_index];
2267 ist->decoding_needed |= DECODING_FOR_OST;
2271 /* check filename in case of an image number is expected */
2272 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2273 if (!av_filename_number_test(oc->filename)) {
2274 print_error(oc->filename, AVERROR(EINVAL));
2279 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2280 av_log(NULL, AV_LOG_ERROR,
2281 "No input streams but output needs an input stream\n");
2285 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2286 /* test if it already exists to avoid losing precious files */
2287 assert_file_overwrite(filename);
2290 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2291 &oc->interrupt_callback,
2293 print_error(filename, err);
2296 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2297 assert_file_overwrite(filename);
2299 if (o->mux_preload) {
2300 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2302 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2305 for (i = 0; i < o->nb_metadata_map; i++) {
2307 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2309 if (in_file_index >= nb_input_files) {
2310 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2313 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2314 in_file_index >= 0 ?
2315 input_files[in_file_index]->ctx : NULL, o);
2319 if (o->chapters_input_file >= nb_input_files) {
2320 if (o->chapters_input_file == INT_MAX) {
2321 /* copy chapters from the first input file that has them*/
2322 o->chapters_input_file = -1;
2323 for (i = 0; i < nb_input_files; i++)
2324 if (input_files[i]->ctx->nb_chapters) {
2325 o->chapters_input_file = i;
2329 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2330 o->chapters_input_file);
2334 if (o->chapters_input_file >= 0)
2335 copy_chapters(input_files[o->chapters_input_file], of,
2336 !o->metadata_chapters_manual);
2338 /* copy global metadata by default */
2339 if (!o->metadata_global_manual && nb_input_files){
2340 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2341 AV_DICT_DONT_OVERWRITE);
2342 if(o->recording_time != INT64_MAX)
2343 av_dict_set(&oc->metadata, "duration", NULL, 0);
2344 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2346 if (!o->metadata_streams_manual)
2347 for (i = of->ost_index; i < nb_output_streams; i++) {
2349 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2351 ist = input_streams[output_streams[i]->source_index];
2352 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2353 if (!output_streams[i]->stream_copy) {
2354 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2355 if (ist->autorotate)
2356 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2360 /* process manually set programs */
2361 for (i = 0; i < o->nb_program; i++) {
2362 const char *p = o->program[i].u.str;
2367 const char *p2 = av_get_token(&p, ":");
2368 const char *to_dealloc = p2;
2375 key = av_get_token(&p2, "=");
2377 av_freep(&to_dealloc);
2383 if (!strcmp(key, "program_num"))
2384 progid = strtol(p2, NULL, 0);
2385 av_freep(&to_dealloc);
2389 program = av_new_program(oc, progid);
2391 p = o->program[i].u.str;
2393 const char *p2 = av_get_token(&p, ":");
2394 const char *to_dealloc = p2;
2400 key = av_get_token(&p2, "=");
2402 av_log(NULL, AV_LOG_FATAL,
2403 "No '=' character in program string %s.\n",
2411 if (!strcmp(key, "title")) {
2412 av_dict_set(&program->metadata, "title", p2, 0);
2413 } else if (!strcmp(key, "program_num")) {
2414 } else if (!strcmp(key, "st")) {
2415 int st_num = strtol(p2, NULL, 0);
2416 av_program_add_stream_index(oc, progid, st_num);
2418 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2421 av_freep(&to_dealloc);
2426 /* process manually set metadata */
2427 for (i = 0; i < o->nb_metadata; i++) {
2430 const char *stream_spec;
2431 int index = 0, j, ret = 0;
2433 val = strchr(o->metadata[i].u.str, '=');
2435 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2436 o->metadata[i].u.str);
2441 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2443 for (j = 0; j < oc->nb_streams; j++) {
2444 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2445 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2446 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2447 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2448 ost->rotate_overridden = 1;
2460 if (index < 0 || index >= oc->nb_chapters) {
2461 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2464 m = &oc->chapters[index]->metadata;
2467 if (index < 0 || index >= oc->nb_programs) {
2468 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2471 m = &oc->programs[index]->metadata;
2474 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2477 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2484 static int opt_target(void *optctx, const char *opt, const char *arg)
2486 OptionsContext *o = optctx;
2487 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2488 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2490 if (!strncmp(arg, "pal-", 4)) {
2493 } else if (!strncmp(arg, "ntsc-", 5)) {
2496 } else if (!strncmp(arg, "film-", 5)) {
2500 /* Try to determine PAL/NTSC by peeking in the input files */
2501 if (nb_input_files) {
2503 for (j = 0; j < nb_input_files; j++) {
2504 for (i = 0; i < input_files[j]->nb_streams; i++) {
2505 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2506 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2509 fr = c->time_base.den * 1000 / c->time_base.num;
2513 } else if ((fr == 29970) || (fr == 23976)) {
2518 if (norm != UNKNOWN)
2522 if (norm != UNKNOWN)
2523 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2526 if (norm == UNKNOWN) {
2527 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2528 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2529 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2533 if (!strcmp(arg, "vcd")) {
2534 opt_video_codec(o, "c:v", "mpeg1video");
2535 opt_audio_codec(o, "c:a", "mp2");
2536 parse_option(o, "f", "vcd", options);
2538 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2539 parse_option(o, "r", frame_rates[norm], options);
2540 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2542 opt_default(NULL, "b:v", "1150000");
2543 opt_default(NULL, "maxrate:v", "1150000");
2544 opt_default(NULL, "minrate:v", "1150000");
2545 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2547 opt_default(NULL, "b:a", "224000");
2548 parse_option(o, "ar", "44100", options);
2549 parse_option(o, "ac", "2", options);
2551 opt_default(NULL, "packetsize", "2324");
2552 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2554 /* We have to offset the PTS, so that it is consistent with the SCR.
2555 SCR starts at 36000, but the first two packs contain only padding
2556 and the first pack from the other stream, respectively, may also have
2557 been written before.
2558 So the real data starts at SCR 36000+3*1200. */
2559 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2560 } else if (!strcmp(arg, "svcd")) {
2562 opt_video_codec(o, "c:v", "mpeg2video");
2563 opt_audio_codec(o, "c:a", "mp2");
2564 parse_option(o, "f", "svcd", options);
2566 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2567 parse_option(o, "r", frame_rates[norm], options);
2568 parse_option(o, "pix_fmt", "yuv420p", options);
2569 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2571 opt_default(NULL, "b:v", "2040000");
2572 opt_default(NULL, "maxrate:v", "2516000");
2573 opt_default(NULL, "minrate:v", "0"); // 1145000;
2574 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2575 opt_default(NULL, "scan_offset", "1");
2577 opt_default(NULL, "b:a", "224000");
2578 parse_option(o, "ar", "44100", options);
2580 opt_default(NULL, "packetsize", "2324");
2582 } else if (!strcmp(arg, "dvd")) {
2584 opt_video_codec(o, "c:v", "mpeg2video");
2585 opt_audio_codec(o, "c:a", "ac3");
2586 parse_option(o, "f", "dvd", options);
2588 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2589 parse_option(o, "r", frame_rates[norm], options);
2590 parse_option(o, "pix_fmt", "yuv420p", options);
2591 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2593 opt_default(NULL, "b:v", "6000000");
2594 opt_default(NULL, "maxrate:v", "9000000");
2595 opt_default(NULL, "minrate:v", "0"); // 1500000;
2596 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2598 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2599 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2601 opt_default(NULL, "b:a", "448000");
2602 parse_option(o, "ar", "48000", options);
2604 } else if (!strncmp(arg, "dv", 2)) {
2606 parse_option(o, "f", "dv", options);
2608 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2609 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2610 norm == PAL ? "yuv420p" : "yuv411p", options);
2611 parse_option(o, "r", frame_rates[norm], options);
2613 parse_option(o, "ar", "48000", options);
2614 parse_option(o, "ac", "2", options);
2617 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2618 return AVERROR(EINVAL);
2621 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2622 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2627 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2629 av_free (vstats_filename);
2630 vstats_filename = av_strdup (arg);
2634 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2637 time_t today2 = time(NULL);
2638 struct tm *today = localtime(&today2);
2640 if (!today) { // maybe tomorrow
2641 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2645 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2647 return opt_vstats_file(NULL, opt, filename);
2650 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2652 OptionsContext *o = optctx;
2653 return parse_option(o, "frames:v", arg, options);
2656 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2658 OptionsContext *o = optctx;
2659 return parse_option(o, "frames:a", arg, options);
2662 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2664 OptionsContext *o = optctx;
2665 return parse_option(o, "frames:d", arg, options);
2668 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2671 AVDictionary *cbak = codec_opts;
2672 AVDictionary *fbak = format_opts;
2676 ret = opt_default(NULL, opt, arg);
2678 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2679 av_dict_copy(&o->g->format_opts, format_opts, 0);
2680 av_dict_free(&codec_opts);
2681 av_dict_free(&format_opts);
2688 static int opt_preset(void *optctx, const char *opt, const char *arg)
2690 OptionsContext *o = optctx;
2692 char filename[1000], line[1000], tmp_line[1000];
2693 const char *codec_name = NULL;
2697 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2699 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2700 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2701 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2703 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2707 while (fgets(line, sizeof(line), f)) {
2708 char *key = tmp_line, *value, *endptr;
2710 if (strcspn(line, "#\n\r") == 0)
2712 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2713 if (!av_strtok(key, "=", &value) ||
2714 !av_strtok(value, "\r\n", &endptr)) {
2715 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2718 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2720 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2721 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2722 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2723 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2724 else if (opt_default_new(o, key, value) < 0) {
2725 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2726 filename, line, key, value);
2736 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2738 OptionsContext *o = optctx;
2739 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2740 int ret = parse_option(o, s, arg, options);
2745 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2747 OptionsContext *o = optctx;
2749 if(!strcmp(opt, "ab")){
2750 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2752 } else if(!strcmp(opt, "b")){
2753 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2754 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2757 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2761 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2763 OptionsContext *o = optctx;
2766 if(!strcmp(opt, "qscale")){
2767 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2768 return parse_option(o, "q:v", arg, options);
2770 s = av_asprintf("q%s", opt + 6);
2771 ret = parse_option(o, s, arg, options);
2776 static int opt_profile(void *optctx, const char *opt, const char *arg)
2778 OptionsContext *o = optctx;
2779 if(!strcmp(opt, "profile")){
2780 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2781 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2784 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2788 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2790 OptionsContext *o = optctx;
2791 return parse_option(o, "filter:v", arg, options);
2794 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2796 OptionsContext *o = optctx;
2797 return parse_option(o, "filter:a", arg, options);
2800 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2802 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2803 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2804 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2805 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2807 if (video_sync_method == VSYNC_AUTO)
2808 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2812 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2814 OptionsContext *o = optctx;
2815 char *tcr = av_asprintf("timecode=%s", arg);
2816 int ret = parse_option(o, "metadata:g", tcr, options);
2818 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2823 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2825 OptionsContext *o = optctx;
2826 char layout_str[32];
2829 int ret, channels, ac_str_size;
2832 layout = av_get_channel_layout(arg);
2834 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2835 return AVERROR(EINVAL);
2837 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2838 ret = opt_default_new(o, opt, layout_str);
2842 /* set 'ac' option based on channel layout */
2843 channels = av_get_channel_layout_nb_channels(layout);
2844 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2845 stream_str = strchr(opt, ':');
2846 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2847 ac_str = av_mallocz(ac_str_size);
2849 return AVERROR(ENOMEM);
2850 av_strlcpy(ac_str, "ac", 3);
2852 av_strlcat(ac_str, stream_str, ac_str_size);
2853 ret = parse_option(o, ac_str, layout_str, options);
2859 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2861 OptionsContext *o = optctx;
2862 return parse_option(o, "q:a", arg, options);
2865 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2867 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2868 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2869 return AVERROR(ENOMEM);
2870 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2871 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2872 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2873 return AVERROR(ENOMEM);
2875 input_stream_potentially_available = 1;
2880 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2882 uint8_t *graph_desc = read_file(arg);
2884 return AVERROR(EINVAL);
2886 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2887 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2888 return AVERROR(ENOMEM);
2889 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2890 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2892 input_stream_potentially_available = 1;
2897 void show_help_default(const char *opt, const char *arg)
2899 /* per-file options have at least one of those set */
2900 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2901 int show_advanced = 0, show_avoptions = 0;
2904 if (!strcmp(opt, "long"))
2906 else if (!strcmp(opt, "full"))
2907 show_advanced = show_avoptions = 1;
2909 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2914 printf("Getting help:\n"
2915 " -h -- print basic options\n"
2916 " -h long -- print more options\n"
2917 " -h full -- print all options (including all format and codec specific options, very long)\n"
2918 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2919 " See man %s for detailed description of the options.\n"
2920 "\n", program_name);
2922 show_help_options(options, "Print help / information / capabilities:",
2925 show_help_options(options, "Global options (affect whole program "
2926 "instead of just one file:",
2927 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2929 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2930 per_file | OPT_EXIT, 0);
2932 show_help_options(options, "Per-file main options:", 0,
2933 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2934 OPT_EXIT, per_file);
2936 show_help_options(options, "Advanced per-file options:",
2937 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2939 show_help_options(options, "Video options:",
2940 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2942 show_help_options(options, "Advanced Video options:",
2943 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2945 show_help_options(options, "Audio options:",
2946 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2948 show_help_options(options, "Advanced Audio options:",
2949 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2950 show_help_options(options, "Subtitle options:",
2951 OPT_SUBTITLE, 0, 0);
2954 if (show_avoptions) {
2955 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2956 show_help_children(avcodec_get_class(), flags);
2957 show_help_children(avformat_get_class(), flags);
2959 show_help_children(sws_get_class(), flags);
2961 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2962 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2966 void show_usage(void)
2968 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2969 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2970 av_log(NULL, AV_LOG_INFO, "\n");
2978 static const OptionGroupDef groups[] = {
2979 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2980 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2983 static int open_files(OptionGroupList *l, const char *inout,
2984 int (*open_file)(OptionsContext*, const char*))
2988 for (i = 0; i < l->nb_groups; i++) {
2989 OptionGroup *g = &l->groups[i];
2995 ret = parse_optgroup(&o, g);
2997 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2998 "%s.\n", inout, g->arg);
3002 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3003 ret = open_file(&o, g->arg);
3006 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3010 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3016 int ffmpeg_parse_options(int argc, char **argv)
3018 OptionParseContext octx;
3022 memset(&octx, 0, sizeof(octx));
3024 /* split the commandline into an internal representation */
3025 ret = split_commandline(&octx, argc, argv, options, groups,
3026 FF_ARRAY_ELEMS(groups));
3028 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3032 /* apply global options */
3033 ret = parse_optgroup(NULL, &octx.global_opts);
3035 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3039 /* open input files */
3040 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3042 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3046 /* create the complex filtergraphs */
3047 ret = init_complex_filters();
3049 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3053 /* open output files */
3054 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3056 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3060 /* configure the complex filtergraphs */
3061 ret = configure_complex_filters();
3063 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3068 uninit_parse_context(&octx);
3070 av_strerror(ret, error, sizeof(error));
3071 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3076 static int opt_progress(void *optctx, const char *opt, const char *arg)
3078 AVIOContext *avio = NULL;
3081 if (!strcmp(arg, "-"))
3083 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3085 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3086 arg, av_err2str(ret));
3089 progress_avio = avio;
3093 #define OFFSET(x) offsetof(OptionsContext, x)
3094 const OptionDef options[] = {
3096 #include "cmdutils_common_opts.h"
3097 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3098 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3099 "force format", "fmt" },
3100 { "y", OPT_BOOL, { &file_overwrite },
3101 "overwrite output files" },
3102 { "n", OPT_BOOL, { &no_file_overwrite },
3103 "never overwrite output files" },
3104 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3105 "Ignore unknown stream types" },
3106 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3107 "Copy unknown stream types" },
3108 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3109 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3110 "codec name", "codec" },
3111 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3112 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3113 "codec name", "codec" },
3114 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3115 OPT_OUTPUT, { .off = OFFSET(presets) },
3116 "preset name", "preset" },
3117 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3118 OPT_OUTPUT, { .func_arg = opt_map },
3119 "set input stream mapping",
3120 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3121 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3122 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3123 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3124 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3125 "set metadata information of outfile from infile",
3126 "outfile[,metadata]:infile[,metadata]" },
3127 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3128 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3129 "set chapters mapping", "input_file_index" },
3130 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3131 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3132 "record or transcode \"duration\" seconds of audio/video",
3134 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3135 "record or transcode stop time", "time_stop" },
3136 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3137 "set the limit file size in bytes", "limit_size" },
3138 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3139 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3140 "set the start time offset", "time_off" },
3141 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3142 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3143 "set the start time offset relative to EOF", "time_off" },
3144 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3145 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3146 "enable/disable seeking by timestamp with -ss" },
3147 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3148 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3149 "enable/disable accurate seeking with -ss" },
3150 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3151 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3152 "set the input ts offset", "time_off" },
3153 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3154 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3155 "set the input ts scale", "scale" },
3156 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3157 "set the recording timestamp ('now' to set the current time)", "time" },
3158 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3159 "add metadata", "string=string" },
3160 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3161 "add program with specified streams", "title=string:st=number..." },
3162 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3163 OPT_OUTPUT, { .func_arg = opt_data_frames },
3164 "set the number of data frames to output", "number" },
3165 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3166 "add timings for benchmarking" },
3167 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3168 "add timings for each task" },
3169 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3170 "write program-readable progress information", "url" },
3171 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3172 "enable or disable interaction on standard input" },
3173 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3174 "set max runtime in seconds", "limit" },
3175 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3176 "dump each input packet" },
3177 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3178 "when dumping packets, also dump the payload" },
3179 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3180 OPT_INPUT, { .off = OFFSET(rate_emu) },
3181 "read input at native frame rate", "" },
3182 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3183 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3184 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3185 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3186 "video sync method", "" },
3187 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3188 "frame drop threshold", "" },
3189 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3190 "audio sync method", "" },
3191 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3192 "audio drift threshold", "threshold" },
3193 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3194 "copy timestamps" },
3195 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3196 "shift input timestamps to start at 0 when using copyts" },
3197 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3198 "copy input stream time base when stream copying", "mode" },
3199 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3200 OPT_OUTPUT, { .off = OFFSET(shortest) },
3201 "finish encoding within shortest input" },
3202 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3203 OPT_OUTPUT, { .off = OFFSET(apad) },
3205 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3206 "timestamp discontinuity delta threshold", "threshold" },
3207 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3208 "timestamp error delta threshold", "threshold" },
3209 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3210 "exit on error", "error" },
3211 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3212 "abort on the specified condition flags", "flags" },
3213 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3214 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3215 "copy initial non-keyframes" },
3216 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3217 "copy or discard frames before start time" },
3218 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3219 "set the number of frames to output", "number" },
3220 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3221 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3222 "force codec tag/fourcc", "fourcc/tag" },
3223 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3224 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3225 "use fixed quality scale (VBR)", "q" },
3226 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3227 OPT_OUTPUT, { .func_arg = opt_qscale },
3228 "use fixed quality scale (VBR)", "q" },
3229 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3230 "set profile", "profile" },
3231 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3232 "set stream filtergraph", "filter_graph" },
3233 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3234 "read stream filtergraph description from a file", "filename" },
3235 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3236 "reinit filtergraph on input parameter changes", "" },
3237 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3238 "create a complex filtergraph", "graph_description" },
3239 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3240 "create a complex filtergraph", "graph_description" },
3241 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3242 "read complex filtergraph description from a file", "filename" },
3243 { "stats", OPT_BOOL, { &print_stats },
3244 "print progress report during encoding", },
3245 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3246 OPT_OUTPUT, { .func_arg = opt_attach },
3247 "add an attachment to the output file", "filename" },
3248 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3249 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3250 "extract an attachment into a file", "filename" },
3251 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3252 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3253 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3254 "print timestamp debugging info" },
3255 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3256 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3257 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3258 OPT_INPUT, { .off = OFFSET(discard) },
3260 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3261 OPT_OUTPUT, { .off = OFFSET(disposition) },
3262 "disposition", "" },
3263 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3264 { .off = OFFSET(thread_queue_size) },
3265 "set the maximum number of queued packets from the demuxer" },
3268 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3269 "set the number of video frames to output", "number" },
3270 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3271 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3272 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3273 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3274 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3275 "set frame size (WxH or abbreviation)", "size" },
3276 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3277 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3278 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3279 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3280 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3281 "set pixel format", "format" },
3282 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3283 "set the number of bits per raw sample", "number" },
3284 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3285 "deprecated use -g 1" },
3286 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3288 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3289 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3290 "rate control override for specific intervals", "override" },
3291 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3292 OPT_OUTPUT, { .func_arg = opt_video_codec },
3293 "force video codec ('copy' to copy stream)", "codec" },
3294 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3296 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3298 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3299 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3300 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3301 "select the pass number (1 to 3)", "n" },
3302 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3303 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3304 "select two pass log file name prefix", "prefix" },
3305 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3306 "this option is deprecated, use the yadif filter instead" },
3307 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3308 "calculate PSNR of compressed frames" },
3309 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3310 "dump video coding statistics to file" },
3311 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3312 "dump video coding statistics to file", "file" },
3313 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3314 "set video filters", "filter_graph" },
3315 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3316 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3317 "specify intra matrix coeffs", "matrix" },
3318 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3319 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3320 "specify inter matrix coeffs", "matrix" },
3321 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3322 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3323 "specify intra matrix coeffs", "matrix" },
3324 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3325 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3326 "top=1/bottom=0/auto=-1 field first", "" },
3327 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3328 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3329 "force video tag/fourcc", "fourcc/tag" },
3330 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3331 "show QP histogram" },
3332 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3333 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3334 "force the selected framerate, disable the best supported framerate selection" },
3335 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3336 OPT_OUTPUT, { .func_arg = opt_streamid },
3337 "set the value of an outfile streamid", "streamIndex:value" },
3338 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3339 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3340 "force key frames at specified timestamps", "timestamps" },
3341 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3342 "audio bitrate (please use -b:a)", "bitrate" },
3343 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3344 "video bitrate (please use -b:v)", "bitrate" },
3345 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3346 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3347 "use HW accelerated decoding", "hwaccel name" },
3348 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3349 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3350 "select a device for HW acceleration", "devicename" },
3351 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3352 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3354 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3355 "show available HW acceleration methods" },
3356 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3357 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3358 "automatically insert correct rotate filters" },
3361 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3362 "set the number of audio frames to output", "number" },
3363 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3364 "set audio quality (codec-specific)", "quality", },
3365 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3366 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3367 "set audio sampling rate (in Hz)", "rate" },
3368 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3369 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3370 "set number of audio channels", "channels" },
3371 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3373 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3374 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3375 "force audio codec ('copy' to copy stream)", "codec" },
3376 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3377 OPT_OUTPUT, { .func_arg = opt_old2new },
3378 "force audio tag/fourcc", "fourcc/tag" },
3379 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3380 "change audio volume (256=normal)" , "volume" },
3381 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3382 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3383 "set sample format", "format" },
3384 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3385 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3386 "set channel layout", "layout" },
3387 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3388 "set audio filters", "filter_graph" },
3389 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3390 "set the maximum number of channels to try to guess the channel layout" },
3392 /* subtitle options */
3393 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3394 "disable subtitle" },
3395 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3396 "force subtitle codec ('copy' to copy stream)", "codec" },
3397 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3398 , "force subtitle tag/fourcc", "fourcc/tag" },
3399 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3400 "fix subtitles duration" },
3401 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3402 "set canvas size (WxH or abbreviation)", "size" },
3405 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3406 "deprecated, use -channel", "channel" },
3407 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3408 "deprecated, use -standard", "standard" },
3409 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3412 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3413 "set the maximum demux-decode delay", "seconds" },
3414 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3415 "set the initial demux-decode delay", "seconds" },
3416 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3417 "override the options from ffserver", "" },
3418 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3419 "specify a file in which to print sdp information", "file" },
3421 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3422 "A comma-separated list of bitstream filters", "bitstream_filters" },
3423 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3424 "deprecated", "audio bitstream_filters" },
3425 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3426 "deprecated", "video bitstream_filters" },
3428 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3429 "set the audio options to the indicated preset", "preset" },
3430 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3431 "set the video options to the indicated preset", "preset" },
3432 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3433 "set the subtitle options to the indicated preset", "preset" },
3434 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3435 "set options from indicated preset file", "filename" },
3436 /* data codec support */
3437 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3438 "force data codec ('copy' to copy stream)", "codec" },
3439 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },