2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
46 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
49 for (i = 0; i < o->nb_ ## name; i++) {\
50 char *spec = o->name[i].specifier;\
51 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52 outvar = o->name[i].u.type;\
58 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
61 for (i = 0; i < o->nb_ ## name; i++) {\
62 char *spec = o->name[i].specifier;\
63 if (!strcmp(spec, mediatype))\
64 outvar = o->name[i].u.type;\
68 const HWAccel hwaccels[] = {
70 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
73 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
76 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
78 #if CONFIG_VIDEOTOOLBOX
79 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
82 { "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
85 { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
88 { "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
92 int hwaccel_lax_profile_check = 0;
93 AVBufferRef *hw_device_ctx;
95 char *vstats_filename;
98 float audio_drift_threshold = 0.1;
99 float dts_delta_threshold = 10;
100 float dts_error_threshold = 3600*30;
102 int audio_volume = 256;
103 int audio_sync_method = 0;
104 int video_sync_method = VSYNC_AUTO;
105 float frame_drop_threshold = 0;
106 int do_deinterlace = 0;
107 int do_benchmark = 0;
108 int do_benchmark_all = 0;
112 int start_at_zero = 0;
115 int exit_on_error = 0;
116 int abort_on_flags = 0;
117 int print_stats = -1;
119 int stdin_interaction = 1;
120 int frame_bits_per_raw_sample = 0;
121 float max_error_rate = 2.0/3;
122 int filter_nbthreads = 0;
123 int filter_complex_nbthreads = 0;
126 static int intra_only = 0;
127 static int file_overwrite = 0;
128 static int no_file_overwrite = 0;
129 static int do_psnr = 0;
130 static int input_sync;
131 static int override_ffserver = 0;
132 static int input_stream_potentially_available = 0;
133 static int ignore_unknown_streams = 0;
134 static int copy_unknown_streams = 0;
136 static void uninit_options(OptionsContext *o)
138 const OptionDef *po = options;
141 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
143 void *dst = (uint8_t*)o + po->u.off;
145 if (po->flags & OPT_SPEC) {
146 SpecifierOpt **so = dst;
147 int i, *count = (int*)(so + 1);
148 for (i = 0; i < *count; i++) {
149 av_freep(&(*so)[i].specifier);
150 if (po->flags & OPT_STRING)
151 av_freep(&(*so)[i].u.str);
155 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
160 for (i = 0; i < o->nb_stream_maps; i++)
161 av_freep(&o->stream_maps[i].linklabel);
162 av_freep(&o->stream_maps);
163 av_freep(&o->audio_channel_maps);
164 av_freep(&o->streamid_map);
165 av_freep(&o->attachments);
168 static void init_options(OptionsContext *o)
170 memset(o, 0, sizeof(*o));
172 o->stop_time = INT64_MAX;
173 o->mux_max_delay = 0.7;
174 o->start_time = AV_NOPTS_VALUE;
175 o->start_time_eof = AV_NOPTS_VALUE;
176 o->recording_time = INT64_MAX;
177 o->limit_filesize = UINT64_MAX;
178 o->chapters_input_file = INT_MAX;
179 o->accurate_seek = 1;
182 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
186 printf("Hardware acceleration methods:\n");
187 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
188 printf("%s\n", hwaccels[i].name);
194 /* return a copy of the input with the stream specifiers removed from the keys */
195 static AVDictionary *strip_specifiers(AVDictionary *dict)
197 AVDictionaryEntry *e = NULL;
198 AVDictionary *ret = NULL;
200 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
201 char *p = strchr(e->key, ':');
205 av_dict_set(&ret, e->key, e->value, 0);
212 static int opt_abort_on(void *optctx, const char *opt, const char *arg)
214 static const AVOption opts[] = {
215 { "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
216 { "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
219 static const AVClass class = {
221 .item_name = av_default_item_name,
223 .version = LIBAVUTIL_VERSION_INT,
225 const AVClass *pclass = &class;
227 return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
230 static int opt_sameq(void *optctx, const char *opt, const char *arg)
232 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
233 "If you are looking for an option to preserve the quality (which is not "
234 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
236 return AVERROR(EINVAL);
239 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
241 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
242 return opt_default(optctx, "channel", arg);
245 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
247 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
248 return opt_default(optctx, "standard", arg);
251 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
253 OptionsContext *o = optctx;
254 return parse_option(o, "codec:a", arg, options);
257 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
259 OptionsContext *o = optctx;
260 return parse_option(o, "codec:v", arg, options);
263 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
265 OptionsContext *o = optctx;
266 return parse_option(o, "codec:s", arg, options);
269 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
271 OptionsContext *o = optctx;
272 return parse_option(o, "codec:d", arg, options);
275 static int opt_map(void *optctx, const char *opt, const char *arg)
277 OptionsContext *o = optctx;
279 int i, negative = 0, file_idx;
280 int sync_file_idx = -1, sync_stream_idx = 0;
289 map = av_strdup(arg);
291 return AVERROR(ENOMEM);
293 /* parse sync stream first, just pick first matching stream */
294 if (sync = strchr(map, ',')) {
296 sync_file_idx = strtol(sync + 1, &sync, 0);
297 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
298 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
303 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
304 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
305 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
309 if (i == input_files[sync_file_idx]->nb_streams) {
310 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
311 "match any streams.\n", arg);
318 /* this mapping refers to lavfi output */
319 const char *c = map + 1;
320 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
321 m = &o->stream_maps[o->nb_stream_maps - 1];
322 m->linklabel = av_get_token(&c, "]");
324 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
328 if (allow_unused = strchr(map, '?'))
330 file_idx = strtol(map, &p, 0);
331 if (file_idx >= nb_input_files || file_idx < 0) {
332 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
336 /* disable some already defined maps */
337 for (i = 0; i < o->nb_stream_maps; i++) {
338 m = &o->stream_maps[i];
339 if (file_idx == m->file_index &&
340 check_stream_specifier(input_files[m->file_index]->ctx,
341 input_files[m->file_index]->ctx->streams[m->stream_index],
342 *p == ':' ? p + 1 : p) > 0)
346 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
347 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
348 *p == ':' ? p + 1 : p) <= 0)
350 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
351 m = &o->stream_maps[o->nb_stream_maps - 1];
353 m->file_index = file_idx;
356 if (sync_file_idx >= 0) {
357 m->sync_file_index = sync_file_idx;
358 m->sync_stream_index = sync_stream_idx;
360 m->sync_file_index = file_idx;
361 m->sync_stream_index = i;
368 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
370 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
371 "To ignore this, add a trailing '?' to the map.\n", arg);
380 static int opt_attach(void *optctx, const char *opt, const char *arg)
382 OptionsContext *o = optctx;
383 GROW_ARRAY(o->attachments, o->nb_attachments);
384 o->attachments[o->nb_attachments - 1] = arg;
388 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
390 OptionsContext *o = optctx;
395 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
396 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
398 /* muted channel syntax */
399 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
400 if ((n == 1 || n == 3) && m->channel_idx == -1) {
401 m->file_idx = m->stream_idx = -1;
403 m->ofile_idx = m->ostream_idx = -1;
408 n = sscanf(arg, "%d.%d.%d:%d.%d",
409 &m->file_idx, &m->stream_idx, &m->channel_idx,
410 &m->ofile_idx, &m->ostream_idx);
412 if (n != 3 && n != 5) {
413 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
414 "[file.stream.channel|-1][:syncfile:syncstream]\n");
418 if (n != 5) // only file.stream.channel specified
419 m->ofile_idx = m->ostream_idx = -1;
422 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
423 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
427 if (m->stream_idx < 0 ||
428 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
429 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
430 m->file_idx, m->stream_idx);
433 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
434 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
435 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
436 m->file_idx, m->stream_idx);
439 if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
440 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
441 m->file_idx, m->stream_idx, m->channel_idx);
447 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
449 av_free(sdp_filename);
450 sdp_filename = av_strdup(arg);
455 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
458 err = vaapi_device_init(arg);
466 * Parse a metadata specifier passed as 'arg' parameter.
467 * @param arg metadata string to parse
468 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
469 * @param index for type c/p, chapter/program index is written here
470 * @param stream_spec for type s, the stream specifier is written here
472 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
480 if (*(++arg) && *arg != ':') {
481 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
484 *stream_spec = *arg == ':' ? arg + 1 : "";
489 *index = strtol(++arg, NULL, 0);
492 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
499 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
501 AVDictionary **meta_in = NULL;
502 AVDictionary **meta_out = NULL;
504 char type_in, type_out;
505 const char *istream_spec = NULL, *ostream_spec = NULL;
506 int idx_in = 0, idx_out = 0;
508 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
509 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
512 if (type_out == 'g' || !*outspec)
513 o->metadata_global_manual = 1;
514 if (type_out == 's' || !*outspec)
515 o->metadata_streams_manual = 1;
516 if (type_out == 'c' || !*outspec)
517 o->metadata_chapters_manual = 1;
521 if (type_in == 'g' || type_out == 'g')
522 o->metadata_global_manual = 1;
523 if (type_in == 's' || type_out == 's')
524 o->metadata_streams_manual = 1;
525 if (type_in == 'c' || type_out == 'c')
526 o->metadata_chapters_manual = 1;
528 /* ic is NULL when just disabling automatic mappings */
532 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
533 if ((index) < 0 || (index) >= (nb_elems)) {\
534 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
539 #define SET_DICT(type, meta, context, index)\
542 meta = &context->metadata;\
545 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
546 meta = &context->chapters[index]->metadata;\
549 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
550 meta = &context->programs[index]->metadata;\
553 break; /* handled separately below */ \
554 default: av_assert0(0);\
557 SET_DICT(type_in, meta_in, ic, idx_in);
558 SET_DICT(type_out, meta_out, oc, idx_out);
560 /* for input streams choose first matching stream */
561 if (type_in == 's') {
562 for (i = 0; i < ic->nb_streams; i++) {
563 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
564 meta_in = &ic->streams[i]->metadata;
570 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
575 if (type_out == 's') {
576 for (i = 0; i < oc->nb_streams; i++) {
577 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
578 meta_out = &oc->streams[i]->metadata;
579 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
584 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
589 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
591 OptionsContext *o = optctx;
593 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
594 struct tm time = *gmtime((time_t*)&recording_timestamp);
595 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
597 parse_option(o, "metadata", buf, options);
599 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
600 "tag instead.\n", opt);
604 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
606 const AVCodecDescriptor *desc;
607 const char *codec_string = encoder ? "encoder" : "decoder";
611 avcodec_find_encoder_by_name(name) :
612 avcodec_find_decoder_by_name(name);
614 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
615 codec = encoder ? avcodec_find_encoder(desc->id) :
616 avcodec_find_decoder(desc->id);
618 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
619 codec_string, codec->name, desc->name);
623 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
626 if (codec->type != type) {
627 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
633 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
635 char *codec_name = NULL;
637 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
639 AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
640 st->codecpar->codec_id = codec->id;
643 return avcodec_find_decoder(st->codecpar->codec_id);
646 /* Add all the streams from the given input file to the global
647 * list of input streams. */
648 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
652 for (i = 0; i < ic->nb_streams; i++) {
653 AVStream *st = ic->streams[i];
654 AVCodecParameters *par = st->codecpar;
655 InputStream *ist = av_mallocz(sizeof(*ist));
656 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
657 char *hwaccel_output_format = NULL;
658 char *codec_tag = NULL;
660 char *discard_str = NULL;
661 const AVClass *cc = avcodec_get_class();
662 const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
667 GROW_ARRAY(input_streams, nb_input_streams);
668 input_streams[nb_input_streams - 1] = ist;
671 ist->file_index = nb_input_files;
673 st->discard = AVDISCARD_ALL;
675 ist->min_pts = INT64_MAX;
676 ist->max_pts = INT64_MIN;
679 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
682 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
684 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
686 uint32_t tag = strtol(codec_tag, &next, 0);
688 tag = AV_RL32(codec_tag);
689 st->codecpar->codec_tag = tag;
692 ist->dec = choose_decoder(o, ic, st);
693 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
695 ist->reinit_filters = -1;
696 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
698 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
699 ist->user_set_discard = AVDISCARD_NONE;
700 if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
701 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
706 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
708 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
710 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
714 ret = avcodec_parameters_to_context(ist->dec_ctx, par);
716 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
720 switch (par->codec_type) {
721 case AVMEDIA_TYPE_VIDEO:
723 ist->dec = avcodec_find_decoder(par->codec_id);
725 if (av_codec_get_lowres(st->codec)) {
726 av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
727 ist->dec_ctx->width = st->codec->width;
728 ist->dec_ctx->height = st->codec->height;
729 ist->dec_ctx->coded_width = st->codec->coded_width;
730 ist->dec_ctx->coded_height = st->codec->coded_height;
731 ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
735 // avformat_find_stream_info() doesn't set this for us anymore.
736 ist->dec_ctx->framerate = st->avg_frame_rate;
738 ist->resample_height = ist->dec_ctx->height;
739 ist->resample_width = ist->dec_ctx->width;
740 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
742 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
743 if (framerate && av_parse_video_rate(&ist->framerate,
745 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
750 ist->top_field_first = -1;
751 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
753 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
755 if (!strcmp(hwaccel, "none"))
756 ist->hwaccel_id = HWACCEL_NONE;
757 else if (!strcmp(hwaccel, "auto"))
758 ist->hwaccel_id = HWACCEL_AUTO;
761 for (i = 0; hwaccels[i].name; i++) {
762 if (!strcmp(hwaccels[i].name, hwaccel)) {
763 ist->hwaccel_id = hwaccels[i].id;
768 if (!ist->hwaccel_id) {
769 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
771 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
772 for (i = 0; hwaccels[i].name; i++)
773 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
774 av_log(NULL, AV_LOG_FATAL, "\n");
780 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
781 if (hwaccel_device) {
782 ist->hwaccel_device = av_strdup(hwaccel_device);
783 if (!ist->hwaccel_device)
787 MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
788 hwaccel_output_format, ic, st);
789 if (hwaccel_output_format) {
790 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
791 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
792 av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
793 "format: %s", hwaccel_output_format);
796 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
799 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
802 case AVMEDIA_TYPE_AUDIO:
803 ist->guess_layout_max = INT_MAX;
804 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
805 guess_input_channel_layout(ist);
807 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
808 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
809 ist->resample_channels = ist->dec_ctx->channels;
810 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
813 case AVMEDIA_TYPE_DATA:
814 case AVMEDIA_TYPE_SUBTITLE: {
815 char *canvas_size = NULL;
817 ist->dec = avcodec_find_decoder(par->codec_id);
818 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
819 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
821 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
822 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
827 case AVMEDIA_TYPE_ATTACHMENT:
828 case AVMEDIA_TYPE_UNKNOWN:
834 ret = avcodec_parameters_from_context(par, ist->dec_ctx);
836 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
842 static void assert_file_overwrite(const char *filename)
844 if (file_overwrite && no_file_overwrite) {
845 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
849 if (!file_overwrite) {
850 const char *proto_name = avio_find_protocol_name(filename);
851 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
852 if (stdin_interaction && !no_file_overwrite) {
853 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
856 signal(SIGINT, SIG_DFL);
858 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
864 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
871 static void dump_attachment(AVStream *st, const char *filename)
874 AVIOContext *out = NULL;
875 AVDictionaryEntry *e;
877 if (!st->codecpar->extradata_size) {
878 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
879 nb_input_files - 1, st->index);
882 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
885 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
886 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
890 assert_file_overwrite(filename);
892 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
893 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
898 avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
903 static int open_input_file(OptionsContext *o, const char *filename)
907 AVInputFormat *file_iformat = NULL;
911 AVDictionary *unused_opts = NULL;
912 AVDictionaryEntry *e = NULL;
913 int orig_nb_streams; // number of streams before avformat_find_stream_info
914 char * video_codec_name = NULL;
915 char * audio_codec_name = NULL;
916 char *subtitle_codec_name = NULL;
917 char * data_codec_name = NULL;
918 int scan_all_pmts_set = 0;
921 if (!(file_iformat = av_find_input_format(o->format))) {
922 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
927 if (!strcmp(filename, "-"))
930 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
931 strcmp(filename, "/dev/stdin");
933 /* get default parameters from command line */
934 ic = avformat_alloc_context();
936 print_error(filename, AVERROR(ENOMEM));
939 if (o->nb_audio_sample_rate) {
940 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
942 if (o->nb_audio_channels) {
943 /* because we set audio_channels based on both the "ac" and
944 * "channel_layout" options, we need to check that the specified
945 * demuxer actually has the "channels" option before setting it */
946 if (file_iformat && file_iformat->priv_class &&
947 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
948 AV_OPT_SEARCH_FAKE_OBJ)) {
949 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
952 if (o->nb_frame_rates) {
953 /* set the format-level framerate option;
954 * this is important for video grabbers, e.g. x11 */
955 if (file_iformat && file_iformat->priv_class &&
956 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
957 AV_OPT_SEARCH_FAKE_OBJ)) {
958 av_dict_set(&o->g->format_opts, "framerate",
959 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
962 if (o->nb_frame_sizes) {
963 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
965 if (o->nb_frame_pix_fmts)
966 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
968 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
969 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
970 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
971 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
973 ic->video_codec_id = video_codec_name ?
974 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
975 ic->audio_codec_id = audio_codec_name ?
976 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
977 ic->subtitle_codec_id= subtitle_codec_name ?
978 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
979 ic->data_codec_id = data_codec_name ?
980 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
982 if (video_codec_name)
983 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
984 if (audio_codec_name)
985 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
986 if (subtitle_codec_name)
987 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
989 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
991 ic->flags |= AVFMT_FLAG_NONBLOCK;
992 ic->interrupt_callback = int_cb;
994 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
995 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
996 scan_all_pmts_set = 1;
998 /* open the input file with generic avformat function */
999 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1001 print_error(filename, err);
1002 if (err == AVERROR_PROTOCOL_NOT_FOUND)
1003 av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1006 if (scan_all_pmts_set)
1007 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1008 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1009 assert_avoptions(o->g->format_opts);
1011 /* apply forced codec ids */
1012 for (i = 0; i < ic->nb_streams; i++)
1013 choose_decoder(o, ic, ic->streams[i]);
1015 /* Set AVCodecContext options for avformat_find_stream_info */
1016 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1017 orig_nb_streams = ic->nb_streams;
1019 /* If not enough info to get the stream parameters, we decode the
1020 first frames to get it. (used in mpeg case for example) */
1021 ret = avformat_find_stream_info(ic, opts);
1023 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1024 if (ic->nb_streams == 0) {
1025 avformat_close_input(&ic);
1030 if (o->start_time_eof != AV_NOPTS_VALUE) {
1031 if (ic->duration>0) {
1032 o->start_time = o->start_time_eof + ic->duration;
1034 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1036 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1037 /* add the stream start time */
1038 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1039 timestamp += ic->start_time;
1041 /* if seeking requested, we execute it */
1042 if (o->start_time != AV_NOPTS_VALUE) {
1043 int64_t seek_timestamp = timestamp;
1045 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1046 int dts_heuristic = 0;
1047 for (i=0; i<ic->nb_streams; i++) {
1048 const AVCodecParameters *par = ic->streams[i]->codecpar;
1049 if (par->video_delay)
1052 if (dts_heuristic) {
1053 seek_timestamp -= 3*AV_TIME_BASE / 23;
1056 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1058 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1059 filename, (double)timestamp / AV_TIME_BASE);
1063 /* update the current parameters so that they match the one of the input stream */
1064 add_input_streams(o, ic);
1066 /* dump the file content */
1067 av_dump_format(ic, nb_input_files, filename, 0);
1069 GROW_ARRAY(input_files, nb_input_files);
1070 f = av_mallocz(sizeof(*f));
1073 input_files[nb_input_files - 1] = f;
1076 f->ist_index = nb_input_streams - ic->nb_streams;
1077 f->start_time = o->start_time;
1078 f->recording_time = o->recording_time;
1079 f->input_ts_offset = o->input_ts_offset;
1080 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1081 f->nb_streams = ic->nb_streams;
1082 f->rate_emu = o->rate_emu;
1083 f->accurate_seek = o->accurate_seek;
1086 f->time_base = (AVRational){ 1, 1 };
1088 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1091 /* check if all codec options have been used */
1092 unused_opts = strip_specifiers(o->g->codec_opts);
1093 for (i = f->ist_index; i < nb_input_streams; i++) {
1095 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1096 AV_DICT_IGNORE_SUFFIX)))
1097 av_dict_set(&unused_opts, e->key, NULL, 0);
1101 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1102 const AVClass *class = avcodec_get_class();
1103 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1104 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1105 const AVClass *fclass = avformat_get_class();
1106 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1107 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1108 if (!option || foption)
1112 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1113 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1114 "input file #%d (%s) is not a decoding option.\n", e->key,
1115 option->help ? option->help : "", nb_input_files - 1,
1120 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1121 "input file #%d (%s) has not been used for any stream. The most "
1122 "likely reason is either wrong type (e.g. a video option with "
1123 "no video streams) or that it is a private option of some decoder "
1124 "which was not actually used for any stream.\n", e->key,
1125 option->help ? option->help : "", nb_input_files - 1, filename);
1127 av_dict_free(&unused_opts);
1129 for (i = 0; i < o->nb_dump_attachment; i++) {
1132 for (j = 0; j < ic->nb_streams; j++) {
1133 AVStream *st = ic->streams[j];
1135 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1136 dump_attachment(st, o->dump_attachment[i].u.str);
1140 for (i = 0; i < orig_nb_streams; i++)
1141 av_dict_free(&opts[i]);
1144 input_stream_potentially_available = 1;
1149 static uint8_t *get_line(AVIOContext *s)
1155 if (avio_open_dyn_buf(&line) < 0) {
1156 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1160 while ((c = avio_r8(s)) && c != '\n')
1163 avio_close_dyn_buf(line, &buf);
1168 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1171 char filename[1000];
1172 const char *base[3] = { getenv("AVCONV_DATADIR"),
1177 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1181 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1182 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1183 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1186 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1187 i != 1 ? "" : "/.avconv", preset_name);
1188 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1194 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1196 enum AVMediaType type = ost->st->codecpar->codec_type;
1197 char *codec_name = NULL;
1199 if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1200 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1202 ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1203 NULL, ost->st->codecpar->codec_type);
1204 ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1206 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1207 "output stream #%d:%d. Default encoder for format %s (codec %s) is "
1208 "probably disabled. Please choose an encoder manually.\n",
1209 ost->file_index, ost->index, s->oformat->name,
1210 avcodec_get_name(ost->st->codecpar->codec_id));
1211 return AVERROR_ENCODER_NOT_FOUND;
1213 } else if (!strcmp(codec_name, "copy"))
1214 ost->stream_copy = 1;
1216 ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1217 ost->st->codecpar->codec_id = ost->enc->id;
1219 ost->encoding_needed = !ost->stream_copy;
1221 /* no encoding supported for other media types */
1222 ost->stream_copy = 1;
1223 ost->encoding_needed = 0;
1229 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1232 AVStream *st = avformat_new_stream(oc, NULL);
1233 int idx = oc->nb_streams - 1, ret = 0;
1234 const char *bsfs = NULL;
1235 char *next, *codec_tag = NULL;
1240 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1244 if (oc->nb_streams - 1 < o->nb_streamid_map)
1245 st->id = o->streamid_map[oc->nb_streams - 1];
1247 GROW_ARRAY(output_streams, nb_output_streams);
1248 if (!(ost = av_mallocz(sizeof(*ost))))
1250 output_streams[nb_output_streams - 1] = ost;
1252 ost->file_index = nb_output_files - 1;
1255 st->codecpar->codec_type = type;
1257 ret = choose_encoder(o, oc, ost);
1259 av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1260 "%d:%d\n", ost->file_index, ost->index);
1264 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1265 if (!ost->enc_ctx) {
1266 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1269 ost->enc_ctx->codec_type = type;
1271 ost->ref_par = avcodec_parameters_alloc();
1272 if (!ost->ref_par) {
1273 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1278 AVIOContext *s = NULL;
1279 char *buf = NULL, *arg = NULL, *preset = NULL;
1281 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1283 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1284 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1287 if (!buf[0] || buf[0] == '#') {
1291 if (!(arg = strchr(buf, '='))) {
1292 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1296 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1298 } while (!s->eof_reached);
1302 av_log(NULL, AV_LOG_FATAL,
1303 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1304 preset, ost->file_index, ost->index);
1308 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1311 ost->max_frames = INT64_MAX;
1312 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1313 for (i = 0; i<o->nb_max_frames; i++) {
1314 char *p = o->max_frames[i].specifier;
1315 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1316 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1321 ost->copy_prior_start = -1;
1322 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1324 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1325 while (bsfs && *bsfs) {
1326 const AVBitStreamFilter *filter;
1327 char *bsf, *bsf_options_str, *bsf_name;
1329 bsf = av_get_token(&bsfs, ",");
1332 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1336 filter = av_bsf_get_by_name(bsf_name);
1338 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1342 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1343 ost->nb_bitstream_filters + 1,
1344 sizeof(*ost->bsf_ctx));
1348 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1350 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1354 ost->nb_bitstream_filters++;
1356 if (bsf_options_str && filter->priv_class) {
1357 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1358 const char * shorthand[2] = {NULL};
1361 shorthand[0] = opt->name;
1363 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1365 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1374 if (ost->nb_bitstream_filters) {
1375 ost->bsf_extradata_updated = av_mallocz_array(ost->nb_bitstream_filters, sizeof(*ost->bsf_extradata_updated));
1376 if (!ost->bsf_extradata_updated) {
1377 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1382 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1384 uint32_t tag = strtol(codec_tag, &next, 0);
1386 tag = AV_RL32(codec_tag);
1387 ost->st->codecpar->codec_tag =
1388 ost->enc_ctx->codec_tag = tag;
1391 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1393 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1394 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1397 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1398 ost->disposition = av_strdup(ost->disposition);
1400 ost->max_muxing_queue_size = 128;
1401 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1402 ost->max_muxing_queue_size *= sizeof(AVPacket);
1404 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1405 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1407 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1409 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1410 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1411 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1413 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1415 ost->source_index = source_index;
1416 if (source_index >= 0) {
1417 ost->sync_ist = input_streams[source_index];
1418 input_streams[source_index]->discard = 0;
1419 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1421 ost->last_mux_dts = AV_NOPTS_VALUE;
1423 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1424 if (!ost->muxing_queue)
1430 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1433 const char *p = str;
1440 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1447 /* read file contents into a string */
1448 static uint8_t *read_file(const char *filename)
1450 AVIOContext *pb = NULL;
1451 AVIOContext *dyn_buf = NULL;
1452 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1453 uint8_t buf[1024], *str;
1456 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1460 ret = avio_open_dyn_buf(&dyn_buf);
1465 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1466 avio_write(dyn_buf, buf, ret);
1467 avio_w8(dyn_buf, 0);
1470 ret = avio_close_dyn_buf(dyn_buf, &str);
1476 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1479 AVStream *st = ost->st;
1481 if (ost->filters_script && ost->filters) {
1482 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1483 "output stream #%d:%d.\n", nb_output_files, st->index);
1487 if (ost->filters_script)
1488 return read_file(ost->filters_script);
1489 else if (ost->filters)
1490 return av_strdup(ost->filters);
1492 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1496 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1497 const OutputStream *ost, enum AVMediaType type)
1499 if (ost->filters_script || ost->filters) {
1500 av_log(NULL, AV_LOG_ERROR,
1501 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1502 "Filtering and streamcopy cannot be used together.\n",
1503 ost->filters ? "Filtergraph" : "Filtergraph script",
1504 ost->filters ? ost->filters : ost->filters_script,
1505 av_get_media_type_string(type), ost->file_index, ost->index);
1510 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1514 AVCodecContext *video_enc;
1515 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1517 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1519 video_enc = ost->enc_ctx;
1521 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1522 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1523 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1526 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1527 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1529 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1530 if (frame_aspect_ratio) {
1532 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1533 q.num <= 0 || q.den <= 0) {
1534 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1537 ost->frame_aspect_ratio = q;
1540 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1541 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1543 if (!ost->stream_copy) {
1544 const char *p = NULL;
1545 char *frame_size = NULL;
1546 char *frame_pix_fmt = NULL;
1547 char *intra_matrix = NULL, *inter_matrix = NULL;
1548 char *chroma_intra_matrix = NULL;
1552 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1553 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1554 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1558 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1559 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1560 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1561 ost->keep_pix_fmt = 1;
1562 if (!*++frame_pix_fmt)
1563 frame_pix_fmt = NULL;
1565 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1566 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1569 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1572 video_enc->gop_size = 0;
1573 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1575 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1576 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1579 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1581 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1582 if (chroma_intra_matrix) {
1583 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1585 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1588 av_codec_set_chroma_intra_matrix(video_enc, p);
1589 parse_matrix_coeffs(p, chroma_intra_matrix);
1591 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1593 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1594 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1597 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1600 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1601 for (i = 0; p; i++) {
1603 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1605 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1608 video_enc->rc_override =
1609 av_realloc_array(video_enc->rc_override,
1610 i + 1, sizeof(RcOverride));
1611 if (!video_enc->rc_override) {
1612 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1615 video_enc->rc_override[i].start_frame = start;
1616 video_enc->rc_override[i].end_frame = end;
1618 video_enc->rc_override[i].qscale = q;
1619 video_enc->rc_override[i].quality_factor = 1.0;
1622 video_enc->rc_override[i].qscale = 0;
1623 video_enc->rc_override[i].quality_factor = -q/100.0;
1628 video_enc->rc_override_count = i;
1631 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1634 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1637 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1638 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1641 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1642 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1646 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1647 if (ost->logfile_prefix &&
1648 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1652 char logfilename[1024];
1655 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1656 ost->logfile_prefix ? ost->logfile_prefix :
1657 DEFAULT_PASS_LOGFILENAME_PREFIX,
1659 if (!strcmp(ost->enc->name, "libx264")) {
1660 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1662 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1663 char *logbuffer = read_file(logfilename);
1666 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1670 video_enc->stats_in = logbuffer;
1672 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1673 f = av_fopen_utf8(logfilename, "wb");
1675 av_log(NULL, AV_LOG_FATAL,
1676 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1677 logfilename, strerror(errno));
1685 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1686 if (ost->forced_keyframes)
1687 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1689 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1691 ost->top_field_first = -1;
1692 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1695 ost->avfilter = get_ost_filters(o, oc, ost);
1699 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1702 if (ost->stream_copy)
1703 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1708 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1713 AVCodecContext *audio_enc;
1715 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1718 audio_enc = ost->enc_ctx;
1719 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1721 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1722 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1724 if (!ost->stream_copy) {
1725 char *sample_fmt = NULL;
1727 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1729 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1731 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1732 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1736 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1738 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1739 ost->apad = av_strdup(ost->apad);
1741 ost->avfilter = get_ost_filters(o, oc, ost);
1745 /* check for channel mapping for this audio stream */
1746 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1747 AudioChannelMap *map = &o->audio_channel_maps[n];
1748 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1749 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1752 if (map->channel_idx == -1) {
1754 } else if (ost->source_index < 0) {
1755 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1756 ost->file_index, ost->st->index);
1759 ist = input_streams[ost->source_index];
1762 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1763 if (av_reallocp_array(&ost->audio_channels_map,
1764 ost->audio_channels_mapped + 1,
1765 sizeof(*ost->audio_channels_map)
1769 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1775 if (ost->stream_copy)
1776 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1781 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1785 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1786 if (!ost->stream_copy) {
1787 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1794 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1798 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1799 if (!ost->stream_copy) {
1800 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1807 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1809 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1810 ost->stream_copy = 1;
1815 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1819 AVCodecContext *subtitle_enc;
1821 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1823 subtitle_enc = ost->enc_ctx;
1825 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1827 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1829 if (!ost->stream_copy) {
1830 char *frame_size = NULL;
1832 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1833 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1834 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1842 /* arg format is "output-stream-index:streamid-value". */
1843 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1845 OptionsContext *o = optctx;
1850 av_strlcpy(idx_str, arg, sizeof(idx_str));
1851 p = strchr(idx_str, ':');
1853 av_log(NULL, AV_LOG_FATAL,
1854 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1859 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1860 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1861 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1865 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1867 AVFormatContext *is = ifile->ctx;
1868 AVFormatContext *os = ofile->ctx;
1872 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1874 return AVERROR(ENOMEM);
1877 for (i = 0; i < is->nb_chapters; i++) {
1878 AVChapter *in_ch = is->chapters[i], *out_ch;
1879 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1880 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1881 AV_TIME_BASE_Q, in_ch->time_base);
1882 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1883 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1886 if (in_ch->end < ts_off)
1888 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1891 out_ch = av_mallocz(sizeof(AVChapter));
1893 return AVERROR(ENOMEM);
1895 out_ch->id = in_ch->id;
1896 out_ch->time_base = in_ch->time_base;
1897 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1898 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1901 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1903 os->chapters[os->nb_chapters++] = out_ch;
1908 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1911 AVFormatContext *ic = avformat_alloc_context();
1913 ic->interrupt_callback = int_cb;
1914 err = avformat_open_input(&ic, filename, NULL, NULL);
1917 /* copy stream format */
1918 for(i=0;i<ic->nb_streams;i++) {
1922 const char *enc_config;
1924 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1926 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1927 return AVERROR(EINVAL);
1929 if (codec->type == AVMEDIA_TYPE_AUDIO)
1930 opt_audio_codec(o, "c:a", codec->name);
1931 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1932 opt_video_codec(o, "c:v", codec->name);
1933 ost = new_output_stream(o, s, codec->type, -1);
1936 avcodec_get_context_defaults3(st->codec, codec);
1937 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1939 AVDictionary *opts = NULL;
1940 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1941 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1942 av_dict_free(&opts);
1945 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1946 choose_sample_fmt(st, codec);
1947 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1948 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1949 avcodec_copy_context(ost->enc_ctx, st->codec);
1951 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1954 avformat_close_input(&ic);
1958 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1959 AVFormatContext *oc)
1963 switch (ofilter->type) {
1964 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1965 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1967 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1972 ost->source_index = -1;
1973 ost->filter = ofilter;
1976 ofilter->format = -1;
1978 if (ost->stream_copy) {
1979 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1980 "which is fed from a complex filtergraph. Filtering and streamcopy "
1981 "cannot be used together.\n", ost->file_index, ost->index);
1985 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1986 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1987 av_log(NULL, AV_LOG_ERROR,
1988 "%s '%s' was specified through the %s option "
1989 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1990 "%s and -filter_complex cannot be used together for the same stream.\n",
1991 ost->filters ? "Filtergraph" : "Filtergraph script",
1992 ost->filters ? ost->filters : ost->filters_script,
1993 opt, ost->file_index, ost->index, opt);
1997 avfilter_inout_free(&ofilter->out_tmp);
2000 static int init_complex_filters(void)
2004 for (i = 0; i < nb_filtergraphs; i++) {
2005 ret = init_complex_filtergraph(filtergraphs[i]);
2012 static int configure_complex_filters(void)
2016 for (i = 0; i < nb_filtergraphs; i++) {
2017 FilterGraph *fg = filtergraphs[i];
2019 if (filtergraph_is_simple(fg))
2022 for (j = 0; j < fg->nb_inputs; j++) {
2023 ret = ifilter_parameters_from_decoder(fg->inputs[j],
2024 fg->inputs[j]->ist->dec_ctx);
2026 av_log(NULL, AV_LOG_ERROR,
2027 "Error initializing filtergraph %d input %d\n", i, j);
2032 ret = configure_filtergraph(filtergraphs[i]);
2039 static int open_output_file(OptionsContext *o, const char *filename)
2041 AVFormatContext *oc;
2043 AVOutputFormat *file_oformat;
2047 AVDictionary *unused_opts = NULL;
2048 AVDictionaryEntry *e = NULL;
2049 int format_flags = 0;
2051 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2052 o->stop_time = INT64_MAX;
2053 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2056 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2057 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2058 if (o->stop_time <= start_time) {
2059 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2062 o->recording_time = o->stop_time - start_time;
2066 GROW_ARRAY(output_files, nb_output_files);
2067 of = av_mallocz(sizeof(*of));
2070 output_files[nb_output_files - 1] = of;
2072 of->ost_index = nb_output_streams;
2073 of->recording_time = o->recording_time;
2074 of->start_time = o->start_time;
2075 of->limit_filesize = o->limit_filesize;
2076 of->shortest = o->shortest;
2077 av_dict_copy(&of->opts, o->g->format_opts, 0);
2079 if (!strcmp(filename, "-"))
2082 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2084 print_error(filename, err);
2089 if (o->recording_time != INT64_MAX)
2090 oc->duration = o->recording_time;
2092 file_oformat= oc->oformat;
2093 oc->interrupt_callback = int_cb;
2095 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2097 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2098 av_opt_eval_flags(oc, o, e->value, &format_flags);
2101 /* create streams for all unlabeled output pads */
2102 for (i = 0; i < nb_filtergraphs; i++) {
2103 FilterGraph *fg = filtergraphs[i];
2104 for (j = 0; j < fg->nb_outputs; j++) {
2105 OutputFilter *ofilter = fg->outputs[j];
2107 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2110 switch (ofilter->type) {
2111 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2112 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2113 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2115 init_output_filter(ofilter, o, oc);
2119 /* ffserver seeking with date=... needs a date reference */
2120 if (!strcmp(file_oformat->name, "ffm") &&
2121 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2122 av_strstart(filename, "http:", NULL)) {
2123 int err = parse_option(o, "metadata", "creation_time=now", options);
2125 print_error(filename, err);
2130 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2131 av_strstart(filename, "http:", NULL)) {
2133 /* special case for files sent to ffserver: we get the stream
2134 parameters from ffserver */
2135 int err = read_ffserver_streams(o, oc, filename);
2137 print_error(filename, err);
2140 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2141 ost = output_streams[j];
2142 for (i = 0; i < nb_input_streams; i++) {
2143 ist = input_streams[i];
2144 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2146 ost->source_index= i;
2147 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2148 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2150 ist->st->discard = ist->user_set_discard;
2155 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
2159 } else if (!o->nb_stream_maps) {
2160 char *subtitle_codec_name = NULL;
2161 /* pick the "best" stream of each type */
2163 /* video: highest resolution */
2164 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2165 int area = 0, idx = -1;
2166 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2167 for (i = 0; i < nb_input_streams; i++) {
2169 ist = input_streams[i];
2170 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2171 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2173 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2175 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2182 new_video_stream(o, oc, idx);
2185 /* audio: most channels */
2186 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2187 int best_score = 0, idx = -1;
2188 for (i = 0; i < nb_input_streams; i++) {
2190 ist = input_streams[i];
2191 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2192 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2193 score > best_score) {
2199 new_audio_stream(o, oc, idx);
2202 /* subtitles: pick first */
2203 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2204 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2205 for (i = 0; i < nb_input_streams; i++)
2206 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2207 AVCodecDescriptor const *input_descriptor =
2208 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2209 AVCodecDescriptor const *output_descriptor = NULL;
2210 AVCodec const *output_codec =
2211 avcodec_find_encoder(oc->oformat->subtitle_codec);
2212 int input_props = 0, output_props = 0;
2214 output_descriptor = avcodec_descriptor_get(output_codec->id);
2215 if (input_descriptor)
2216 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2217 if (output_descriptor)
2218 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2219 if (subtitle_codec_name ||
2220 input_props & output_props ||
2221 // Map dvb teletext which has neither property to any output subtitle encoder
2222 input_descriptor && output_descriptor &&
2223 (!input_descriptor->props ||
2224 !output_descriptor->props)) {
2225 new_subtitle_stream(o, oc, i);
2230 /* Data only if codec id match */
2231 if (!o->data_disable ) {
2232 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2233 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2234 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2235 && input_streams[i]->st->codecpar->codec_id == codec_id )
2236 new_data_stream(o, oc, i);
2240 for (i = 0; i < o->nb_stream_maps; i++) {
2241 StreamMap *map = &o->stream_maps[i];
2246 if (map->linklabel) {
2248 OutputFilter *ofilter = NULL;
2251 for (j = 0; j < nb_filtergraphs; j++) {
2252 fg = filtergraphs[j];
2253 for (k = 0; k < fg->nb_outputs; k++) {
2254 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2255 if (out && !strcmp(out->name, map->linklabel)) {
2256 ofilter = fg->outputs[k];
2263 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2264 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2267 init_output_filter(ofilter, o, oc);
2269 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2271 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2272 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2274 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2276 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2278 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2282 switch (ist->st->codecpar->codec_type) {
2283 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2284 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2285 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2286 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2287 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2288 case AVMEDIA_TYPE_UNKNOWN:
2289 if (copy_unknown_streams) {
2290 ost = new_unknown_stream (o, oc, src_idx);
2294 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2295 "Cannot map stream #%d:%d - unsupported type.\n",
2296 map->file_index, map->stream_index);
2297 if (!ignore_unknown_streams) {
2298 av_log(NULL, AV_LOG_FATAL,
2299 "If you want unsupported types ignored instead "
2300 "of failing, please use the -ignore_unknown option\n"
2301 "If you want them copied, please use -copy_unknown\n");
2306 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2307 + map->sync_stream_index];
2312 /* handle attached files */
2313 for (i = 0; i < o->nb_attachments; i++) {
2315 uint8_t *attachment;
2319 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2320 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2324 if ((len = avio_size(pb)) <= 0) {
2325 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2329 if (!(attachment = av_malloc(len))) {
2330 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2334 avio_read(pb, attachment, len);
2336 ost = new_attachment_stream(o, oc, -1);
2337 ost->stream_copy = 0;
2338 ost->attachment_filename = o->attachments[i];
2339 ost->st->codecpar->extradata = attachment;
2340 ost->st->codecpar->extradata_size = len;
2342 p = strrchr(o->attachments[i], '/');
2343 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2347 #if FF_API_LAVF_AVCTX
2348 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2349 AVDictionaryEntry *e;
2350 ost = output_streams[i];
2352 if ((ost->stream_copy || ost->attachment_filename)
2353 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2354 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2355 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2360 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2361 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2362 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2366 /* check if all codec options have been used */
2367 unused_opts = strip_specifiers(o->g->codec_opts);
2368 for (i = of->ost_index; i < nb_output_streams; i++) {
2370 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2371 AV_DICT_IGNORE_SUFFIX)))
2372 av_dict_set(&unused_opts, e->key, NULL, 0);
2376 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2377 const AVClass *class = avcodec_get_class();
2378 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2379 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2380 const AVClass *fclass = avformat_get_class();
2381 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2382 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2383 if (!option || foption)
2387 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2388 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2389 "output file #%d (%s) is not an encoding option.\n", e->key,
2390 option->help ? option->help : "", nb_output_files - 1,
2395 // gop_timecode is injected by generic code but not always used
2396 if (!strcmp(e->key, "gop_timecode"))
2399 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2400 "output file #%d (%s) has not been used for any stream. The most "
2401 "likely reason is either wrong type (e.g. a video option with "
2402 "no video streams) or that it is a private option of some encoder "
2403 "which was not actually used for any stream.\n", e->key,
2404 option->help ? option->help : "", nb_output_files - 1, filename);
2406 av_dict_free(&unused_opts);
2408 /* set the decoding_needed flags and create simple filtergraphs */
2409 for (i = of->ost_index; i < nb_output_streams; i++) {
2410 OutputStream *ost = output_streams[i];
2412 if (ost->encoding_needed && ost->source_index >= 0) {
2413 InputStream *ist = input_streams[ost->source_index];
2414 ist->decoding_needed |= DECODING_FOR_OST;
2416 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2417 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2418 err = init_simple_filtergraph(ist, ost);
2420 av_log(NULL, AV_LOG_ERROR,
2421 "Error initializing a simple filtergraph between streams "
2422 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2423 nb_output_files - 1, ost->st->index);
2429 /* set the filter output constraints */
2431 OutputFilter *f = ost->filter;
2433 switch (ost->enc_ctx->codec_type) {
2434 case AVMEDIA_TYPE_VIDEO:
2435 f->frame_rate = ost->frame_rate;
2436 f->width = ost->enc_ctx->width;
2437 f->height = ost->enc_ctx->height;
2438 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2439 f->format = ost->enc_ctx->pix_fmt;
2440 } else if (ost->enc->pix_fmts) {
2442 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2444 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2447 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2450 case AVMEDIA_TYPE_AUDIO:
2451 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2452 f->format = ost->enc_ctx->sample_fmt;
2453 } else if (ost->enc->sample_fmts) {
2455 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2457 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2460 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2462 if (ost->enc_ctx->sample_rate) {
2463 f->sample_rate = ost->enc_ctx->sample_rate;
2464 } else if (ost->enc->supported_samplerates) {
2466 while (ost->enc->supported_samplerates[count])
2468 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2469 if (!f->sample_rates)
2471 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2472 (count + 1) * sizeof(*f->sample_rates));
2474 if (ost->enc_ctx->channels) {
2475 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2476 } else if (ost->enc->channel_layouts) {
2478 while (ost->enc->channel_layouts[count])
2480 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2481 if (!f->channel_layouts)
2483 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2484 (count + 1) * sizeof(*f->channel_layouts));
2491 /* check filename in case of an image number is expected */
2492 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2493 if (!av_filename_number_test(oc->filename)) {
2494 print_error(oc->filename, AVERROR(EINVAL));
2499 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2500 av_log(NULL, AV_LOG_ERROR,
2501 "No input streams but output needs an input stream\n");
2505 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2506 /* test if it already exists to avoid losing precious files */
2507 assert_file_overwrite(filename);
2510 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2511 &oc->interrupt_callback,
2513 print_error(filename, err);
2516 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2517 assert_file_overwrite(filename);
2519 if (o->mux_preload) {
2520 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2522 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2525 for (i = 0; i < o->nb_metadata_map; i++) {
2527 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2529 if (in_file_index >= nb_input_files) {
2530 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2533 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2534 in_file_index >= 0 ?
2535 input_files[in_file_index]->ctx : NULL, o);
2539 if (o->chapters_input_file >= nb_input_files) {
2540 if (o->chapters_input_file == INT_MAX) {
2541 /* copy chapters from the first input file that has them*/
2542 o->chapters_input_file = -1;
2543 for (i = 0; i < nb_input_files; i++)
2544 if (input_files[i]->ctx->nb_chapters) {
2545 o->chapters_input_file = i;
2549 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2550 o->chapters_input_file);
2554 if (o->chapters_input_file >= 0)
2555 copy_chapters(input_files[o->chapters_input_file], of,
2556 !o->metadata_chapters_manual);
2558 /* copy global metadata by default */
2559 if (!o->metadata_global_manual && nb_input_files){
2560 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2561 AV_DICT_DONT_OVERWRITE);
2562 if(o->recording_time != INT64_MAX)
2563 av_dict_set(&oc->metadata, "duration", NULL, 0);
2564 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2566 if (!o->metadata_streams_manual)
2567 for (i = of->ost_index; i < nb_output_streams; i++) {
2569 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2571 ist = input_streams[output_streams[i]->source_index];
2572 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2573 if (!output_streams[i]->stream_copy) {
2574 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2575 if (ist->autorotate)
2576 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2580 /* process manually set programs */
2581 for (i = 0; i < o->nb_program; i++) {
2582 const char *p = o->program[i].u.str;
2587 const char *p2 = av_get_token(&p, ":");
2588 const char *to_dealloc = p2;
2595 key = av_get_token(&p2, "=");
2597 av_freep(&to_dealloc);
2603 if (!strcmp(key, "program_num"))
2604 progid = strtol(p2, NULL, 0);
2605 av_freep(&to_dealloc);
2609 program = av_new_program(oc, progid);
2611 p = o->program[i].u.str;
2613 const char *p2 = av_get_token(&p, ":");
2614 const char *to_dealloc = p2;
2620 key = av_get_token(&p2, "=");
2622 av_log(NULL, AV_LOG_FATAL,
2623 "No '=' character in program string %s.\n",
2631 if (!strcmp(key, "title")) {
2632 av_dict_set(&program->metadata, "title", p2, 0);
2633 } else if (!strcmp(key, "program_num")) {
2634 } else if (!strcmp(key, "st")) {
2635 int st_num = strtol(p2, NULL, 0);
2636 av_program_add_stream_index(oc, progid, st_num);
2638 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2641 av_freep(&to_dealloc);
2646 /* process manually set metadata */
2647 for (i = 0; i < o->nb_metadata; i++) {
2650 const char *stream_spec;
2651 int index = 0, j, ret = 0;
2653 val = strchr(o->metadata[i].u.str, '=');
2655 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2656 o->metadata[i].u.str);
2661 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2663 for (j = 0; j < oc->nb_streams; j++) {
2664 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2665 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2666 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2667 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2668 ost->rotate_overridden = 1;
2680 if (index < 0 || index >= oc->nb_chapters) {
2681 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2684 m = &oc->chapters[index]->metadata;
2687 if (index < 0 || index >= oc->nb_programs) {
2688 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2691 m = &oc->programs[index]->metadata;
2694 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2697 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2704 static int opt_target(void *optctx, const char *opt, const char *arg)
2706 OptionsContext *o = optctx;
2707 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2708 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2710 if (!strncmp(arg, "pal-", 4)) {
2713 } else if (!strncmp(arg, "ntsc-", 5)) {
2716 } else if (!strncmp(arg, "film-", 5)) {
2720 /* Try to determine PAL/NTSC by peeking in the input files */
2721 if (nb_input_files) {
2723 for (j = 0; j < nb_input_files; j++) {
2724 for (i = 0; i < input_files[j]->nb_streams; i++) {
2725 AVStream *st = input_files[j]->ctx->streams[i];
2726 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2728 fr = st->time_base.den * 1000 / st->time_base.num;
2732 } else if ((fr == 29970) || (fr == 23976)) {
2737 if (norm != UNKNOWN)
2741 if (norm != UNKNOWN)
2742 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2745 if (norm == UNKNOWN) {
2746 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2747 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2748 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2752 if (!strcmp(arg, "vcd")) {
2753 opt_video_codec(o, "c:v", "mpeg1video");
2754 opt_audio_codec(o, "c:a", "mp2");
2755 parse_option(o, "f", "vcd", options);
2757 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2758 parse_option(o, "r", frame_rates[norm], options);
2759 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2761 opt_default(NULL, "b:v", "1150000");
2762 opt_default(NULL, "maxrate:v", "1150000");
2763 opt_default(NULL, "minrate:v", "1150000");
2764 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2766 opt_default(NULL, "b:a", "224000");
2767 parse_option(o, "ar", "44100", options);
2768 parse_option(o, "ac", "2", options);
2770 opt_default(NULL, "packetsize", "2324");
2771 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2773 /* We have to offset the PTS, so that it is consistent with the SCR.
2774 SCR starts at 36000, but the first two packs contain only padding
2775 and the first pack from the other stream, respectively, may also have
2776 been written before.
2777 So the real data starts at SCR 36000+3*1200. */
2778 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2779 } else if (!strcmp(arg, "svcd")) {
2781 opt_video_codec(o, "c:v", "mpeg2video");
2782 opt_audio_codec(o, "c:a", "mp2");
2783 parse_option(o, "f", "svcd", options);
2785 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2786 parse_option(o, "r", frame_rates[norm], options);
2787 parse_option(o, "pix_fmt", "yuv420p", options);
2788 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2790 opt_default(NULL, "b:v", "2040000");
2791 opt_default(NULL, "maxrate:v", "2516000");
2792 opt_default(NULL, "minrate:v", "0"); // 1145000;
2793 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2794 opt_default(NULL, "scan_offset", "1");
2796 opt_default(NULL, "b:a", "224000");
2797 parse_option(o, "ar", "44100", options);
2799 opt_default(NULL, "packetsize", "2324");
2801 } else if (!strcmp(arg, "dvd")) {
2803 opt_video_codec(o, "c:v", "mpeg2video");
2804 opt_audio_codec(o, "c:a", "ac3");
2805 parse_option(o, "f", "dvd", options);
2807 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2808 parse_option(o, "r", frame_rates[norm], options);
2809 parse_option(o, "pix_fmt", "yuv420p", options);
2810 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2812 opt_default(NULL, "b:v", "6000000");
2813 opt_default(NULL, "maxrate:v", "9000000");
2814 opt_default(NULL, "minrate:v", "0"); // 1500000;
2815 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2817 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2818 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2820 opt_default(NULL, "b:a", "448000");
2821 parse_option(o, "ar", "48000", options);
2823 } else if (!strncmp(arg, "dv", 2)) {
2825 parse_option(o, "f", "dv", options);
2827 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2828 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2829 norm == PAL ? "yuv420p" : "yuv411p", options);
2830 parse_option(o, "r", frame_rates[norm], options);
2832 parse_option(o, "ar", "48000", options);
2833 parse_option(o, "ac", "2", options);
2836 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2837 return AVERROR(EINVAL);
2840 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2841 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2846 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2848 av_free (vstats_filename);
2849 vstats_filename = av_strdup (arg);
2853 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2856 time_t today2 = time(NULL);
2857 struct tm *today = localtime(&today2);
2859 if (!today) { // maybe tomorrow
2860 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2864 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2866 return opt_vstats_file(NULL, opt, filename);
2869 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2871 OptionsContext *o = optctx;
2872 return parse_option(o, "frames:v", arg, options);
2875 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2877 OptionsContext *o = optctx;
2878 return parse_option(o, "frames:a", arg, options);
2881 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2883 OptionsContext *o = optctx;
2884 return parse_option(o, "frames:d", arg, options);
2887 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2890 AVDictionary *cbak = codec_opts;
2891 AVDictionary *fbak = format_opts;
2895 ret = opt_default(NULL, opt, arg);
2897 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2898 av_dict_copy(&o->g->format_opts, format_opts, 0);
2899 av_dict_free(&codec_opts);
2900 av_dict_free(&format_opts);
2907 static int opt_preset(void *optctx, const char *opt, const char *arg)
2909 OptionsContext *o = optctx;
2911 char filename[1000], line[1000], tmp_line[1000];
2912 const char *codec_name = NULL;
2916 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2918 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2919 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2920 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2922 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2926 while (fgets(line, sizeof(line), f)) {
2927 char *key = tmp_line, *value, *endptr;
2929 if (strcspn(line, "#\n\r") == 0)
2931 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2932 if (!av_strtok(key, "=", &value) ||
2933 !av_strtok(value, "\r\n", &endptr)) {
2934 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2937 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2939 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2940 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2941 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2942 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2943 else if (opt_default_new(o, key, value) < 0) {
2944 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2945 filename, line, key, value);
2955 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2957 OptionsContext *o = optctx;
2958 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2959 int ret = parse_option(o, s, arg, options);
2964 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2966 OptionsContext *o = optctx;
2968 if(!strcmp(opt, "ab")){
2969 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2971 } else if(!strcmp(opt, "b")){
2972 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2973 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2976 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2980 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2982 OptionsContext *o = optctx;
2985 if(!strcmp(opt, "qscale")){
2986 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2987 return parse_option(o, "q:v", arg, options);
2989 s = av_asprintf("q%s", opt + 6);
2990 ret = parse_option(o, s, arg, options);
2995 static int opt_profile(void *optctx, const char *opt, const char *arg)
2997 OptionsContext *o = optctx;
2998 if(!strcmp(opt, "profile")){
2999 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3000 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3003 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3007 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3009 OptionsContext *o = optctx;
3010 return parse_option(o, "filter:v", arg, options);
3013 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3015 OptionsContext *o = optctx;
3016 return parse_option(o, "filter:a", arg, options);
3019 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3021 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3022 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3023 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3024 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3026 if (video_sync_method == VSYNC_AUTO)
3027 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3031 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3033 OptionsContext *o = optctx;
3034 char *tcr = av_asprintf("timecode=%s", arg);
3035 int ret = parse_option(o, "metadata:g", tcr, options);
3037 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3042 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3044 OptionsContext *o = optctx;
3045 char layout_str[32];
3048 int ret, channels, ac_str_size;
3051 layout = av_get_channel_layout(arg);
3053 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3054 return AVERROR(EINVAL);
3056 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3057 ret = opt_default_new(o, opt, layout_str);
3061 /* set 'ac' option based on channel layout */
3062 channels = av_get_channel_layout_nb_channels(layout);
3063 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3064 stream_str = strchr(opt, ':');
3065 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3066 ac_str = av_mallocz(ac_str_size);
3068 return AVERROR(ENOMEM);
3069 av_strlcpy(ac_str, "ac", 3);
3071 av_strlcat(ac_str, stream_str, ac_str_size);
3072 ret = parse_option(o, ac_str, layout_str, options);
3078 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3080 OptionsContext *o = optctx;
3081 return parse_option(o, "q:a", arg, options);
3084 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3086 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3087 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3088 return AVERROR(ENOMEM);
3089 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3090 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3091 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3092 return AVERROR(ENOMEM);
3094 input_stream_potentially_available = 1;
3099 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3101 uint8_t *graph_desc = read_file(arg);
3103 return AVERROR(EINVAL);
3105 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3106 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3107 return AVERROR(ENOMEM);
3108 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3109 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3111 input_stream_potentially_available = 1;
3116 void show_help_default(const char *opt, const char *arg)
3118 /* per-file options have at least one of those set */
3119 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3120 int show_advanced = 0, show_avoptions = 0;
3123 if (!strcmp(opt, "long"))
3125 else if (!strcmp(opt, "full"))
3126 show_advanced = show_avoptions = 1;
3128 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3133 printf("Getting help:\n"
3134 " -h -- print basic options\n"
3135 " -h long -- print more options\n"
3136 " -h full -- print all options (including all format and codec specific options, very long)\n"
3137 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3138 " See man %s for detailed description of the options.\n"
3139 "\n", program_name);
3141 show_help_options(options, "Print help / information / capabilities:",
3144 show_help_options(options, "Global options (affect whole program "
3145 "instead of just one file:",
3146 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3148 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3149 per_file | OPT_EXIT, 0);
3151 show_help_options(options, "Per-file main options:", 0,
3152 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3153 OPT_EXIT, per_file);
3155 show_help_options(options, "Advanced per-file options:",
3156 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3158 show_help_options(options, "Video options:",
3159 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3161 show_help_options(options, "Advanced Video options:",
3162 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3164 show_help_options(options, "Audio options:",
3165 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3167 show_help_options(options, "Advanced Audio options:",
3168 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3169 show_help_options(options, "Subtitle options:",
3170 OPT_SUBTITLE, 0, 0);
3173 if (show_avoptions) {
3174 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3175 show_help_children(avcodec_get_class(), flags);
3176 show_help_children(avformat_get_class(), flags);
3178 show_help_children(sws_get_class(), flags);
3180 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3181 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3185 void show_usage(void)
3187 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3188 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3189 av_log(NULL, AV_LOG_INFO, "\n");
3197 static const OptionGroupDef groups[] = {
3198 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3199 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3202 static int open_files(OptionGroupList *l, const char *inout,
3203 int (*open_file)(OptionsContext*, const char*))
3207 for (i = 0; i < l->nb_groups; i++) {
3208 OptionGroup *g = &l->groups[i];
3214 ret = parse_optgroup(&o, g);
3216 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3217 "%s.\n", inout, g->arg);
3221 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3222 ret = open_file(&o, g->arg);
3225 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3229 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3235 int ffmpeg_parse_options(int argc, char **argv)
3237 OptionParseContext octx;
3241 memset(&octx, 0, sizeof(octx));
3243 /* split the commandline into an internal representation */
3244 ret = split_commandline(&octx, argc, argv, options, groups,
3245 FF_ARRAY_ELEMS(groups));
3247 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3251 /* apply global options */
3252 ret = parse_optgroup(NULL, &octx.global_opts);
3254 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3258 /* configure terminal and setup signal handlers */
3261 /* open input files */
3262 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3264 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3268 /* create the complex filtergraphs */
3269 ret = init_complex_filters();
3271 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3275 /* open output files */
3276 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3278 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3282 /* configure the complex filtergraphs */
3283 ret = configure_complex_filters();
3285 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3290 uninit_parse_context(&octx);
3292 av_strerror(ret, error, sizeof(error));
3293 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3298 static int opt_progress(void *optctx, const char *opt, const char *arg)
3300 AVIOContext *avio = NULL;
3303 if (!strcmp(arg, "-"))
3305 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3307 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3308 arg, av_err2str(ret));
3311 progress_avio = avio;
3315 #define OFFSET(x) offsetof(OptionsContext, x)
3316 const OptionDef options[] = {
3318 #include "cmdutils_common_opts.h"
3319 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3320 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3321 "force format", "fmt" },
3322 { "y", OPT_BOOL, { &file_overwrite },
3323 "overwrite output files" },
3324 { "n", OPT_BOOL, { &no_file_overwrite },
3325 "never overwrite output files" },
3326 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3327 "Ignore unknown stream types" },
3328 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3329 "Copy unknown stream types" },
3330 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3331 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3332 "codec name", "codec" },
3333 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3334 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3335 "codec name", "codec" },
3336 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3337 OPT_OUTPUT, { .off = OFFSET(presets) },
3338 "preset name", "preset" },
3339 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3340 OPT_OUTPUT, { .func_arg = opt_map },
3341 "set input stream mapping",
3342 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3343 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3344 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3345 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3346 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3347 "set metadata information of outfile from infile",
3348 "outfile[,metadata]:infile[,metadata]" },
3349 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3350 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3351 "set chapters mapping", "input_file_index" },
3352 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3353 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3354 "record or transcode \"duration\" seconds of audio/video",
3356 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3357 "record or transcode stop time", "time_stop" },
3358 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3359 "set the limit file size in bytes", "limit_size" },
3360 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3361 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3362 "set the start time offset", "time_off" },
3363 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3364 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3365 "set the start time offset relative to EOF", "time_off" },
3366 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3367 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3368 "enable/disable seeking by timestamp with -ss" },
3369 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3370 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3371 "enable/disable accurate seeking with -ss" },
3372 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3373 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3374 "set the input ts offset", "time_off" },
3375 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3376 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3377 "set the input ts scale", "scale" },
3378 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3379 "set the recording timestamp ('now' to set the current time)", "time" },
3380 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3381 "add metadata", "string=string" },
3382 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3383 "add program with specified streams", "title=string:st=number..." },
3384 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3385 OPT_OUTPUT, { .func_arg = opt_data_frames },
3386 "set the number of data frames to output", "number" },
3387 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3388 "add timings for benchmarking" },
3389 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3390 "add timings for each task" },
3391 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3392 "write program-readable progress information", "url" },
3393 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3394 "enable or disable interaction on standard input" },
3395 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3396 "set max runtime in seconds", "limit" },
3397 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3398 "dump each input packet" },
3399 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3400 "when dumping packets, also dump the payload" },
3401 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3402 OPT_INPUT, { .off = OFFSET(rate_emu) },
3403 "read input at native frame rate", "" },
3404 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3405 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3406 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3407 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3408 "video sync method", "" },
3409 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3410 "frame drop threshold", "" },
3411 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3412 "audio sync method", "" },
3413 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3414 "audio drift threshold", "threshold" },
3415 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3416 "copy timestamps" },
3417 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3418 "shift input timestamps to start at 0 when using copyts" },
3419 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3420 "copy input stream time base when stream copying", "mode" },
3421 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3422 OPT_OUTPUT, { .off = OFFSET(shortest) },
3423 "finish encoding within shortest input" },
3424 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3425 OPT_OUTPUT, { .off = OFFSET(apad) },
3427 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3428 "timestamp discontinuity delta threshold", "threshold" },
3429 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3430 "timestamp error delta threshold", "threshold" },
3431 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3432 "exit on error", "error" },
3433 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3434 "abort on the specified condition flags", "flags" },
3435 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3436 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3437 "copy initial non-keyframes" },
3438 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3439 "copy or discard frames before start time" },
3440 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3441 "set the number of frames to output", "number" },
3442 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3443 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3444 "force codec tag/fourcc", "fourcc/tag" },
3445 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3446 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3447 "use fixed quality scale (VBR)", "q" },
3448 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3449 OPT_OUTPUT, { .func_arg = opt_qscale },
3450 "use fixed quality scale (VBR)", "q" },
3451 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3452 "set profile", "profile" },
3453 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3454 "set stream filtergraph", "filter_graph" },
3455 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3456 "number of non-complex filter threads" },
3457 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3458 "read stream filtergraph description from a file", "filename" },
3459 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3460 "reinit filtergraph on input parameter changes", "" },
3461 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3462 "create a complex filtergraph", "graph_description" },
3463 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3464 "number of threads for -filter_complex" },
3465 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3466 "create a complex filtergraph", "graph_description" },
3467 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3468 "read complex filtergraph description from a file", "filename" },
3469 { "stats", OPT_BOOL, { &print_stats },
3470 "print progress report during encoding", },
3471 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3472 OPT_OUTPUT, { .func_arg = opt_attach },
3473 "add an attachment to the output file", "filename" },
3474 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3475 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3476 "extract an attachment into a file", "filename" },
3477 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3478 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3479 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3480 "print timestamp debugging info" },
3481 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3482 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3483 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3484 OPT_INPUT, { .off = OFFSET(discard) },
3486 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3487 OPT_OUTPUT, { .off = OFFSET(disposition) },
3488 "disposition", "" },
3489 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3490 { .off = OFFSET(thread_queue_size) },
3491 "set the maximum number of queued packets from the demuxer" },
3494 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3495 "set the number of video frames to output", "number" },
3496 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3497 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3498 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3499 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3500 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3501 "set frame size (WxH or abbreviation)", "size" },
3502 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3503 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3504 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3505 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3506 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3507 "set pixel format", "format" },
3508 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3509 "set the number of bits per raw sample", "number" },
3510 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3511 "deprecated use -g 1" },
3512 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3514 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3515 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3516 "rate control override for specific intervals", "override" },
3517 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3518 OPT_OUTPUT, { .func_arg = opt_video_codec },
3519 "force video codec ('copy' to copy stream)", "codec" },
3520 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3522 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3524 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3525 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3526 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3527 "select the pass number (1 to 3)", "n" },
3528 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3529 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3530 "select two pass log file name prefix", "prefix" },
3531 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3532 "this option is deprecated, use the yadif filter instead" },
3533 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3534 "calculate PSNR of compressed frames" },
3535 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3536 "dump video coding statistics to file" },
3537 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3538 "dump video coding statistics to file", "file" },
3539 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3540 "set video filters", "filter_graph" },
3541 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3542 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3543 "specify intra matrix coeffs", "matrix" },
3544 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3545 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3546 "specify inter matrix coeffs", "matrix" },
3547 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3548 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3549 "specify intra matrix coeffs", "matrix" },
3550 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3551 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3552 "top=1/bottom=0/auto=-1 field first", "" },
3553 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3554 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3555 "force video tag/fourcc", "fourcc/tag" },
3556 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3557 "show QP histogram" },
3558 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3559 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3560 "force the selected framerate, disable the best supported framerate selection" },
3561 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3562 OPT_OUTPUT, { .func_arg = opt_streamid },
3563 "set the value of an outfile streamid", "streamIndex:value" },
3564 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3565 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3566 "force key frames at specified timestamps", "timestamps" },
3567 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3568 "audio bitrate (please use -b:a)", "bitrate" },
3569 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3570 "video bitrate (please use -b:v)", "bitrate" },
3571 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3572 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3573 "use HW accelerated decoding", "hwaccel name" },
3574 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3575 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3576 "select a device for HW acceleration", "devicename" },
3577 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3578 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3579 "select output format used with HW accelerated decoding", "format" },
3580 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3581 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3583 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3584 "show available HW acceleration methods" },
3585 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3586 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3587 "automatically insert correct rotate filters" },
3588 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3589 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3592 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3593 "set the number of audio frames to output", "number" },
3594 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3595 "set audio quality (codec-specific)", "quality", },
3596 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3597 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3598 "set audio sampling rate (in Hz)", "rate" },
3599 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3600 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3601 "set number of audio channels", "channels" },
3602 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3604 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3605 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3606 "force audio codec ('copy' to copy stream)", "codec" },
3607 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3608 OPT_OUTPUT, { .func_arg = opt_old2new },
3609 "force audio tag/fourcc", "fourcc/tag" },
3610 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3611 "change audio volume (256=normal)" , "volume" },
3612 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3613 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3614 "set sample format", "format" },
3615 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3616 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3617 "set channel layout", "layout" },
3618 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3619 "set audio filters", "filter_graph" },
3620 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3621 "set the maximum number of channels to try to guess the channel layout" },
3623 /* subtitle options */
3624 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3625 "disable subtitle" },
3626 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3627 "force subtitle codec ('copy' to copy stream)", "codec" },
3628 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3629 , "force subtitle tag/fourcc", "fourcc/tag" },
3630 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3631 "fix subtitles duration" },
3632 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3633 "set canvas size (WxH or abbreviation)", "size" },
3636 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3637 "deprecated, use -channel", "channel" },
3638 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3639 "deprecated, use -standard", "standard" },
3640 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3643 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3644 "set the maximum demux-decode delay", "seconds" },
3645 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3646 "set the initial demux-decode delay", "seconds" },
3647 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3648 "override the options from ffserver", "" },
3649 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3650 "specify a file in which to print sdp information", "file" },
3652 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3653 "A comma-separated list of bitstream filters", "bitstream_filters" },
3654 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3655 "deprecated", "audio bitstream_filters" },
3656 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3657 "deprecated", "video bitstream_filters" },
3659 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3660 "set the audio options to the indicated preset", "preset" },
3661 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3662 "set the video options to the indicated preset", "preset" },
3663 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3664 "set the subtitle options to the indicated preset", "preset" },
3665 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3666 "set options from indicated preset file", "filename" },
3668 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3669 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3671 /* data codec support */
3672 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3673 "force data codec ('copy' to copy stream)", "codec" },
3674 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3678 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3679 "set VAAPI hardware device (DRM path or X11 display name)", "device" },