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);
677 if (av_codec_get_lowres(dec)) {
678 dec->flags |= CODEC_FLAG_EMU_EDGE;
681 ist->resample_height = ist->dec_ctx->height;
682 ist->resample_width = ist->dec_ctx->width;
683 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
685 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
686 if (framerate && av_parse_video_rate(&ist->framerate,
688 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
693 ist->top_field_first = -1;
694 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
696 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
698 if (!strcmp(hwaccel, "none"))
699 ist->hwaccel_id = HWACCEL_NONE;
700 else if (!strcmp(hwaccel, "auto"))
701 ist->hwaccel_id = HWACCEL_AUTO;
704 for (i = 0; hwaccels[i].name; i++) {
705 if (!strcmp(hwaccels[i].name, hwaccel)) {
706 ist->hwaccel_id = hwaccels[i].id;
711 if (!ist->hwaccel_id) {
712 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
714 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
715 for (i = 0; hwaccels[i].name; i++)
716 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
717 av_log(NULL, AV_LOG_FATAL, "\n");
723 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
724 if (hwaccel_device) {
725 ist->hwaccel_device = av_strdup(hwaccel_device);
726 if (!ist->hwaccel_device)
729 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
732 case AVMEDIA_TYPE_AUDIO:
733 ist->guess_layout_max = INT_MAX;
734 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
735 guess_input_channel_layout(ist);
737 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
738 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
739 ist->resample_channels = ist->dec_ctx->channels;
740 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
743 case AVMEDIA_TYPE_DATA:
744 case AVMEDIA_TYPE_SUBTITLE: {
745 char *canvas_size = NULL;
747 ist->dec = avcodec_find_decoder(dec->codec_id);
748 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
749 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
751 av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
752 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
757 case AVMEDIA_TYPE_ATTACHMENT:
758 case AVMEDIA_TYPE_UNKNOWN:
766 static void assert_file_overwrite(const char *filename)
768 if (file_overwrite && no_file_overwrite) {
769 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
773 if (!file_overwrite) {
774 const char *proto_name = avio_find_protocol_name(filename);
775 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
776 if (stdin_interaction && !no_file_overwrite) {
777 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
780 signal(SIGINT, SIG_DFL);
782 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
788 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
795 static void dump_attachment(AVStream *st, const char *filename)
798 AVIOContext *out = NULL;
799 AVDictionaryEntry *e;
801 if (!st->codec->extradata_size) {
802 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
803 nb_input_files - 1, st->index);
806 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
809 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
810 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
814 assert_file_overwrite(filename);
816 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
817 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
822 avio_write(out, st->codec->extradata, st->codec->extradata_size);
827 static int open_input_file(OptionsContext *o, const char *filename)
831 AVInputFormat *file_iformat = NULL;
835 AVDictionary *unused_opts = NULL;
836 AVDictionaryEntry *e = NULL;
837 int orig_nb_streams; // number of streams before avformat_find_stream_info
838 char * video_codec_name = NULL;
839 char * audio_codec_name = NULL;
840 char *subtitle_codec_name = NULL;
841 char * data_codec_name = NULL;
842 int scan_all_pmts_set = 0;
845 if (!(file_iformat = av_find_input_format(o->format))) {
846 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
851 if (!strcmp(filename, "-"))
854 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
855 strcmp(filename, "/dev/stdin");
857 /* get default parameters from command line */
858 ic = avformat_alloc_context();
860 print_error(filename, AVERROR(ENOMEM));
863 if (o->nb_audio_sample_rate) {
864 av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
866 if (o->nb_audio_channels) {
867 /* because we set audio_channels based on both the "ac" and
868 * "channel_layout" options, we need to check that the specified
869 * demuxer actually has the "channels" option before setting it */
870 if (file_iformat && file_iformat->priv_class &&
871 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
872 AV_OPT_SEARCH_FAKE_OBJ)) {
873 av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
876 if (o->nb_frame_rates) {
877 /* set the format-level framerate option;
878 * this is important for video grabbers, e.g. x11 */
879 if (file_iformat && file_iformat->priv_class &&
880 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
881 AV_OPT_SEARCH_FAKE_OBJ)) {
882 av_dict_set(&o->g->format_opts, "framerate",
883 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
886 if (o->nb_frame_sizes) {
887 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
889 if (o->nb_frame_pix_fmts)
890 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
892 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
893 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
894 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
895 MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
897 ic->video_codec_id = video_codec_name ?
898 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
899 ic->audio_codec_id = audio_codec_name ?
900 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
901 ic->subtitle_codec_id= subtitle_codec_name ?
902 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
903 ic->data_codec_id = data_codec_name ?
904 find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
906 if (video_codec_name)
907 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
908 if (audio_codec_name)
909 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
910 if (subtitle_codec_name)
911 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
913 av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
915 ic->flags |= AVFMT_FLAG_NONBLOCK;
916 ic->interrupt_callback = int_cb;
918 if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
919 av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
920 scan_all_pmts_set = 1;
922 /* open the input file with generic avformat function */
923 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
925 print_error(filename, err);
928 if (scan_all_pmts_set)
929 av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
930 remove_avoptions(&o->g->format_opts, o->g->codec_opts);
931 assert_avoptions(o->g->format_opts);
933 /* apply forced codec ids */
934 for (i = 0; i < ic->nb_streams; i++)
935 choose_decoder(o, ic, ic->streams[i]);
937 /* Set AVCodecContext options for avformat_find_stream_info */
938 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
939 orig_nb_streams = ic->nb_streams;
941 /* If not enough info to get the stream parameters, we decode the
942 first frames to get it. (used in mpeg case for example) */
943 ret = avformat_find_stream_info(ic, opts);
945 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
946 if (ic->nb_streams == 0) {
947 avformat_close_input(&ic);
952 if (o->start_time_eof != AV_NOPTS_VALUE) {
953 if (ic->duration>0) {
954 o->start_time = o->start_time_eof + ic->duration;
956 av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
958 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
959 /* add the stream start time */
960 if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
961 timestamp += ic->start_time;
963 /* if seeking requested, we execute it */
964 if (o->start_time != AV_NOPTS_VALUE) {
965 int64_t seek_timestamp = timestamp;
967 if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
968 int dts_heuristic = 0;
969 for (i=0; i<ic->nb_streams; i++) {
970 AVCodecContext *avctx = ic->streams[i]->codec;
971 if (avctx->has_b_frames)
975 seek_timestamp -= 3*AV_TIME_BASE / 23;
978 ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
980 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
981 filename, (double)timestamp / AV_TIME_BASE);
985 /* update the current parameters so that they match the one of the input stream */
986 add_input_streams(o, ic);
988 /* dump the file content */
989 av_dump_format(ic, nb_input_files, filename, 0);
991 GROW_ARRAY(input_files, nb_input_files);
992 f = av_mallocz(sizeof(*f));
995 input_files[nb_input_files - 1] = f;
998 f->ist_index = nb_input_streams - ic->nb_streams;
999 f->start_time = o->start_time;
1000 f->recording_time = o->recording_time;
1001 f->input_ts_offset = o->input_ts_offset;
1002 f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1003 f->nb_streams = ic->nb_streams;
1004 f->rate_emu = o->rate_emu;
1005 f->accurate_seek = o->accurate_seek;
1007 f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1010 /* check if all codec options have been used */
1011 unused_opts = strip_specifiers(o->g->codec_opts);
1012 for (i = f->ist_index; i < nb_input_streams; i++) {
1014 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1015 AV_DICT_IGNORE_SUFFIX)))
1016 av_dict_set(&unused_opts, e->key, NULL, 0);
1020 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1021 const AVClass *class = avcodec_get_class();
1022 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1023 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1024 const AVClass *fclass = avformat_get_class();
1025 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1026 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1027 if (!option || foption)
1031 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1032 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1033 "input file #%d (%s) is not a decoding option.\n", e->key,
1034 option->help ? option->help : "", nb_input_files - 1,
1039 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1040 "input file #%d (%s) has not been used for any stream. The most "
1041 "likely reason is either wrong type (e.g. a video option with "
1042 "no video streams) or that it is a private option of some decoder "
1043 "which was not actually used for any stream.\n", e->key,
1044 option->help ? option->help : "", nb_input_files - 1, filename);
1046 av_dict_free(&unused_opts);
1048 for (i = 0; i < o->nb_dump_attachment; i++) {
1051 for (j = 0; j < ic->nb_streams; j++) {
1052 AVStream *st = ic->streams[j];
1054 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1055 dump_attachment(st, o->dump_attachment[i].u.str);
1059 for (i = 0; i < orig_nb_streams; i++)
1060 av_dict_free(&opts[i]);
1063 input_stream_potentially_available = 1;
1068 static uint8_t *get_line(AVIOContext *s)
1074 if (avio_open_dyn_buf(&line) < 0) {
1075 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1079 while ((c = avio_r8(s)) && c != '\n')
1082 avio_close_dyn_buf(line, &buf);
1087 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1090 char filename[1000];
1091 const char *base[3] = { getenv("AVCONV_DATADIR"),
1096 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1100 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1101 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1102 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1105 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1106 i != 1 ? "" : "/.avconv", preset_name);
1107 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1113 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1115 char *codec_name = NULL;
1117 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1119 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1120 NULL, ost->st->codec->codec_type);
1121 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1122 } else if (!strcmp(codec_name, "copy"))
1123 ost->stream_copy = 1;
1125 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1126 ost->st->codec->codec_id = ost->enc->id;
1130 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1133 AVStream *st = avformat_new_stream(oc, NULL);
1134 int idx = oc->nb_streams - 1, ret = 0;
1135 char *bsf = NULL, *next, *codec_tag = NULL;
1136 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1141 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1145 if (oc->nb_streams - 1 < o->nb_streamid_map)
1146 st->id = o->streamid_map[oc->nb_streams - 1];
1148 GROW_ARRAY(output_streams, nb_output_streams);
1149 if (!(ost = av_mallocz(sizeof(*ost))))
1151 output_streams[nb_output_streams - 1] = ost;
1153 ost->file_index = nb_output_files - 1;
1156 st->codec->codec_type = type;
1157 choose_encoder(o, oc, ost);
1159 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1160 if (!ost->enc_ctx) {
1161 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1164 ost->enc_ctx->codec_type = type;
1167 AVIOContext *s = NULL;
1168 char *buf = NULL, *arg = NULL, *preset = NULL;
1170 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1172 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1173 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1176 if (!buf[0] || buf[0] == '#') {
1180 if (!(arg = strchr(buf, '='))) {
1181 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1185 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1187 } while (!s->eof_reached);
1191 av_log(NULL, AV_LOG_FATAL,
1192 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1193 preset, ost->file_index, ost->index);
1197 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1200 ost->max_frames = INT64_MAX;
1201 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1202 for (i = 0; i<o->nb_max_frames; i++) {
1203 char *p = o->max_frames[i].specifier;
1204 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1205 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1210 ost->copy_prior_start = -1;
1211 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1213 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1216 if (next = strchr(bsf, ','))
1218 if (arg = strchr(bsf, '='))
1220 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1221 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1225 bsfc_prev->next = bsfc;
1227 ost->bitstream_filters = bsfc;
1228 av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1234 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1236 uint32_t tag = strtol(codec_tag, &next, 0);
1238 tag = AV_RL32(codec_tag);
1239 ost->st->codec->codec_tag =
1240 ost->enc_ctx->codec_tag = tag;
1243 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1245 ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1246 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1249 MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1250 ost->disposition = av_strdup(ost->disposition);
1252 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1253 ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1255 av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1257 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1258 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1259 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1261 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1263 ost->source_index = source_index;
1264 if (source_index >= 0) {
1265 ost->sync_ist = input_streams[source_index];
1266 input_streams[source_index]->discard = 0;
1267 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1269 ost->last_mux_dts = AV_NOPTS_VALUE;
1274 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1277 const char *p = str;
1284 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1291 /* read file contents into a string */
1292 static uint8_t *read_file(const char *filename)
1294 AVIOContext *pb = NULL;
1295 AVIOContext *dyn_buf = NULL;
1296 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1297 uint8_t buf[1024], *str;
1300 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1304 ret = avio_open_dyn_buf(&dyn_buf);
1309 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1310 avio_write(dyn_buf, buf, ret);
1311 avio_w8(dyn_buf, 0);
1314 ret = avio_close_dyn_buf(dyn_buf, &str);
1320 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1323 AVStream *st = ost->st;
1325 if (ost->filters_script && ost->filters) {
1326 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1327 "output stream #%d:%d.\n", nb_output_files, st->index);
1331 if (ost->filters_script)
1332 return read_file(ost->filters_script);
1333 else if (ost->filters)
1334 return av_strdup(ost->filters);
1336 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1340 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1341 const OutputStream *ost, enum AVMediaType type)
1343 if (ost->filters_script || ost->filters) {
1344 av_log(NULL, AV_LOG_ERROR,
1345 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1346 "Filtering and streamcopy cannot be used together.\n",
1347 ost->filters ? "Filtergraph" : "Filtergraph script",
1348 ost->filters ? ost->filters : ost->filters_script,
1349 av_get_media_type_string(type), ost->file_index, ost->index);
1354 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1358 AVCodecContext *video_enc;
1359 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1361 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1363 video_enc = ost->enc_ctx;
1365 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1366 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1367 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1370 if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1371 av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1373 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1374 if (frame_aspect_ratio) {
1376 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1377 q.num <= 0 || q.den <= 0) {
1378 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1381 ost->frame_aspect_ratio = q;
1384 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1385 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1387 if (!ost->stream_copy) {
1388 const char *p = NULL;
1389 char *frame_size = NULL;
1390 char *frame_pix_fmt = NULL;
1391 char *intra_matrix = NULL, *inter_matrix = NULL;
1392 char *chroma_intra_matrix = NULL;
1396 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1397 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1398 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1402 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1403 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1404 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1405 ost->keep_pix_fmt = 1;
1406 if (!*++frame_pix_fmt)
1407 frame_pix_fmt = NULL;
1409 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1410 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1413 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1416 video_enc->gop_size = 0;
1417 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1419 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1420 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1423 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1425 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1426 if (chroma_intra_matrix) {
1427 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1429 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1432 av_codec_set_chroma_intra_matrix(video_enc, p);
1433 parse_matrix_coeffs(p, chroma_intra_matrix);
1435 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1437 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1438 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1441 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1444 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1445 for (i = 0; p; i++) {
1447 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1449 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1452 video_enc->rc_override =
1453 av_realloc_array(video_enc->rc_override,
1454 i + 1, sizeof(RcOverride));
1455 if (!video_enc->rc_override) {
1456 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1459 video_enc->rc_override[i].start_frame = start;
1460 video_enc->rc_override[i].end_frame = end;
1462 video_enc->rc_override[i].qscale = q;
1463 video_enc->rc_override[i].quality_factor = 1.0;
1466 video_enc->rc_override[i].qscale = 0;
1467 video_enc->rc_override[i].quality_factor = -q/100.0;
1472 video_enc->rc_override_count = i;
1475 video_enc->flags|= AV_CODEC_FLAG_PSNR;
1478 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1481 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1482 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1485 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1486 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1490 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1491 if (ost->logfile_prefix &&
1492 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1496 char logfilename[1024];
1499 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1500 ost->logfile_prefix ? ost->logfile_prefix :
1501 DEFAULT_PASS_LOGFILENAME_PREFIX,
1503 if (!strcmp(ost->enc->name, "libx264")) {
1504 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1506 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1507 char *logbuffer = read_file(logfilename);
1510 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1514 video_enc->stats_in = logbuffer;
1516 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1517 f = av_fopen_utf8(logfilename, "wb");
1519 av_log(NULL, AV_LOG_FATAL,
1520 "Cannot write log file '%s' for pass-1 encoding: %s\n",
1521 logfilename, strerror(errno));
1529 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1530 if (ost->forced_keyframes)
1531 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1533 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1535 ost->top_field_first = -1;
1536 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1539 ost->avfilter = get_ost_filters(o, oc, ost);
1543 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1546 if (ost->stream_copy)
1547 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1552 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1557 AVCodecContext *audio_enc;
1559 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1562 audio_enc = ost->enc_ctx;
1563 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1565 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1566 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1568 if (!ost->stream_copy) {
1569 char *sample_fmt = NULL;
1571 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1573 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1575 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1576 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1580 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1582 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1583 ost->apad = av_strdup(ost->apad);
1585 ost->avfilter = get_ost_filters(o, oc, ost);
1589 /* check for channel mapping for this audio stream */
1590 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1591 AudioChannelMap *map = &o->audio_channel_maps[n];
1592 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1593 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1596 if (map->channel_idx == -1) {
1598 } else if (ost->source_index < 0) {
1599 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1600 ost->file_index, ost->st->index);
1603 ist = input_streams[ost->source_index];
1606 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1607 if (av_reallocp_array(&ost->audio_channels_map,
1608 ost->audio_channels_mapped + 1,
1609 sizeof(*ost->audio_channels_map)
1613 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1619 if (ost->stream_copy)
1620 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1625 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1629 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1630 if (!ost->stream_copy) {
1631 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1638 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1642 ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1643 if (!ost->stream_copy) {
1644 av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1651 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1653 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1654 ost->stream_copy = 1;
1659 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1663 AVCodecContext *subtitle_enc;
1665 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1667 subtitle_enc = ost->enc_ctx;
1669 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1671 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1673 if (!ost->stream_copy) {
1674 char *frame_size = NULL;
1676 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1677 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1678 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1686 /* arg format is "output-stream-index:streamid-value". */
1687 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1689 OptionsContext *o = optctx;
1694 av_strlcpy(idx_str, arg, sizeof(idx_str));
1695 p = strchr(idx_str, ':');
1697 av_log(NULL, AV_LOG_FATAL,
1698 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1703 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1704 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1705 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1709 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1711 AVFormatContext *is = ifile->ctx;
1712 AVFormatContext *os = ofile->ctx;
1716 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1718 return AVERROR(ENOMEM);
1721 for (i = 0; i < is->nb_chapters; i++) {
1722 AVChapter *in_ch = is->chapters[i], *out_ch;
1723 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1724 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1725 AV_TIME_BASE_Q, in_ch->time_base);
1726 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1727 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1730 if (in_ch->end < ts_off)
1732 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1735 out_ch = av_mallocz(sizeof(AVChapter));
1737 return AVERROR(ENOMEM);
1739 out_ch->id = in_ch->id;
1740 out_ch->time_base = in_ch->time_base;
1741 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1742 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1745 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1747 os->chapters[os->nb_chapters++] = out_ch;
1752 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1755 AVFormatContext *ic = avformat_alloc_context();
1757 ic->interrupt_callback = int_cb;
1758 err = avformat_open_input(&ic, filename, NULL, NULL);
1761 /* copy stream format */
1762 for(i=0;i<ic->nb_streams;i++) {
1766 const char *enc_config;
1768 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1770 av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1771 return AVERROR(EINVAL);
1773 if (codec->type == AVMEDIA_TYPE_AUDIO)
1774 opt_audio_codec(o, "c:a", codec->name);
1775 else if (codec->type == AVMEDIA_TYPE_VIDEO)
1776 opt_video_codec(o, "c:v", codec->name);
1777 ost = new_output_stream(o, s, codec->type, -1);
1780 avcodec_get_context_defaults3(st->codec, codec);
1781 enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1783 AVDictionary *opts = NULL;
1784 av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1785 av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1786 av_dict_free(&opts);
1789 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1790 choose_sample_fmt(st, codec);
1791 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1792 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1793 avcodec_copy_context(ost->enc_ctx, st->codec);
1795 av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1798 avformat_close_input(&ic);
1802 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1803 AVFormatContext *oc)
1807 switch (ofilter->type) {
1808 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1809 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1811 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1816 ost->source_index = -1;
1817 ost->filter = ofilter;
1821 if (ost->stream_copy) {
1822 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1823 "which is fed from a complex filtergraph. Filtering and streamcopy "
1824 "cannot be used together.\n", ost->file_index, ost->index);
1828 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1829 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1830 av_log(NULL, AV_LOG_ERROR,
1831 "%s '%s' was specified through the %s option "
1832 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1833 "%s and -filter_complex cannot be used together for the same stream.\n",
1834 ost->filters ? "Filtergraph" : "Filtergraph script",
1835 ost->filters ? ost->filters : ost->filters_script,
1836 opt, ost->file_index, ost->index, opt);
1840 avfilter_inout_free(&ofilter->out_tmp);
1843 static int init_complex_filters(void)
1847 for (i = 0; i < nb_filtergraphs; i++) {
1848 ret = init_complex_filtergraph(filtergraphs[i]);
1855 static int configure_complex_filters(void)
1859 for (i = 0; i < nb_filtergraphs; i++)
1860 if (!filtergraphs[i]->graph &&
1861 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1866 static int open_output_file(OptionsContext *o, const char *filename)
1868 AVFormatContext *oc;
1870 AVOutputFormat *file_oformat;
1874 AVDictionary *unused_opts = NULL;
1875 AVDictionaryEntry *e = NULL;
1878 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1879 o->stop_time = INT64_MAX;
1880 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1883 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1884 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1885 if (o->stop_time <= start_time) {
1886 av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1889 o->recording_time = o->stop_time - start_time;
1893 GROW_ARRAY(output_files, nb_output_files);
1894 of = av_mallocz(sizeof(*of));
1897 output_files[nb_output_files - 1] = of;
1899 of->ost_index = nb_output_streams;
1900 of->recording_time = o->recording_time;
1901 of->start_time = o->start_time;
1902 of->limit_filesize = o->limit_filesize;
1903 of->shortest = o->shortest;
1904 av_dict_copy(&of->opts, o->g->format_opts, 0);
1906 if (!strcmp(filename, "-"))
1909 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1911 print_error(filename, err);
1916 if (o->recording_time != INT64_MAX)
1917 oc->duration = o->recording_time;
1919 file_oformat= oc->oformat;
1920 oc->interrupt_callback = int_cb;
1922 /* create streams for all unlabeled output pads */
1923 for (i = 0; i < nb_filtergraphs; i++) {
1924 FilterGraph *fg = filtergraphs[i];
1925 for (j = 0; j < fg->nb_outputs; j++) {
1926 OutputFilter *ofilter = fg->outputs[j];
1928 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1931 switch (ofilter->type) {
1932 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1933 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1934 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1936 init_output_filter(ofilter, o, oc);
1940 /* ffserver seeking with date=... needs a date reference */
1941 if (!strcmp(file_oformat->name, "ffm") &&
1942 av_strstart(filename, "http:", NULL)) {
1943 int err = parse_option(o, "metadata", "creation_time=now", options);
1945 print_error(filename, err);
1950 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1951 av_strstart(filename, "http:", NULL)) {
1953 /* special case for files sent to ffserver: we get the stream
1954 parameters from ffserver */
1955 int err = read_ffserver_streams(o, oc, filename);
1957 print_error(filename, err);
1960 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1961 ost = output_streams[j];
1962 for (i = 0; i < nb_input_streams; i++) {
1963 ist = input_streams[i];
1964 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1966 ost->source_index= i;
1967 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1968 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1970 ist->st->discard = ist->user_set_discard;
1975 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));
1979 } else if (!o->nb_stream_maps) {
1980 char *subtitle_codec_name = NULL;
1981 /* pick the "best" stream of each type */
1983 /* video: highest resolution */
1984 if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1985 int area = 0, idx = -1;
1986 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1987 for (i = 0; i < nb_input_streams; i++) {
1989 ist = input_streams[i];
1990 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
1991 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1993 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1995 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2002 new_video_stream(o, oc, idx);
2005 /* audio: most channels */
2006 if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2007 int best_score = 0, idx = -1;
2008 for (i = 0; i < nb_input_streams; i++) {
2010 ist = input_streams[i];
2011 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2012 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2013 score > best_score) {
2019 new_audio_stream(o, oc, idx);
2022 /* subtitles: pick first */
2023 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2024 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2025 for (i = 0; i < nb_input_streams; i++)
2026 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2027 AVCodecDescriptor const *input_descriptor =
2028 avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2029 AVCodecDescriptor const *output_descriptor = NULL;
2030 AVCodec const *output_codec =
2031 avcodec_find_encoder(oc->oformat->subtitle_codec);
2032 int input_props = 0, output_props = 0;
2034 output_descriptor = avcodec_descriptor_get(output_codec->id);
2035 if (input_descriptor)
2036 input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2037 if (output_descriptor)
2038 output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2039 if (subtitle_codec_name ||
2040 input_props & output_props ||
2041 // Map dvb teletext which has neither property to any output subtitle encoder
2042 input_descriptor && output_descriptor &&
2043 (!input_descriptor->props ||
2044 !output_descriptor->props)) {
2045 new_subtitle_stream(o, oc, i);
2050 /* Data only if codec id match */
2051 if (!o->data_disable ) {
2052 enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2053 for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2054 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2055 && input_streams[i]->st->codec->codec_id == codec_id )
2056 new_data_stream(o, oc, i);
2060 for (i = 0; i < o->nb_stream_maps; i++) {
2061 StreamMap *map = &o->stream_maps[i];
2066 if (map->linklabel) {
2068 OutputFilter *ofilter = NULL;
2071 for (j = 0; j < nb_filtergraphs; j++) {
2072 fg = filtergraphs[j];
2073 for (k = 0; k < fg->nb_outputs; k++) {
2074 AVFilterInOut *out = fg->outputs[k]->out_tmp;
2075 if (out && !strcmp(out->name, map->linklabel)) {
2076 ofilter = fg->outputs[k];
2083 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2084 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2087 init_output_filter(ofilter, o, oc);
2089 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2091 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2092 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2094 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2096 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2098 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2102 switch (ist->st->codec->codec_type) {
2103 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2104 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2105 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2106 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2107 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2108 case AVMEDIA_TYPE_UNKNOWN:
2109 if (copy_unknown_streams) {
2110 ost = new_unknown_stream (o, oc, src_idx);
2114 av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2115 "Cannot map stream #%d:%d - unsupported type.\n",
2116 map->file_index, map->stream_index);
2117 if (!ignore_unknown_streams) {
2118 av_log(NULL, AV_LOG_FATAL,
2119 "If you want unsupported types ignored instead "
2120 "of failing, please use the -ignore_unknown option\n"
2121 "If you want them copied, please use -copy_unknown\n");
2126 ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2127 + map->sync_stream_index];
2132 /* handle attached files */
2133 for (i = 0; i < o->nb_attachments; i++) {
2135 uint8_t *attachment;
2139 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2140 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2144 if ((len = avio_size(pb)) <= 0) {
2145 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2149 if (!(attachment = av_malloc(len))) {
2150 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2154 avio_read(pb, attachment, len);
2156 ost = new_attachment_stream(o, oc, -1);
2157 ost->stream_copy = 1;
2158 ost->attachment_filename = o->attachments[i];
2160 ost->st->codec->extradata = attachment;
2161 ost->st->codec->extradata_size = len;
2163 p = strrchr(o->attachments[i], '/');
2164 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2168 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2169 AVDictionaryEntry *e;
2170 ost = output_streams[i];
2172 if ((ost->stream_copy || ost->attachment_filename)
2173 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2174 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2175 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2179 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2180 av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2181 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2185 /* check if all codec options have been used */
2186 unused_opts = strip_specifiers(o->g->codec_opts);
2187 for (i = of->ost_index; i < nb_output_streams; i++) {
2189 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2190 AV_DICT_IGNORE_SUFFIX)))
2191 av_dict_set(&unused_opts, e->key, NULL, 0);
2195 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2196 const AVClass *class = avcodec_get_class();
2197 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2198 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2199 const AVClass *fclass = avformat_get_class();
2200 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2201 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2202 if (!option || foption)
2206 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2207 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2208 "output file #%d (%s) is not an encoding option.\n", e->key,
2209 option->help ? option->help : "", nb_output_files - 1,
2214 // gop_timecode is injected by generic code but not always used
2215 if (!strcmp(e->key, "gop_timecode"))
2218 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2219 "output file #%d (%s) has not been used for any stream. The most "
2220 "likely reason is either wrong type (e.g. a video option with "
2221 "no video streams) or that it is a private option of some encoder "
2222 "which was not actually used for any stream.\n", e->key,
2223 option->help ? option->help : "", nb_output_files - 1, filename);
2225 av_dict_free(&unused_opts);
2227 /* set the encoding/decoding_needed flags */
2228 for (i = of->ost_index; i < nb_output_streams; i++) {
2229 OutputStream *ost = output_streams[i];
2231 ost->encoding_needed = !ost->stream_copy;
2232 if (ost->encoding_needed && ost->source_index >= 0) {
2233 InputStream *ist = input_streams[ost->source_index];
2234 ist->decoding_needed |= DECODING_FOR_OST;
2238 /* check filename in case of an image number is expected */
2239 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2240 if (!av_filename_number_test(oc->filename)) {
2241 print_error(oc->filename, AVERROR(EINVAL));
2246 if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2247 av_log(NULL, AV_LOG_ERROR,
2248 "No input streams but output needs an input stream\n");
2252 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2253 /* test if it already exists to avoid losing precious files */
2254 assert_file_overwrite(filename);
2257 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2258 &oc->interrupt_callback,
2260 print_error(filename, err);
2263 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2264 assert_file_overwrite(filename);
2266 if (o->mux_preload) {
2267 av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2269 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2272 for (i = 0; i < o->nb_metadata_map; i++) {
2274 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2276 if (in_file_index >= nb_input_files) {
2277 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2280 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2281 in_file_index >= 0 ?
2282 input_files[in_file_index]->ctx : NULL, o);
2286 if (o->chapters_input_file >= nb_input_files) {
2287 if (o->chapters_input_file == INT_MAX) {
2288 /* copy chapters from the first input file that has them*/
2289 o->chapters_input_file = -1;
2290 for (i = 0; i < nb_input_files; i++)
2291 if (input_files[i]->ctx->nb_chapters) {
2292 o->chapters_input_file = i;
2296 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2297 o->chapters_input_file);
2301 if (o->chapters_input_file >= 0)
2302 copy_chapters(input_files[o->chapters_input_file], of,
2303 !o->metadata_chapters_manual);
2305 /* copy global metadata by default */
2306 if (!o->metadata_global_manual && nb_input_files){
2307 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2308 AV_DICT_DONT_OVERWRITE);
2309 if(o->recording_time != INT64_MAX)
2310 av_dict_set(&oc->metadata, "duration", NULL, 0);
2311 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2313 if (!o->metadata_streams_manual)
2314 for (i = of->ost_index; i < nb_output_streams; i++) {
2316 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2318 ist = input_streams[output_streams[i]->source_index];
2319 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2320 if (!output_streams[i]->stream_copy) {
2321 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2322 if (ist->autorotate)
2323 av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2327 /* process manually set metadata */
2328 for (i = 0; i < o->nb_metadata; i++) {
2331 const char *stream_spec;
2332 int index = 0, j, ret = 0;
2335 val = strchr(o->metadata[i].u.str, '=');
2337 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2338 o->metadata[i].u.str);
2343 if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2344 !strcmp(val, "now")) {
2345 time_t now = time(0);
2346 struct tm *ptm, tmbuf;
2347 ptm = localtime_r(&now, &tmbuf);
2349 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2354 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2356 for (j = 0; j < oc->nb_streams; j++) {
2357 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2358 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2359 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2360 if (!strcmp(o->metadata[i].u.str, "rotate")) {
2361 ost->rotate_overridden = 1;
2373 if (index < 0 || index >= oc->nb_chapters) {
2374 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2377 m = &oc->chapters[index]->metadata;
2380 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2383 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2390 static int opt_target(void *optctx, const char *opt, const char *arg)
2392 OptionsContext *o = optctx;
2393 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2394 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2396 if (!strncmp(arg, "pal-", 4)) {
2399 } else if (!strncmp(arg, "ntsc-", 5)) {
2402 } else if (!strncmp(arg, "film-", 5)) {
2406 /* Try to determine PAL/NTSC by peeking in the input files */
2407 if (nb_input_files) {
2409 for (j = 0; j < nb_input_files; j++) {
2410 for (i = 0; i < input_files[j]->nb_streams; i++) {
2411 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2412 if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2415 fr = c->time_base.den * 1000 / c->time_base.num;
2419 } else if ((fr == 29970) || (fr == 23976)) {
2424 if (norm != UNKNOWN)
2428 if (norm != UNKNOWN)
2429 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2432 if (norm == UNKNOWN) {
2433 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2434 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2435 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2439 if (!strcmp(arg, "vcd")) {
2440 opt_video_codec(o, "c:v", "mpeg1video");
2441 opt_audio_codec(o, "c:a", "mp2");
2442 parse_option(o, "f", "vcd", options);
2444 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2445 parse_option(o, "r", frame_rates[norm], options);
2446 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2448 opt_default(NULL, "b:v", "1150000");
2449 opt_default(NULL, "maxrate:v", "1150000");
2450 opt_default(NULL, "minrate:v", "1150000");
2451 opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2453 opt_default(NULL, "b:a", "224000");
2454 parse_option(o, "ar", "44100", options);
2455 parse_option(o, "ac", "2", options);
2457 opt_default(NULL, "packetsize", "2324");
2458 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2460 /* We have to offset the PTS, so that it is consistent with the SCR.
2461 SCR starts at 36000, but the first two packs contain only padding
2462 and the first pack from the other stream, respectively, may also have
2463 been written before.
2464 So the real data starts at SCR 36000+3*1200. */
2465 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2466 } else if (!strcmp(arg, "svcd")) {
2468 opt_video_codec(o, "c:v", "mpeg2video");
2469 opt_audio_codec(o, "c:a", "mp2");
2470 parse_option(o, "f", "svcd", options);
2472 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2473 parse_option(o, "r", frame_rates[norm], options);
2474 parse_option(o, "pix_fmt", "yuv420p", options);
2475 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2477 opt_default(NULL, "b:v", "2040000");
2478 opt_default(NULL, "maxrate:v", "2516000");
2479 opt_default(NULL, "minrate:v", "0"); // 1145000;
2480 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2481 opt_default(NULL, "scan_offset", "1");
2483 opt_default(NULL, "b:a", "224000");
2484 parse_option(o, "ar", "44100", options);
2486 opt_default(NULL, "packetsize", "2324");
2488 } else if (!strcmp(arg, "dvd")) {
2490 opt_video_codec(o, "c:v", "mpeg2video");
2491 opt_audio_codec(o, "c:a", "ac3");
2492 parse_option(o, "f", "dvd", options);
2494 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2495 parse_option(o, "r", frame_rates[norm], options);
2496 parse_option(o, "pix_fmt", "yuv420p", options);
2497 opt_default(NULL, "g", norm == PAL ? "15" : "18");
2499 opt_default(NULL, "b:v", "6000000");
2500 opt_default(NULL, "maxrate:v", "9000000");
2501 opt_default(NULL, "minrate:v", "0"); // 1500000;
2502 opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2504 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2505 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2507 opt_default(NULL, "b:a", "448000");
2508 parse_option(o, "ar", "48000", options);
2510 } else if (!strncmp(arg, "dv", 2)) {
2512 parse_option(o, "f", "dv", options);
2514 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2515 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2516 norm == PAL ? "yuv420p" : "yuv411p", options);
2517 parse_option(o, "r", frame_rates[norm], options);
2519 parse_option(o, "ar", "48000", options);
2520 parse_option(o, "ac", "2", options);
2523 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2524 return AVERROR(EINVAL);
2527 av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2528 av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2533 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2535 av_free (vstats_filename);
2536 vstats_filename = av_strdup (arg);
2540 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2543 time_t today2 = time(NULL);
2544 struct tm *today = localtime(&today2);
2546 if (!today) { // maybe tomorrow
2547 av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2551 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2553 return opt_vstats_file(NULL, opt, filename);
2556 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2558 OptionsContext *o = optctx;
2559 return parse_option(o, "frames:v", arg, options);
2562 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2564 OptionsContext *o = optctx;
2565 return parse_option(o, "frames:a", arg, options);
2568 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2570 OptionsContext *o = optctx;
2571 return parse_option(o, "frames:d", arg, options);
2574 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2577 AVDictionary *cbak = codec_opts;
2578 AVDictionary *fbak = format_opts;
2582 ret = opt_default(NULL, opt, arg);
2584 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2585 av_dict_copy(&o->g->format_opts, format_opts, 0);
2586 av_dict_free(&codec_opts);
2587 av_dict_free(&format_opts);
2594 static int opt_preset(void *optctx, const char *opt, const char *arg)
2596 OptionsContext *o = optctx;
2598 char filename[1000], line[1000], tmp_line[1000];
2599 const char *codec_name = NULL;
2603 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2605 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2606 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2607 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2609 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2613 while (fgets(line, sizeof(line), f)) {
2614 char *key = tmp_line, *value, *endptr;
2616 if (strcspn(line, "#\n\r") == 0)
2618 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2619 if (!av_strtok(key, "=", &value) ||
2620 !av_strtok(value, "\r\n", &endptr)) {
2621 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2624 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2626 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2627 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2628 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2629 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2630 else if (opt_default_new(o, key, value) < 0) {
2631 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2632 filename, line, key, value);
2642 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2644 OptionsContext *o = optctx;
2645 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2646 int ret = parse_option(o, s, arg, options);
2651 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2653 OptionsContext *o = optctx;
2655 if(!strcmp(opt, "ab")){
2656 av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2658 } else if(!strcmp(opt, "b")){
2659 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2660 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2663 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2667 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2669 OptionsContext *o = optctx;
2672 if(!strcmp(opt, "qscale")){
2673 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2674 return parse_option(o, "q:v", arg, options);
2676 s = av_asprintf("q%s", opt + 6);
2677 ret = parse_option(o, s, arg, options);
2682 static int opt_profile(void *optctx, const char *opt, const char *arg)
2684 OptionsContext *o = optctx;
2685 if(!strcmp(opt, "profile")){
2686 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2687 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2690 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2694 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2696 OptionsContext *o = optctx;
2697 return parse_option(o, "filter:v", arg, options);
2700 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2702 OptionsContext *o = optctx;
2703 return parse_option(o, "filter:a", arg, options);
2706 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2708 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2709 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2710 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2711 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2713 if (video_sync_method == VSYNC_AUTO)
2714 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2718 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2720 OptionsContext *o = optctx;
2721 char *tcr = av_asprintf("timecode=%s", arg);
2722 int ret = parse_option(o, "metadata:g", tcr, options);
2724 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2729 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2731 OptionsContext *o = optctx;
2732 char layout_str[32];
2735 int ret, channels, ac_str_size;
2738 layout = av_get_channel_layout(arg);
2740 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2741 return AVERROR(EINVAL);
2743 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2744 ret = opt_default_new(o, opt, layout_str);
2748 /* set 'ac' option based on channel layout */
2749 channels = av_get_channel_layout_nb_channels(layout);
2750 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2751 stream_str = strchr(opt, ':');
2752 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2753 ac_str = av_mallocz(ac_str_size);
2755 return AVERROR(ENOMEM);
2756 av_strlcpy(ac_str, "ac", 3);
2758 av_strlcat(ac_str, stream_str, ac_str_size);
2759 ret = parse_option(o, ac_str, layout_str, options);
2765 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2767 OptionsContext *o = optctx;
2768 return parse_option(o, "q:a", arg, options);
2771 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2773 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2774 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2775 return AVERROR(ENOMEM);
2776 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2777 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2778 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2779 return AVERROR(ENOMEM);
2781 input_stream_potentially_available = 1;
2786 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2788 uint8_t *graph_desc = read_file(arg);
2790 return AVERROR(EINVAL);
2792 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2793 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2794 return AVERROR(ENOMEM);
2795 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2796 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2798 input_stream_potentially_available = 1;
2803 void show_help_default(const char *opt, const char *arg)
2805 /* per-file options have at least one of those set */
2806 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2807 int show_advanced = 0, show_avoptions = 0;
2810 if (!strcmp(opt, "long"))
2812 else if (!strcmp(opt, "full"))
2813 show_advanced = show_avoptions = 1;
2815 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2820 printf("Getting help:\n"
2821 " -h -- print basic options\n"
2822 " -h long -- print more options\n"
2823 " -h full -- print all options (including all format and codec specific options, very long)\n"
2824 " See man %s for detailed description of the options.\n"
2825 "\n", program_name);
2827 show_help_options(options, "Print help / information / capabilities:",
2830 show_help_options(options, "Global options (affect whole program "
2831 "instead of just one file:",
2832 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2834 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2835 per_file | OPT_EXIT, 0);
2837 show_help_options(options, "Per-file main options:", 0,
2838 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2839 OPT_EXIT, per_file);
2841 show_help_options(options, "Advanced per-file options:",
2842 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2844 show_help_options(options, "Video options:",
2845 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2847 show_help_options(options, "Advanced Video options:",
2848 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2850 show_help_options(options, "Audio options:",
2851 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2853 show_help_options(options, "Advanced Audio options:",
2854 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2855 show_help_options(options, "Subtitle options:",
2856 OPT_SUBTITLE, 0, 0);
2859 if (show_avoptions) {
2860 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2861 show_help_children(avcodec_get_class(), flags);
2862 show_help_children(avformat_get_class(), flags);
2864 show_help_children(sws_get_class(), flags);
2866 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2867 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2871 void show_usage(void)
2873 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2874 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2875 av_log(NULL, AV_LOG_INFO, "\n");
2883 static const OptionGroupDef groups[] = {
2884 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2885 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2888 static int open_files(OptionGroupList *l, const char *inout,
2889 int (*open_file)(OptionsContext*, const char*))
2893 for (i = 0; i < l->nb_groups; i++) {
2894 OptionGroup *g = &l->groups[i];
2900 ret = parse_optgroup(&o, g);
2902 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2903 "%s.\n", inout, g->arg);
2907 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2908 ret = open_file(&o, g->arg);
2911 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2915 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2921 int ffmpeg_parse_options(int argc, char **argv)
2923 OptionParseContext octx;
2927 memset(&octx, 0, sizeof(octx));
2929 /* split the commandline into an internal representation */
2930 ret = split_commandline(&octx, argc, argv, options, groups,
2931 FF_ARRAY_ELEMS(groups));
2933 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2937 /* apply global options */
2938 ret = parse_optgroup(NULL, &octx.global_opts);
2940 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2944 /* open input files */
2945 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2947 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2951 /* create the complex filtergraphs */
2952 ret = init_complex_filters();
2954 av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2958 /* open output files */
2959 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2961 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2965 /* configure the complex filtergraphs */
2966 ret = configure_complex_filters();
2968 av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2973 uninit_parse_context(&octx);
2975 av_strerror(ret, error, sizeof(error));
2976 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2981 static int opt_progress(void *optctx, const char *opt, const char *arg)
2983 AVIOContext *avio = NULL;
2986 if (!strcmp(arg, "-"))
2988 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2990 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2991 arg, av_err2str(ret));
2994 progress_avio = avio;
2998 #define OFFSET(x) offsetof(OptionsContext, x)
2999 const OptionDef options[] = {
3001 #include "cmdutils_common_opts.h"
3002 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3003 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3004 "force format", "fmt" },
3005 { "y", OPT_BOOL, { &file_overwrite },
3006 "overwrite output files" },
3007 { "n", OPT_BOOL, { &no_file_overwrite },
3008 "never overwrite output files" },
3009 { "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3010 "Ignore unknown stream types" },
3011 { "copy_unknown", OPT_BOOL | OPT_EXPERT, { ©_unknown_streams },
3012 "Copy unknown stream types" },
3013 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3014 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3015 "codec name", "codec" },
3016 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3017 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3018 "codec name", "codec" },
3019 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3020 OPT_OUTPUT, { .off = OFFSET(presets) },
3021 "preset name", "preset" },
3022 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3023 OPT_OUTPUT, { .func_arg = opt_map },
3024 "set input stream mapping",
3025 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3026 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3027 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3028 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3029 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3030 "set metadata information of outfile from infile",
3031 "outfile[,metadata]:infile[,metadata]" },
3032 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3033 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3034 "set chapters mapping", "input_file_index" },
3035 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3036 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3037 "record or transcode \"duration\" seconds of audio/video",
3039 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3040 "record or transcode stop time", "time_stop" },
3041 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3042 "set the limit file size in bytes", "limit_size" },
3043 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3044 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3045 "set the start time offset", "time_off" },
3046 { "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3047 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3048 "set the start time offset relative to EOF", "time_off" },
3049 { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3050 OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3051 "enable/disable seeking by timestamp with -ss" },
3052 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3053 OPT_INPUT, { .off = OFFSET(accurate_seek) },
3054 "enable/disable accurate seeking with -ss" },
3055 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3056 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3057 "set the input ts offset", "time_off" },
3058 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3059 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3060 "set the input ts scale", "scale" },
3061 { "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3062 "set the recording timestamp ('now' to set the current time)", "time" },
3063 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3064 "add metadata", "string=string" },
3065 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3066 OPT_OUTPUT, { .func_arg = opt_data_frames },
3067 "set the number of data frames to output", "number" },
3068 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3069 "add timings for benchmarking" },
3070 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3071 "add timings for each task" },
3072 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3073 "write program-readable progress information", "url" },
3074 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3075 "enable or disable interaction on standard input" },
3076 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3077 "set max runtime in seconds", "limit" },
3078 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3079 "dump each input packet" },
3080 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3081 "when dumping packets, also dump the payload" },
3082 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3083 OPT_INPUT, { .off = OFFSET(rate_emu) },
3084 "read input at native frame rate", "" },
3085 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3086 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
3087 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3088 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
3089 "video sync method", "" },
3090 { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3091 "frame drop threshold", "" },
3092 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3093 "audio sync method", "" },
3094 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3095 "audio drift threshold", "threshold" },
3096 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
3097 "copy timestamps" },
3098 { "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3099 "shift input timestamps to start at 0 when using copyts" },
3100 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
3101 "copy input stream time base when stream copying", "mode" },
3102 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3103 OPT_OUTPUT, { .off = OFFSET(shortest) },
3104 "finish encoding within shortest input" },
3105 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3106 OPT_OUTPUT, { .off = OFFSET(apad) },
3108 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3109 "timestamp discontinuity delta threshold", "threshold" },
3110 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3111 "timestamp error delta threshold", "threshold" },
3112 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3113 "exit on error", "error" },
3114 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3115 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3116 "copy initial non-keyframes" },
3117 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3118 "copy or discard frames before start time" },
3119 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3120 "set the number of frames to output", "number" },
3121 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3122 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3123 "force codec tag/fourcc", "fourcc/tag" },
3124 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3125 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3126 "use fixed quality scale (VBR)", "q" },
3127 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3128 OPT_OUTPUT, { .func_arg = opt_qscale },
3129 "use fixed quality scale (VBR)", "q" },
3130 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3131 "set profile", "profile" },
3132 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3133 "set stream filtergraph", "filter_graph" },
3134 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3135 "read stream filtergraph description from a file", "filename" },
3136 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3137 "reinit filtergraph on input parameter changes", "" },
3138 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3139 "create a complex filtergraph", "graph_description" },
3140 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3141 "create a complex filtergraph", "graph_description" },
3142 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3143 "read complex filtergraph description from a file", "filename" },
3144 { "stats", OPT_BOOL, { &print_stats },
3145 "print progress report during encoding", },
3146 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3147 OPT_OUTPUT, { .func_arg = opt_attach },
3148 "add an attachment to the output file", "filename" },
3149 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3150 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3151 "extract an attachment into a file", "filename" },
3152 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3153 "print timestamp debugging info" },
3154 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3155 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3156 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3157 OPT_INPUT, { .off = OFFSET(discard) },
3159 { "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3160 OPT_OUTPUT, { .off = OFFSET(disposition) },
3161 "disposition", "" },
3162 { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3163 { .off = OFFSET(thread_queue_size) },
3164 "set the maximum number of queued packets from the demuxer" },
3167 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3168 "set the number of video frames to output", "number" },
3169 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3170 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3171 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3172 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3173 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3174 "set frame size (WxH or abbreviation)", "size" },
3175 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3176 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3177 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3178 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3179 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3180 "set pixel format", "format" },
3181 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3182 "set the number of bits per raw sample", "number" },
3183 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3184 "deprecated use -g 1" },
3185 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3187 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3188 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3189 "rate control override for specific intervals", "override" },
3190 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3191 OPT_OUTPUT, { .func_arg = opt_video_codec },
3192 "force video codec ('copy' to copy stream)", "codec" },
3193 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3195 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3197 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3198 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3199 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3200 "select the pass number (1 to 3)", "n" },
3201 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3202 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3203 "select two pass log file name prefix", "prefix" },
3204 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3205 "this option is deprecated, use the yadif filter instead" },
3206 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3207 "calculate PSNR of compressed frames" },
3208 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
3209 "dump video coding statistics to file" },
3210 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
3211 "dump video coding statistics to file", "file" },
3212 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3213 "set video filters", "filter_graph" },
3214 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3215 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3216 "specify intra matrix coeffs", "matrix" },
3217 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3218 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3219 "specify inter matrix coeffs", "matrix" },
3220 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3221 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3222 "specify intra matrix coeffs", "matrix" },
3223 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3224 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3225 "top=1/bottom=0/auto=-1 field first", "" },
3226 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3227 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3228 "force video tag/fourcc", "fourcc/tag" },
3229 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3230 "show QP histogram" },
3231 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3232 OPT_OUTPUT, { .off = OFFSET(force_fps) },
3233 "force the selected framerate, disable the best supported framerate selection" },
3234 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3235 OPT_OUTPUT, { .func_arg = opt_streamid },
3236 "set the value of an outfile streamid", "streamIndex:value" },
3237 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3238 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3239 "force key frames at specified timestamps", "timestamps" },
3240 { "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3241 "audio bitrate (please use -b:a)", "bitrate" },
3242 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3243 "video bitrate (please use -b:v)", "bitrate" },
3244 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3245 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3246 "use HW accelerated decoding", "hwaccel name" },
3247 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3248 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3249 "select a device for HW acceleration", "devicename" },
3251 { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3253 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3254 { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3256 { "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3257 "show available HW acceleration methods" },
3258 { "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3259 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3260 "automatically insert correct rotate filters" },
3263 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3264 "set the number of audio frames to output", "number" },
3265 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3266 "set audio quality (codec-specific)", "quality", },
3267 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3268 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3269 "set audio sampling rate (in Hz)", "rate" },
3270 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3271 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3272 "set number of audio channels", "channels" },
3273 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3275 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3276 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3277 "force audio codec ('copy' to copy stream)", "codec" },
3278 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3279 OPT_OUTPUT, { .func_arg = opt_old2new },
3280 "force audio tag/fourcc", "fourcc/tag" },
3281 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3282 "change audio volume (256=normal)" , "volume" },
3283 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3284 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3285 "set sample format", "format" },
3286 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3287 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3288 "set channel layout", "layout" },
3289 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3290 "set audio filters", "filter_graph" },
3291 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3292 "set the maximum number of channels to try to guess the channel layout" },
3294 /* subtitle options */
3295 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3296 "disable subtitle" },
3297 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3298 "force subtitle codec ('copy' to copy stream)", "codec" },
3299 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3300 , "force subtitle tag/fourcc", "fourcc/tag" },
3301 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3302 "fix subtitles duration" },
3303 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3304 "set canvas size (WxH or abbreviation)", "size" },
3307 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3308 "deprecated, use -channel", "channel" },
3309 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3310 "deprecated, use -standard", "standard" },
3311 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3314 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3315 "set the maximum demux-decode delay", "seconds" },
3316 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3317 "set the initial demux-decode delay", "seconds" },
3318 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3319 "override the options from ffserver", "" },
3320 { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3321 "specify a file in which to print sdp information", "file" },
3323 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3324 "A comma-separated list of bitstream filters", "bitstream_filters" },
3325 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3326 "deprecated", "audio bitstream_filters" },
3327 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3328 "deprecated", "video bitstream_filters" },
3330 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3331 "set the audio options to the indicated preset", "preset" },
3332 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3333 "set the video options to the indicated preset", "preset" },
3334 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3335 "set the subtitle options to the indicated preset", "preset" },
3336 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3337 "set options from indicated preset file", "filename" },
3338 /* data codec support */
3339 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3340 "force data codec ('copy' to copy stream)", "codec" },
3341 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },