2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
43 #include "libavutil/time_internal.h"
45 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
47 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
50 for (i = 0; i < o->nb_ ## name; i++) {\
51 char *spec = o->name[i].specifier;\
52 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
53 outvar = o->name[i].u.type;\
59 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
62 for (i = 0; i < o->nb_ ## name; i++) {\
63 char *spec = o->name[i].specifier;\
64 if (!strcmp(spec, mediatype))\
65 outvar = o->name[i].u.type;\
69 const HWAccel hwaccels[] = {
71 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
74 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
77 { "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 #if CONFIG_VIDEOTOOLBOX
80 { "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
85 char *vstats_filename;
88 float audio_drift_threshold = 0.1;
89 float dts_delta_threshold = 10;
90 float dts_error_threshold = 3600*30;
92 int audio_volume = 256;
93 int audio_sync_method = 0;
94 int video_sync_method = VSYNC_AUTO;
95 float frame_drop_threshold = 0;
96 int do_deinterlace = 0;
98 int do_benchmark_all = 0;
102 int start_at_zero = 0;
105 int exit_on_error = 0;
106 int print_stats = -1;
108 int stdin_interaction = 1;
109 int frame_bits_per_raw_sample = 0;
110 float max_error_rate = 2.0/3;
113 static int intra_only = 0;
114 static int file_overwrite = 0;
115 static int no_file_overwrite = 0;
116 static int do_psnr = 0;
117 static int input_sync;
118 static int override_ffserver = 0;
119 static int input_stream_potentially_available = 0;
120 static int ignore_unknown_streams = 0;
121 static int copy_unknown_streams = 0;
123 static void uninit_options(OptionsContext *o)
125 const OptionDef *po = options;
128 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
130 void *dst = (uint8_t*)o + po->u.off;
132 if (po->flags & OPT_SPEC) {
133 SpecifierOpt **so = dst;
134 int i, *count = (int*)(so + 1);
135 for (i = 0; i < *count; i++) {
136 av_freep(&(*so)[i].specifier);
137 if (po->flags & OPT_STRING)
138 av_freep(&(*so)[i].u.str);
142 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
147 for (i = 0; i < o->nb_stream_maps; i++)
148 av_freep(&o->stream_maps[i].linklabel);
149 av_freep(&o->stream_maps);
150 av_freep(&o->audio_channel_maps);
151 av_freep(&o->streamid_map);
152 av_freep(&o->attachments);
155 static void init_options(OptionsContext *o)
157 memset(o, 0, sizeof(*o));
159 o->stop_time = INT64_MAX;
160 o->mux_max_delay = 0.7;
161 o->start_time = AV_NOPTS_VALUE;
162 o->start_time_eof = AV_NOPTS_VALUE;
163 o->recording_time = INT64_MAX;
164 o->limit_filesize = UINT64_MAX;
165 o->chapters_input_file = INT_MAX;
166 o->accurate_seek = 1;
169 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
173 printf("Hardware acceleration methods:\n");
174 for (i = 0; i < FF_ARRAY_ELEMS(hwaccels) - 1; i++) {
175 printf("%s\n", hwaccels[i].name);
181 /* return a copy of the input with the stream specifiers removed from the keys */
182 static AVDictionary *strip_specifiers(AVDictionary *dict)
184 AVDictionaryEntry *e = NULL;
185 AVDictionary *ret = NULL;
187 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
188 char *p = strchr(e->key, ':');
192 av_dict_set(&ret, e->key, e->value, 0);
199 static int opt_sameq(void *optctx, const char *opt, const char *arg)
201 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
202 "If you are looking for an option to preserve the quality (which is not "
203 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
205 return AVERROR(EINVAL);
208 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
210 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
211 return opt_default(optctx, "channel", arg);
214 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
216 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
217 return opt_default(optctx, "standard", arg);
220 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
222 OptionsContext *o = optctx;
223 return parse_option(o, "codec:a", arg, options);
226 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
228 OptionsContext *o = optctx;
229 return parse_option(o, "codec:v", arg, options);
232 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
234 OptionsContext *o = optctx;
235 return parse_option(o, "codec:s", arg, options);
238 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
240 OptionsContext *o = optctx;
241 return parse_option(o, "codec:d", arg, options);
244 static int opt_map(void *optctx, const char *opt, const char *arg)
246 OptionsContext *o = optctx;
248 int i, negative = 0, file_idx;
249 int sync_file_idx = -1, sync_stream_idx = 0;
258 map = av_strdup(arg);
260 return AVERROR(ENOMEM);
262 /* parse sync stream first, just pick first matching stream */
263 if (sync = strchr(map, ',')) {
265 sync_file_idx = strtol(sync + 1, &sync, 0);
266 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
267 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
272 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
273 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
274 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
278 if (i == input_files[sync_file_idx]->nb_streams) {
279 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
280 "match any streams.\n", arg);
287 /* this mapping refers to lavfi output */
288 const char *c = map + 1;
289 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
290 m = &o->stream_maps[o->nb_stream_maps - 1];
291 m->linklabel = av_get_token(&c, "]");
293 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
297 if (allow_unused = strchr(map, '?'))
299 file_idx = strtol(map, &p, 0);
300 if (file_idx >= nb_input_files || file_idx < 0) {
301 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
305 /* disable some already defined maps */
306 for (i = 0; i < o->nb_stream_maps; i++) {
307 m = &o->stream_maps[i];
308 if (file_idx == m->file_index &&
309 check_stream_specifier(input_files[m->file_index]->ctx,
310 input_files[m->file_index]->ctx->streams[m->stream_index],
311 *p == ':' ? p + 1 : p) > 0)
315 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
316 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
317 *p == ':' ? p + 1 : p) <= 0)
319 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
320 m = &o->stream_maps[o->nb_stream_maps - 1];
322 m->file_index = file_idx;
325 if (sync_file_idx >= 0) {
326 m->sync_file_index = sync_file_idx;
327 m->sync_stream_index = sync_stream_idx;
329 m->sync_file_index = file_idx;
330 m->sync_stream_index = i;
337 av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
339 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
340 "To ignore this, add a trailing '?' to the map.\n", arg);
349 static int opt_attach(void *optctx, const char *opt, const char *arg)
351 OptionsContext *o = optctx;
352 GROW_ARRAY(o->attachments, o->nb_attachments);
353 o->attachments[o->nb_attachments - 1] = arg;
357 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
359 OptionsContext *o = optctx;
364 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
365 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
367 /* muted channel syntax */
368 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
369 if ((n == 1 || n == 3) && m->channel_idx == -1) {
370 m->file_idx = m->stream_idx = -1;
372 m->ofile_idx = m->ostream_idx = -1;
377 n = sscanf(arg, "%d.%d.%d:%d.%d",
378 &m->file_idx, &m->stream_idx, &m->channel_idx,
379 &m->ofile_idx, &m->ostream_idx);
381 if (n != 3 && n != 5) {
382 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
383 "[file.stream.channel|-1][:syncfile:syncstream]\n");
387 if (n != 5) // only file.stream.channel specified
388 m->ofile_idx = m->ostream_idx = -1;
391 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
392 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
396 if (m->stream_idx < 0 ||
397 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
398 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
399 m->file_idx, m->stream_idx);
402 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
403 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
404 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
405 m->file_idx, m->stream_idx);
408 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
409 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
410 m->file_idx, m->stream_idx, m->channel_idx);
416 static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
418 av_free(sdp_filename);
419 sdp_filename = av_strdup(arg);
424 * Parse a metadata specifier passed as 'arg' parameter.
425 * @param arg metadata string to parse
426 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
427 * @param index for type c/p, chapter/program index is written here
428 * @param stream_spec for type s, the stream specifier is written here
430 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
438 if (*(++arg) && *arg != ':') {
439 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
442 *stream_spec = *arg == ':' ? arg + 1 : "";
447 *index = strtol(++arg, NULL, 0);
450 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
457 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
459 AVDictionary **meta_in = NULL;
460 AVDictionary **meta_out = NULL;
462 char type_in, type_out;
463 const char *istream_spec = NULL, *ostream_spec = NULL;
464 int idx_in = 0, idx_out = 0;
466 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
467 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
470 if (type_out == 'g' || !*outspec)
471 o->metadata_global_manual = 1;
472 if (type_out == 's' || !*outspec)
473 o->metadata_streams_manual = 1;
474 if (type_out == 'c' || !*outspec)
475 o->metadata_chapters_manual = 1;
479 if (type_in == 'g' || type_out == 'g')
480 o->metadata_global_manual = 1;
481 if (type_in == 's' || type_out == 's')
482 o->metadata_streams_manual = 1;
483 if (type_in == 'c' || type_out == 'c')
484 o->metadata_chapters_manual = 1;
486 /* ic is NULL when just disabling automatic mappings */
490 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
491 if ((index) < 0 || (index) >= (nb_elems)) {\
492 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
497 #define SET_DICT(type, meta, context, index)\
500 meta = &context->metadata;\
503 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
504 meta = &context->chapters[index]->metadata;\
507 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
508 meta = &context->programs[index]->metadata;\
511 break; /* handled separately below */ \
512 default: av_assert0(0);\
515 SET_DICT(type_in, meta_in, ic, idx_in);
516 SET_DICT(type_out, meta_out, oc, idx_out);
518 /* for input streams choose first matching stream */
519 if (type_in == 's') {
520 for (i = 0; i < ic->nb_streams; i++) {
521 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
522 meta_in = &ic->streams[i]->metadata;
528 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
533 if (type_out == 's') {
534 for (i = 0; i < oc->nb_streams; i++) {
535 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
536 meta_out = &oc->streams[i]->metadata;
537 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
542 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
547 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
549 OptionsContext *o = optctx;
551 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
552 struct tm time = *gmtime((time_t*)&recording_timestamp);
553 if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
555 parse_option(o, "metadata", buf, options);
557 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
558 "tag instead.\n", opt);
562 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
564 const AVCodecDescriptor *desc;
565 const char *codec_string = encoder ? "encoder" : "decoder";
569 avcodec_find_encoder_by_name(name) :
570 avcodec_find_decoder_by_name(name);
572 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
573 codec = encoder ? avcodec_find_encoder(desc->id) :
574 avcodec_find_decoder(desc->id);
576 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
577 codec_string, codec->name, desc->name);
581 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
584 if (codec->type != type) {
585 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
591 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
593 char *codec_name = NULL;
595 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
597 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
598 st->codec->codec_id = codec->id;
601 return avcodec_find_decoder(st->codec->codec_id);
604 /* Add all the streams from the given input file to the global
605 * list of input streams. */
606 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
610 for (i = 0; i < ic->nb_streams; i++) {
611 AVStream *st = ic->streams[i];
612 AVCodecContext *dec = st->codec;
613 InputStream *ist = av_mallocz(sizeof(*ist));
614 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
615 char *codec_tag = NULL;
617 char *discard_str = NULL;
618 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
623 GROW_ARRAY(input_streams, nb_input_streams);
624 input_streams[nb_input_streams - 1] = ist;
627 ist->file_index = nb_input_files;
629 st->discard = AVDISCARD_ALL;
632 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
635 MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
637 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
639 uint32_t tag = strtol(codec_tag, &next, 0);
641 tag = AV_RL32(codec_tag);
642 st->codec->codec_tag = tag;
645 ist->dec = choose_decoder(o, ic, st);
646 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
648 ist->reinit_filters = -1;
649 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
651 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
652 ist->user_set_discard = AVDISCARD_NONE;
653 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
654 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
659 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
661 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
663 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
667 ret = avcodec_copy_context(ist->dec_ctx, dec);
669 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
673 switch (dec->codec_type) {
674 case AVMEDIA_TYPE_VIDEO:
676 ist->dec = avcodec_find_decoder(dec->codec_id);
678 if (av_codec_get_lowres(dec)) {
679 dec->flags |= CODEC_FLAG_EMU_EDGE;
683 ist->resample_height = ist->dec_ctx->height;
684 ist->resample_width = ist->dec_ctx->width;
685 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
687 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
688 if (framerate && av_parse_video_rate(&ist->framerate,
690 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
695 ist->top_field_first = -1;
696 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
698 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
700 if (!strcmp(hwaccel, "none"))
701 ist->hwaccel_id = HWACCEL_NONE;
702 else if (!strcmp(hwaccel, "auto"))
703 ist->hwaccel_id = HWACCEL_AUTO;
706 for (i = 0; hwaccels[i].name; i++) {
707 if (!strcmp(hwaccels[i].name, hwaccel)) {
708 ist->hwaccel_id = hwaccels[i].id;
713 if (!ist->hwaccel_id) {
714 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
716 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
717 for (i = 0; hwaccels[i].name; i++)
718 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
719 av_log(NULL, AV_LOG_FATAL, "\n");
725 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
726 if (hwaccel_device) {
727 ist->hwaccel_device = av_strdup(hwaccel_device);
728 if (!ist->hwaccel_device)
731 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
734 case AVMEDIA_TYPE_AUDIO:
735 ist->guess_layout_max = INT_MAX;
736 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
737 guess_input_channel_layout(ist);
739 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
740 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
741 ist->resample_channels = ist->dec_ctx->channels;
742 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
745 case AVMEDIA_TYPE_DATA:
746 case AVMEDIA_TYPE_SUBTITLE: {
747 char *canvas_size = NULL;
749 ist->dec = avcodec_find_decoder(dec->codec_id);
750 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
751 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
753 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
754 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
759 case AVMEDIA_TYPE_ATTACHMENT:
760 case AVMEDIA_TYPE_UNKNOWN:
768 static void assert_file_overwrite(const char *filename)
770 if (file_overwrite && no_file_overwrite) {
771 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
775 if (!file_overwrite) {
776 const char *proto_name = avio_find_protocol_name(filename);
777 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
778 if (stdin_interaction && !no_file_overwrite) {
779 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
782 signal(SIGINT, SIG_DFL);
784 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
790 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
797 static void dump_attachment(AVStream *st, const char *filename)
800 AVIOContext *out = NULL;
801 AVDictionaryEntry *e;
803 if (!st->codec->extradata_size) {
804 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
805 nb_input_files - 1, st->index);
808 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
811 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
812 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
816 assert_file_overwrite(filename);
818 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
819 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
824 avio_write(out, st->codec->extradata, st->codec->extradata_size);
829 static int open_input_file(OptionsContext *o, const char *filename)
833 AVInputFormat *file_iformat = NULL;
837 AVDictionary *unused_opts = NULL;
838 AVDictionaryEntry *e = NULL;
839 int orig_nb_streams; // number of streams before avformat_find_stream_info
840 char * video_codec_name = NULL;
841 char * audio_codec_name = NULL;
842 char *subtitle_codec_name = NULL;
843 char * data_codec_name = NULL;
844 int scan_all_pmts_set = 0;
847 if (!(file_iformat = av_find_input_format(o->format))) {
848 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
853 if (!strcmp(filename, "-"))
856 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
857 strcmp(filename, "/dev/stdin");
859 /* get default parameters from command line */
860 ic = avformat_alloc_context();
862 print_error(filename, AVERROR(ENOMEM));
865 if (o->nb_audio_sample_rate) {
866 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
868 if (o->nb_audio_channels) {
869 /* because we set audio_channels based on both the "ac" and
870 * "channel_layout" options, we need to check that the specified
871 * demuxer actually has the "channels" option before setting it */
872 if (file_iformat && file_iformat->priv_class &&
873 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
874 AV_OPT_SEARCH_FAKE_OBJ)) {
875 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
878 if (o->nb_frame_rates) {
879 /* set the format-level framerate option;
880 * this is important for video grabbers, e.g. x11 */
881 if (file_iformat && file_iformat->priv_class &&
882 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
883 AV_OPT_SEARCH_FAKE_OBJ)) {
884 av_dict_set(&o->g->format_opts, "framerate",
885 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
888 if (o->nb_frame_sizes) {
889 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
891 if (o->nb_frame_pix_fmts)
892 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
894 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
895 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
896 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
897 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
899 ic->video_codec_id = video_codec_name ?
900 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
901 ic->audio_codec_id = audio_codec_name ?
902 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
903 ic->subtitle_codec_id= subtitle_codec_name ?
904 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
905 ic->data_codec_id = data_codec_name ?
906 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
908 if (video_codec_name)
909 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
910 if (audio_codec_name)
911 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
912 if (subtitle_codec_name)
913 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
915 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
917 ic->flags |= AVFMT_FLAG_NONBLOCK;
918 ic->interrupt_callback = int_cb;
920 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
921 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
922 scan_all_pmts_set = 1;
924 /* open the input file with generic avformat function */
925 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
927 print_error(filename, err);
930 if (scan_all_pmts_set)
931 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
932 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
933 assert_avoptions(o->g->format_opts);
935 /* apply forced codec ids */
936 for (i = 0; i < ic->nb_streams; i++)
937 choose_decoder(o, ic, ic->streams[i]);
939 /* Set AVCodecContext options for avformat_find_stream_info */
940 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
941 orig_nb_streams = ic->nb_streams;
943 /* If not enough info to get the stream parameters, we decode the
944 first frames to get it. (used in mpeg case for example) */
945 ret = avformat_find_stream_info(ic, opts);
947 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
948 if (ic->nb_streams == 0) {
949 avformat_close_input(&ic);
954 if (o->start_time_eof != AV_NOPTS_VALUE) {
955 if (ic->duration>0) {
956 o->start_time = o->start_time_eof + ic->duration;
958 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
960 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
961 /* add the stream start time */
962 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
963 timestamp += ic->start_time;
965 /* if seeking requested, we execute it */
966 if (o->start_time != AV_NOPTS_VALUE) {
967 int64_t seek_timestamp = timestamp;
969 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
970 int dts_heuristic = 0;
971 for (i=0; i<ic->nb_streams; i++) {
972 AVCodecContext *avctx = ic->streams[i]->codec;
973 if (avctx->has_b_frames)
977 seek_timestamp -= 3*AV_TIME_BASE / 23;
980 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
982 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
983 filename, (double)timestamp / AV_TIME_BASE);
987 /* update the current parameters so that they match the one of the input stream */
988 add_input_streams(o, ic);
990 /* dump the file content */
991 av_dump_format(ic, nb_input_files, filename, 0);
993 GROW_ARRAY(input_files, nb_input_files);
994 f = av_mallocz(sizeof(*f));
997 input_files[nb_input_files - 1] = f;
1000 f->ist_index = nb_input_streams - ic->nb_streams;
1001 f->start_time = o->start_time;
1002 f->recording_time = o->recording_time;
1003 f->input_ts_offset = o->input_ts_offset;
1004 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1005 f->nb_streams = ic->nb_streams;
1006 f->rate_emu = o->rate_emu;
1007 f->accurate_seek = o->accurate_seek;
1009 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1012 /* check if all codec options have been used */
1013 unused_opts = strip_specifiers(o->g->codec_opts);
1014 for (i = f->ist_index; i < nb_input_streams; i++) {
1016 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1017 AV_DICT_IGNORE_SUFFIX)))
1018 av_dict_set(&unused_opts, e->key, NULL, 0);
1022 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1023 const AVClass *class = avcodec_get_class();
1024 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1025 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1026 const AVClass *fclass = avformat_get_class();
1027 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1028 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1029 if (!option || foption)
1033 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1034 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1035 "input file #%d (%s) is not a decoding option.\n", e->key,
1036 option->help ? option->help : "", nb_input_files - 1,
1041 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1042 "input file #%d (%s) has not been used for any stream. The most "
1043 "likely reason is either wrong type (e.g. a video option with "
1044 "no video streams) or that it is a private option of some decoder "
1045 "which was not actually used for any stream.\n", e->key,
1046 option->help ? option->help : "", nb_input_files - 1, filename);
1048 av_dict_free(&unused_opts);
1050 for (i = 0; i < o->nb_dump_attachment; i++) {
1053 for (j = 0; j < ic->nb_streams; j++) {
1054 AVStream *st = ic->streams[j];
1056 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1057 dump_attachment(st, o->dump_attachment[i].u.str);
1061 for (i = 0; i < orig_nb_streams; i++)
1062 av_dict_free(&opts[i]);
1065 input_stream_potentially_available = 1;
1070 static uint8_t *get_line(AVIOContext *s)
1076 if (avio_open_dyn_buf(&line) < 0) {
1077 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1081 while ((c = avio_r8(s)) && c != '\n')
1084 avio_close_dyn_buf(line, &buf);
1089 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1092 char filename[1000];
1093 const char *base[3] = { getenv("AVCONV_DATADIR"),
1098 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1102 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1103 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1104 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1107 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1108 i != 1 ? "" : "/.avconv", preset_name);
1109 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1115 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1117 char *codec_name = NULL;
1119 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1121 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1122 NULL, ost->st->codec->codec_type);
1123 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1124 } else if (!strcmp(codec_name, "copy"))
1125 ost->stream_copy = 1;
1127 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1128 ost->st->codec->codec_id = ost->enc->id;
1132 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1135 AVStream *st = avformat_new_stream(oc, NULL);
1136 int idx = oc->nb_streams - 1, ret = 0;
1137 char *bsf = NULL, *next, *codec_tag = NULL;
1138 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1143 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1147 if (oc->nb_streams - 1 < o->nb_streamid_map)
1148 st->id = o->streamid_map[oc->nb_streams - 1];
1150 GROW_ARRAY(output_streams, nb_output_streams);
1151 if (!(ost = av_mallocz(sizeof(*ost))))
1153 output_streams[nb_output_streams - 1] = ost;
1155 ost->file_index = nb_output_files - 1;
1158 st->codec->codec_type = type;
1159 choose_encoder(o, oc, ost);
1161 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1162 if (!ost->enc_ctx) {
1163 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1166 ost->enc_ctx->codec_type = type;
1169 AVIOContext *s = NULL;
1170 char *buf = NULL, *arg = NULL, *preset = NULL;
1172 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1174 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1175 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1178 if (!buf[0] || buf[0] == '#') {
1182 if (!(arg = strchr(buf, '='))) {
1183 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1187 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1189 } while (!s->eof_reached);
1193 av_log(NULL, AV_LOG_FATAL,
1194 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1195 preset, ost->file_index, ost->index);
1199 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1202 ost->max_frames = INT64_MAX;
1203 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1204 for (i = 0; i<o->nb_max_frames; i++) {
1205 char *p = o->max_frames[i].specifier;
1206 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1207 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1212 ost->copy_prior_start = -1;
1213 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1215 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1218 if (next = strchr(bsf, ','))
1220 if (arg = strchr(bsf, '='))
1222 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1223 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1227 bsfc_prev->next = bsfc;
1229 ost->bitstream_filters = bsfc;
1230 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1236 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1238 uint32_t tag = strtol(codec_tag, &next, 0);
1240 tag = AV_RL32(codec_tag);
1241 ost->st->codec->codec_tag =
1242 ost->enc_ctx->codec_tag = tag;
1245 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1247 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1248 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1251 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1252 ost->disposition = av_strdup(ost->disposition);
1254 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1255 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1257 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1259 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1260 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1261 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1263 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1265 ost->source_index = source_index;
1266 if (source_index >= 0) {
1267 ost->sync_ist = input_streams[source_index];
1268 input_streams[source_index]->discard = 0;
1269 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1271 ost->last_mux_dts = AV_NOPTS_VALUE;
1276 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1279 const char *p = str;
1286 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1293 /* read file contents into a string */
1294 static uint8_t *read_file(const char *filename)
1296 AVIOContext *pb = NULL;
1297 AVIOContext *dyn_buf = NULL;
1298 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1299 uint8_t buf[1024], *str;
1302 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1306 ret = avio_open_dyn_buf(&dyn_buf);
1311 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1312 avio_write(dyn_buf, buf, ret);
1313 avio_w8(dyn_buf, 0);
1316 ret = avio_close_dyn_buf(dyn_buf, &str);
1322 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1325 AVStream *st = ost->st;
1327 if (ost->filters_script && ost->filters) {
1328 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1329 "output stream #%d:%d.\n", nb_output_files, st->index);
1333 if (ost->filters_script)
1334 return read_file(ost->filters_script);
1335 else if (ost->filters)
1336 return av_strdup(ost->filters);
1338 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1342 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1343 const OutputStream *ost, enum AVMediaType type)
1345 if (ost->filters_script || ost->filters) {
1346 av_log(NULL, AV_LOG_ERROR,
1347 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1348 "Filtering and streamcopy cannot be used together.\n",
1349 ost->filters ? "Filtergraph" : "Filtergraph script",
1350 ost->filters ? ost->filters : ost->filters_script,
1351 av_get_media_type_string(type), ost->file_index, ost->index);
1356 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1360 AVCodecContext *video_enc;
1361 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1363 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1365 video_enc = ost->enc_ctx;
1367 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1368 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1369 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1372 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1373 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1375 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1376 if (frame_aspect_ratio) {
1378 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1379 q.num <= 0 || q.den <= 0) {
1380 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1383 ost->frame_aspect_ratio = q;
1386 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1387 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1389 if (!ost->stream_copy) {
1390 const char *p = NULL;
1391 char *frame_size = NULL;
1392 char *frame_pix_fmt = NULL;
1393 char *intra_matrix = NULL, *inter_matrix = NULL;
1394 char *chroma_intra_matrix = NULL;
1398 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1399 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1400 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1404 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1405 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1406 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1407 ost->keep_pix_fmt = 1;
1408 if (!*++frame_pix_fmt)
1409 frame_pix_fmt = NULL;
1411 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1412 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1415 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1418 video_enc->gop_size = 0;
1419 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1421 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1422 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1425 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1427 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1428 if (chroma_intra_matrix) {
1429 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1431 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1434 av_codec_set_chroma_intra_matrix(video_enc, p);
1435 parse_matrix_coeffs(p, chroma_intra_matrix);
1437 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1439 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1440 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1443 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1446 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1447 for (i = 0; p; i++) {
1449 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1451 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1454 video_enc->rc_override =
1455 av_realloc_array(video_enc->rc_override,
1456 i + 1, sizeof(RcOverride));
1457 if (!video_enc->rc_override) {
1458 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1461 video_enc->rc_override[i].start_frame = start;
1462 video_enc->rc_override[i].end_frame = end;
1464 video_enc->rc_override[i].qscale = q;
1465 video_enc->rc_override[i].quality_factor = 1.0;
1468 video_enc->rc_override[i].qscale = 0;
1469 video_enc->rc_override[i].quality_factor = -q/100.0;
1474 video_enc->rc_override_count = i;
1477 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1480 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1483 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1484 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1487 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1488 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1492 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1493 if (ost->logfile_prefix &&
1494 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1498 char logfilename[1024];
1501 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1502 ost->logfile_prefix ? ost->logfile_prefix :
1503 DEFAULT_PASS_LOGFILENAME_PREFIX,
1505 if (!strcmp(ost->enc->name, "libx264")) {
1506 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1508 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1509 char *logbuffer = read_file(logfilename);
1512 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1516 video_enc->stats_in = logbuffer;
1518 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1519 f = av_fopen_utf8(logfilename, "wb");
1521 av_log(NULL, AV_LOG_FATAL,
1522 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1523 logfilename, strerror(errno));
1531 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1532 if (ost->forced_keyframes)
1533 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1535 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1537 ost->top_field_first = -1;
1538 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1541 ost->avfilter = get_ost_filters(o, oc, ost);
1545 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1548 if (ost->stream_copy)
1549 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1554 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1559 AVCodecContext *audio_enc;
1561 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1564 audio_enc = ost->enc_ctx;
1565 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1567 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1568 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1570 if (!ost->stream_copy) {
1571 char *sample_fmt = NULL;
1573 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1575 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1577 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1578 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1582 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1584 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1585 ost->apad = av_strdup(ost->apad);
1587 ost->avfilter = get_ost_filters(o, oc, ost);
1591 /* check for channel mapping for this audio stream */
1592 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1593 AudioChannelMap *map = &o->audio_channel_maps[n];
1594 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1595 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1598 if (map->channel_idx == -1) {
1600 } else if (ost->source_index < 0) {
1601 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1602 ost->file_index, ost->st->index);
1605 ist = input_streams[ost->source_index];
1608 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1609 if (av_reallocp_array(&ost->audio_channels_map,
1610 ost->audio_channels_mapped + 1,
1611 sizeof(*ost->audio_channels_map)
1615 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1621 if (ost->stream_copy)
1622 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1627 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1631 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1632 if (!ost->stream_copy) {
1633 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1640 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1644 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1645 if (!ost->stream_copy) {
1646 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1653 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1655 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1656 ost->stream_copy = 1;
1661 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1665 AVCodecContext *subtitle_enc;
1667 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1669 subtitle_enc = ost->enc_ctx;
1671 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1673 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1675 if (!ost->stream_copy) {
1676 char *frame_size = NULL;
1678 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1679 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1680 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1688 /* arg format is "output-stream-index:streamid-value". */
1689 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1691 OptionsContext *o = optctx;
1696 av_strlcpy(idx_str, arg, sizeof(idx_str));
1697 p = strchr(idx_str, ':');
1699 av_log(NULL, AV_LOG_FATAL,
1700 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1705 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1706 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1707 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1711 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1713 AVFormatContext *is = ifile->ctx;
1714 AVFormatContext *os = ofile->ctx;
1718 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1720 return AVERROR(ENOMEM);
1723 for (i = 0; i < is->nb_chapters; i++) {
1724 AVChapter *in_ch = is->chapters[i], *out_ch;
1725 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1726 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1727 AV_TIME_BASE_Q, in_ch->time_base);
1728 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1729 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1732 if (in_ch->end < ts_off)
1734 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1737 out_ch = av_mallocz(sizeof(AVChapter));
1739 return AVERROR(ENOMEM);
1741 out_ch->id = in_ch->id;
1742 out_ch->time_base = in_ch->time_base;
1743 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1744 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1747 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1749 os->chapters[os->nb_chapters++] = out_ch;
1754 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1757 AVFormatContext *ic = avformat_alloc_context();
1759 ic->interrupt_callback = int_cb;
1760 err = avformat_open_input(&ic, filename, NULL, NULL);
1763 /* copy stream format */
1764 for(i=0;i<ic->nb_streams;i++) {
1768 const char *enc_config;
1770 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1772 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1773 return AVERROR(EINVAL);
1775 if (codec->type == AVMEDIA_TYPE_AUDIO)
1776 opt_audio_codec(o, "c:a", codec->name);
1777 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1778 opt_video_codec(o, "c:v", codec->name);
1779 ost = new_output_stream(o, s, codec->type, -1);
1782 avcodec_get_context_defaults3(st->codec, codec);
1783 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1785 AVDictionary *opts = NULL;
1786 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1787 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1788 av_dict_free(&opts);
1791 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1792 choose_sample_fmt(st, codec);
1793 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1794 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1795 avcodec_copy_context(ost->enc_ctx, st->codec);
1797 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1800 avformat_close_input(&ic);
1804 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1805 AVFormatContext *oc)
1809 switch (ofilter->type) {
1810 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1811 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1813 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1818 ost->source_index = -1;
1819 ost->filter = ofilter;
1823 if (ost->stream_copy) {
1824 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1825 "which is fed from a complex filtergraph. Filtering and streamcopy "
1826 "cannot be used together.\n", ost->file_index, ost->index);
1830 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1831 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1832 av_log(NULL, AV_LOG_ERROR,
1833 "%s '%s' was specified through the %s option "
1834 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1835 "%s and -filter_complex cannot be used together for the same stream.\n",
1836 ost->filters ? "Filtergraph" : "Filtergraph script",
1837 ost->filters ? ost->filters : ost->filters_script,
1838 opt, ost->file_index, ost->index, opt);
1842 avfilter_inout_free(&ofilter->out_tmp);
1845 static int init_complex_filters(void)
1849 for (i = 0; i < nb_filtergraphs; i++) {
1850 ret = init_complex_filtergraph(filtergraphs[i]);
1857 static int configure_complex_filters(void)
1861 for (i = 0; i < nb_filtergraphs; i++)
1862 if (!filtergraphs[i]->graph &&
1863 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1868 static int open_output_file(OptionsContext *o, const char *filename)
1870 AVFormatContext *oc;
1872 AVOutputFormat *file_oformat;
1876 AVDictionary *unused_opts = NULL;
1877 AVDictionaryEntry *e = NULL;
1880 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1881 o->stop_time = INT64_MAX;
1882 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1885 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1886 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1887 if (o->stop_time <= start_time) {
1888 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1891 o->recording_time = o->stop_time - start_time;
1895 GROW_ARRAY(output_files, nb_output_files);
1896 of = av_mallocz(sizeof(*of));
1899 output_files[nb_output_files - 1] = of;
1901 of->ost_index = nb_output_streams;
1902 of->recording_time = o->recording_time;
1903 of->start_time = o->start_time;
1904 of->limit_filesize = o->limit_filesize;
1905 of->shortest = o->shortest;
1906 av_dict_copy(&of->opts, o->g->format_opts, 0);
1908 if (!strcmp(filename, "-"))
1911 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1913 print_error(filename, err);
1918 if (o->recording_time != INT64_MAX)
1919 oc->duration = o->recording_time;
1921 file_oformat= oc->oformat;
1922 oc->interrupt_callback = int_cb;
1924 /* create streams for all unlabeled output pads */
1925 for (i = 0; i < nb_filtergraphs; i++) {
1926 FilterGraph *fg = filtergraphs[i];
1927 for (j = 0; j < fg->nb_outputs; j++) {
1928 OutputFilter *ofilter = fg->outputs[j];
1930 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1933 switch (ofilter->type) {
1934 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1935 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1936 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1938 init_output_filter(ofilter, o, oc);
1942 /* ffserver seeking with date=... needs a date reference */
1943 if (!strcmp(file_oformat->name, "ffm") &&
1944 av_strstart(filename, "http:", NULL)) {
1945 int err = parse_option(o, "metadata", "creation_time=now", options);
1947 print_error(filename, err);
1952 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1953 av_strstart(filename, "http:", NULL)) {
1955 /* special case for files sent to ffserver: we get the stream
1956 parameters from ffserver */
1957 int err = read_ffserver_streams(o, oc, filename);
1959 print_error(filename, err);
1962 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1963 ost = output_streams[j];
1964 for (i = 0; i < nb_input_streams; i++) {
1965 ist = input_streams[i];
1966 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1968 ost->source_index= i;
1969 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1970 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1972 ist->st->discard = ist->user_set_discard;
1977 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1981 } else if (!o->nb_stream_maps) {
1982 char *subtitle_codec_name = NULL;
1983 /* pick the "best" stream of each type */
1985 /* video: highest resolution */
1986 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1987 int area = 0, idx = -1;
1988 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1989 for (i = 0; i < nb_input_streams; i++) {
1991 ist = input_streams[i];
1992 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
1993 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1995 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1997 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2004 new_video_stream(o, oc, idx);
2007 /* audio: most channels */
2008 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2009 int best_score = 0, idx = -1;
2010 for (i = 0; i < nb_input_streams; i++) {
2012 ist = input_streams[i];
2013 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2014 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2015 score > best_score) {
2021 new_audio_stream(o, oc, idx);
2024 /* subtitles: pick first */
2025 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2026 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2027 for (i = 0; i < nb_input_streams; i++)
2028 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2029 AVCodecDescriptor const *input_descriptor =
2030 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2031 AVCodecDescriptor const *output_descriptor = NULL;
2032 AVCodec const *output_codec =
2033 avcodec_find_encoder(oc->oformat->subtitle_codec);
2034 int input_props = 0, output_props = 0;
2036 output_descriptor = avcodec_descriptor_get(output_codec->id);
2037 if (input_descriptor)
2038 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2039 if (output_descriptor)
2040 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2041 if (subtitle_codec_name ||
2042 input_props & output_props ||
2043 // Map dvb teletext which has neither property to any output subtitle encoder
2044 input_descriptor && output_descriptor &&
2045 (!input_descriptor->props ||
2046 !output_descriptor->props)) {
2047 new_subtitle_stream(o, oc, i);
2052 /* Data only if codec id match */
2053 if (!o->data_disable ) {
2054 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2055 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2056 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2057 && input_streams[i]->st->codec->codec_id == codec_id )
2058 new_data_stream(o, oc, i);
2062 for (i = 0; i < o->nb_stream_maps; i++) {
2063 StreamMap *map = &o->stream_maps[i];
2068 if (map->linklabel) {
2070 OutputFilter *ofilter = NULL;
2073 for (j = 0; j < nb_filtergraphs; j++) {
2074 fg = filtergraphs[j];
2075 for (k = 0; k < fg->nb_outputs; k++) {
2076 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2077 if (out && !strcmp(out->name, map->linklabel)) {
2078 ofilter = fg->outputs[k];
2085 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2086 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2089 init_output_filter(ofilter, o, oc);
2091 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2093 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2094 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2096 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2098 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2100 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2104 switch (ist->st->codec->codec_type) {
2105 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2106 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2107 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2108 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2109 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2110 case AVMEDIA_TYPE_UNKNOWN:
2111 if (copy_unknown_streams) {
2112 ost = new_unknown_stream (o, oc, src_idx);
2116 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2117 "Cannot map stream #%d:%d - unsupported type.\n",
2118 map->file_index, map->stream_index);
2119 if (!ignore_unknown_streams) {
2120 av_log(NULL, AV_LOG_FATAL,
2121 "If you want unsupported types ignored instead "
2122 "of failing, please use the -ignore_unknown option\n"
2123 "If you want them copied, please use -copy_unknown\n");
2128 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2129 + map->sync_stream_index];
2134 /* handle attached files */
2135 for (i = 0; i < o->nb_attachments; i++) {
2137 uint8_t *attachment;
2141 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2142 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2146 if ((len = avio_size(pb)) <= 0) {
2147 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2151 if (!(attachment = av_malloc(len))) {
2152 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2156 avio_read(pb, attachment, len);
2158 ost = new_attachment_stream(o, oc, -1);
2159 ost->stream_copy = 1;
2160 ost->attachment_filename = o->attachments[i];
2162 ost->st->codec->extradata = attachment;
2163 ost->st->codec->extradata_size = len;
2165 p = strrchr(o->attachments[i], '/');
2166 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2170 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2171 AVDictionaryEntry *e;
2172 ost = output_streams[i];
2174 if ((ost->stream_copy || ost->attachment_filename)
2175 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2176 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2177 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2181 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2182 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2183 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2187 /* check if all codec options have been used */
2188 unused_opts = strip_specifiers(o->g->codec_opts);
2189 for (i = of->ost_index; i < nb_output_streams; i++) {
2191 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2192 AV_DICT_IGNORE_SUFFIX)))
2193 av_dict_set(&unused_opts, e->key, NULL, 0);
2197 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2198 const AVClass *class = avcodec_get_class();
2199 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2200 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2201 const AVClass *fclass = avformat_get_class();
2202 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2203 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2204 if (!option || foption)
2208 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2209 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2210 "output file #%d (%s) is not an encoding option.\n", e->key,
2211 option->help ? option->help : "", nb_output_files - 1,
2216 // gop_timecode is injected by generic code but not always used
2217 if (!strcmp(e->key, "gop_timecode"))
2220 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2221 "output file #%d (%s) has not been used for any stream. The most "
2222 "likely reason is either wrong type (e.g. a video option with "
2223 "no video streams) or that it is a private option of some encoder "
2224 "which was not actually used for any stream.\n", e->key,
2225 option->help ? option->help : "", nb_output_files - 1, filename);
2227 av_dict_free(&unused_opts);
2229 /* set the encoding/decoding_needed flags */
2230 for (i = of->ost_index; i < nb_output_streams; i++) {
2231 OutputStream *ost = output_streams[i];
2233 ost->encoding_needed = !ost->stream_copy;
2234 if (ost->encoding_needed && ost->source_index >= 0) {
2235 InputStream *ist = input_streams[ost->source_index];
2236 ist->decoding_needed |= DECODING_FOR_OST;
2240 /* check filename in case of an image number is expected */
2241 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2242 if (!av_filename_number_test(oc->filename)) {
2243 print_error(oc->filename, AVERROR(EINVAL));
2248 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2249 av_log(NULL, AV_LOG_ERROR,
2250 "No input streams but output needs an input stream\n");
2254 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2255 /* test if it already exists to avoid losing precious files */
2256 assert_file_overwrite(filename);
2259 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2260 &oc->interrupt_callback,
2262 print_error(filename, err);
2265 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2266 assert_file_overwrite(filename);
2268 if (o->mux_preload) {
2269 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2271 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2274 for (i = 0; i < o->nb_metadata_map; i++) {
2276 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2278 if (in_file_index >= nb_input_files) {
2279 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2282 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2283 in_file_index >= 0 ?
2284 input_files[in_file_index]->ctx : NULL, o);
2288 if (o->chapters_input_file >= nb_input_files) {
2289 if (o->chapters_input_file == INT_MAX) {
2290 /* copy chapters from the first input file that has them*/
2291 o->chapters_input_file = -1;
2292 for (i = 0; i < nb_input_files; i++)
2293 if (input_files[i]->ctx->nb_chapters) {
2294 o->chapters_input_file = i;
2298 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2299 o->chapters_input_file);
2303 if (o->chapters_input_file >= 0)
2304 copy_chapters(input_files[o->chapters_input_file], of,
2305 !o->metadata_chapters_manual);
2307 /* copy global metadata by default */
2308 if (!o->metadata_global_manual && nb_input_files){
2309 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2310 AV_DICT_DONT_OVERWRITE);
2311 if(o->recording_time != INT64_MAX)
2312 av_dict_set(&oc->metadata, "duration", NULL, 0);
2313 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2315 if (!o->metadata_streams_manual)
2316 for (i = of->ost_index; i < nb_output_streams; i++) {
2318 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2320 ist = input_streams[output_streams[i]->source_index];
2321 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2322 if (!output_streams[i]->stream_copy) {
2323 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2324 if (ist->autorotate)
2325 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2329 /* process manually set metadata */
2330 for (i = 0; i < o->nb_metadata; i++) {
2333 const char *stream_spec;
2334 int index = 0, j, ret = 0;
2337 val = strchr(o->metadata[i].u.str, '=');
2339 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2340 o->metadata[i].u.str);
2345 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2346 !strcmp(val, "now")) {
2347 time_t now = time(0);
2348 struct tm *ptm, tmbuf;
2349 ptm = localtime_r(&now, &tmbuf);
2351 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2356 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2358 for (j = 0; j < oc->nb_streams; j++) {
2359 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2360 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2361 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2362 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2363 ost->rotate_overridden = 1;
2375 if (index < 0 || index >= oc->nb_chapters) {
2376 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2379 m = &oc->chapters[index]->metadata;
2382 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2385 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2392 static int opt_target(void *optctx, const char *opt, const char *arg)
2394 OptionsContext *o = optctx;
2395 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2396 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2398 if (!strncmp(arg, "pal-", 4)) {
2401 } else if (!strncmp(arg, "ntsc-", 5)) {
2404 } else if (!strncmp(arg, "film-", 5)) {
2408 /* Try to determine PAL/NTSC by peeking in the input files */
2409 if (nb_input_files) {
2411 for (j = 0; j < nb_input_files; j++) {
2412 for (i = 0; i < input_files[j]->nb_streams; i++) {
2413 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2414 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2417 fr = c->time_base.den * 1000 / c->time_base.num;
2421 } else if ((fr == 29970) || (fr == 23976)) {
2426 if (norm != UNKNOWN)
2430 if (norm != UNKNOWN)
2431 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2434 if (norm == UNKNOWN) {
2435 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2436 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2437 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2441 if (!strcmp(arg, "vcd")) {
2442 opt_video_codec(o, "c:v", "mpeg1video");
2443 opt_audio_codec(o, "c:a", "mp2");
2444 parse_option(o, "f", "vcd", options);
2446 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2447 parse_option(o, "r", frame_rates[norm], options);
2448 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2450 opt_default(NULL, "b:v", "1150000");
2451 opt_default(NULL, "maxrate:v", "1150000");
2452 opt_default(NULL, "minrate:v", "1150000");
2453 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2455 opt_default(NULL, "b:a", "224000");
2456 parse_option(o, "ar", "44100", options);
2457 parse_option(o, "ac", "2", options);
2459 opt_default(NULL, "packetsize", "2324");
2460 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2462 /* We have to offset the PTS, so that it is consistent with the SCR.
2463 SCR starts at 36000, but the first two packs contain only padding
2464 and the first pack from the other stream, respectively, may also have
2465 been written before.
2466 So the real data starts at SCR 36000+3*1200. */
2467 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2468 } else if (!strcmp(arg, "svcd")) {
2470 opt_video_codec(o, "c:v", "mpeg2video");
2471 opt_audio_codec(o, "c:a", "mp2");
2472 parse_option(o, "f", "svcd", options);
2474 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2475 parse_option(o, "r", frame_rates[norm], options);
2476 parse_option(o, "pix_fmt", "yuv420p", options);
2477 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2479 opt_default(NULL, "b:v", "2040000");
2480 opt_default(NULL, "maxrate:v", "2516000");
2481 opt_default(NULL, "minrate:v", "0"); // 1145000;
2482 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2483 opt_default(NULL, "scan_offset", "1");
2485 opt_default(NULL, "b:a", "224000");
2486 parse_option(o, "ar", "44100", options);
2488 opt_default(NULL, "packetsize", "2324");
2490 } else if (!strcmp(arg, "dvd")) {
2492 opt_video_codec(o, "c:v", "mpeg2video");
2493 opt_audio_codec(o, "c:a", "ac3");
2494 parse_option(o, "f", "dvd", options);
2496 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2497 parse_option(o, "r", frame_rates[norm], options);
2498 parse_option(o, "pix_fmt", "yuv420p", options);
2499 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2501 opt_default(NULL, "b:v", "6000000");
2502 opt_default(NULL, "maxrate:v", "9000000");
2503 opt_default(NULL, "minrate:v", "0"); // 1500000;
2504 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2506 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2507 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2509 opt_default(NULL, "b:a", "448000");
2510 parse_option(o, "ar", "48000", options);
2512 } else if (!strncmp(arg, "dv", 2)) {
2514 parse_option(o, "f", "dv", options);
2516 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2517 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2518 norm == PAL ? "yuv420p" : "yuv411p", options);
2519 parse_option(o, "r", frame_rates[norm], options);
2521 parse_option(o, "ar", "48000", options);
2522 parse_option(o, "ac", "2", options);
2525 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2526 return AVERROR(EINVAL);
2529 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2530 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2535 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2537 av_free (vstats_filename);
2538 vstats_filename = av_strdup (arg);
2542 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2545 time_t today2 = time(NULL);
2546 struct tm *today = localtime(&today2);
2548 if (!today) { // maybe tomorrow
2549 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2553 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2555 return opt_vstats_file(NULL, opt, filename);
2558 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2560 OptionsContext *o = optctx;
2561 return parse_option(o, "frames:v", arg, options);
2564 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2566 OptionsContext *o = optctx;
2567 return parse_option(o, "frames:a", arg, options);
2570 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2572 OptionsContext *o = optctx;
2573 return parse_option(o, "frames:d", arg, options);
2576 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2579 AVDictionary *cbak = codec_opts;
2580 AVDictionary *fbak = format_opts;
2584 ret = opt_default(NULL, opt, arg);
2586 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2587 av_dict_copy(&o->g->format_opts, format_opts, 0);
2588 av_dict_free(&codec_opts);
2589 av_dict_free(&format_opts);
2596 static int opt_preset(void *optctx, const char *opt, const char *arg)
2598 OptionsContext *o = optctx;
2600 char filename[1000], line[1000], tmp_line[1000];
2601 const char *codec_name = NULL;
2605 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2607 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2608 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2609 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2611 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2615 while (fgets(line, sizeof(line), f)) {
2616 char *key = tmp_line, *value, *endptr;
2618 if (strcspn(line, "#\n\r") == 0)
2620 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2621 if (!av_strtok(key, "=", &value) ||
2622 !av_strtok(value, "\r\n", &endptr)) {
2623 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2626 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2628 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2629 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2630 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2631 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2632 else if (opt_default_new(o, key, value) < 0) {
2633 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2634 filename, line, key, value);
2644 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2646 OptionsContext *o = optctx;
2647 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2648 int ret = parse_option(o, s, arg, options);
2653 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2655 OptionsContext *o = optctx;
2657 if(!strcmp(opt, "ab")){
2658 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2660 } else if(!strcmp(opt, "b")){
2661 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2662 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2665 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2669 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2671 OptionsContext *o = optctx;
2674 if(!strcmp(opt, "qscale")){
2675 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2676 return parse_option(o, "q:v", arg, options);
2678 s = av_asprintf("q%s", opt + 6);
2679 ret = parse_option(o, s, arg, options);
2684 static int opt_profile(void *optctx, const char *opt, const char *arg)
2686 OptionsContext *o = optctx;
2687 if(!strcmp(opt, "profile")){
2688 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2689 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2692 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2696 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2698 OptionsContext *o = optctx;
2699 return parse_option(o, "filter:v", arg, options);
2702 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2704 OptionsContext *o = optctx;
2705 return parse_option(o, "filter:a", arg, options);
2708 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2710 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2711 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2712 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2713 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2715 if (video_sync_method == VSYNC_AUTO)
2716 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2720 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2722 OptionsContext *o = optctx;
2723 char *tcr = av_asprintf("timecode=%s", arg);
2724 int ret = parse_option(o, "metadata:g", tcr, options);
2726 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2731 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2733 OptionsContext *o = optctx;
2734 char layout_str[32];
2737 int ret, channels, ac_str_size;
2740 layout = av_get_channel_layout(arg);
2742 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2743 return AVERROR(EINVAL);
2745 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2746 ret = opt_default_new(o, opt, layout_str);
2750 /* set 'ac' option based on channel layout */
2751 channels = av_get_channel_layout_nb_channels(layout);
2752 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2753 stream_str = strchr(opt, ':');
2754 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2755 ac_str = av_mallocz(ac_str_size);
2757 return AVERROR(ENOMEM);
2758 av_strlcpy(ac_str, "ac", 3);
2760 av_strlcat(ac_str, stream_str, ac_str_size);
2761 ret = parse_option(o, ac_str, layout_str, options);
2767 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2769 OptionsContext *o = optctx;
2770 return parse_option(o, "q:a", arg, options);
2773 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2775 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2776 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2777 return AVERROR(ENOMEM);
2778 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2779 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2780 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2781 return AVERROR(ENOMEM);
2783 input_stream_potentially_available = 1;
2788 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2790 uint8_t *graph_desc = read_file(arg);
2792 return AVERROR(EINVAL);
2794 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2795 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2796 return AVERROR(ENOMEM);
2797 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2798 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2800 input_stream_potentially_available = 1;
2805 void show_help_default(const char *opt, const char *arg)
2807 /* per-file options have at least one of those set */
2808 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2809 int show_advanced = 0, show_avoptions = 0;
2812 if (!strcmp(opt, "long"))
2814 else if (!strcmp(opt, "full"))
2815 show_advanced = show_avoptions = 1;
2817 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2822 printf("Getting help:\n"
2823 " -h -- print basic options\n"
2824 " -h long -- print more options\n"
2825 " -h full -- print all options (including all format and codec specific options, very long)\n"
2826 " -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2827 " See man %s for detailed description of the options.\n"
2828 "\n", program_name);
2830 show_help_options(options, "Print help / information / capabilities:",
2833 show_help_options(options, "Global options (affect whole program "
2834 "instead of just one file:",
2835 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2837 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2838 per_file | OPT_EXIT, 0);
2840 show_help_options(options, "Per-file main options:", 0,
2841 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2842 OPT_EXIT, per_file);
2844 show_help_options(options, "Advanced per-file options:",
2845 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2847 show_help_options(options, "Video options:",
2848 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2850 show_help_options(options, "Advanced Video options:",
2851 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2853 show_help_options(options, "Audio options:",
2854 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2856 show_help_options(options, "Advanced Audio options:",
2857 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2858 show_help_options(options, "Subtitle options:",
2859 OPT_SUBTITLE, 0, 0);
2862 if (show_avoptions) {
2863 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2864 show_help_children(avcodec_get_class(), flags);
2865 show_help_children(avformat_get_class(), flags);
2867 show_help_children(sws_get_class(), flags);
2869 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2870 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2874 void show_usage(void)
2876 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2877 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2878 av_log(NULL, AV_LOG_INFO, "\n");
2886 static const OptionGroupDef groups[] = {
2887 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2888 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2891 static int open_files(OptionGroupList *l, const char *inout,
2892 int (*open_file)(OptionsContext*, const char*))
2896 for (i = 0; i < l->nb_groups; i++) {
2897 OptionGroup *g = &l->groups[i];
2903 ret = parse_optgroup(&o, g);
2905 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2906 "%s.\n", inout, g->arg);
2910 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2911 ret = open_file(&o, g->arg);
2914 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2918 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2924 int ffmpeg_parse_options(int argc, char **argv)
2926 OptionParseContext octx;
2930 memset(&octx, 0, sizeof(octx));
2932 /* split the commandline into an internal representation */
2933 ret = split_commandline(&octx, argc, argv, options, groups,
2934 FF_ARRAY_ELEMS(groups));
2936 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2940 /* apply global options */
2941 ret = parse_optgroup(NULL, &octx.global_opts);
2943 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2947 /* open input files */
2948 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2950 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2954 /* create the complex filtergraphs */
2955 ret = init_complex_filters();
2957 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2961 /* open output files */
2962 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2964 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2968 /* configure the complex filtergraphs */
2969 ret = configure_complex_filters();
2971 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2976 uninit_parse_context(&octx);
2978 av_strerror(ret, error, sizeof(error));
2979 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2984 static int opt_progress(void *optctx, const char *opt, const char *arg)
2986 AVIOContext *avio = NULL;
2989 if (!strcmp(arg, "-"))
2991 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2993 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2994 arg, av_err2str(ret));
2997 progress_avio = avio;
3001 #define OFFSET(x) offsetof(OptionsContext, x)
3002 const OptionDef options[] = {
3004 #include "cmdutils_common_opts.h"
3005 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3006 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3007 "force format", "fmt" },
3008 { "y", OPT_BOOL, { &file_overwrite },
3009 "overwrite output files" },
3010 { "n", OPT_BOOL, { &no_file_overwrite },
3011 "never overwrite output files" },
3012 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3013 "Ignore unknown stream types" },
3014 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3015 "Copy unknown stream types" },
3016 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3017 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3018 "codec name", "codec" },
3019 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3020 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3021 "codec name", "codec" },
3022 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3023 OPT_OUTPUT, { .off = OFFSET(presets) },
3024 "preset name", "preset" },
3025 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3026 OPT_OUTPUT, { .func_arg = opt_map },
3027 "set input stream mapping",
3028 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3029 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3030 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3031 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3032 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3033 "set metadata information of outfile from infile",
3034 "outfile[,metadata]:infile[,metadata]" },
3035 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3036 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3037 "set chapters mapping", "input_file_index" },
3038 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3039 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3040 "record or transcode \"duration\" seconds of audio/video",
3042 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3043 "record or transcode stop time", "time_stop" },
3044 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3045 "set the limit file size in bytes", "limit_size" },
3046 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3047 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3048 "set the start time offset", "time_off" },
3049 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3050 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3051 "set the start time offset relative to EOF", "time_off" },
3052 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3053 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3054 "enable/disable seeking by timestamp with -ss" },
3055 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3056 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3057 "enable/disable accurate seeking with -ss" },
3058 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3059 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3060 "set the input ts offset", "time_off" },
3061 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3062 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3063 "set the input ts scale", "scale" },
3064 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3065 "set the recording timestamp ('now' to set the current time)", "time" },
3066 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3067 "add metadata", "string=string" },
3068 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3069 OPT_OUTPUT, { .func_arg = opt_data_frames },
3070 "set the number of data frames to output", "number" },
3071 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3072 "add timings for benchmarking" },
3073 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3074 "add timings for each task" },
3075 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3076 "write program-readable progress information", "url" },
3077 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3078 "enable or disable interaction on standard input" },
3079 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3080 "set max runtime in seconds", "limit" },
3081 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3082 "dump each input packet" },
3083 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3084 "when dumping packets, also dump the payload" },
3085 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3086 OPT_INPUT, { .off = OFFSET(rate_emu) },
3087 "read input at native frame rate", "" },
3088 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3089 "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3090 "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3091 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
3092 "video sync method", "" },
3093 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3094 "frame drop threshold", "" },
3095 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3096 "audio sync method", "" },
3097 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3098 "audio drift threshold", "threshold" },
3099 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3100 "copy timestamps" },
3101 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3102 "shift input timestamps to start at 0 when using copyts" },
3103 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3104 "copy input stream time base when stream copying", "mode" },
3105 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3106 OPT_OUTPUT, { .off = OFFSET(shortest) },
3107 "finish encoding within shortest input" },
3108 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3109 OPT_OUTPUT, { .off = OFFSET(apad) },
3111 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3112 "timestamp discontinuity delta threshold", "threshold" },
3113 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3114 "timestamp error delta threshold", "threshold" },
3115 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3116 "exit on error", "error" },
3117 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3118 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3119 "copy initial non-keyframes" },
3120 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3121 "copy or discard frames before start time" },
3122 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3123 "set the number of frames to output", "number" },
3124 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3125 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3126 "force codec tag/fourcc", "fourcc/tag" },
3127 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3128 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3129 "use fixed quality scale (VBR)", "q" },
3130 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3131 OPT_OUTPUT, { .func_arg = opt_qscale },
3132 "use fixed quality scale (VBR)", "q" },
3133 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3134 "set profile", "profile" },
3135 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3136 "set stream filtergraph", "filter_graph" },
3137 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3138 "read stream filtergraph description from a file", "filename" },
3139 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3140 "reinit filtergraph on input parameter changes", "" },
3141 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3142 "create a complex filtergraph", "graph_description" },
3143 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3144 "create a complex filtergraph", "graph_description" },
3145 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3146 "read complex filtergraph description from a file", "filename" },
3147 { "stats", OPT_BOOL, { &print_stats },
3148 "print progress report during encoding", },
3149 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3150 OPT_OUTPUT, { .func_arg = opt_attach },
3151 "add an attachment to the output file", "filename" },
3152 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3153 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3154 "extract an attachment into a file", "filename" },
3155 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3156 "print timestamp debugging info" },
3157 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3158 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3159 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3160 OPT_INPUT, { .off = OFFSET(discard) },
3162 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3163 OPT_OUTPUT, { .off = OFFSET(disposition) },
3164 "disposition", "" },
3165 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3166 { .off = OFFSET(thread_queue_size) },
3167 "set the maximum number of queued packets from the demuxer" },
3170 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3171 "set the number of video frames to output", "number" },
3172 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3173 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3174 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3175 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3176 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3177 "set frame size (WxH or abbreviation)", "size" },
3178 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3179 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3180 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3181 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3182 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3183 "set pixel format", "format" },
3184 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3185 "set the number of bits per raw sample", "number" },
3186 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3187 "deprecated use -g 1" },
3188 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3190 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3191 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3192 "rate control override for specific intervals", "override" },
3193 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3194 OPT_OUTPUT, { .func_arg = opt_video_codec },
3195 "force video codec ('copy' to copy stream)", "codec" },
3196 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3198 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3200 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3201 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3202 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3203 "select the pass number (1 to 3)", "n" },
3204 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3205 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3206 "select two pass log file name prefix", "prefix" },
3207 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3208 "this option is deprecated, use the yadif filter instead" },
3209 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3210 "calculate PSNR of compressed frames" },
3211 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3212 "dump video coding statistics to file" },
3213 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3214 "dump video coding statistics to file", "file" },
3215 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3216 "set video filters", "filter_graph" },
3217 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3218 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3219 "specify intra matrix coeffs", "matrix" },
3220 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3221 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3222 "specify inter matrix coeffs", "matrix" },
3223 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3224 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3225 "specify intra matrix coeffs", "matrix" },
3226 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3227 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3228 "top=1/bottom=0/auto=-1 field first", "" },
3229 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3230 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3231 "force video tag/fourcc", "fourcc/tag" },
3232 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3233 "show QP histogram" },
3234 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3235 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3236 "force the selected framerate, disable the best supported framerate selection" },
3237 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3238 OPT_OUTPUT, { .func_arg = opt_streamid },
3239 "set the value of an outfile streamid", "streamIndex:value" },
3240 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3241 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3242 "force key frames at specified timestamps", "timestamps" },
3243 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3244 "audio bitrate (please use -b:a)", "bitrate" },
3245 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3246 "video bitrate (please use -b:v)", "bitrate" },
3247 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3248 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3249 "use HW accelerated decoding", "hwaccel name" },
3250 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3251 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3252 "select a device for HW acceleration", "devicename" },
3254 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3256 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3257 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3259 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3260 "show available HW acceleration methods" },
3261 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3262 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3263 "automatically insert correct rotate filters" },
3266 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3267 "set the number of audio frames to output", "number" },
3268 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3269 "set audio quality (codec-specific)", "quality", },
3270 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3271 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3272 "set audio sampling rate (in Hz)", "rate" },
3273 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3274 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3275 "set number of audio channels", "channels" },
3276 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3278 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3279 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3280 "force audio codec ('copy' to copy stream)", "codec" },
3281 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3282 OPT_OUTPUT, { .func_arg = opt_old2new },
3283 "force audio tag/fourcc", "fourcc/tag" },
3284 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3285 "change audio volume (256=normal)" , "volume" },
3286 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3287 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3288 "set sample format", "format" },
3289 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3290 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3291 "set channel layout", "layout" },
3292 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3293 "set audio filters", "filter_graph" },
3294 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3295 "set the maximum number of channels to try to guess the channel layout" },
3297 /* subtitle options */
3298 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3299 "disable subtitle" },
3300 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3301 "force subtitle codec ('copy' to copy stream)", "codec" },
3302 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3303 , "force subtitle tag/fourcc", "fourcc/tag" },
3304 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3305 "fix subtitles duration" },
3306 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3307 "set canvas size (WxH or abbreviation)", "size" },
3310 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3311 "deprecated, use -channel", "channel" },
3312 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3313 "deprecated, use -standard", "standard" },
3314 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3317 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3318 "set the maximum demux-decode delay", "seconds" },
3319 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3320 "set the initial demux-decode delay", "seconds" },
3321 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3322 "override the options from ffserver", "" },
3323 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3324 "specify a file in which to print sdp information", "file" },
3326 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3327 "A comma-separated list of bitstream filters", "bitstream_filters" },
3328 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3329 "deprecated", "audio bitstream_filters" },
3330 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3331 "deprecated", "video bitstream_filters" },
3333 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3334 "set the audio options to the indicated preset", "preset" },
3335 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3336 "set the video options to the indicated preset", "preset" },
3337 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3338 "set the subtitle options to the indicated preset", "preset" },
3339 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3340 "set options from indicated preset file", "filename" },
3341 /* data codec support */
3342 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3343 "force data codec ('copy' to copy stream)", "codec" },
3344 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },