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, *time_base = 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 MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1314 if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1315 q.num <= 0 || q.den <= 0) {
1316 av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1322 ost->max_frames = INT64_MAX;
1323 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1324 for (i = 0; i<o->nb_max_frames; i++) {
1325 char *p = o->max_frames[i].specifier;
1326 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1327 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1332 ost->copy_prior_start = -1;
1333 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1335 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1336 while (bsfs && *bsfs) {
1337 const AVBitStreamFilter *filter;
1338 char *bsf, *bsf_options_str, *bsf_name;
1340 bsf = av_get_token(&bsfs, ",");
1343 bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1347 filter = av_bsf_get_by_name(bsf_name);
1349 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1353 ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1354 ost->nb_bitstream_filters + 1,
1355 sizeof(*ost->bsf_ctx));
1359 ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1361 av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1365 ost->nb_bitstream_filters++;
1367 if (bsf_options_str && filter->priv_class) {
1368 const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1369 const char * shorthand[2] = {NULL};
1372 shorthand[0] = opt->name;
1374 ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1376 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1385 if (ost->nb_bitstream_filters) {
1386 ost->bsf_extradata_updated = av_mallocz_array(ost->nb_bitstream_filters, sizeof(*ost->bsf_extradata_updated));
1387 if (!ost->bsf_extradata_updated) {
1388 av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1393 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1395 uint32_t tag = strtol(codec_tag, &next, 0);
1397 tag = AV_RL32(codec_tag);
1398 ost->st->codecpar->codec_tag =
1399 ost->enc_ctx->codec_tag = tag;
1402 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1404 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1405 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1408 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1409 ost->disposition = av_strdup(ost->disposition);
1411 ost->max_muxing_queue_size = 128;
1412 MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1413 ost->max_muxing_queue_size *= sizeof(AVPacket);
1415 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1416 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1418 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1420 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1421 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1422 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1424 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1426 ost->source_index = source_index;
1427 if (source_index >= 0) {
1428 ost->sync_ist = input_streams[source_index];
1429 input_streams[source_index]->discard = 0;
1430 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1432 ost->last_mux_dts = AV_NOPTS_VALUE;
1434 ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1435 if (!ost->muxing_queue)
1441 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1444 const char *p = str;
1451 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1458 /* read file contents into a string */
1459 static uint8_t *read_file(const char *filename)
1461 AVIOContext *pb = NULL;
1462 AVIOContext *dyn_buf = NULL;
1463 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1464 uint8_t buf[1024], *str;
1467 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1471 ret = avio_open_dyn_buf(&dyn_buf);
1476 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1477 avio_write(dyn_buf, buf, ret);
1478 avio_w8(dyn_buf, 0);
1481 ret = avio_close_dyn_buf(dyn_buf, &str);
1487 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1490 AVStream *st = ost->st;
1492 if (ost->filters_script && ost->filters) {
1493 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1494 "output stream #%d:%d.\n", nb_output_files, st->index);
1498 if (ost->filters_script)
1499 return read_file(ost->filters_script);
1500 else if (ost->filters)
1501 return av_strdup(ost->filters);
1503 return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1507 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1508 const OutputStream *ost, enum AVMediaType type)
1510 if (ost->filters_script || ost->filters) {
1511 av_log(NULL, AV_LOG_ERROR,
1512 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1513 "Filtering and streamcopy cannot be used together.\n",
1514 ost->filters ? "Filtergraph" : "Filtergraph script",
1515 ost->filters ? ost->filters : ost->filters_script,
1516 av_get_media_type_string(type), ost->file_index, ost->index);
1521 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1525 AVCodecContext *video_enc;
1526 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1528 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1530 video_enc = ost->enc_ctx;
1532 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1533 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1534 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1537 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1538 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1540 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1541 if (frame_aspect_ratio) {
1543 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1544 q.num <= 0 || q.den <= 0) {
1545 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1548 ost->frame_aspect_ratio = q;
1551 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1552 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1554 if (!ost->stream_copy) {
1555 const char *p = NULL;
1556 char *frame_size = NULL;
1557 char *frame_pix_fmt = NULL;
1558 char *intra_matrix = NULL, *inter_matrix = NULL;
1559 char *chroma_intra_matrix = NULL;
1563 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1564 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1565 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1569 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1570 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1571 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1572 ost->keep_pix_fmt = 1;
1573 if (!*++frame_pix_fmt)
1574 frame_pix_fmt = NULL;
1576 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1577 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1580 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1583 video_enc->gop_size = 0;
1584 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1586 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1587 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1590 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1592 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1593 if (chroma_intra_matrix) {
1594 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1596 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1599 av_codec_set_chroma_intra_matrix(video_enc, p);
1600 parse_matrix_coeffs(p, chroma_intra_matrix);
1602 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1604 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1605 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1608 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1611 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1612 for (i = 0; p; i++) {
1614 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1616 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1619 video_enc->rc_override =
1620 av_realloc_array(video_enc->rc_override,
1621 i + 1, sizeof(RcOverride));
1622 if (!video_enc->rc_override) {
1623 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1626 video_enc->rc_override[i].start_frame = start;
1627 video_enc->rc_override[i].end_frame = end;
1629 video_enc->rc_override[i].qscale = q;
1630 video_enc->rc_override[i].quality_factor = 1.0;
1633 video_enc->rc_override[i].qscale = 0;
1634 video_enc->rc_override[i].quality_factor = -q/100.0;
1639 video_enc->rc_override_count = i;
1642 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1645 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1648 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1649 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1652 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1653 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1657 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1658 if (ost->logfile_prefix &&
1659 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1663 char logfilename[1024];
1666 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1667 ost->logfile_prefix ? ost->logfile_prefix :
1668 DEFAULT_PASS_LOGFILENAME_PREFIX,
1670 if (!strcmp(ost->enc->name, "libx264")) {
1671 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1673 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1674 char *logbuffer = read_file(logfilename);
1677 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1681 video_enc->stats_in = logbuffer;
1683 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1684 f = av_fopen_utf8(logfilename, "wb");
1686 av_log(NULL, AV_LOG_FATAL,
1687 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1688 logfilename, strerror(errno));
1696 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1697 if (ost->forced_keyframes)
1698 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1700 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1702 ost->top_field_first = -1;
1703 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1706 ost->avfilter = get_ost_filters(o, oc, ost);
1710 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1713 if (ost->stream_copy)
1714 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1719 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1724 AVCodecContext *audio_enc;
1726 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1729 audio_enc = ost->enc_ctx;
1730 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1732 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1733 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1735 if (!ost->stream_copy) {
1736 char *sample_fmt = NULL;
1738 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1740 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1742 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1743 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1747 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1749 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1750 ost->apad = av_strdup(ost->apad);
1752 ost->avfilter = get_ost_filters(o, oc, ost);
1756 /* check for channel mapping for this audio stream */
1757 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1758 AudioChannelMap *map = &o->audio_channel_maps[n];
1759 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1760 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1763 if (map->channel_idx == -1) {
1765 } else if (ost->source_index < 0) {
1766 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1767 ost->file_index, ost->st->index);
1770 ist = input_streams[ost->source_index];
1773 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1774 if (av_reallocp_array(&ost->audio_channels_map,
1775 ost->audio_channels_mapped + 1,
1776 sizeof(*ost->audio_channels_map)
1780 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1786 if (ost->stream_copy)
1787 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1792 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1796 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1797 if (!ost->stream_copy) {
1798 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1805 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1809 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1810 if (!ost->stream_copy) {
1811 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1818 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1820 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1821 ost->stream_copy = 1;
1826 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1830 AVCodecContext *subtitle_enc;
1832 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1834 subtitle_enc = ost->enc_ctx;
1836 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1838 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1840 if (!ost->stream_copy) {
1841 char *frame_size = NULL;
1843 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1844 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1845 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1853 /* arg format is "output-stream-index:streamid-value". */
1854 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1856 OptionsContext *o = optctx;
1861 av_strlcpy(idx_str, arg, sizeof(idx_str));
1862 p = strchr(idx_str, ':');
1864 av_log(NULL, AV_LOG_FATAL,
1865 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1870 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1871 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1872 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1876 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1878 AVFormatContext *is = ifile->ctx;
1879 AVFormatContext *os = ofile->ctx;
1883 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1885 return AVERROR(ENOMEM);
1888 for (i = 0; i < is->nb_chapters; i++) {
1889 AVChapter *in_ch = is->chapters[i], *out_ch;
1890 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1891 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1892 AV_TIME_BASE_Q, in_ch->time_base);
1893 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1894 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1897 if (in_ch->end < ts_off)
1899 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1902 out_ch = av_mallocz(sizeof(AVChapter));
1904 return AVERROR(ENOMEM);
1906 out_ch->id = in_ch->id;
1907 out_ch->time_base = in_ch->time_base;
1908 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1909 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1912 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1914 os->chapters[os->nb_chapters++] = out_ch;
1919 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1922 AVFormatContext *ic = avformat_alloc_context();
1924 ic->interrupt_callback = int_cb;
1925 err = avformat_open_input(&ic, filename, NULL, NULL);
1928 /* copy stream format */
1929 for(i=0;i<ic->nb_streams;i++) {
1933 const char *enc_config;
1935 codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1937 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1938 return AVERROR(EINVAL);
1940 if (codec->type == AVMEDIA_TYPE_AUDIO)
1941 opt_audio_codec(o, "c:a", codec->name);
1942 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1943 opt_video_codec(o, "c:v", codec->name);
1944 ost = new_output_stream(o, s, codec->type, -1);
1947 avcodec_get_context_defaults3(st->codec, codec);
1948 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1950 AVDictionary *opts = NULL;
1951 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1952 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1953 av_dict_free(&opts);
1956 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1957 choose_sample_fmt(st, codec);
1958 else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1959 choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1960 avcodec_copy_context(ost->enc_ctx, st->codec);
1962 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1965 avformat_close_input(&ic);
1969 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1970 AVFormatContext *oc)
1974 switch (ofilter->type) {
1975 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1976 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1978 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1983 ost->source_index = -1;
1984 ost->filter = ofilter;
1987 ofilter->format = -1;
1989 if (ost->stream_copy) {
1990 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1991 "which is fed from a complex filtergraph. Filtering and streamcopy "
1992 "cannot be used together.\n", ost->file_index, ost->index);
1996 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1997 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1998 av_log(NULL, AV_LOG_ERROR,
1999 "%s '%s' was specified through the %s option "
2000 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
2001 "%s and -filter_complex cannot be used together for the same stream.\n",
2002 ost->filters ? "Filtergraph" : "Filtergraph script",
2003 ost->filters ? ost->filters : ost->filters_script,
2004 opt, ost->file_index, ost->index, opt);
2008 avfilter_inout_free(&ofilter->out_tmp);
2011 static int init_complex_filters(void)
2015 for (i = 0; i < nb_filtergraphs; i++) {
2016 ret = init_complex_filtergraph(filtergraphs[i]);
2023 static int configure_complex_filters(void)
2027 for (i = 0; i < nb_filtergraphs; i++) {
2028 FilterGraph *fg = filtergraphs[i];
2030 if (filtergraph_is_simple(fg))
2033 for (j = 0; j < fg->nb_inputs; j++) {
2034 ret = ifilter_parameters_from_decoder(fg->inputs[j],
2035 fg->inputs[j]->ist->dec_ctx);
2037 av_log(NULL, AV_LOG_ERROR,
2038 "Error initializing filtergraph %d input %d\n", i, j);
2043 ret = configure_filtergraph(filtergraphs[i]);
2050 static int open_output_file(OptionsContext *o, const char *filename)
2052 AVFormatContext *oc;
2054 AVOutputFormat *file_oformat;
2058 AVDictionary *unused_opts = NULL;
2059 AVDictionaryEntry *e = NULL;
2060 int format_flags = 0;
2062 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2063 o->stop_time = INT64_MAX;
2064 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2067 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2068 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2069 if (o->stop_time <= start_time) {
2070 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2073 o->recording_time = o->stop_time - start_time;
2077 GROW_ARRAY(output_files, nb_output_files);
2078 of = av_mallocz(sizeof(*of));
2081 output_files[nb_output_files - 1] = of;
2083 of->ost_index = nb_output_streams;
2084 of->recording_time = o->recording_time;
2085 of->start_time = o->start_time;
2086 of->limit_filesize = o->limit_filesize;
2087 of->shortest = o->shortest;
2088 av_dict_copy(&of->opts, o->g->format_opts, 0);
2090 if (!strcmp(filename, "-"))
2093 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2095 print_error(filename, err);
2100 if (o->recording_time != INT64_MAX)
2101 oc->duration = o->recording_time;
2103 file_oformat= oc->oformat;
2104 oc->interrupt_callback = int_cb;
2106 e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2108 const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2109 av_opt_eval_flags(oc, o, e->value, &format_flags);
2112 /* create streams for all unlabeled output pads */
2113 for (i = 0; i < nb_filtergraphs; i++) {
2114 FilterGraph *fg = filtergraphs[i];
2115 for (j = 0; j < fg->nb_outputs; j++) {
2116 OutputFilter *ofilter = fg->outputs[j];
2118 if (!ofilter->out_tmp || ofilter->out_tmp->name)
2121 switch (ofilter->type) {
2122 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2123 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2124 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2126 init_output_filter(ofilter, o, oc);
2130 /* ffserver seeking with date=... needs a date reference */
2131 if (!strcmp(file_oformat->name, "ffm") &&
2132 !(format_flags & AVFMT_FLAG_BITEXACT) &&
2133 av_strstart(filename, "http:", NULL)) {
2134 int err = parse_option(o, "metadata", "creation_time=now", options);
2136 print_error(filename, err);
2141 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2142 av_strstart(filename, "http:", NULL)) {
2144 /* special case for files sent to ffserver: we get the stream
2145 parameters from ffserver */
2146 int err = read_ffserver_streams(o, oc, filename);
2148 print_error(filename, err);
2151 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2152 ost = output_streams[j];
2153 for (i = 0; i < nb_input_streams; i++) {
2154 ist = input_streams[i];
2155 if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2157 ost->source_index= i;
2158 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2159 if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2161 ist->st->discard = ist->user_set_discard;
2166 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));
2170 } else if (!o->nb_stream_maps) {
2171 char *subtitle_codec_name = NULL;
2172 /* pick the "best" stream of each type */
2174 /* video: highest resolution */
2175 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2176 int area = 0, idx = -1;
2177 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2178 for (i = 0; i < nb_input_streams; i++) {
2180 ist = input_streams[i];
2181 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2182 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2184 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2186 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2193 new_video_stream(o, oc, idx);
2196 /* audio: most channels */
2197 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2198 int best_score = 0, idx = -1;
2199 for (i = 0; i < nb_input_streams; i++) {
2201 ist = input_streams[i];
2202 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2203 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2204 score > best_score) {
2210 new_audio_stream(o, oc, idx);
2213 /* subtitles: pick first */
2214 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2215 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2216 for (i = 0; i < nb_input_streams; i++)
2217 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2218 AVCodecDescriptor const *input_descriptor =
2219 avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2220 AVCodecDescriptor const *output_descriptor = NULL;
2221 AVCodec const *output_codec =
2222 avcodec_find_encoder(oc->oformat->subtitle_codec);
2223 int input_props = 0, output_props = 0;
2225 output_descriptor = avcodec_descriptor_get(output_codec->id);
2226 if (input_descriptor)
2227 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2228 if (output_descriptor)
2229 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2230 if (subtitle_codec_name ||
2231 input_props & output_props ||
2232 // Map dvb teletext which has neither property to any output subtitle encoder
2233 input_descriptor && output_descriptor &&
2234 (!input_descriptor->props ||
2235 !output_descriptor->props)) {
2236 new_subtitle_stream(o, oc, i);
2241 /* Data only if codec id match */
2242 if (!o->data_disable ) {
2243 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2244 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2245 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2246 && input_streams[i]->st->codecpar->codec_id == codec_id )
2247 new_data_stream(o, oc, i);
2251 for (i = 0; i < o->nb_stream_maps; i++) {
2252 StreamMap *map = &o->stream_maps[i];
2257 if (map->linklabel) {
2259 OutputFilter *ofilter = NULL;
2262 for (j = 0; j < nb_filtergraphs; j++) {
2263 fg = filtergraphs[j];
2264 for (k = 0; k < fg->nb_outputs; k++) {
2265 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2266 if (out && !strcmp(out->name, map->linklabel)) {
2267 ofilter = fg->outputs[k];
2274 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2275 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2278 init_output_filter(ofilter, o, oc);
2280 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2282 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2283 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2285 if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2287 if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2289 if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2293 switch (ist->st->codecpar->codec_type) {
2294 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2295 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2296 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2297 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2298 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2299 case AVMEDIA_TYPE_UNKNOWN:
2300 if (copy_unknown_streams) {
2301 ost = new_unknown_stream (o, oc, src_idx);
2305 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2306 "Cannot map stream #%d:%d - unsupported type.\n",
2307 map->file_index, map->stream_index);
2308 if (!ignore_unknown_streams) {
2309 av_log(NULL, AV_LOG_FATAL,
2310 "If you want unsupported types ignored instead "
2311 "of failing, please use the -ignore_unknown option\n"
2312 "If you want them copied, please use -copy_unknown\n");
2317 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2318 + map->sync_stream_index];
2323 /* handle attached files */
2324 for (i = 0; i < o->nb_attachments; i++) {
2326 uint8_t *attachment;
2330 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2331 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2335 if ((len = avio_size(pb)) <= 0) {
2336 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2340 if (!(attachment = av_malloc(len))) {
2341 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2345 avio_read(pb, attachment, len);
2347 ost = new_attachment_stream(o, oc, -1);
2348 ost->stream_copy = 0;
2349 ost->attachment_filename = o->attachments[i];
2350 ost->st->codecpar->extradata = attachment;
2351 ost->st->codecpar->extradata_size = len;
2353 p = strrchr(o->attachments[i], '/');
2354 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2358 #if FF_API_LAVF_AVCTX
2359 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2360 AVDictionaryEntry *e;
2361 ost = output_streams[i];
2363 if ((ost->stream_copy || ost->attachment_filename)
2364 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2365 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2366 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2371 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2372 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2373 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2377 /* check if all codec options have been used */
2378 unused_opts = strip_specifiers(o->g->codec_opts);
2379 for (i = of->ost_index; i < nb_output_streams; i++) {
2381 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2382 AV_DICT_IGNORE_SUFFIX)))
2383 av_dict_set(&unused_opts, e->key, NULL, 0);
2387 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2388 const AVClass *class = avcodec_get_class();
2389 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2390 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2391 const AVClass *fclass = avformat_get_class();
2392 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2393 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2394 if (!option || foption)
2398 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2399 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2400 "output file #%d (%s) is not an encoding option.\n", e->key,
2401 option->help ? option->help : "", nb_output_files - 1,
2406 // gop_timecode is injected by generic code but not always used
2407 if (!strcmp(e->key, "gop_timecode"))
2410 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2411 "output file #%d (%s) has not been used for any stream. The most "
2412 "likely reason is either wrong type (e.g. a video option with "
2413 "no video streams) or that it is a private option of some encoder "
2414 "which was not actually used for any stream.\n", e->key,
2415 option->help ? option->help : "", nb_output_files - 1, filename);
2417 av_dict_free(&unused_opts);
2419 /* set the decoding_needed flags and create simple filtergraphs */
2420 for (i = of->ost_index; i < nb_output_streams; i++) {
2421 OutputStream *ost = output_streams[i];
2423 if (ost->encoding_needed && ost->source_index >= 0) {
2424 InputStream *ist = input_streams[ost->source_index];
2425 ist->decoding_needed |= DECODING_FOR_OST;
2427 if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2428 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2429 err = init_simple_filtergraph(ist, ost);
2431 av_log(NULL, AV_LOG_ERROR,
2432 "Error initializing a simple filtergraph between streams "
2433 "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2434 nb_output_files - 1, ost->st->index);
2440 /* set the filter output constraints */
2442 OutputFilter *f = ost->filter;
2444 switch (ost->enc_ctx->codec_type) {
2445 case AVMEDIA_TYPE_VIDEO:
2446 f->frame_rate = ost->frame_rate;
2447 f->width = ost->enc_ctx->width;
2448 f->height = ost->enc_ctx->height;
2449 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2450 f->format = ost->enc_ctx->pix_fmt;
2451 } else if (ost->enc->pix_fmts) {
2453 while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2455 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2458 memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2461 case AVMEDIA_TYPE_AUDIO:
2462 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2463 f->format = ost->enc_ctx->sample_fmt;
2464 } else if (ost->enc->sample_fmts) {
2466 while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2468 f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2471 memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2473 if (ost->enc_ctx->sample_rate) {
2474 f->sample_rate = ost->enc_ctx->sample_rate;
2475 } else if (ost->enc->supported_samplerates) {
2477 while (ost->enc->supported_samplerates[count])
2479 f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2480 if (!f->sample_rates)
2482 memcpy(f->sample_rates, ost->enc->supported_samplerates,
2483 (count + 1) * sizeof(*f->sample_rates));
2485 if (ost->enc_ctx->channels) {
2486 f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2487 } else if (ost->enc->channel_layouts) {
2489 while (ost->enc->channel_layouts[count])
2491 f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2492 if (!f->channel_layouts)
2494 memcpy(f->channel_layouts, ost->enc->channel_layouts,
2495 (count + 1) * sizeof(*f->channel_layouts));
2502 /* check filename in case of an image number is expected */
2503 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2504 if (!av_filename_number_test(oc->filename)) {
2505 print_error(oc->filename, AVERROR(EINVAL));
2510 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2511 av_log(NULL, AV_LOG_ERROR,
2512 "No input streams but output needs an input stream\n");
2516 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2517 /* test if it already exists to avoid losing precious files */
2518 assert_file_overwrite(filename);
2521 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2522 &oc->interrupt_callback,
2524 print_error(filename, err);
2527 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2528 assert_file_overwrite(filename);
2530 if (o->mux_preload) {
2531 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2533 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2536 for (i = 0; i < o->nb_metadata_map; i++) {
2538 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2540 if (in_file_index >= nb_input_files) {
2541 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2544 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2545 in_file_index >= 0 ?
2546 input_files[in_file_index]->ctx : NULL, o);
2550 if (o->chapters_input_file >= nb_input_files) {
2551 if (o->chapters_input_file == INT_MAX) {
2552 /* copy chapters from the first input file that has them*/
2553 o->chapters_input_file = -1;
2554 for (i = 0; i < nb_input_files; i++)
2555 if (input_files[i]->ctx->nb_chapters) {
2556 o->chapters_input_file = i;
2560 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2561 o->chapters_input_file);
2565 if (o->chapters_input_file >= 0)
2566 copy_chapters(input_files[o->chapters_input_file], of,
2567 !o->metadata_chapters_manual);
2569 /* copy global metadata by default */
2570 if (!o->metadata_global_manual && nb_input_files){
2571 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2572 AV_DICT_DONT_OVERWRITE);
2573 if(o->recording_time != INT64_MAX)
2574 av_dict_set(&oc->metadata, "duration", NULL, 0);
2575 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2577 if (!o->metadata_streams_manual)
2578 for (i = of->ost_index; i < nb_output_streams; i++) {
2580 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2582 ist = input_streams[output_streams[i]->source_index];
2583 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2584 if (!output_streams[i]->stream_copy) {
2585 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2586 if (ist->autorotate)
2587 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2591 /* process manually set programs */
2592 for (i = 0; i < o->nb_program; i++) {
2593 const char *p = o->program[i].u.str;
2598 const char *p2 = av_get_token(&p, ":");
2599 const char *to_dealloc = p2;
2606 key = av_get_token(&p2, "=");
2608 av_freep(&to_dealloc);
2614 if (!strcmp(key, "program_num"))
2615 progid = strtol(p2, NULL, 0);
2616 av_freep(&to_dealloc);
2620 program = av_new_program(oc, progid);
2622 p = o->program[i].u.str;
2624 const char *p2 = av_get_token(&p, ":");
2625 const char *to_dealloc = p2;
2631 key = av_get_token(&p2, "=");
2633 av_log(NULL, AV_LOG_FATAL,
2634 "No '=' character in program string %s.\n",
2642 if (!strcmp(key, "title")) {
2643 av_dict_set(&program->metadata, "title", p2, 0);
2644 } else if (!strcmp(key, "program_num")) {
2645 } else if (!strcmp(key, "st")) {
2646 int st_num = strtol(p2, NULL, 0);
2647 av_program_add_stream_index(oc, progid, st_num);
2649 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2652 av_freep(&to_dealloc);
2657 /* process manually set metadata */
2658 for (i = 0; i < o->nb_metadata; i++) {
2661 const char *stream_spec;
2662 int index = 0, j, ret = 0;
2664 val = strchr(o->metadata[i].u.str, '=');
2666 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2667 o->metadata[i].u.str);
2672 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2674 for (j = 0; j < oc->nb_streams; j++) {
2675 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2676 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2677 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2678 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2679 ost->rotate_overridden = 1;
2691 if (index < 0 || index >= oc->nb_chapters) {
2692 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2695 m = &oc->chapters[index]->metadata;
2698 if (index < 0 || index >= oc->nb_programs) {
2699 av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2702 m = &oc->programs[index]->metadata;
2705 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2708 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2715 static int opt_target(void *optctx, const char *opt, const char *arg)
2717 OptionsContext *o = optctx;
2718 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2719 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2721 if (!strncmp(arg, "pal-", 4)) {
2724 } else if (!strncmp(arg, "ntsc-", 5)) {
2727 } else if (!strncmp(arg, "film-", 5)) {
2731 /* Try to determine PAL/NTSC by peeking in the input files */
2732 if (nb_input_files) {
2734 for (j = 0; j < nb_input_files; j++) {
2735 for (i = 0; i < input_files[j]->nb_streams; i++) {
2736 AVStream *st = input_files[j]->ctx->streams[i];
2737 if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2739 fr = st->time_base.den * 1000 / st->time_base.num;
2743 } else if ((fr == 29970) || (fr == 23976)) {
2748 if (norm != UNKNOWN)
2752 if (norm != UNKNOWN)
2753 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2756 if (norm == UNKNOWN) {
2757 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2758 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2759 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2763 if (!strcmp(arg, "vcd")) {
2764 opt_video_codec(o, "c:v", "mpeg1video");
2765 opt_audio_codec(o, "c:a", "mp2");
2766 parse_option(o, "f", "vcd", options);
2768 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2769 parse_option(o, "r", frame_rates[norm], options);
2770 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2772 opt_default(NULL, "b:v", "1150000");
2773 opt_default(NULL, "maxrate:v", "1150000");
2774 opt_default(NULL, "minrate:v", "1150000");
2775 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2777 opt_default(NULL, "b:a", "224000");
2778 parse_option(o, "ar", "44100", options);
2779 parse_option(o, "ac", "2", options);
2781 opt_default(NULL, "packetsize", "2324");
2782 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2784 /* We have to offset the PTS, so that it is consistent with the SCR.
2785 SCR starts at 36000, but the first two packs contain only padding
2786 and the first pack from the other stream, respectively, may also have
2787 been written before.
2788 So the real data starts at SCR 36000+3*1200. */
2789 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2790 } else if (!strcmp(arg, "svcd")) {
2792 opt_video_codec(o, "c:v", "mpeg2video");
2793 opt_audio_codec(o, "c:a", "mp2");
2794 parse_option(o, "f", "svcd", options);
2796 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2797 parse_option(o, "r", frame_rates[norm], options);
2798 parse_option(o, "pix_fmt", "yuv420p", options);
2799 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2801 opt_default(NULL, "b:v", "2040000");
2802 opt_default(NULL, "maxrate:v", "2516000");
2803 opt_default(NULL, "minrate:v", "0"); // 1145000;
2804 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2805 opt_default(NULL, "scan_offset", "1");
2807 opt_default(NULL, "b:a", "224000");
2808 parse_option(o, "ar", "44100", options);
2810 opt_default(NULL, "packetsize", "2324");
2812 } else if (!strcmp(arg, "dvd")) {
2814 opt_video_codec(o, "c:v", "mpeg2video");
2815 opt_audio_codec(o, "c:a", "ac3");
2816 parse_option(o, "f", "dvd", options);
2818 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2819 parse_option(o, "r", frame_rates[norm], options);
2820 parse_option(o, "pix_fmt", "yuv420p", options);
2821 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2823 opt_default(NULL, "b:v", "6000000");
2824 opt_default(NULL, "maxrate:v", "9000000");
2825 opt_default(NULL, "minrate:v", "0"); // 1500000;
2826 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2828 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2829 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2831 opt_default(NULL, "b:a", "448000");
2832 parse_option(o, "ar", "48000", options);
2834 } else if (!strncmp(arg, "dv", 2)) {
2836 parse_option(o, "f", "dv", options);
2838 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2839 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2840 norm == PAL ? "yuv420p" : "yuv411p", options);
2841 parse_option(o, "r", frame_rates[norm], options);
2843 parse_option(o, "ar", "48000", options);
2844 parse_option(o, "ac", "2", options);
2847 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2848 return AVERROR(EINVAL);
2851 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2852 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2857 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2859 av_free (vstats_filename);
2860 vstats_filename = av_strdup (arg);
2864 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2867 time_t today2 = time(NULL);
2868 struct tm *today = localtime(&today2);
2870 if (!today) { // maybe tomorrow
2871 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2875 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2877 return opt_vstats_file(NULL, opt, filename);
2880 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2882 OptionsContext *o = optctx;
2883 return parse_option(o, "frames:v", arg, options);
2886 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2888 OptionsContext *o = optctx;
2889 return parse_option(o, "frames:a", arg, options);
2892 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2894 OptionsContext *o = optctx;
2895 return parse_option(o, "frames:d", arg, options);
2898 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2901 AVDictionary *cbak = codec_opts;
2902 AVDictionary *fbak = format_opts;
2906 ret = opt_default(NULL, opt, arg);
2908 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2909 av_dict_copy(&o->g->format_opts, format_opts, 0);
2910 av_dict_free(&codec_opts);
2911 av_dict_free(&format_opts);
2918 static int opt_preset(void *optctx, const char *opt, const char *arg)
2920 OptionsContext *o = optctx;
2922 char filename[1000], line[1000], tmp_line[1000];
2923 const char *codec_name = NULL;
2927 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2929 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2930 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2931 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2933 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2937 while (fgets(line, sizeof(line), f)) {
2938 char *key = tmp_line, *value, *endptr;
2940 if (strcspn(line, "#\n\r") == 0)
2942 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2943 if (!av_strtok(key, "=", &value) ||
2944 !av_strtok(value, "\r\n", &endptr)) {
2945 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2948 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2950 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2951 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2952 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2953 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2954 else if (opt_default_new(o, key, value) < 0) {
2955 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2956 filename, line, key, value);
2966 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2968 OptionsContext *o = optctx;
2969 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2970 int ret = parse_option(o, s, arg, options);
2975 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2977 OptionsContext *o = optctx;
2979 if(!strcmp(opt, "ab")){
2980 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2982 } else if(!strcmp(opt, "b")){
2983 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2984 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2987 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2991 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2993 OptionsContext *o = optctx;
2996 if(!strcmp(opt, "qscale")){
2997 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2998 return parse_option(o, "q:v", arg, options);
3000 s = av_asprintf("q%s", opt + 6);
3001 ret = parse_option(o, s, arg, options);
3006 static int opt_profile(void *optctx, const char *opt, const char *arg)
3008 OptionsContext *o = optctx;
3009 if(!strcmp(opt, "profile")){
3010 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3011 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3014 av_dict_set(&o->g->codec_opts, opt, arg, 0);
3018 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3020 OptionsContext *o = optctx;
3021 return parse_option(o, "filter:v", arg, options);
3024 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3026 OptionsContext *o = optctx;
3027 return parse_option(o, "filter:a", arg, options);
3030 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3032 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3033 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3034 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3035 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3037 if (video_sync_method == VSYNC_AUTO)
3038 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3042 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3044 OptionsContext *o = optctx;
3045 char *tcr = av_asprintf("timecode=%s", arg);
3046 int ret = parse_option(o, "metadata:g", tcr, options);
3048 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3053 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3055 OptionsContext *o = optctx;
3056 char layout_str[32];
3059 int ret, channels, ac_str_size;
3062 layout = av_get_channel_layout(arg);
3064 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3065 return AVERROR(EINVAL);
3067 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3068 ret = opt_default_new(o, opt, layout_str);
3072 /* set 'ac' option based on channel layout */
3073 channels = av_get_channel_layout_nb_channels(layout);
3074 snprintf(layout_str, sizeof(layout_str), "%d", channels);
3075 stream_str = strchr(opt, ':');
3076 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3077 ac_str = av_mallocz(ac_str_size);
3079 return AVERROR(ENOMEM);
3080 av_strlcpy(ac_str, "ac", 3);
3082 av_strlcat(ac_str, stream_str, ac_str_size);
3083 ret = parse_option(o, ac_str, layout_str, options);
3089 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3091 OptionsContext *o = optctx;
3092 return parse_option(o, "q:a", arg, options);
3095 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3097 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3098 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3099 return AVERROR(ENOMEM);
3100 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3101 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3102 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3103 return AVERROR(ENOMEM);
3105 input_stream_potentially_available = 1;
3110 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3112 uint8_t *graph_desc = read_file(arg);
3114 return AVERROR(EINVAL);
3116 GROW_ARRAY(filtergraphs, nb_filtergraphs);
3117 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3118 return AVERROR(ENOMEM);
3119 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3120 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3122 input_stream_potentially_available = 1;
3127 void show_help_default(const char *opt, const char *arg)
3129 /* per-file options have at least one of those set */
3130 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3131 int show_advanced = 0, show_avoptions = 0;
3134 if (!strcmp(opt, "long"))
3136 else if (!strcmp(opt, "full"))
3137 show_advanced = show_avoptions = 1;
3139 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3144 printf("Getting help:\n"
3145 " -h -- print basic options\n"
3146 " -h long -- print more options\n"
3147 " -h full -- print all options (including all format and codec specific options, very long)\n"
3148 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3149 " See man %s for detailed description of the options.\n"
3150 "\n", program_name);
3152 show_help_options(options, "Print help / information / capabilities:",
3155 show_help_options(options, "Global options (affect whole program "
3156 "instead of just one file:",
3157 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3159 show_help_options(options, "Advanced global options:", OPT_EXPERT,
3160 per_file | OPT_EXIT, 0);
3162 show_help_options(options, "Per-file main options:", 0,
3163 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3164 OPT_EXIT, per_file);
3166 show_help_options(options, "Advanced per-file options:",
3167 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3169 show_help_options(options, "Video options:",
3170 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3172 show_help_options(options, "Advanced Video options:",
3173 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3175 show_help_options(options, "Audio options:",
3176 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3178 show_help_options(options, "Advanced Audio options:",
3179 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3180 show_help_options(options, "Subtitle options:",
3181 OPT_SUBTITLE, 0, 0);
3184 if (show_avoptions) {
3185 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3186 show_help_children(avcodec_get_class(), flags);
3187 show_help_children(avformat_get_class(), flags);
3189 show_help_children(sws_get_class(), flags);
3191 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3192 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3196 void show_usage(void)
3198 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3199 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3200 av_log(NULL, AV_LOG_INFO, "\n");
3208 static const OptionGroupDef groups[] = {
3209 [GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3210 [GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3213 static int open_files(OptionGroupList *l, const char *inout,
3214 int (*open_file)(OptionsContext*, const char*))
3218 for (i = 0; i < l->nb_groups; i++) {
3219 OptionGroup *g = &l->groups[i];
3225 ret = parse_optgroup(&o, g);
3227 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3228 "%s.\n", inout, g->arg);
3232 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3233 ret = open_file(&o, g->arg);
3236 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3240 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3246 int ffmpeg_parse_options(int argc, char **argv)
3248 OptionParseContext octx;
3252 memset(&octx, 0, sizeof(octx));
3254 /* split the commandline into an internal representation */
3255 ret = split_commandline(&octx, argc, argv, options, groups,
3256 FF_ARRAY_ELEMS(groups));
3258 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3262 /* apply global options */
3263 ret = parse_optgroup(NULL, &octx.global_opts);
3265 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3269 /* configure terminal and setup signal handlers */
3272 /* open input files */
3273 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3275 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3279 /* create the complex filtergraphs */
3280 ret = init_complex_filters();
3282 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3286 /* open output files */
3287 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3289 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3293 /* configure the complex filtergraphs */
3294 ret = configure_complex_filters();
3296 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3301 uninit_parse_context(&octx);
3303 av_strerror(ret, error, sizeof(error));
3304 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3309 static int opt_progress(void *optctx, const char *opt, const char *arg)
3311 AVIOContext *avio = NULL;
3314 if (!strcmp(arg, "-"))
3316 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3318 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3319 arg, av_err2str(ret));
3322 progress_avio = avio;
3326 #define OFFSET(x) offsetof(OptionsContext, x)
3327 const OptionDef options[] = {
3329 #include "cmdutils_common_opts.h"
3330 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3331 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3332 "force format", "fmt" },
3333 { "y", OPT_BOOL, { &file_overwrite },
3334 "overwrite output files" },
3335 { "n", OPT_BOOL, { &no_file_overwrite },
3336 "never overwrite output files" },
3337 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3338 "Ignore unknown stream types" },
3339 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3340 "Copy unknown stream types" },
3341 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3342 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3343 "codec name", "codec" },
3344 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3345 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3346 "codec name", "codec" },
3347 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3348 OPT_OUTPUT, { .off = OFFSET(presets) },
3349 "preset name", "preset" },
3350 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3351 OPT_OUTPUT, { .func_arg = opt_map },
3352 "set input stream mapping",
3353 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3354 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3355 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3356 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3357 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3358 "set metadata information of outfile from infile",
3359 "outfile[,metadata]:infile[,metadata]" },
3360 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3361 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3362 "set chapters mapping", "input_file_index" },
3363 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3364 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3365 "record or transcode \"duration\" seconds of audio/video",
3367 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3368 "record or transcode stop time", "time_stop" },
3369 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3370 "set the limit file size in bytes", "limit_size" },
3371 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3372 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3373 "set the start time offset", "time_off" },
3374 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3375 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3376 "set the start time offset relative to EOF", "time_off" },
3377 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3378 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3379 "enable/disable seeking by timestamp with -ss" },
3380 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3381 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3382 "enable/disable accurate seeking with -ss" },
3383 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3384 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3385 "set the input ts offset", "time_off" },
3386 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3387 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3388 "set the input ts scale", "scale" },
3389 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3390 "set the recording timestamp ('now' to set the current time)", "time" },
3391 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3392 "add metadata", "string=string" },
3393 { "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3394 "add program with specified streams", "title=string:st=number..." },
3395 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3396 OPT_OUTPUT, { .func_arg = opt_data_frames },
3397 "set the number of data frames to output", "number" },
3398 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3399 "add timings for benchmarking" },
3400 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3401 "add timings for each task" },
3402 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3403 "write program-readable progress information", "url" },
3404 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3405 "enable or disable interaction on standard input" },
3406 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3407 "set max runtime in seconds", "limit" },
3408 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3409 "dump each input packet" },
3410 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3411 "when dumping packets, also dump the payload" },
3412 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3413 OPT_INPUT, { .off = OFFSET(rate_emu) },
3414 "read input at native frame rate", "" },
3415 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3416 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3417 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3418 { "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3419 "video sync method", "" },
3420 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3421 "frame drop threshold", "" },
3422 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3423 "audio sync method", "" },
3424 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3425 "audio drift threshold", "threshold" },
3426 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3427 "copy timestamps" },
3428 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3429 "shift input timestamps to start at 0 when using copyts" },
3430 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3431 "copy input stream time base when stream copying", "mode" },
3432 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3433 OPT_OUTPUT, { .off = OFFSET(shortest) },
3434 "finish encoding within shortest input" },
3435 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3436 OPT_OUTPUT, { .off = OFFSET(apad) },
3438 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3439 "timestamp discontinuity delta threshold", "threshold" },
3440 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3441 "timestamp error delta threshold", "threshold" },
3442 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3443 "exit on error", "error" },
3444 { "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3445 "abort on the specified condition flags", "flags" },
3446 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3447 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3448 "copy initial non-keyframes" },
3449 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3450 "copy or discard frames before start time" },
3451 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3452 "set the number of frames to output", "number" },
3453 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3454 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3455 "force codec tag/fourcc", "fourcc/tag" },
3456 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3457 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3458 "use fixed quality scale (VBR)", "q" },
3459 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3460 OPT_OUTPUT, { .func_arg = opt_qscale },
3461 "use fixed quality scale (VBR)", "q" },
3462 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3463 "set profile", "profile" },
3464 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3465 "set stream filtergraph", "filter_graph" },
3466 { "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3467 "number of non-complex filter threads" },
3468 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3469 "read stream filtergraph description from a file", "filename" },
3470 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3471 "reinit filtergraph on input parameter changes", "" },
3472 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3473 "create a complex filtergraph", "graph_description" },
3474 { "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3475 "number of threads for -filter_complex" },
3476 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3477 "create a complex filtergraph", "graph_description" },
3478 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3479 "read complex filtergraph description from a file", "filename" },
3480 { "stats", OPT_BOOL, { &print_stats },
3481 "print progress report during encoding", },
3482 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3483 OPT_OUTPUT, { .func_arg = opt_attach },
3484 "add an attachment to the output file", "filename" },
3485 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3486 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3487 "extract an attachment into a file", "filename" },
3488 { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3489 OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3490 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3491 "print timestamp debugging info" },
3492 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3493 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3494 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3495 OPT_INPUT, { .off = OFFSET(discard) },
3497 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3498 OPT_OUTPUT, { .off = OFFSET(disposition) },
3499 "disposition", "" },
3500 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3501 { .off = OFFSET(thread_queue_size) },
3502 "set the maximum number of queued packets from the demuxer" },
3505 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3506 "set the number of video frames to output", "number" },
3507 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3508 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3509 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3510 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3511 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3512 "set frame size (WxH or abbreviation)", "size" },
3513 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3514 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3515 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3516 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3517 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3518 "set pixel format", "format" },
3519 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3520 "set the number of bits per raw sample", "number" },
3521 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3522 "deprecated use -g 1" },
3523 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3525 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3526 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3527 "rate control override for specific intervals", "override" },
3528 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3529 OPT_OUTPUT, { .func_arg = opt_video_codec },
3530 "force video codec ('copy' to copy stream)", "codec" },
3531 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3533 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3535 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3536 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3537 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3538 "select the pass number (1 to 3)", "n" },
3539 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3540 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3541 "select two pass log file name prefix", "prefix" },
3542 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3543 "this option is deprecated, use the yadif filter instead" },
3544 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3545 "calculate PSNR of compressed frames" },
3546 { "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3547 "dump video coding statistics to file" },
3548 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3549 "dump video coding statistics to file", "file" },
3550 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3551 "set video filters", "filter_graph" },
3552 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3553 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3554 "specify intra matrix coeffs", "matrix" },
3555 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3556 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3557 "specify inter matrix coeffs", "matrix" },
3558 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3559 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3560 "specify intra matrix coeffs", "matrix" },
3561 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3562 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3563 "top=1/bottom=0/auto=-1 field first", "" },
3564 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3565 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3566 "force video tag/fourcc", "fourcc/tag" },
3567 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3568 "show QP histogram" },
3569 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3570 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3571 "force the selected framerate, disable the best supported framerate selection" },
3572 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3573 OPT_OUTPUT, { .func_arg = opt_streamid },
3574 "set the value of an outfile streamid", "streamIndex:value" },
3575 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3576 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3577 "force key frames at specified timestamps", "timestamps" },
3578 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3579 "audio bitrate (please use -b:a)", "bitrate" },
3580 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3581 "video bitrate (please use -b:v)", "bitrate" },
3582 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3583 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3584 "use HW accelerated decoding", "hwaccel name" },
3585 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3586 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3587 "select a device for HW acceleration", "devicename" },
3588 { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3589 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3590 "select output format used with HW accelerated decoding", "format" },
3591 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3592 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3594 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3595 "show available HW acceleration methods" },
3596 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3597 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3598 "automatically insert correct rotate filters" },
3599 { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3600 "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3603 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3604 "set the number of audio frames to output", "number" },
3605 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3606 "set audio quality (codec-specific)", "quality", },
3607 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3608 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3609 "set audio sampling rate (in Hz)", "rate" },
3610 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3611 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3612 "set number of audio channels", "channels" },
3613 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3615 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3616 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3617 "force audio codec ('copy' to copy stream)", "codec" },
3618 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3619 OPT_OUTPUT, { .func_arg = opt_old2new },
3620 "force audio tag/fourcc", "fourcc/tag" },
3621 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3622 "change audio volume (256=normal)" , "volume" },
3623 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3624 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3625 "set sample format", "format" },
3626 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3627 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3628 "set channel layout", "layout" },
3629 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3630 "set audio filters", "filter_graph" },
3631 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3632 "set the maximum number of channels to try to guess the channel layout" },
3634 /* subtitle options */
3635 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3636 "disable subtitle" },
3637 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3638 "force subtitle codec ('copy' to copy stream)", "codec" },
3639 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3640 , "force subtitle tag/fourcc", "fourcc/tag" },
3641 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3642 "fix subtitles duration" },
3643 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3644 "set canvas size (WxH or abbreviation)", "size" },
3647 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3648 "deprecated, use -channel", "channel" },
3649 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3650 "deprecated, use -standard", "standard" },
3651 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3654 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3655 "set the maximum demux-decode delay", "seconds" },
3656 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3657 "set the initial demux-decode delay", "seconds" },
3658 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3659 "override the options from ffserver", "" },
3660 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3661 "specify a file in which to print sdp information", "file" },
3663 { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3664 "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3666 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3667 "A comma-separated list of bitstream filters", "bitstream_filters" },
3668 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3669 "deprecated", "audio bitstream_filters" },
3670 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3671 "deprecated", "video bitstream_filters" },
3673 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3674 "set the audio options to the indicated preset", "preset" },
3675 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3676 "set the video options to the indicated preset", "preset" },
3677 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3678 "set the subtitle options to the indicated preset", "preset" },
3679 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3680 "set options from indicated preset file", "filename" },
3682 { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3683 "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3685 /* data codec support */
3686 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3687 "force data codec ('copy' to copy stream)", "codec" },
3688 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3692 { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3693 "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3697 { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3698 "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},