2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43 #include "libavutil/time_internal.h"
45 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
47 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
50 for (i = 0; i < o->nb_ ## name; i++) {\
51 char *spec = o->name[i].specifier;\
52 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
53 outvar = o->name[i].u.type;\
59 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
62 for (i = 0; i < o->nb_ ## name; i++) {\
63 char *spec = o->name[i].specifier;\
64 if (!strcmp(spec, mediatype))\
65 outvar = o->name[i].u.type;\
69 const HWAccel hwaccels[] = {
71 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
74 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
77 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 #if CONFIG_VIDEOTOOLBOX
80 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
83 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
88 char *vstats_filename;
91 float audio_drift_threshold = 0.1;
92 float dts_delta_threshold = 10;
93 float dts_error_threshold = 3600*30;
95 int audio_volume = 256;
96 int audio_sync_method = 0;
97 int video_sync_method = VSYNC_AUTO;
98 float frame_drop_threshold = 0;
99 int do_deinterlace = 0;
100 int do_benchmark = 0;
101 int do_benchmark_all = 0;
105 int start_at_zero = 0;
108 int exit_on_error = 0;
109 int abort_on_flags = 0;
110 int print_stats = -1;
112 int stdin_interaction = 1;
113 int frame_bits_per_raw_sample = 0;
114 float max_error_rate = 2.0/3;
117 static int intra_only = 0;
118 static int file_overwrite = 0;
119 static int no_file_overwrite = 0;
120 static int do_psnr = 0;
121 static int input_sync;
122 static int override_ffserver = 0;
123 static int input_stream_potentially_available = 0;
124 static int ignore_unknown_streams = 0;
125 static int copy_unknown_streams = 0;
127 static void uninit_options(OptionsContext *o)
129 const OptionDef *po = options;
132 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
134 void *dst = (uint8_t*)o + po->u.off;
136 if (po->flags & OPT_SPEC) {
137 SpecifierOpt **so = dst;
138 int i, *count = (int*)(so + 1);
139 for (i = 0; i < *count; i++) {
140 av_freep(&(*so)[i].specifier);
141 if (po->flags & OPT_STRING)
142 av_freep(&(*so)[i].u.str);
146 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
151 for (i = 0; i < o->nb_stream_maps; i++)
152 av_freep(&o->stream_maps[i].linklabel);
153 av_freep(&o->stream_maps);
154 av_freep(&o->audio_channel_maps);
155 av_freep(&o->streamid_map);
156 av_freep(&o->attachments);
159 static void init_options(OptionsContext *o)
161 memset(o, 0, sizeof(*o));
163 o->stop_time = INT64_MAX;
164 o->mux_max_delay = 0.7;
165 o->start_time = AV_NOPTS_VALUE;
166 o->start_time_eof = AV_NOPTS_VALUE;
167 o->recording_time = INT64_MAX;
168 o->limit_filesize = UINT64_MAX;
169 o->chapters_input_file = INT_MAX;
170 o->accurate_seek = 1;
173 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
177 printf("Hardware acceleration methods:\n");
178 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
179 printf("%s\n", hwaccels[i].name);
185 /* return a copy of the input with the stream specifiers removed from the keys */
186 static AVDictionary *strip_specifiers(AVDictionary *dict)
188 AVDictionaryEntry *e = NULL;
189 AVDictionary *ret = NULL;
191 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
192 char *p = strchr(e->key, ':');
196 av_dict_set(&ret, e->key, e->value, 0);
203 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
205 static const AVOption opts[] = {
206 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
207 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
210 static const AVClass class = {
212 .item_name = av_default_item_name,
214 .version = LIBAVUTIL_VERSION_INT,
216 const AVClass *pclass = &class;
218 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
221 static int opt_sameq(void *optctx, const char *opt, const char *arg)
223 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
224 "If you are looking for an option to preserve the quality (which is not "
225 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
227 return AVERROR(EINVAL);
230 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
232 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
233 return opt_default(optctx, "channel", arg);
236 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
238 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
239 return opt_default(optctx, "standard", arg);
242 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
244 OptionsContext *o = optctx;
245 return parse_option(o, "codec:a", arg, options);
248 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
250 OptionsContext *o = optctx;
251 return parse_option(o, "codec:v", arg, options);
254 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
256 OptionsContext *o = optctx;
257 return parse_option(o, "codec:s", arg, options);
260 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
262 OptionsContext *o = optctx;
263 return parse_option(o, "codec:d", arg, options);
266 static int opt_map(void *optctx, const char *opt, const char *arg)
268 OptionsContext *o = optctx;
270 int i, negative = 0, file_idx;
271 int sync_file_idx = -1, sync_stream_idx = 0;
280 map = av_strdup(arg);
282 return AVERROR(ENOMEM);
284 /* parse sync stream first, just pick first matching stream */
285 if (sync = strchr(map, ',')) {
287 sync_file_idx = strtol(sync + 1, &sync, 0);
288 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
289 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
294 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
295 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
296 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
300 if (i == input_files[sync_file_idx]->nb_streams) {
301 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
302 "match any streams.\n", arg);
309 /* this mapping refers to lavfi output */
310 const char *c = map + 1;
311 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
312 m = &o->stream_maps[o->nb_stream_maps - 1];
313 m->linklabel = av_get_token(&c, "]");
315 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
319 if (allow_unused = strchr(map, '?'))
321 file_idx = strtol(map, &p, 0);
322 if (file_idx >= nb_input_files || file_idx < 0) {
323 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
327 /* disable some already defined maps */
328 for (i = 0; i < o->nb_stream_maps; i++) {
329 m = &o->stream_maps[i];
330 if (file_idx == m->file_index &&
331 check_stream_specifier(input_files[m->file_index]->ctx,
332 input_files[m->file_index]->ctx->streams[m->stream_index],
333 *p == ':' ? p + 1 : p) > 0)
337 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
338 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
339 *p == ':' ? p + 1 : p) <= 0)
341 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
342 m = &o->stream_maps[o->nb_stream_maps - 1];
344 m->file_index = file_idx;
347 if (sync_file_idx >= 0) {
348 m->sync_file_index = sync_file_idx;
349 m->sync_stream_index = sync_stream_idx;
351 m->sync_file_index = file_idx;
352 m->sync_stream_index = i;
359 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
361 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
362 "To ignore this, add a trailing '?' to the map.\n", arg);
371 static int opt_attach(void *optctx, const char *opt, const char *arg)
373 OptionsContext *o = optctx;
374 GROW_ARRAY(o->attachments, o->nb_attachments);
375 o->attachments[o->nb_attachments - 1] = arg;
379 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
381 OptionsContext *o = optctx;
386 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
387 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
389 /* muted channel syntax */
390 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
391 if ((n == 1 || n == 3) && m->channel_idx == -1) {
392 m->file_idx = m->stream_idx = -1;
394 m->ofile_idx = m->ostream_idx = -1;
399 n = sscanf(arg, "%d.%d.%d:%d.%d",
400 &m->file_idx, &m->stream_idx, &m->channel_idx,
401 &m->ofile_idx, &m->ostream_idx);
403 if (n != 3 && n != 5) {
404 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
405 "[file.stream.channel|-1][:syncfile:syncstream]\n");
409 if (n != 5) // only file.stream.channel specified
410 m->ofile_idx = m->ostream_idx = -1;
413 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
414 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
418 if (m->stream_idx < 0 ||
419 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
420 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
421 m->file_idx, m->stream_idx);
424 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
425 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
426 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
427 m->file_idx, m->stream_idx);
430 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
431 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
432 m->file_idx, m->stream_idx, m->channel_idx);
438 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
440 av_free(sdp_filename);
441 sdp_filename = av_strdup(arg);
446 * Parse a metadata specifier passed as 'arg' parameter.
447 * @param arg metadata string to parse
448 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
449 * @param index for type c/p, chapter/program index is written here
450 * @param stream_spec for type s, the stream specifier is written here
452 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
460 if (*(++arg) && *arg != ':') {
461 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
464 *stream_spec = *arg == ':' ? arg + 1 : "";
469 *index = strtol(++arg, NULL, 0);
472 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
479 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
481 AVDictionary **meta_in = NULL;
482 AVDictionary **meta_out = NULL;
484 char type_in, type_out;
485 const char *istream_spec = NULL, *ostream_spec = NULL;
486 int idx_in = 0, idx_out = 0;
488 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
489 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
492 if (type_out == 'g' || !*outspec)
493 o->metadata_global_manual = 1;
494 if (type_out == 's' || !*outspec)
495 o->metadata_streams_manual = 1;
496 if (type_out == 'c' || !*outspec)
497 o->metadata_chapters_manual = 1;
501 if (type_in == 'g' || type_out == 'g')
502 o->metadata_global_manual = 1;
503 if (type_in == 's' || type_out == 's')
504 o->metadata_streams_manual = 1;
505 if (type_in == 'c' || type_out == 'c')
506 o->metadata_chapters_manual = 1;
508 /* ic is NULL when just disabling automatic mappings */
512 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
513 if ((index) < 0 || (index) >= (nb_elems)) {\
514 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
519 #define SET_DICT(type, meta, context, index)\
522 meta = &context->metadata;\
525 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
526 meta = &context->chapters[index]->metadata;\
529 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
530 meta = &context->programs[index]->metadata;\
533 break; /* handled separately below */ \
534 default: av_assert0(0);\
537 SET_DICT(type_in, meta_in, ic, idx_in);
538 SET_DICT(type_out, meta_out, oc, idx_out);
540 /* for input streams choose first matching stream */
541 if (type_in == 's') {
542 for (i = 0; i < ic->nb_streams; i++) {
543 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
544 meta_in = &ic->streams[i]->metadata;
550 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
555 if (type_out == 's') {
556 for (i = 0; i < oc->nb_streams; i++) {
557 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
558 meta_out = &oc->streams[i]->metadata;
559 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
564 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
569 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
571 OptionsContext *o = optctx;
573 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
574 struct tm time = *gmtime((time_t*)&recording_timestamp);
575 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
577 parse_option(o, "metadata", buf, options);
579 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
580 "tag instead.\n", opt);
584 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
586 const AVCodecDescriptor *desc;
587 const char *codec_string = encoder ? "encoder" : "decoder";
591 avcodec_find_encoder_by_name(name) :
592 avcodec_find_decoder_by_name(name);
594 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
595 codec = encoder ? avcodec_find_encoder(desc->id) :
596 avcodec_find_decoder(desc->id);
598 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
599 codec_string, codec->name, desc->name);
603 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
606 if (codec->type != type) {
607 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
613 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
615 char *codec_name = NULL;
617 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
619 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
620 st->codec->codec_id = codec->id;
623 return avcodec_find_decoder(st->codec->codec_id);
626 /* Add all the streams from the given input file to the global
627 * list of input streams. */
628 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
632 for (i = 0; i < ic->nb_streams; i++) {
633 AVStream *st = ic->streams[i];
634 AVCodecContext *dec = st->codec;
635 InputStream *ist = av_mallocz(sizeof(*ist));
636 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
637 char *codec_tag = NULL;
639 char *discard_str = NULL;
640 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
645 GROW_ARRAY(input_streams, nb_input_streams);
646 input_streams[nb_input_streams - 1] = ist;
649 ist->file_index = nb_input_files;
651 st->discard = AVDISCARD_ALL;
653 ist->min_pts = INT64_MAX;
654 ist->max_pts = INT64_MIN;
657 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
660 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
662 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
664 uint32_t tag = strtol(codec_tag, &next, 0);
666 tag = AV_RL32(codec_tag);
667 st->codec->codec_tag = tag;
670 ist->dec = choose_decoder(o, ic, st);
671 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
673 ist->reinit_filters = -1;
674 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
676 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
677 ist->user_set_discard = AVDISCARD_NONE;
678 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
679 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
684 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
686 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
688 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
692 ret = avcodec_copy_context(ist->dec_ctx, dec);
694 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
698 switch (dec->codec_type) {
699 case AVMEDIA_TYPE_VIDEO:
701 ist->dec = avcodec_find_decoder(dec->codec_id);
703 if (av_codec_get_lowres(dec)) {
704 dec->flags |= CODEC_FLAG_EMU_EDGE;
708 ist->resample_height = ist->dec_ctx->height;
709 ist->resample_width = ist->dec_ctx->width;
710 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
712 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
713 if (framerate && av_parse_video_rate(&ist->framerate,
715 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
720 ist->top_field_first = -1;
721 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
723 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
725 if (!strcmp(hwaccel, "none"))
726 ist->hwaccel_id = HWACCEL_NONE;
727 else if (!strcmp(hwaccel, "auto"))
728 ist->hwaccel_id = HWACCEL_AUTO;
731 for (i = 0; hwaccels[i].name; i++) {
732 if (!strcmp(hwaccels[i].name, hwaccel)) {
733 ist->hwaccel_id = hwaccels[i].id;
738 if (!ist->hwaccel_id) {
739 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
741 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
742 for (i = 0; hwaccels[i].name; i++)
743 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
744 av_log(NULL, AV_LOG_FATAL, "\n");
750 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
751 if (hwaccel_device) {
752 ist->hwaccel_device = av_strdup(hwaccel_device);
753 if (!ist->hwaccel_device)
756 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
759 case AVMEDIA_TYPE_AUDIO:
760 ist->guess_layout_max = INT_MAX;
761 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
762 guess_input_channel_layout(ist);
764 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
765 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
766 ist->resample_channels = ist->dec_ctx->channels;
767 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
770 case AVMEDIA_TYPE_DATA:
771 case AVMEDIA_TYPE_SUBTITLE: {
772 char *canvas_size = NULL;
774 ist->dec = avcodec_find_decoder(dec->codec_id);
775 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
776 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
778 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
779 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
784 case AVMEDIA_TYPE_ATTACHMENT:
785 case AVMEDIA_TYPE_UNKNOWN:
793 static void assert_file_overwrite(const char *filename)
795 if (file_overwrite && no_file_overwrite) {
796 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
800 if (!file_overwrite) {
801 const char *proto_name = avio_find_protocol_name(filename);
802 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
803 if (stdin_interaction && !no_file_overwrite) {
804 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
807 signal(SIGINT, SIG_DFL);
809 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
815 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
822 static void dump_attachment(AVStream *st, const char *filename)
825 AVIOContext *out = NULL;
826 AVDictionaryEntry *e;
828 if (!st->codec->extradata_size) {
829 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
830 nb_input_files - 1, st->index);
833 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
836 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
837 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
841 assert_file_overwrite(filename);
843 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
844 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
849 avio_write(out, st->codec->extradata, st->codec->extradata_size);
854 static int open_input_file(OptionsContext *o, const char *filename)
858 AVInputFormat *file_iformat = NULL;
862 AVDictionary *unused_opts = NULL;
863 AVDictionaryEntry *e = NULL;
864 int orig_nb_streams; // number of streams before avformat_find_stream_info
865 char * video_codec_name = NULL;
866 char * audio_codec_name = NULL;
867 char *subtitle_codec_name = NULL;
868 char * data_codec_name = NULL;
869 int scan_all_pmts_set = 0;
872 if (!(file_iformat = av_find_input_format(o->format))) {
873 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
878 if (!strcmp(filename, "-"))
881 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
882 strcmp(filename, "/dev/stdin");
884 /* get default parameters from command line */
885 ic = avformat_alloc_context();
887 print_error(filename, AVERROR(ENOMEM));
890 if (o->nb_audio_sample_rate) {
891 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
893 if (o->nb_audio_channels) {
894 /* because we set audio_channels based on both the "ac" and
895 * "channel_layout" options, we need to check that the specified
896 * demuxer actually has the "channels" option before setting it */
897 if (file_iformat && file_iformat->priv_class &&
898 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
899 AV_OPT_SEARCH_FAKE_OBJ)) {
900 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
903 if (o->nb_frame_rates) {
904 /* set the format-level framerate option;
905 * this is important for video grabbers, e.g. x11 */
906 if (file_iformat && file_iformat->priv_class &&
907 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
908 AV_OPT_SEARCH_FAKE_OBJ)) {
909 av_dict_set(&o->g->format_opts, "framerate",
910 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
913 if (o->nb_frame_sizes) {
914 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
916 if (o->nb_frame_pix_fmts)
917 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
919 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
920 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
921 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
922 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
924 ic->video_codec_id = video_codec_name ?
925 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
926 ic->audio_codec_id = audio_codec_name ?
927 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
928 ic->subtitle_codec_id= subtitle_codec_name ?
929 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
930 ic->data_codec_id = data_codec_name ?
931 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
933 if (video_codec_name)
934 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
935 if (audio_codec_name)
936 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
937 if (subtitle_codec_name)
938 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
940 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
942 ic->flags |= AVFMT_FLAG_NONBLOCK;
943 ic->interrupt_callback = int_cb;
945 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
946 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
947 scan_all_pmts_set = 1;
949 /* open the input file with generic avformat function */
950 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
952 print_error(filename, err);
955 if (scan_all_pmts_set)
956 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
957 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
958 assert_avoptions(o->g->format_opts);
960 /* apply forced codec ids */
961 for (i = 0; i < ic->nb_streams; i++)
962 choose_decoder(o, ic, ic->streams[i]);
964 /* Set AVCodecContext options for avformat_find_stream_info */
965 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
966 orig_nb_streams = ic->nb_streams;
968 /* If not enough info to get the stream parameters, we decode the
969 first frames to get it. (used in mpeg case for example) */
970 ret = avformat_find_stream_info(ic, opts);
972 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
973 if (ic->nb_streams == 0) {
974 avformat_close_input(&ic);
979 if (o->start_time_eof != AV_NOPTS_VALUE) {
980 if (ic->duration>0) {
981 o->start_time = o->start_time_eof + ic->duration;
983 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
985 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
986 /* add the stream start time */
987 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
988 timestamp += ic->start_time;
990 /* if seeking requested, we execute it */
991 if (o->start_time != AV_NOPTS_VALUE) {
992 int64_t seek_timestamp = timestamp;
994 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
995 int dts_heuristic = 0;
996 for (i=0; i<ic->nb_streams; i++) {
997 AVCodecContext *avctx = ic->streams[i]->codec;
998 if (avctx->has_b_frames)
1001 if (dts_heuristic) {
1002 seek_timestamp -= 3*AV_TIME_BASE / 23;
1005 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1007 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1008 filename, (double)timestamp / AV_TIME_BASE);
1012 /* update the current parameters so that they match the one of the input stream */
1013 add_input_streams(o, ic);
1015 /* dump the file content */
1016 av_dump_format(ic, nb_input_files, filename, 0);
1018 GROW_ARRAY(input_files, nb_input_files);
1019 f = av_mallocz(sizeof(*f));
1022 input_files[nb_input_files - 1] = f;
1025 f->ist_index = nb_input_streams - ic->nb_streams;
1026 f->start_time = o->start_time;
1027 f->recording_time = o->recording_time;
1028 f->input_ts_offset = o->input_ts_offset;
1029 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1030 f->nb_streams = ic->nb_streams;
1031 f->rate_emu = o->rate_emu;
1032 f->accurate_seek = o->accurate_seek;
1035 f->time_base = (AVRational){ 1, 1 };
1037 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1040 /* check if all codec options have been used */
1041 unused_opts = strip_specifiers(o->g->codec_opts);
1042 for (i = f->ist_index; i < nb_input_streams; i++) {
1044 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1045 AV_DICT_IGNORE_SUFFIX)))
1046 av_dict_set(&unused_opts, e->key, NULL, 0);
1050 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1051 const AVClass *class = avcodec_get_class();
1052 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1053 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1054 const AVClass *fclass = avformat_get_class();
1055 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1056 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1057 if (!option || foption)
1061 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1062 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1063 "input file #%d (%s) is not a decoding option.\n", e->key,
1064 option->help ? option->help : "", nb_input_files - 1,
1069 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1070 "input file #%d (%s) has not been used for any stream. The most "
1071 "likely reason is either wrong type (e.g. a video option with "
1072 "no video streams) or that it is a private option of some decoder "
1073 "which was not actually used for any stream.\n", e->key,
1074 option->help ? option->help : "", nb_input_files - 1, filename);
1076 av_dict_free(&unused_opts);
1078 for (i = 0; i < o->nb_dump_attachment; i++) {
1081 for (j = 0; j < ic->nb_streams; j++) {
1082 AVStream *st = ic->streams[j];
1084 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1085 dump_attachment(st, o->dump_attachment[i].u.str);
1089 for (i = 0; i < orig_nb_streams; i++)
1090 av_dict_free(&opts[i]);
1093 input_stream_potentially_available = 1;
1098 static uint8_t *get_line(AVIOContext *s)
1104 if (avio_open_dyn_buf(&line) < 0) {
1105 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1109 while ((c = avio_r8(s)) && c != '\n')
1112 avio_close_dyn_buf(line, &buf);
1117 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1120 char filename[1000];
1121 const char *base[3] = { getenv("AVCONV_DATADIR"),
1126 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1130 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1131 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1132 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1135 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1136 i != 1 ? "" : "/.avconv", preset_name);
1137 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1143 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1145 char *codec_name = NULL;
1147 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1149 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1150 NULL, ost->st->codec->codec_type);
1151 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1152 } else if (!strcmp(codec_name, "copy"))
1153 ost->stream_copy = 1;
1155 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1156 ost->st->codec->codec_id = ost->enc->id;
1160 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1163 AVStream *st = avformat_new_stream(oc, NULL);
1164 int idx = oc->nb_streams - 1, ret = 0;
1165 char *bsf = NULL, *next, *codec_tag = NULL;
1166 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1171 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1175 if (oc->nb_streams - 1 < o->nb_streamid_map)
1176 st->id = o->streamid_map[oc->nb_streams - 1];
1178 GROW_ARRAY(output_streams, nb_output_streams);
1179 if (!(ost = av_mallocz(sizeof(*ost))))
1181 output_streams[nb_output_streams - 1] = ost;
1183 ost->file_index = nb_output_files - 1;
1186 st->codec->codec_type = type;
1187 choose_encoder(o, oc, ost);
1189 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1190 if (!ost->enc_ctx) {
1191 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1194 ost->enc_ctx->codec_type = type;
1197 AVIOContext *s = NULL;
1198 char *buf = NULL, *arg = NULL, *preset = NULL;
1200 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1202 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1203 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1206 if (!buf[0] || buf[0] == '#') {
1210 if (!(arg = strchr(buf, '='))) {
1211 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1215 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1217 } while (!s->eof_reached);
1221 av_log(NULL, AV_LOG_FATAL,
1222 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1223 preset, ost->file_index, ost->index);
1227 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1230 ost->max_frames = INT64_MAX;
1231 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1232 for (i = 0; i<o->nb_max_frames; i++) {
1233 char *p = o->max_frames[i].specifier;
1234 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1235 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1240 ost->copy_prior_start = -1;
1241 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1243 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1246 if (next = strchr(bsf, ','))
1248 if (arg = strchr(bsf, '='))
1250 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1251 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1255 bsfc_prev->next = bsfc;
1257 ost->bitstream_filters = bsfc;
1259 if (!(bsfc->args = av_strdup(arg))) {
1260 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1268 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1270 uint32_t tag = strtol(codec_tag, &next, 0);
1272 tag = AV_RL32(codec_tag);
1273 ost->st->codec->codec_tag =
1274 ost->enc_ctx->codec_tag = tag;
1277 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1279 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1280 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1283 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1284 ost->disposition = av_strdup(ost->disposition);
1286 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1287 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1289 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1291 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1292 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1293 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1295 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1297 ost->source_index = source_index;
1298 if (source_index >= 0) {
1299 ost->sync_ist = input_streams[source_index];
1300 input_streams[source_index]->discard = 0;
1301 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1303 ost->last_mux_dts = AV_NOPTS_VALUE;
1308 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1311 const char *p = str;
1318 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1325 /* read file contents into a string */
1326 static uint8_t *read_file(const char *filename)
1328 AVIOContext *pb = NULL;
1329 AVIOContext *dyn_buf = NULL;
1330 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1331 uint8_t buf[1024], *str;
1334 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1338 ret = avio_open_dyn_buf(&dyn_buf);
1343 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1344 avio_write(dyn_buf, buf, ret);
1345 avio_w8(dyn_buf, 0);
1348 ret = avio_close_dyn_buf(dyn_buf, &str);
1354 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1357 AVStream *st = ost->st;
1359 if (ost->filters_script && ost->filters) {
1360 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1361 "output stream #%d:%d.\n", nb_output_files, st->index);
1365 if (ost->filters_script)
1366 return read_file(ost->filters_script);
1367 else if (ost->filters)
1368 return av_strdup(ost->filters);
1370 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1374 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1375 const OutputStream *ost, enum AVMediaType type)
1377 if (ost->filters_script || ost->filters) {
1378 av_log(NULL, AV_LOG_ERROR,
1379 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1380 "Filtering and streamcopy cannot be used together.\n",
1381 ost->filters ? "Filtergraph" : "Filtergraph script",
1382 ost->filters ? ost->filters : ost->filters_script,
1383 av_get_media_type_string(type), ost->file_index, ost->index);
1388 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1392 AVCodecContext *video_enc;
1393 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1395 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1397 video_enc = ost->enc_ctx;
1399 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1400 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1401 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1404 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1405 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1407 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1408 if (frame_aspect_ratio) {
1410 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1411 q.num <= 0 || q.den <= 0) {
1412 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1415 ost->frame_aspect_ratio = q;
1418 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1419 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1421 if (!ost->stream_copy) {
1422 const char *p = NULL;
1423 char *frame_size = NULL;
1424 char *frame_pix_fmt = NULL;
1425 char *intra_matrix = NULL, *inter_matrix = NULL;
1426 char *chroma_intra_matrix = NULL;
1430 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1431 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1432 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1436 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1437 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1438 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1439 ost->keep_pix_fmt = 1;
1440 if (!*++frame_pix_fmt)
1441 frame_pix_fmt = NULL;
1443 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1444 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1447 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1450 video_enc->gop_size = 0;
1451 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1453 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1454 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1457 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1459 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1460 if (chroma_intra_matrix) {
1461 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1463 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1466 av_codec_set_chroma_intra_matrix(video_enc, p);
1467 parse_matrix_coeffs(p, chroma_intra_matrix);
1469 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1471 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1472 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1475 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1478 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1479 for (i = 0; p; i++) {
1481 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1483 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1486 video_enc->rc_override =
1487 av_realloc_array(video_enc->rc_override,
1488 i + 1, sizeof(RcOverride));
1489 if (!video_enc->rc_override) {
1490 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1493 video_enc->rc_override[i].start_frame = start;
1494 video_enc->rc_override[i].end_frame = end;
1496 video_enc->rc_override[i].qscale = q;
1497 video_enc->rc_override[i].quality_factor = 1.0;
1500 video_enc->rc_override[i].qscale = 0;
1501 video_enc->rc_override[i].quality_factor = -q/100.0;
1506 video_enc->rc_override_count = i;
1509 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1512 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1515 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1516 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1519 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1520 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1524 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1525 if (ost->logfile_prefix &&
1526 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1530 char logfilename[1024];
1533 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1534 ost->logfile_prefix ? ost->logfile_prefix :
1535 DEFAULT_PASS_LOGFILENAME_PREFIX,
1537 if (!strcmp(ost->enc->name, "libx264")) {
1538 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1540 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1541 char *logbuffer = read_file(logfilename);
1544 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1548 video_enc->stats_in = logbuffer;
1550 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1551 f = av_fopen_utf8(logfilename, "wb");
1553 av_log(NULL, AV_LOG_FATAL,
1554 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1555 logfilename, strerror(errno));
1563 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1564 if (ost->forced_keyframes)
1565 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1567 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1569 ost->top_field_first = -1;
1570 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1573 ost->avfilter = get_ost_filters(o, oc, ost);
1577 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1580 if (ost->stream_copy)
1581 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1586 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1591 AVCodecContext *audio_enc;
1593 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1596 audio_enc = ost->enc_ctx;
1597 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1599 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1600 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1602 if (!ost->stream_copy) {
1603 char *sample_fmt = NULL;
1605 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1607 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1609 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1610 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1614 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1616 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1617 ost->apad = av_strdup(ost->apad);
1619 ost->avfilter = get_ost_filters(o, oc, ost);
1623 /* check for channel mapping for this audio stream */
1624 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1625 AudioChannelMap *map = &o->audio_channel_maps[n];
1626 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1627 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1630 if (map->channel_idx == -1) {
1632 } else if (ost->source_index < 0) {
1633 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1634 ost->file_index, ost->st->index);
1637 ist = input_streams[ost->source_index];
1640 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1641 if (av_reallocp_array(&ost->audio_channels_map,
1642 ost->audio_channels_mapped + 1,
1643 sizeof(*ost->audio_channels_map)
1647 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1653 if (ost->stream_copy)
1654 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1659 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1663 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1664 if (!ost->stream_copy) {
1665 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1672 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1676 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1677 if (!ost->stream_copy) {
1678 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1685 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1687 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1688 ost->stream_copy = 1;
1693 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1697 AVCodecContext *subtitle_enc;
1699 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1701 subtitle_enc = ost->enc_ctx;
1703 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1705 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1707 if (!ost->stream_copy) {
1708 char *frame_size = NULL;
1710 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1711 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1712 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1720 /* arg format is "output-stream-index:streamid-value". */
1721 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1723 OptionsContext *o = optctx;
1728 av_strlcpy(idx_str, arg, sizeof(idx_str));
1729 p = strchr(idx_str, ':');
1731 av_log(NULL, AV_LOG_FATAL,
1732 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1737 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1738 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1739 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1743 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1745 AVFormatContext *is = ifile->ctx;
1746 AVFormatContext *os = ofile->ctx;
1750 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1752 return AVERROR(ENOMEM);
1755 for (i = 0; i < is->nb_chapters; i++) {
1756 AVChapter *in_ch = is->chapters[i], *out_ch;
1757 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1758 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1759 AV_TIME_BASE_Q, in_ch->time_base);
1760 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1761 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1764 if (in_ch->end < ts_off)
1766 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1769 out_ch = av_mallocz(sizeof(AVChapter));
1771 return AVERROR(ENOMEM);
1773 out_ch->id = in_ch->id;
1774 out_ch->time_base = in_ch->time_base;
1775 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1776 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1779 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1781 os->chapters[os->nb_chapters++] = out_ch;
1786 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1789 AVFormatContext *ic = avformat_alloc_context();
1791 ic->interrupt_callback = int_cb;
1792 err = avformat_open_input(&ic, filename, NULL, NULL);
1795 /* copy stream format */
1796 for(i=0;i<ic->nb_streams;i++) {
1800 const char *enc_config;
1802 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1804 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1805 return AVERROR(EINVAL);
1807 if (codec->type == AVMEDIA_TYPE_AUDIO)
1808 opt_audio_codec(o, "c:a", codec->name);
1809 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1810 opt_video_codec(o, "c:v", codec->name);
1811 ost = new_output_stream(o, s, codec->type, -1);
1814 avcodec_get_context_defaults3(st->codec, codec);
1815 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1817 AVDictionary *opts = NULL;
1818 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1819 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1820 av_dict_free(&opts);
1823 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1824 choose_sample_fmt(st, codec);
1825 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1826 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1827 avcodec_copy_context(ost->enc_ctx, st->codec);
1829 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1832 avformat_close_input(&ic);
1836 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1837 AVFormatContext *oc)
1841 switch (ofilter->type) {
1842 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1843 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1845 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1850 ost->source_index = -1;
1851 ost->filter = ofilter;
1855 if (ost->stream_copy) {
1856 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1857 "which is fed from a complex filtergraph. Filtering and streamcopy "
1858 "cannot be used together.\n", ost->file_index, ost->index);
1862 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1863 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1864 av_log(NULL, AV_LOG_ERROR,
1865 "%s '%s' was specified through the %s option "
1866 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1867 "%s and -filter_complex cannot be used together for the same stream.\n",
1868 ost->filters ? "Filtergraph" : "Filtergraph script",
1869 ost->filters ? ost->filters : ost->filters_script,
1870 opt, ost->file_index, ost->index, opt);
1874 avfilter_inout_free(&ofilter->out_tmp);
1877 static int init_complex_filters(void)
1881 for (i = 0; i < nb_filtergraphs; i++) {
1882 ret = init_complex_filtergraph(filtergraphs[i]);
1889 static int configure_complex_filters(void)
1893 for (i = 0; i < nb_filtergraphs; i++)
1894 if (!filtergraphs[i]->graph &&
1895 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1900 static int open_output_file(OptionsContext *o, const char *filename)
1902 AVFormatContext *oc;
1904 AVOutputFormat *file_oformat;
1908 AVDictionary *unused_opts = NULL;
1909 AVDictionaryEntry *e = NULL;
1912 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1913 o->stop_time = INT64_MAX;
1914 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1917 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1918 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1919 if (o->stop_time <= start_time) {
1920 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1923 o->recording_time = o->stop_time - start_time;
1927 GROW_ARRAY(output_files, nb_output_files);
1928 of = av_mallocz(sizeof(*of));
1931 output_files[nb_output_files - 1] = of;
1933 of->ost_index = nb_output_streams;
1934 of->recording_time = o->recording_time;
1935 of->start_time = o->start_time;
1936 of->limit_filesize = o->limit_filesize;
1937 of->shortest = o->shortest;
1938 av_dict_copy(&of->opts, o->g->format_opts, 0);
1940 if (!strcmp(filename, "-"))
1943 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1945 print_error(filename, err);
1950 if (o->recording_time != INT64_MAX)
1951 oc->duration = o->recording_time;
1953 file_oformat= oc->oformat;
1954 oc->interrupt_callback = int_cb;
1956 /* create streams for all unlabeled output pads */
1957 for (i = 0; i < nb_filtergraphs; i++) {
1958 FilterGraph *fg = filtergraphs[i];
1959 for (j = 0; j < fg->nb_outputs; j++) {
1960 OutputFilter *ofilter = fg->outputs[j];
1962 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1965 switch (ofilter->type) {
1966 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1967 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1968 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1970 init_output_filter(ofilter, o, oc);
1974 /* ffserver seeking with date=... needs a date reference */
1975 if (!strcmp(file_oformat->name, "ffm") &&
1976 av_strstart(filename, "http:", NULL)) {
1977 int err = parse_option(o, "metadata", "creation_time=now", options);
1979 print_error(filename, err);
1984 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1985 av_strstart(filename, "http:", NULL)) {
1987 /* special case for files sent to ffserver: we get the stream
1988 parameters from ffserver */
1989 int err = read_ffserver_streams(o, oc, filename);
1991 print_error(filename, err);
1994 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1995 ost = output_streams[j];
1996 for (i = 0; i < nb_input_streams; i++) {
1997 ist = input_streams[i];
1998 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
2000 ost->source_index= i;
2001 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2002 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2004 ist->st->discard = ist->user_set_discard;
2009 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));
2013 } else if (!o->nb_stream_maps) {
2014 char *subtitle_codec_name = NULL;
2015 /* pick the "best" stream of each type */
2017 /* video: highest resolution */
2018 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2019 int area = 0, idx = -1;
2020 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2021 for (i = 0; i < nb_input_streams; i++) {
2023 ist = input_streams[i];
2024 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
2025 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2027 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2029 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2036 new_video_stream(o, oc, idx);
2039 /* audio: most channels */
2040 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2041 int best_score = 0, idx = -1;
2042 for (i = 0; i < nb_input_streams; i++) {
2044 ist = input_streams[i];
2045 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2046 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2047 score > best_score) {
2053 new_audio_stream(o, oc, idx);
2056 /* subtitles: pick first */
2057 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2058 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2059 for (i = 0; i < nb_input_streams; i++)
2060 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2061 AVCodecDescriptor const *input_descriptor =
2062 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2063 AVCodecDescriptor const *output_descriptor = NULL;
2064 AVCodec const *output_codec =
2065 avcodec_find_encoder(oc->oformat->subtitle_codec);
2066 int input_props = 0, output_props = 0;
2068 output_descriptor = avcodec_descriptor_get(output_codec->id);
2069 if (input_descriptor)
2070 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2071 if (output_descriptor)
2072 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2073 if (subtitle_codec_name ||
2074 input_props & output_props ||
2075 // Map dvb teletext which has neither property to any output subtitle encoder
2076 input_descriptor && output_descriptor &&
2077 (!input_descriptor->props ||
2078 !output_descriptor->props)) {
2079 new_subtitle_stream(o, oc, i);
2084 /* Data only if codec id match */
2085 if (!o->data_disable ) {
2086 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2087 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2088 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2089 && input_streams[i]->st->codec->codec_id == codec_id )
2090 new_data_stream(o, oc, i);
2094 for (i = 0; i < o->nb_stream_maps; i++) {
2095 StreamMap *map = &o->stream_maps[i];
2100 if (map->linklabel) {
2102 OutputFilter *ofilter = NULL;
2105 for (j = 0; j < nb_filtergraphs; j++) {
2106 fg = filtergraphs[j];
2107 for (k = 0; k < fg->nb_outputs; k++) {
2108 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2109 if (out && !strcmp(out->name, map->linklabel)) {
2110 ofilter = fg->outputs[k];
2117 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2118 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2121 init_output_filter(ofilter, o, oc);
2123 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2125 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2126 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2128 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2130 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2132 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2136 switch (ist->st->codec->codec_type) {
2137 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2138 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2139 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2140 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2141 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2142 case AVMEDIA_TYPE_UNKNOWN:
2143 if (copy_unknown_streams) {
2144 ost = new_unknown_stream (o, oc, src_idx);
2148 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2149 "Cannot map stream #%d:%d - unsupported type.\n",
2150 map->file_index, map->stream_index);
2151 if (!ignore_unknown_streams) {
2152 av_log(NULL, AV_LOG_FATAL,
2153 "If you want unsupported types ignored instead "
2154 "of failing, please use the -ignore_unknown option\n"
2155 "If you want them copied, please use -copy_unknown\n");
2160 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2161 + map->sync_stream_index];
2166 /* handle attached files */
2167 for (i = 0; i < o->nb_attachments; i++) {
2169 uint8_t *attachment;
2173 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2174 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2178 if ((len = avio_size(pb)) <= 0) {
2179 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2183 if (!(attachment = av_malloc(len))) {
2184 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2188 avio_read(pb, attachment, len);
2190 ost = new_attachment_stream(o, oc, -1);
2191 ost->stream_copy = 1;
2192 ost->attachment_filename = o->attachments[i];
2194 ost->st->codec->extradata = attachment;
2195 ost->st->codec->extradata_size = len;
2197 p = strrchr(o->attachments[i], '/');
2198 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2202 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2203 AVDictionaryEntry *e;
2204 ost = output_streams[i];
2206 if ((ost->stream_copy || ost->attachment_filename)
2207 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2208 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2209 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2213 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2214 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2215 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2219 /* check if all codec options have been used */
2220 unused_opts = strip_specifiers(o->g->codec_opts);
2221 for (i = of->ost_index; i < nb_output_streams; i++) {
2223 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2224 AV_DICT_IGNORE_SUFFIX)))
2225 av_dict_set(&unused_opts, e->key, NULL, 0);
2229 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2230 const AVClass *class = avcodec_get_class();
2231 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2232 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2233 const AVClass *fclass = avformat_get_class();
2234 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2235 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2236 if (!option || foption)
2240 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2241 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2242 "output file #%d (%s) is not an encoding option.\n", e->key,
2243 option->help ? option->help : "", nb_output_files - 1,
2248 // gop_timecode is injected by generic code but not always used
2249 if (!strcmp(e->key, "gop_timecode"))
2252 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2253 "output file #%d (%s) has not been used for any stream. The most "
2254 "likely reason is either wrong type (e.g. a video option with "
2255 "no video streams) or that it is a private option of some encoder "
2256 "which was not actually used for any stream.\n", e->key,
2257 option->help ? option->help : "", nb_output_files - 1, filename);
2259 av_dict_free(&unused_opts);
2261 /* set the encoding/decoding_needed flags */
2262 for (i = of->ost_index; i < nb_output_streams; i++) {
2263 OutputStream *ost = output_streams[i];
2265 ost->encoding_needed = !ost->stream_copy;
2266 if (ost->encoding_needed && ost->source_index >= 0) {
2267 InputStream *ist = input_streams[ost->source_index];
2268 ist->decoding_needed |= DECODING_FOR_OST;
2272 /* check filename in case of an image number is expected */
2273 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2274 if (!av_filename_number_test(oc->filename)) {
2275 print_error(oc->filename, AVERROR(EINVAL));
2280 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2281 av_log(NULL, AV_LOG_ERROR,
2282 "No input streams but output needs an input stream\n");
2286 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2287 /* test if it already exists to avoid losing precious files */
2288 assert_file_overwrite(filename);
2291 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2292 &oc->interrupt_callback,
2294 print_error(filename, err);
2297 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2298 assert_file_overwrite(filename);
2300 if (o->mux_preload) {
2301 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2303 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2306 for (i = 0; i < o->nb_metadata_map; i++) {
2308 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2310 if (in_file_index >= nb_input_files) {
2311 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2314 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2315 in_file_index >= 0 ?
2316 input_files[in_file_index]->ctx : NULL, o);
2320 if (o->chapters_input_file >= nb_input_files) {
2321 if (o->chapters_input_file == INT_MAX) {
2322 /* copy chapters from the first input file that has them*/
2323 o->chapters_input_file = -1;
2324 for (i = 0; i < nb_input_files; i++)
2325 if (input_files[i]->ctx->nb_chapters) {
2326 o->chapters_input_file = i;
2330 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2331 o->chapters_input_file);
2335 if (o->chapters_input_file >= 0)
2336 copy_chapters(input_files[o->chapters_input_file], of,
2337 !o->metadata_chapters_manual);
2339 /* copy global metadata by default */
2340 if (!o->metadata_global_manual && nb_input_files){
2341 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2342 AV_DICT_DONT_OVERWRITE);
2343 if(o->recording_time != INT64_MAX)
2344 av_dict_set(&oc->metadata, "duration", NULL, 0);
2345 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2347 if (!o->metadata_streams_manual)
2348 for (i = of->ost_index; i < nb_output_streams; i++) {
2350 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2352 ist = input_streams[output_streams[i]->source_index];
2353 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2354 if (!output_streams[i]->stream_copy) {
2355 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2356 if (ist->autorotate)
2357 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2361 /* process manually set programs */
2362 for (i = 0; i < o->nb_program; i++) {
2363 const char *p = o->program[i].u.str;
2368 const char *p2 = av_get_token(&p, ":");
2374 key = av_get_token(&p2, "=");
2379 if (!strcmp(key, "program_num"))
2380 progid = strtol(p2, NULL, 0);
2383 program = av_new_program(oc, progid);
2385 p = o->program[i].u.str;
2387 const char *p2 = av_get_token(&p, ":");
2393 key = av_get_token(&p2, "=");
2395 av_log(NULL, AV_LOG_FATAL,
2396 "No '=' character in program string %s.\n",
2404 if (!strcmp(key, "title")) {
2405 av_dict_set(&program->metadata, "title", p2, 0);
2406 } else if (!strcmp(key, "program_num")) {
2407 } else if (!strcmp(key, "st")) {
2408 int st_num = strtol(p2, NULL, 0);
2409 av_program_add_stream_index(oc, progid, st_num);
2411 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2417 /* process manually set metadata */
2418 for (i = 0; i < o->nb_metadata; i++) {
2421 const char *stream_spec;
2422 int index = 0, j, ret = 0;
2425 val = strchr(o->metadata[i].u.str, '=');
2427 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2428 o->metadata[i].u.str);
2433 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2434 !strcmp(val, "now")) {
2435 time_t now = time(0);
2436 struct tm *ptm, tmbuf;
2437 ptm = localtime_r(&now, &tmbuf);
2439 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2444 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2446 for (j = 0; j < oc->nb_streams; j++) {
2447 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2448 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2449 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2450 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2451 ost->rotate_overridden = 1;
2463 if (index < 0 || index >= oc->nb_chapters) {
2464 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2467 m = &oc->chapters[index]->metadata;
2470 if (index < 0 || index >= oc->nb_programs) {
2471 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2474 m = &oc->programs[index]->metadata;
2477 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2480 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2487 static int opt_target(void *optctx, const char *opt, const char *arg)
2489 OptionsContext *o = optctx;
2490 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2491 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2493 if (!strncmp(arg, "pal-", 4)) {
2496 } else if (!strncmp(arg, "ntsc-", 5)) {
2499 } else if (!strncmp(arg, "film-", 5)) {
2503 /* Try to determine PAL/NTSC by peeking in the input files */
2504 if (nb_input_files) {
2506 for (j = 0; j < nb_input_files; j++) {
2507 for (i = 0; i < input_files[j]->nb_streams; i++) {
2508 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2509 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2512 fr = c->time_base.den * 1000 / c->time_base.num;
2516 } else if ((fr == 29970) || (fr == 23976)) {
2521 if (norm != UNKNOWN)
2525 if (norm != UNKNOWN)
2526 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2529 if (norm == UNKNOWN) {
2530 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2531 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2532 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2536 if (!strcmp(arg, "vcd")) {
2537 opt_video_codec(o, "c:v", "mpeg1video");
2538 opt_audio_codec(o, "c:a", "mp2");
2539 parse_option(o, "f", "vcd", options);
2541 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2542 parse_option(o, "r", frame_rates[norm], options);
2543 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2545 opt_default(NULL, "b:v", "1150000");
2546 opt_default(NULL, "maxrate:v", "1150000");
2547 opt_default(NULL, "minrate:v", "1150000");
2548 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2550 opt_default(NULL, "b:a", "224000");
2551 parse_option(o, "ar", "44100", options);
2552 parse_option(o, "ac", "2", options);
2554 opt_default(NULL, "packetsize", "2324");
2555 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2557 /* We have to offset the PTS, so that it is consistent with the SCR.
2558 SCR starts at 36000, but the first two packs contain only padding
2559 and the first pack from the other stream, respectively, may also have
2560 been written before.
2561 So the real data starts at SCR 36000+3*1200. */
2562 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2563 } else if (!strcmp(arg, "svcd")) {
2565 opt_video_codec(o, "c:v", "mpeg2video");
2566 opt_audio_codec(o, "c:a", "mp2");
2567 parse_option(o, "f", "svcd", options);
2569 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2570 parse_option(o, "r", frame_rates[norm], options);
2571 parse_option(o, "pix_fmt", "yuv420p", options);
2572 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2574 opt_default(NULL, "b:v", "2040000");
2575 opt_default(NULL, "maxrate:v", "2516000");
2576 opt_default(NULL, "minrate:v", "0"); // 1145000;
2577 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2578 opt_default(NULL, "scan_offset", "1");
2580 opt_default(NULL, "b:a", "224000");
2581 parse_option(o, "ar", "44100", options);
2583 opt_default(NULL, "packetsize", "2324");
2585 } else if (!strcmp(arg, "dvd")) {
2587 opt_video_codec(o, "c:v", "mpeg2video");
2588 opt_audio_codec(o, "c:a", "ac3");
2589 parse_option(o, "f", "dvd", options);
2591 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2592 parse_option(o, "r", frame_rates[norm], options);
2593 parse_option(o, "pix_fmt", "yuv420p", options);
2594 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2596 opt_default(NULL, "b:v", "6000000");
2597 opt_default(NULL, "maxrate:v", "9000000");
2598 opt_default(NULL, "minrate:v", "0"); // 1500000;
2599 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2601 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2602 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2604 opt_default(NULL, "b:a", "448000");
2605 parse_option(o, "ar", "48000", options);
2607 } else if (!strncmp(arg, "dv", 2)) {
2609 parse_option(o, "f", "dv", options);
2611 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2612 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2613 norm == PAL ? "yuv420p" : "yuv411p", options);
2614 parse_option(o, "r", frame_rates[norm], options);
2616 parse_option(o, "ar", "48000", options);
2617 parse_option(o, "ac", "2", options);
2620 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2621 return AVERROR(EINVAL);
2624 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2625 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2630 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2632 av_free (vstats_filename);
2633 vstats_filename = av_strdup (arg);
2637 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2640 time_t today2 = time(NULL);
2641 struct tm *today = localtime(&today2);
2643 if (!today) { // maybe tomorrow
2644 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2648 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2650 return opt_vstats_file(NULL, opt, filename);
2653 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2655 OptionsContext *o = optctx;
2656 return parse_option(o, "frames:v", arg, options);
2659 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2661 OptionsContext *o = optctx;
2662 return parse_option(o, "frames:a", arg, options);
2665 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2667 OptionsContext *o = optctx;
2668 return parse_option(o, "frames:d", arg, options);
2671 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2674 AVDictionary *cbak = codec_opts;
2675 AVDictionary *fbak = format_opts;
2679 ret = opt_default(NULL, opt, arg);
2681 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2682 av_dict_copy(&o->g->format_opts, format_opts, 0);
2683 av_dict_free(&codec_opts);
2684 av_dict_free(&format_opts);
2691 static int opt_preset(void *optctx, const char *opt, const char *arg)
2693 OptionsContext *o = optctx;
2695 char filename[1000], line[1000], tmp_line[1000];
2696 const char *codec_name = NULL;
2700 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2702 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2703 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2704 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2706 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2710 while (fgets(line, sizeof(line), f)) {
2711 char *key = tmp_line, *value, *endptr;
2713 if (strcspn(line, "#\n\r") == 0)
2715 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2716 if (!av_strtok(key, "=", &value) ||
2717 !av_strtok(value, "\r\n", &endptr)) {
2718 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2721 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2723 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2724 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2725 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2726 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2727 else if (opt_default_new(o, key, value) < 0) {
2728 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2729 filename, line, key, value);
2739 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2741 OptionsContext *o = optctx;
2742 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2743 int ret = parse_option(o, s, arg, options);
2748 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2750 OptionsContext *o = optctx;
2752 if(!strcmp(opt, "ab")){
2753 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2755 } else if(!strcmp(opt, "b")){
2756 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2757 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2760 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2764 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2766 OptionsContext *o = optctx;
2769 if(!strcmp(opt, "qscale")){
2770 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2771 return parse_option(o, "q:v", arg, options);
2773 s = av_asprintf("q%s", opt + 6);
2774 ret = parse_option(o, s, arg, options);
2779 static int opt_profile(void *optctx, const char *opt, const char *arg)
2781 OptionsContext *o = optctx;
2782 if(!strcmp(opt, "profile")){
2783 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2784 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2787 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2791 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2793 OptionsContext *o = optctx;
2794 return parse_option(o, "filter:v", arg, options);
2797 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2799 OptionsContext *o = optctx;
2800 return parse_option(o, "filter:a", arg, options);
2803 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2805 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2806 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2807 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2808 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2810 if (video_sync_method == VSYNC_AUTO)
2811 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2815 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2817 OptionsContext *o = optctx;
2818 char *tcr = av_asprintf("timecode=%s", arg);
2819 int ret = parse_option(o, "metadata:g", tcr, options);
2821 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2826 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2828 OptionsContext *o = optctx;
2829 char layout_str[32];
2832 int ret, channels, ac_str_size;
2835 layout = av_get_channel_layout(arg);
2837 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2838 return AVERROR(EINVAL);
2840 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2841 ret = opt_default_new(o, opt, layout_str);
2845 /* set 'ac' option based on channel layout */
2846 channels = av_get_channel_layout_nb_channels(layout);
2847 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2848 stream_str = strchr(opt, ':');
2849 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2850 ac_str = av_mallocz(ac_str_size);
2852 return AVERROR(ENOMEM);
2853 av_strlcpy(ac_str, "ac", 3);
2855 av_strlcat(ac_str, stream_str, ac_str_size);
2856 ret = parse_option(o, ac_str, layout_str, options);
2862 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2864 OptionsContext *o = optctx;
2865 return parse_option(o, "q:a", arg, options);
2868 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2870 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2871 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2872 return AVERROR(ENOMEM);
2873 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2874 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2875 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2876 return AVERROR(ENOMEM);
2878 input_stream_potentially_available = 1;
2883 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2885 uint8_t *graph_desc = read_file(arg);
2887 return AVERROR(EINVAL);
2889 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2890 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2891 return AVERROR(ENOMEM);
2892 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2893 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2895 input_stream_potentially_available = 1;
2900 void show_help_default(const char *opt, const char *arg)
2902 /* per-file options have at least one of those set */
2903 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2904 int show_advanced = 0, show_avoptions = 0;
2907 if (!strcmp(opt, "long"))
2909 else if (!strcmp(opt, "full"))
2910 show_advanced = show_avoptions = 1;
2912 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2917 printf("Getting help:\n"
2918 " -h -- print basic options\n"
2919 " -h long -- print more options\n"
2920 " -h full -- print all options (including all format and codec specific options, very long)\n"
2921 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2922 " See man %s for detailed description of the options.\n"
2923 "\n", program_name);
2925 show_help_options(options, "Print help / information / capabilities:",
2928 show_help_options(options, "Global options (affect whole program "
2929 "instead of just one file:",
2930 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2932 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2933 per_file | OPT_EXIT, 0);
2935 show_help_options(options, "Per-file main options:", 0,
2936 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2937 OPT_EXIT, per_file);
2939 show_help_options(options, "Advanced per-file options:",
2940 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2942 show_help_options(options, "Video options:",
2943 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2945 show_help_options(options, "Advanced Video options:",
2946 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2948 show_help_options(options, "Audio options:",
2949 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2951 show_help_options(options, "Advanced Audio options:",
2952 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2953 show_help_options(options, "Subtitle options:",
2954 OPT_SUBTITLE, 0, 0);
2957 if (show_avoptions) {
2958 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2959 show_help_children(avcodec_get_class(), flags);
2960 show_help_children(avformat_get_class(), flags);
2962 show_help_children(sws_get_class(), flags);
2964 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2965 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2969 void show_usage(void)
2971 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2972 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2973 av_log(NULL, AV_LOG_INFO, "\n");
2981 static const OptionGroupDef groups[] = {
2982 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2983 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2986 static int open_files(OptionGroupList *l, const char *inout,
2987 int (*open_file)(OptionsContext*, const char*))
2991 for (i = 0; i < l->nb_groups; i++) {
2992 OptionGroup *g = &l->groups[i];
2998 ret = parse_optgroup(&o, g);
3000 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3001 "%s.\n", inout, g->arg);
3005 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3006 ret = open_file(&o, g->arg);
3009 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3013 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3019 int ffmpeg_parse_options(int argc, char **argv)
3021 OptionParseContext octx;
3025 memset(&octx, 0, sizeof(octx));
3027 /* split the commandline into an internal representation */
3028 ret = split_commandline(&octx, argc, argv, options, groups,
3029 FF_ARRAY_ELEMS(groups));
3031 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3035 /* apply global options */
3036 ret = parse_optgroup(NULL, &octx.global_opts);
3038 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3042 /* open input files */
3043 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3045 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3049 /* create the complex filtergraphs */
3050 ret = init_complex_filters();
3052 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3056 /* open output files */
3057 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3059 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3063 /* configure the complex filtergraphs */
3064 ret = configure_complex_filters();
3066 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3071 uninit_parse_context(&octx);
3073 av_strerror(ret, error, sizeof(error));
3074 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3079 static int opt_progress(void *optctx, const char *opt, const char *arg)
3081 AVIOContext *avio = NULL;
3084 if (!strcmp(arg, "-"))
3086 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3088 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3089 arg, av_err2str(ret));
3092 progress_avio = avio;
3096 #define OFFSET(x) offsetof(OptionsContext, x)
3097 const OptionDef options[] = {
3099 #include "cmdutils_common_opts.h"
3100 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3101 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3102 "force format", "fmt" },
3103 { "y", OPT_BOOL, { &file_overwrite },
3104 "overwrite output files" },
3105 { "n", OPT_BOOL, { &no_file_overwrite },
3106 "never overwrite output files" },
3107 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3108 "Ignore unknown stream types" },
3109 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3110 "Copy unknown stream types" },
3111 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3112 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3113 "codec name", "codec" },
3114 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3115 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3116 "codec name", "codec" },
3117 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3118 OPT_OUTPUT, { .off = OFFSET(presets) },
3119 "preset name", "preset" },
3120 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3121 OPT_OUTPUT, { .func_arg = opt_map },
3122 "set input stream mapping",
3123 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3124 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3125 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3126 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3127 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3128 "set metadata information of outfile from infile",
3129 "outfile[,metadata]:infile[,metadata]" },
3130 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3131 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3132 "set chapters mapping", "input_file_index" },
3133 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3134 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3135 "record or transcode \"duration\" seconds of audio/video",
3137 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3138 "record or transcode stop time", "time_stop" },
3139 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3140 "set the limit file size in bytes", "limit_size" },
3141 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3142 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3143 "set the start time offset", "time_off" },
3144 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3145 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3146 "set the start time offset relative to EOF", "time_off" },
3147 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3148 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3149 "enable/disable seeking by timestamp with -ss" },
3150 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3151 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3152 "enable/disable accurate seeking with -ss" },
3153 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3154 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3155 "set the input ts offset", "time_off" },
3156 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3157 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3158 "set the input ts scale", "scale" },
3159 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3160 "set the recording timestamp ('now' to set the current time)", "time" },
3161 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3162 "add metadata", "string=string" },
3163 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3164 "add program with specified streams", "title=string:st=number..." },
3165 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3166 OPT_OUTPUT, { .func_arg = opt_data_frames },
3167 "set the number of data frames to output", "number" },
3168 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3169 "add timings for benchmarking" },
3170 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3171 "add timings for each task" },
3172 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3173 "write program-readable progress information", "url" },
3174 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3175 "enable or disable interaction on standard input" },
3176 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3177 "set max runtime in seconds", "limit" },
3178 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3179 "dump each input packet" },
3180 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3181 "when dumping packets, also dump the payload" },
3182 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3183 OPT_INPUT, { .off = OFFSET(rate_emu) },
3184 "read input at native frame rate", "" },
3185 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3186 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3187 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3188 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3189 "video sync method", "" },
3190 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3191 "frame drop threshold", "" },
3192 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3193 "audio sync method", "" },
3194 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3195 "audio drift threshold", "threshold" },
3196 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3197 "copy timestamps" },
3198 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3199 "shift input timestamps to start at 0 when using copyts" },
3200 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3201 "copy input stream time base when stream copying", "mode" },
3202 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3203 OPT_OUTPUT, { .off = OFFSET(shortest) },
3204 "finish encoding within shortest input" },
3205 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3206 OPT_OUTPUT, { .off = OFFSET(apad) },
3208 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3209 "timestamp discontinuity delta threshold", "threshold" },
3210 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3211 "timestamp error delta threshold", "threshold" },
3212 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3213 "exit on error", "error" },
3214 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3215 "abort on the specified condition flags", "flags" },
3216 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3217 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3218 "copy initial non-keyframes" },
3219 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3220 "copy or discard frames before start time" },
3221 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3222 "set the number of frames to output", "number" },
3223 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3224 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3225 "force codec tag/fourcc", "fourcc/tag" },
3226 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3227 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3228 "use fixed quality scale (VBR)", "q" },
3229 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3230 OPT_OUTPUT, { .func_arg = opt_qscale },
3231 "use fixed quality scale (VBR)", "q" },
3232 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3233 "set profile", "profile" },
3234 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3235 "set stream filtergraph", "filter_graph" },
3236 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3237 "read stream filtergraph description from a file", "filename" },
3238 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3239 "reinit filtergraph on input parameter changes", "" },
3240 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3241 "create a complex filtergraph", "graph_description" },
3242 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3243 "create a complex filtergraph", "graph_description" },
3244 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3245 "read complex filtergraph description from a file", "filename" },
3246 { "stats", OPT_BOOL, { &print_stats },
3247 "print progress report during encoding", },
3248 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3249 OPT_OUTPUT, { .func_arg = opt_attach },
3250 "add an attachment to the output file", "filename" },
3251 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3252 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3253 "extract an attachment into a file", "filename" },
3254 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3255 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3256 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3257 "print timestamp debugging info" },
3258 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3259 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3260 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3261 OPT_INPUT, { .off = OFFSET(discard) },
3263 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3264 OPT_OUTPUT, { .off = OFFSET(disposition) },
3265 "disposition", "" },
3266 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3267 { .off = OFFSET(thread_queue_size) },
3268 "set the maximum number of queued packets from the demuxer" },
3271 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3272 "set the number of video frames to output", "number" },
3273 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3274 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3275 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3276 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3277 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3278 "set frame size (WxH or abbreviation)", "size" },
3279 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3280 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3281 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3282 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3283 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3284 "set pixel format", "format" },
3285 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3286 "set the number of bits per raw sample", "number" },
3287 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3288 "deprecated use -g 1" },
3289 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3291 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3292 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3293 "rate control override for specific intervals", "override" },
3294 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3295 OPT_OUTPUT, { .func_arg = opt_video_codec },
3296 "force video codec ('copy' to copy stream)", "codec" },
3297 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3299 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3301 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3302 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3303 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3304 "select the pass number (1 to 3)", "n" },
3305 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3306 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3307 "select two pass log file name prefix", "prefix" },
3308 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3309 "this option is deprecated, use the yadif filter instead" },
3310 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3311 "calculate PSNR of compressed frames" },
3312 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3313 "dump video coding statistics to file" },
3314 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3315 "dump video coding statistics to file", "file" },
3316 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3317 "set video filters", "filter_graph" },
3318 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3319 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3320 "specify intra matrix coeffs", "matrix" },
3321 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3322 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3323 "specify inter matrix coeffs", "matrix" },
3324 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3325 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3326 "specify intra matrix coeffs", "matrix" },
3327 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3328 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3329 "top=1/bottom=0/auto=-1 field first", "" },
3330 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3331 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3332 "force video tag/fourcc", "fourcc/tag" },
3333 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3334 "show QP histogram" },
3335 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3336 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3337 "force the selected framerate, disable the best supported framerate selection" },
3338 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3339 OPT_OUTPUT, { .func_arg = opt_streamid },
3340 "set the value of an outfile streamid", "streamIndex:value" },
3341 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3342 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3343 "force key frames at specified timestamps", "timestamps" },
3344 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3345 "audio bitrate (please use -b:a)", "bitrate" },
3346 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3347 "video bitrate (please use -b:v)", "bitrate" },
3348 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3349 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3350 "use HW accelerated decoding", "hwaccel name" },
3351 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3352 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3353 "select a device for HW acceleration", "devicename" },
3355 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3357 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3358 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3360 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3361 "show available HW acceleration methods" },
3362 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3363 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3364 "automatically insert correct rotate filters" },
3367 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3368 "set the number of audio frames to output", "number" },
3369 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3370 "set audio quality (codec-specific)", "quality", },
3371 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3372 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3373 "set audio sampling rate (in Hz)", "rate" },
3374 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3375 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3376 "set number of audio channels", "channels" },
3377 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3379 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3380 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3381 "force audio codec ('copy' to copy stream)", "codec" },
3382 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3383 OPT_OUTPUT, { .func_arg = opt_old2new },
3384 "force audio tag/fourcc", "fourcc/tag" },
3385 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3386 "change audio volume (256=normal)" , "volume" },
3387 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3388 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3389 "set sample format", "format" },
3390 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3391 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3392 "set channel layout", "layout" },
3393 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3394 "set audio filters", "filter_graph" },
3395 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3396 "set the maximum number of channels to try to guess the channel layout" },
3398 /* subtitle options */
3399 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3400 "disable subtitle" },
3401 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3402 "force subtitle codec ('copy' to copy stream)", "codec" },
3403 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3404 , "force subtitle tag/fourcc", "fourcc/tag" },
3405 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3406 "fix subtitles duration" },
3407 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3408 "set canvas size (WxH or abbreviation)", "size" },
3411 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3412 "deprecated, use -channel", "channel" },
3413 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3414 "deprecated, use -standard", "standard" },
3415 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3418 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3419 "set the maximum demux-decode delay", "seconds" },
3420 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3421 "set the initial demux-decode delay", "seconds" },
3422 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3423 "override the options from ffserver", "" },
3424 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3425 "specify a file in which to print sdp information", "file" },
3427 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3428 "A comma-separated list of bitstream filters", "bitstream_filters" },
3429 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3430 "deprecated", "audio bitstream_filters" },
3431 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3432 "deprecated", "video bitstream_filters" },
3434 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3435 "set the audio options to the indicated preset", "preset" },
3436 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3437 "set the video options to the indicated preset", "preset" },
3438 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3439 "set the subtitle options to the indicated preset", "preset" },
3440 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3441 "set options from indicated preset file", "filename" },
3442 /* data codec support */
3443 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3444 "force data codec ('copy' to copy stream)", "codec" },
3445 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },