2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
81 float audio_drift_threshold = 0.1;
82 float dts_delta_threshold = 10;
83 float dts_error_threshold = 3600*30;
85 int audio_volume = 256;
86 int audio_sync_method = 0;
87 int video_sync_method = VSYNC_AUTO;
88 int do_deinterlace = 0;
90 int do_benchmark_all = 0;
96 int exit_on_error = 0;
99 int stdin_interaction = 1;
100 int frame_bits_per_raw_sample = 0;
101 float max_error_rate = 2.0/3;
104 static int intra_only = 0;
105 static int file_overwrite = 0;
106 static int no_file_overwrite = 0;
107 static int video_discard = 0;
108 static int intra_dc_precision = 8;
109 static int do_psnr = 0;
110 static int input_sync;
111 static int override_ffserver = 0;
113 static void uninit_options(OptionsContext *o)
115 const OptionDef *po = options;
118 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
120 void *dst = (uint8_t*)o + po->u.off;
122 if (po->flags & OPT_SPEC) {
123 SpecifierOpt **so = dst;
124 int i, *count = (int*)(so + 1);
125 for (i = 0; i < *count; i++) {
126 av_freep(&(*so)[i].specifier);
127 if (po->flags & OPT_STRING)
128 av_freep(&(*so)[i].u.str);
132 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
137 for (i = 0; i < o->nb_stream_maps; i++)
138 av_freep(&o->stream_maps[i].linklabel);
139 av_freep(&o->stream_maps);
140 av_freep(&o->audio_channel_maps);
141 av_freep(&o->streamid_map);
142 av_freep(&o->attachments);
145 static void init_options(OptionsContext *o)
147 memset(o, 0, sizeof(*o));
149 o->stop_time = INT64_MAX;
150 o->mux_max_delay = 0.7;
151 o->start_time = AV_NOPTS_VALUE;
152 o->recording_time = INT64_MAX;
153 o->limit_filesize = UINT64_MAX;
154 o->chapters_input_file = INT_MAX;
155 o->accurate_seek = 1;
158 /* return a copy of the input with the stream specifiers removed from the keys */
159 static AVDictionary *strip_specifiers(AVDictionary *dict)
161 AVDictionaryEntry *e = NULL;
162 AVDictionary *ret = NULL;
164 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
165 char *p = strchr(e->key, ':');
169 av_dict_set(&ret, e->key, e->value, 0);
176 static int opt_sameq(void *optctx, const char *opt, const char *arg)
178 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
179 "If you are looking for an option to preserve the quality (which is not "
180 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
182 return AVERROR(EINVAL);
185 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
187 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
188 return opt_default(optctx, "channel", arg);
191 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
193 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
194 return opt_default(optctx, "standard", arg);
197 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
199 OptionsContext *o = optctx;
200 return parse_option(o, "codec:a", arg, options);
203 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
205 OptionsContext *o = optctx;
206 return parse_option(o, "codec:v", arg, options);
209 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
211 OptionsContext *o = optctx;
212 return parse_option(o, "codec:s", arg, options);
215 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
217 OptionsContext *o = optctx;
218 return parse_option(o, "codec:d", arg, options);
221 static int opt_map(void *optctx, const char *opt, const char *arg)
223 OptionsContext *o = optctx;
225 int i, negative = 0, file_idx;
226 int sync_file_idx = -1, sync_stream_idx = 0;
234 map = av_strdup(arg);
236 /* parse sync stream first, just pick first matching stream */
237 if (sync = strchr(map, ',')) {
239 sync_file_idx = strtol(sync + 1, &sync, 0);
240 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
241 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
246 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
247 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
248 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
252 if (i == input_files[sync_file_idx]->nb_streams) {
253 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
254 "match any streams.\n", arg);
261 /* this mapping refers to lavfi output */
262 const char *c = map + 1;
263 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
264 m = &o->stream_maps[o->nb_stream_maps - 1];
265 m->linklabel = av_get_token(&c, "]");
267 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
271 file_idx = strtol(map, &p, 0);
272 if (file_idx >= nb_input_files || file_idx < 0) {
273 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
277 /* disable some already defined maps */
278 for (i = 0; i < o->nb_stream_maps; i++) {
279 m = &o->stream_maps[i];
280 if (file_idx == m->file_index &&
281 check_stream_specifier(input_files[m->file_index]->ctx,
282 input_files[m->file_index]->ctx->streams[m->stream_index],
283 *p == ':' ? p + 1 : p) > 0)
287 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
288 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
289 *p == ':' ? p + 1 : p) <= 0)
291 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
292 m = &o->stream_maps[o->nb_stream_maps - 1];
294 m->file_index = file_idx;
297 if (sync_file_idx >= 0) {
298 m->sync_file_index = sync_file_idx;
299 m->sync_stream_index = sync_stream_idx;
301 m->sync_file_index = file_idx;
302 m->sync_stream_index = i;
308 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
316 static int opt_attach(void *optctx, const char *opt, const char *arg)
318 OptionsContext *o = optctx;
319 GROW_ARRAY(o->attachments, o->nb_attachments);
320 o->attachments[o->nb_attachments - 1] = arg;
324 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
326 OptionsContext *o = optctx;
331 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
332 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
334 /* muted channel syntax */
335 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
336 if ((n == 1 || n == 3) && m->channel_idx == -1) {
337 m->file_idx = m->stream_idx = -1;
339 m->ofile_idx = m->ostream_idx = -1;
344 n = sscanf(arg, "%d.%d.%d:%d.%d",
345 &m->file_idx, &m->stream_idx, &m->channel_idx,
346 &m->ofile_idx, &m->ostream_idx);
348 if (n != 3 && n != 5) {
349 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
350 "[file.stream.channel|-1][:syncfile:syncstream]\n");
354 if (n != 5) // only file.stream.channel specified
355 m->ofile_idx = m->ostream_idx = -1;
358 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
359 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
363 if (m->stream_idx < 0 ||
364 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
365 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
366 m->file_idx, m->stream_idx);
369 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
370 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
371 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
372 m->file_idx, m->stream_idx);
375 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
376 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
377 m->file_idx, m->stream_idx, m->channel_idx);
384 * Parse a metadata specifier passed as 'arg' parameter.
385 * @param arg metadata string to parse
386 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
387 * @param index for type c/p, chapter/program index is written here
388 * @param stream_spec for type s, the stream specifier is written here
390 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
398 if (*(++arg) && *arg != ':') {
399 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
402 *stream_spec = *arg == ':' ? arg + 1 : "";
407 *index = strtol(++arg, NULL, 0);
410 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
417 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
419 AVDictionary **meta_in = NULL;
420 AVDictionary **meta_out = NULL;
422 char type_in, type_out;
423 const char *istream_spec = NULL, *ostream_spec = NULL;
424 int idx_in = 0, idx_out = 0;
426 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
427 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
430 if (type_out == 'g' || !*outspec)
431 o->metadata_global_manual = 1;
432 if (type_out == 's' || !*outspec)
433 o->metadata_streams_manual = 1;
434 if (type_out == 'c' || !*outspec)
435 o->metadata_chapters_manual = 1;
439 if (type_in == 'g' || type_out == 'g')
440 o->metadata_global_manual = 1;
441 if (type_in == 's' || type_out == 's')
442 o->metadata_streams_manual = 1;
443 if (type_in == 'c' || type_out == 'c')
444 o->metadata_chapters_manual = 1;
446 /* ic is NULL when just disabling automatic mappings */
450 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
451 if ((index) < 0 || (index) >= (nb_elems)) {\
452 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
457 #define SET_DICT(type, meta, context, index)\
460 meta = &context->metadata;\
463 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
464 meta = &context->chapters[index]->metadata;\
467 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
468 meta = &context->programs[index]->metadata;\
471 break; /* handled separately below */ \
472 default: av_assert0(0);\
475 SET_DICT(type_in, meta_in, ic, idx_in);
476 SET_DICT(type_out, meta_out, oc, idx_out);
478 /* for input streams choose first matching stream */
479 if (type_in == 's') {
480 for (i = 0; i < ic->nb_streams; i++) {
481 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
482 meta_in = &ic->streams[i]->metadata;
488 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
493 if (type_out == 's') {
494 for (i = 0; i < oc->nb_streams; i++) {
495 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
496 meta_out = &oc->streams[i]->metadata;
497 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
502 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
507 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
509 OptionsContext *o = optctx;
511 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
512 struct tm time = *gmtime((time_t*)&recording_timestamp);
513 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
514 parse_option(o, "metadata", buf, options);
516 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
517 "tag instead.\n", opt);
521 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
523 const AVCodecDescriptor *desc;
524 const char *codec_string = encoder ? "encoder" : "decoder";
528 avcodec_find_encoder_by_name(name) :
529 avcodec_find_decoder_by_name(name);
531 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
532 codec = encoder ? avcodec_find_encoder(desc->id) :
533 avcodec_find_decoder(desc->id);
535 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
536 codec_string, codec->name, desc->name);
540 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
543 if (codec->type != type) {
544 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
550 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
552 char *codec_name = NULL;
554 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
556 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
557 st->codec->codec_id = codec->id;
560 return avcodec_find_decoder(st->codec->codec_id);
563 /* Add all the streams from the given input file to the global
564 * list of input streams. */
565 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
569 for (i = 0; i < ic->nb_streams; i++) {
570 AVStream *st = ic->streams[i];
571 AVCodecContext *dec = st->codec;
572 InputStream *ist = av_mallocz(sizeof(*ist));
573 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
574 char *codec_tag = NULL;
580 GROW_ARRAY(input_streams, nb_input_streams);
581 input_streams[nb_input_streams - 1] = ist;
584 ist->file_index = nb_input_files;
586 st->discard = AVDISCARD_ALL;
589 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
591 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
593 uint32_t tag = strtol(codec_tag, &next, 0);
595 tag = AV_RL32(codec_tag);
596 st->codec->codec_tag = tag;
599 ist->dec = choose_decoder(o, ic, st);
600 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
602 ist->reinit_filters = -1;
603 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
605 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
607 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
609 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
613 ret = avcodec_copy_context(ist->dec_ctx, dec);
615 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
619 switch (dec->codec_type) {
620 case AVMEDIA_TYPE_VIDEO:
622 ist->dec = avcodec_find_decoder(dec->codec_id);
623 if (av_codec_get_lowres(dec)) {
624 dec->flags |= CODEC_FLAG_EMU_EDGE;
627 ist->resample_height = ist->dec_ctx->height;
628 ist->resample_width = ist->dec_ctx->width;
629 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
631 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
632 if (framerate && av_parse_video_rate(&ist->framerate,
634 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
639 ist->top_field_first = -1;
640 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
642 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
644 if (!strcmp(hwaccel, "none"))
645 ist->hwaccel_id = HWACCEL_NONE;
646 else if (!strcmp(hwaccel, "auto"))
647 ist->hwaccel_id = HWACCEL_AUTO;
650 for (i = 0; hwaccels[i].name; i++) {
651 if (!strcmp(hwaccels[i].name, hwaccel)) {
652 ist->hwaccel_id = hwaccels[i].id;
657 if (!ist->hwaccel_id) {
658 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
660 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
661 for (i = 0; hwaccels[i].name; i++)
662 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
663 av_log(NULL, AV_LOG_FATAL, "\n");
669 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
670 if (hwaccel_device) {
671 ist->hwaccel_device = av_strdup(hwaccel_device);
672 if (!ist->hwaccel_device)
675 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
678 case AVMEDIA_TYPE_AUDIO:
679 ist->guess_layout_max = INT_MAX;
680 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
681 guess_input_channel_layout(ist);
683 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
684 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
685 ist->resample_channels = ist->dec_ctx->channels;
686 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
689 case AVMEDIA_TYPE_DATA:
690 case AVMEDIA_TYPE_SUBTITLE: {
691 char *canvas_size = NULL;
693 ist->dec = avcodec_find_decoder(dec->codec_id);
694 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
695 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
697 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
698 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
703 case AVMEDIA_TYPE_ATTACHMENT:
704 case AVMEDIA_TYPE_UNKNOWN:
712 static void assert_file_overwrite(const char *filename)
714 if (file_overwrite && no_file_overwrite) {
715 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
719 if (!file_overwrite) {
720 const char *proto_name = avio_find_protocol_name(filename);
721 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
722 if (stdin_interaction && !no_file_overwrite) {
723 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
726 signal(SIGINT, SIG_DFL);
728 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
734 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
741 static void dump_attachment(AVStream *st, const char *filename)
744 AVIOContext *out = NULL;
745 AVDictionaryEntry *e;
747 if (!st->codec->extradata_size) {
748 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
749 nb_input_files - 1, st->index);
752 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
755 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
756 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
760 assert_file_overwrite(filename);
762 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
763 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
768 avio_write(out, st->codec->extradata, st->codec->extradata_size);
773 static int open_input_file(OptionsContext *o, const char *filename)
777 AVInputFormat *file_iformat = NULL;
782 AVDictionary *unused_opts = NULL;
783 AVDictionaryEntry *e = NULL;
784 int orig_nb_streams; // number of streams before avformat_find_stream_info
785 char * video_codec_name = NULL;
786 char * audio_codec_name = NULL;
787 char *subtitle_codec_name = NULL;
790 if (!(file_iformat = av_find_input_format(o->format))) {
791 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
796 if (!strcmp(filename, "-"))
799 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
800 strcmp(filename, "/dev/stdin");
802 /* get default parameters from command line */
803 ic = avformat_alloc_context();
805 print_error(filename, AVERROR(ENOMEM));
808 if (o->nb_audio_sample_rate) {
809 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
810 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
812 if (o->nb_audio_channels) {
813 /* because we set audio_channels based on both the "ac" and
814 * "channel_layout" options, we need to check that the specified
815 * demuxer actually has the "channels" option before setting it */
816 if (file_iformat && file_iformat->priv_class &&
817 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
818 AV_OPT_SEARCH_FAKE_OBJ)) {
819 snprintf(buf, sizeof(buf), "%d",
820 o->audio_channels[o->nb_audio_channels - 1].u.i);
821 av_dict_set(&o->g->format_opts, "channels", buf, 0);
824 if (o->nb_frame_rates) {
825 /* set the format-level framerate option;
826 * this is important for video grabbers, e.g. x11 */
827 if (file_iformat && file_iformat->priv_class &&
828 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
829 AV_OPT_SEARCH_FAKE_OBJ)) {
830 av_dict_set(&o->g->format_opts, "framerate",
831 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
834 if (o->nb_frame_sizes) {
835 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
837 if (o->nb_frame_pix_fmts)
838 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
840 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
841 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
842 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
844 ic->video_codec_id = video_codec_name ?
845 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
846 ic->audio_codec_id = audio_codec_name ?
847 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
848 ic->subtitle_codec_id= subtitle_codec_name ?
849 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
851 if (video_codec_name)
852 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
853 if (audio_codec_name)
854 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
855 if (subtitle_codec_name)
856 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
858 ic->flags |= AVFMT_FLAG_NONBLOCK;
859 ic->interrupt_callback = int_cb;
861 /* open the input file with generic avformat function */
862 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
864 print_error(filename, err);
867 assert_avoptions(o->g->format_opts);
869 /* apply forced codec ids */
870 for (i = 0; i < ic->nb_streams; i++)
871 choose_decoder(o, ic, ic->streams[i]);
873 /* Set AVCodecContext options for avformat_find_stream_info */
874 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
875 orig_nb_streams = ic->nb_streams;
877 /* If not enough info to get the stream parameters, we decode the
878 first frames to get it. (used in mpeg case for example) */
879 ret = avformat_find_stream_info(ic, opts);
881 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
882 avformat_close_input(&ic);
886 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
887 /* add the stream start time */
888 if (ic->start_time != AV_NOPTS_VALUE)
889 timestamp += ic->start_time;
891 /* if seeking requested, we execute it */
892 if (o->start_time != AV_NOPTS_VALUE) {
893 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
895 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
896 filename, (double)timestamp / AV_TIME_BASE);
900 /* update the current parameters so that they match the one of the input stream */
901 add_input_streams(o, ic);
903 /* dump the file content */
904 av_dump_format(ic, nb_input_files, filename, 0);
906 GROW_ARRAY(input_files, nb_input_files);
907 f = av_mallocz(sizeof(*f));
910 input_files[nb_input_files - 1] = f;
913 f->ist_index = nb_input_streams - ic->nb_streams;
914 f->start_time = o->start_time;
915 f->recording_time = o->recording_time;
916 f->input_ts_offset = o->input_ts_offset;
917 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
918 f->nb_streams = ic->nb_streams;
919 f->rate_emu = o->rate_emu;
920 f->accurate_seek = o->accurate_seek;
922 /* check if all codec options have been used */
923 unused_opts = strip_specifiers(o->g->codec_opts);
924 for (i = f->ist_index; i < nb_input_streams; i++) {
926 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
927 AV_DICT_IGNORE_SUFFIX)))
928 av_dict_set(&unused_opts, e->key, NULL, 0);
932 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
933 const AVClass *class = avcodec_get_class();
934 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
935 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
936 const AVClass *fclass = avformat_get_class();
937 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
938 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
939 if (!option || foption)
943 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
944 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
945 "input file #%d (%s) is not a decoding option.\n", e->key,
946 option->help ? option->help : "", nb_input_files - 1,
951 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
952 "input file #%d (%s) has not been used for any stream. The most "
953 "likely reason is either wrong type (e.g. a video option with "
954 "no video streams) or that it is a private option of some decoder "
955 "which was not actually used for any stream.\n", e->key,
956 option->help ? option->help : "", nb_input_files - 1, filename);
958 av_dict_free(&unused_opts);
960 for (i = 0; i < o->nb_dump_attachment; i++) {
963 for (j = 0; j < ic->nb_streams; j++) {
964 AVStream *st = ic->streams[j];
966 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
967 dump_attachment(st, o->dump_attachment[i].u.str);
971 for (i = 0; i < orig_nb_streams; i++)
972 av_dict_free(&opts[i]);
978 static uint8_t *get_line(AVIOContext *s)
984 if (avio_open_dyn_buf(&line) < 0) {
985 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
989 while ((c = avio_r8(s)) && c != '\n')
992 avio_close_dyn_buf(line, &buf);
997 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1000 char filename[1000];
1001 const char *base[3] = { getenv("AVCONV_DATADIR"),
1006 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1010 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1011 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1012 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1015 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1016 i != 1 ? "" : "/.avconv", preset_name);
1017 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1023 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1025 char *codec_name = NULL;
1027 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1029 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1030 NULL, ost->st->codec->codec_type);
1031 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1032 } else if (!strcmp(codec_name, "copy"))
1033 ost->stream_copy = 1;
1035 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1036 ost->st->codec->codec_id = ost->enc->id;
1040 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1043 AVStream *st = avformat_new_stream(oc, NULL);
1044 int idx = oc->nb_streams - 1, ret = 0;
1045 char *bsf = NULL, *next, *codec_tag = NULL;
1046 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1051 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1055 if (oc->nb_streams - 1 < o->nb_streamid_map)
1056 st->id = o->streamid_map[oc->nb_streams - 1];
1058 GROW_ARRAY(output_streams, nb_output_streams);
1059 if (!(ost = av_mallocz(sizeof(*ost))))
1061 output_streams[nb_output_streams - 1] = ost;
1063 ost->file_index = nb_output_files - 1;
1066 st->codec->codec_type = type;
1067 choose_encoder(o, oc, ost);
1069 AVIOContext *s = NULL;
1070 char *buf = NULL, *arg = NULL, *preset = NULL;
1072 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1074 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1075 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1078 if (!buf[0] || buf[0] == '#') {
1082 if (!(arg = strchr(buf, '='))) {
1083 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1087 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1089 } while (!s->eof_reached);
1093 av_log(NULL, AV_LOG_FATAL,
1094 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1095 preset, ost->file_index, ost->index);
1099 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1102 avcodec_get_context_defaults3(st->codec, ost->enc);
1103 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1105 ost->max_frames = INT64_MAX;
1106 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1107 for (i = 0; i<o->nb_max_frames; i++) {
1108 char *p = o->max_frames[i].specifier;
1109 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1110 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1115 ost->copy_prior_start = -1;
1116 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1118 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1120 if (next = strchr(bsf, ','))
1122 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1123 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1127 bsfc_prev->next = bsfc;
1129 ost->bitstream_filters = bsfc;
1135 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1137 uint32_t tag = strtol(codec_tag, &next, 0);
1139 tag = AV_RL32(codec_tag);
1140 st->codec->codec_tag = tag;
1143 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1145 st->codec->flags |= CODEC_FLAG_QSCALE;
1146 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1149 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1150 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1152 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1154 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1155 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1156 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1158 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1160 ost->source_index = source_index;
1161 if (source_index >= 0) {
1162 ost->sync_ist = input_streams[source_index];
1163 input_streams[source_index]->discard = 0;
1164 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1166 ost->last_mux_dts = AV_NOPTS_VALUE;
1171 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1174 const char *p = str;
1181 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1188 /* read file contents into a string */
1189 static uint8_t *read_file(const char *filename)
1191 AVIOContext *pb = NULL;
1192 AVIOContext *dyn_buf = NULL;
1193 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1194 uint8_t buf[1024], *str;
1197 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1201 ret = avio_open_dyn_buf(&dyn_buf);
1206 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1207 avio_write(dyn_buf, buf, ret);
1208 avio_w8(dyn_buf, 0);
1211 ret = avio_close_dyn_buf(dyn_buf, &str);
1217 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1220 AVStream *st = ost->st;
1222 if (ost->filters_script && ost->filters) {
1223 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1224 "output stream #%d:%d.\n", nb_output_files, st->index);
1228 if (ost->filters_script)
1229 return read_file(ost->filters_script);
1230 else if (ost->filters)
1231 return av_strdup(ost->filters);
1233 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1237 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1238 const OutputStream *ost, enum AVMediaType type)
1240 if (ost->filters_script || ost->filters) {
1241 av_log(NULL, AV_LOG_ERROR,
1242 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1243 "Filtering and streamcopy cannot be used together.\n",
1244 ost->filters ? "Filtergraph" : "Filtergraph script",
1245 ost->filters ? ost->filters : ost->filters_script,
1246 av_get_media_type_string(type), ost->file_index, ost->index);
1251 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1255 AVCodecContext *video_enc;
1256 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1258 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1260 video_enc = st->codec;
1262 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1263 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1264 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1268 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1269 if (frame_aspect_ratio) {
1271 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1272 q.num <= 0 || q.den <= 0) {
1273 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1276 ost->frame_aspect_ratio = q;
1279 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1280 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1282 if (!ost->stream_copy) {
1283 const char *p = NULL;
1284 char *frame_size = NULL;
1285 char *frame_pix_fmt = NULL;
1286 char *intra_matrix = NULL, *inter_matrix = NULL;
1287 char *chroma_intra_matrix = NULL;
1291 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1292 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1293 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1297 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1298 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1299 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1300 ost->keep_pix_fmt = 1;
1301 if (!*++frame_pix_fmt)
1302 frame_pix_fmt = NULL;
1304 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1305 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1308 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1311 video_enc->gop_size = 0;
1312 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1314 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1315 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1318 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1320 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1321 if (chroma_intra_matrix) {
1322 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1324 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1327 av_codec_set_chroma_intra_matrix(video_enc, p);
1328 parse_matrix_coeffs(p, chroma_intra_matrix);
1330 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1332 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1333 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1336 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1339 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1340 for (i = 0; p; i++) {
1342 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1344 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1347 /* FIXME realloc failure */
1348 video_enc->rc_override =
1349 av_realloc(video_enc->rc_override,
1350 sizeof(RcOverride) * (i + 1));
1351 video_enc->rc_override[i].start_frame = start;
1352 video_enc->rc_override[i].end_frame = end;
1354 video_enc->rc_override[i].qscale = q;
1355 video_enc->rc_override[i].quality_factor = 1.0;
1358 video_enc->rc_override[i].qscale = 0;
1359 video_enc->rc_override[i].quality_factor = -q/100.0;
1364 video_enc->rc_override_count = i;
1365 video_enc->intra_dc_precision = intra_dc_precision - 8;
1368 video_enc->flags|= CODEC_FLAG_PSNR;
1371 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1374 video_enc->flags |= CODEC_FLAG_PASS1;
1375 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1378 video_enc->flags |= CODEC_FLAG_PASS2;
1379 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1383 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1384 if (ost->logfile_prefix &&
1385 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1388 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1389 if (ost->forced_keyframes)
1390 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1392 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1394 ost->top_field_first = -1;
1395 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1398 ost->avfilter = get_ost_filters(o, oc, ost);
1402 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1405 if (ost->stream_copy)
1406 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1411 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1416 AVCodecContext *audio_enc;
1418 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1421 audio_enc = st->codec;
1422 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1424 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1425 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1427 if (!ost->stream_copy) {
1428 char *sample_fmt = NULL;
1430 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1432 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1434 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1435 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1439 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1441 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1442 ost->apad = av_strdup(ost->apad);
1444 ost->avfilter = get_ost_filters(o, oc, ost);
1448 /* check for channel mapping for this audio stream */
1449 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1450 AudioChannelMap *map = &o->audio_channel_maps[n];
1451 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1452 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1455 if (map->channel_idx == -1) {
1457 } else if (ost->source_index < 0) {
1458 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1459 ost->file_index, ost->st->index);
1462 ist = input_streams[ost->source_index];
1465 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1466 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1467 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1469 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1470 ost->file_index, ost->st->index);
1476 if (ost->stream_copy)
1477 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1482 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1486 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1487 if (!ost->stream_copy) {
1488 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1495 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1497 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1498 ost->stream_copy = 1;
1503 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1507 AVCodecContext *subtitle_enc;
1509 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1511 subtitle_enc = st->codec;
1513 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1515 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1517 if (!ost->stream_copy) {
1518 char *frame_size = NULL;
1520 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1521 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1522 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1530 /* arg format is "output-stream-index:streamid-value". */
1531 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1533 OptionsContext *o = optctx;
1538 av_strlcpy(idx_str, arg, sizeof(idx_str));
1539 p = strchr(idx_str, ':');
1541 av_log(NULL, AV_LOG_FATAL,
1542 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1547 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1548 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1549 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1553 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1555 AVFormatContext *is = ifile->ctx;
1556 AVFormatContext *os = ofile->ctx;
1560 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1562 return AVERROR(ENOMEM);
1565 for (i = 0; i < is->nb_chapters; i++) {
1566 AVChapter *in_ch = is->chapters[i], *out_ch;
1567 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1568 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1569 AV_TIME_BASE_Q, in_ch->time_base);
1570 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1571 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1574 if (in_ch->end < ts_off)
1576 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1579 out_ch = av_mallocz(sizeof(AVChapter));
1581 return AVERROR(ENOMEM);
1583 out_ch->id = in_ch->id;
1584 out_ch->time_base = in_ch->time_base;
1585 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1586 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1589 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1591 os->chapters[os->nb_chapters++] = out_ch;
1596 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1599 AVFormatContext *ic = avformat_alloc_context();
1601 ic->interrupt_callback = int_cb;
1602 err = avformat_open_input(&ic, filename, NULL, NULL);
1605 /* copy stream format */
1606 for(i=0;i<ic->nb_streams;i++) {
1610 AVCodecContext *avctx;
1612 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1613 ost = new_output_stream(o, s, codec->type, -1);
1618 // FIXME: a more elegant solution is needed
1619 memcpy(st, ic->streams[i], sizeof(AVStream));
1621 st->info = av_malloc(sizeof(*st->info));
1622 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1624 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1626 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1627 choose_sample_fmt(st, codec);
1628 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1629 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1632 avformat_close_input(&ic);
1636 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1637 AVFormatContext *oc)
1641 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1642 ofilter->out_tmp->pad_idx)) {
1643 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1644 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1646 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1651 ost->source_index = -1;
1652 ost->filter = ofilter;
1656 if (ost->stream_copy) {
1657 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1658 "which is fed from a complex filtergraph. Filtering and streamcopy "
1659 "cannot be used together.\n", ost->file_index, ost->index);
1663 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1664 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1665 av_log(NULL, AV_LOG_ERROR,
1666 "%s '%s' was specified through the %s option "
1667 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1668 "%s and -filter_complex cannot be used together for the same stream.\n",
1669 ost->filters ? "Filtergraph" : "Filtergraph script",
1670 ost->filters ? ost->filters : ost->filters_script,
1671 opt, ost->file_index, ost->index, opt);
1675 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1676 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1679 avfilter_inout_free(&ofilter->out_tmp);
1682 static int configure_complex_filters(void)
1686 for (i = 0; i < nb_filtergraphs; i++)
1687 if (!filtergraphs[i]->graph &&
1688 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1693 static int open_output_file(OptionsContext *o, const char *filename)
1695 AVFormatContext *oc;
1697 AVOutputFormat *file_oformat;
1701 AVDictionary *unused_opts = NULL;
1702 AVDictionaryEntry *e = NULL;
1704 if (configure_complex_filters() < 0) {
1705 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1709 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1710 o->stop_time = INT64_MAX;
1711 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1714 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1715 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1716 if (o->stop_time <= start_time) {
1717 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1718 o->stop_time = INT64_MAX;
1720 o->recording_time = o->stop_time - start_time;
1724 GROW_ARRAY(output_files, nb_output_files);
1725 of = av_mallocz(sizeof(*of));
1728 output_files[nb_output_files - 1] = of;
1730 of->ost_index = nb_output_streams;
1731 of->recording_time = o->recording_time;
1732 of->start_time = o->start_time;
1733 of->limit_filesize = o->limit_filesize;
1734 of->shortest = o->shortest;
1735 av_dict_copy(&of->opts, o->g->format_opts, 0);
1737 if (!strcmp(filename, "-"))
1740 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1742 print_error(filename, err);
1747 if (o->recording_time != INT64_MAX)
1748 oc->duration = o->recording_time;
1750 file_oformat= oc->oformat;
1751 oc->interrupt_callback = int_cb;
1753 /* create streams for all unlabeled output pads */
1754 for (i = 0; i < nb_filtergraphs; i++) {
1755 FilterGraph *fg = filtergraphs[i];
1756 for (j = 0; j < fg->nb_outputs; j++) {
1757 OutputFilter *ofilter = fg->outputs[j];
1759 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1762 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1763 ofilter->out_tmp->pad_idx)) {
1764 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1765 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1766 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1768 init_output_filter(ofilter, o, oc);
1772 /* ffserver seeking with date=... needs a date reference */
1773 if (!strcmp(file_oformat->name, "ffm") &&
1774 av_strstart(filename, "http:", NULL)) {
1775 int err = parse_option(o, "metadata", "creation_time=now", options);
1777 print_error(filename, err);
1782 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1783 av_strstart(filename, "http:", NULL)) {
1785 /* special case for files sent to ffserver: we get the stream
1786 parameters from ffserver */
1787 int err = read_ffserver_streams(o, oc, filename);
1789 print_error(filename, err);
1792 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1793 ost = output_streams[j];
1794 for (i = 0; i < nb_input_streams; i++) {
1795 ist = input_streams[i];
1796 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1798 ost->source_index= i;
1799 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1800 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1802 ist->st->discard = AVDISCARD_NONE;
1807 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));
1811 } else if (!o->nb_stream_maps) {
1812 char *subtitle_codec_name = NULL;
1813 /* pick the "best" stream of each type */
1815 /* video: highest resolution */
1816 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1817 int area = 0, idx = -1;
1818 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1819 for (i = 0; i < nb_input_streams; i++) {
1821 ist = input_streams[i];
1822 new_area = ist->st->codec->width * ist->st->codec->height;
1823 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1825 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1827 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1834 new_video_stream(o, oc, idx);
1837 /* audio: most channels */
1838 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1839 int channels = 0, idx = -1;
1840 for (i = 0; i < nb_input_streams; i++) {
1841 ist = input_streams[i];
1842 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1843 ist->st->codec->channels > channels) {
1844 channels = ist->st->codec->channels;
1849 new_audio_stream(o, oc, idx);
1852 /* subtitles: pick first */
1853 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1854 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1855 for (i = 0; i < nb_input_streams; i++)
1856 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1857 new_subtitle_stream(o, oc, i);
1861 /* do something with data? */
1863 for (i = 0; i < o->nb_stream_maps; i++) {
1864 StreamMap *map = &o->stream_maps[i];
1869 if (map->linklabel) {
1871 OutputFilter *ofilter = NULL;
1874 for (j = 0; j < nb_filtergraphs; j++) {
1875 fg = filtergraphs[j];
1876 for (k = 0; k < fg->nb_outputs; k++) {
1877 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1878 if (out && !strcmp(out->name, map->linklabel)) {
1879 ofilter = fg->outputs[k];
1886 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1887 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1890 init_output_filter(ofilter, o, oc);
1892 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1894 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1895 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1897 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1899 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1901 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1904 switch (ist->st->codec->codec_type) {
1905 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1906 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1907 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1908 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1909 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1911 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1912 map->file_index, map->stream_index);
1919 /* handle attached files */
1920 for (i = 0; i < o->nb_attachments; i++) {
1922 uint8_t *attachment;
1926 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1927 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1931 if ((len = avio_size(pb)) <= 0) {
1932 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1936 if (!(attachment = av_malloc(len))) {
1937 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1941 avio_read(pb, attachment, len);
1943 ost = new_attachment_stream(o, oc, -1);
1944 ost->stream_copy = 0;
1945 ost->attachment_filename = o->attachments[i];
1947 ost->st->codec->extradata = attachment;
1948 ost->st->codec->extradata_size = len;
1950 p = strrchr(o->attachments[i], '/');
1951 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1955 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1956 AVDictionaryEntry *e;
1957 ost = output_streams[i];
1959 if ((ost->stream_copy || ost->attachment_filename)
1960 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1961 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1962 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1966 /* check if all codec options have been used */
1967 unused_opts = strip_specifiers(o->g->codec_opts);
1968 for (i = of->ost_index; i < nb_output_streams; i++) {
1970 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1971 AV_DICT_IGNORE_SUFFIX)))
1972 av_dict_set(&unused_opts, e->key, NULL, 0);
1976 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1977 const AVClass *class = avcodec_get_class();
1978 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1979 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1982 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1983 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1984 "output file #%d (%s) is not an encoding option.\n", e->key,
1985 option->help ? option->help : "", nb_output_files - 1,
1990 // gop_timecode is injected by generic code but not always used
1991 if (!strcmp(e->key, "gop_timecode"))
1994 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1995 "output file #%d (%s) has not been used for any stream. The most "
1996 "likely reason is either wrong type (e.g. a video option with "
1997 "no video streams) or that it is a private option of some encoder "
1998 "which was not actually used for any stream.\n", e->key,
1999 option->help ? option->help : "", nb_output_files - 1, filename);
2001 av_dict_free(&unused_opts);
2003 /* check filename in case of an image number is expected */
2004 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2005 if (!av_filename_number_test(oc->filename)) {
2006 print_error(oc->filename, AVERROR(EINVAL));
2011 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2012 /* test if it already exists to avoid losing precious files */
2013 assert_file_overwrite(filename);
2016 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2017 &oc->interrupt_callback,
2019 print_error(filename, err);
2022 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2023 assert_file_overwrite(filename);
2025 if (o->mux_preload) {
2027 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
2028 av_dict_set(&of->opts, "preload", buf, 0);
2030 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2033 for (i = 0; i < o->nb_metadata_map; i++) {
2035 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2037 if (in_file_index >= nb_input_files) {
2038 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2041 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2042 in_file_index >= 0 ?
2043 input_files[in_file_index]->ctx : NULL, o);
2047 if (o->chapters_input_file >= nb_input_files) {
2048 if (o->chapters_input_file == INT_MAX) {
2049 /* copy chapters from the first input file that has them*/
2050 o->chapters_input_file = -1;
2051 for (i = 0; i < nb_input_files; i++)
2052 if (input_files[i]->ctx->nb_chapters) {
2053 o->chapters_input_file = i;
2057 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2058 o->chapters_input_file);
2062 if (o->chapters_input_file >= 0)
2063 copy_chapters(input_files[o->chapters_input_file], of,
2064 !o->metadata_chapters_manual);
2066 /* copy global metadata by default */
2067 if (!o->metadata_global_manual && nb_input_files){
2068 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2069 AV_DICT_DONT_OVERWRITE);
2070 if(o->recording_time != INT64_MAX)
2071 av_dict_set(&oc->metadata, "duration", NULL, 0);
2072 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2074 if (!o->metadata_streams_manual)
2075 for (i = of->ost_index; i < nb_output_streams; i++) {
2077 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2079 ist = input_streams[output_streams[i]->source_index];
2080 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2081 if (!output_streams[i]->stream_copy)
2082 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2085 /* process manually set metadata */
2086 for (i = 0; i < o->nb_metadata; i++) {
2089 const char *stream_spec;
2090 int index = 0, j, ret = 0;
2092 val = strchr(o->metadata[i].u.str, '=');
2094 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2095 o->metadata[i].u.str);
2100 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2102 for (j = 0; j < oc->nb_streams; j++) {
2103 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2104 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2115 if (index < 0 || index >= oc->nb_chapters) {
2116 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2119 m = &oc->chapters[index]->metadata;
2122 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2125 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2132 static int opt_target(void *optctx, const char *opt, const char *arg)
2134 OptionsContext *o = optctx;
2135 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2136 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2138 if (!strncmp(arg, "pal-", 4)) {
2141 } else if (!strncmp(arg, "ntsc-", 5)) {
2144 } else if (!strncmp(arg, "film-", 5)) {
2148 /* Try to determine PAL/NTSC by peeking in the input files */
2149 if (nb_input_files) {
2151 for (j = 0; j < nb_input_files; j++) {
2152 for (i = 0; i < input_files[j]->nb_streams; i++) {
2153 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2154 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2156 fr = c->time_base.den * 1000 / c->time_base.num;
2160 } else if ((fr == 29970) || (fr == 23976)) {
2165 if (norm != UNKNOWN)
2169 if (norm != UNKNOWN)
2170 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2173 if (norm == UNKNOWN) {
2174 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2175 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2176 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2180 if (!strcmp(arg, "vcd")) {
2181 opt_video_codec(o, "c:v", "mpeg1video");
2182 opt_audio_codec(o, "c:a", "mp2");
2183 parse_option(o, "f", "vcd", options);
2185 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2186 parse_option(o, "r", frame_rates[norm], options);
2187 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2189 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2190 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2191 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2192 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2194 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2195 parse_option(o, "ar", "44100", options);
2196 parse_option(o, "ac", "2", options);
2198 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2199 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2201 /* We have to offset the PTS, so that it is consistent with the SCR.
2202 SCR starts at 36000, but the first two packs contain only padding
2203 and the first pack from the other stream, respectively, may also have
2204 been written before.
2205 So the real data starts at SCR 36000+3*1200. */
2206 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2207 } else if (!strcmp(arg, "svcd")) {
2209 opt_video_codec(o, "c:v", "mpeg2video");
2210 opt_audio_codec(o, "c:a", "mp2");
2211 parse_option(o, "f", "svcd", options);
2213 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2214 parse_option(o, "r", frame_rates[norm], options);
2215 parse_option(o, "pix_fmt", "yuv420p", options);
2216 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2218 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2219 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2220 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2221 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2222 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2224 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2225 parse_option(o, "ar", "44100", options);
2227 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2229 } else if (!strcmp(arg, "dvd")) {
2231 opt_video_codec(o, "c:v", "mpeg2video");
2232 opt_audio_codec(o, "c:a", "ac3");
2233 parse_option(o, "f", "dvd", options);
2235 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2236 parse_option(o, "r", frame_rates[norm], options);
2237 parse_option(o, "pix_fmt", "yuv420p", options);
2238 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2240 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2241 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2242 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2243 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2245 av_dict_set(&o->g->format_opts, "packetsize", "2048", AV_DICT_DONT_OVERWRITE); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2246 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2248 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2249 parse_option(o, "ar", "48000", options);
2251 } else if (!strncmp(arg, "dv", 2)) {
2253 parse_option(o, "f", "dv", options);
2255 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2256 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2257 norm == PAL ? "yuv420p" : "yuv411p", options);
2258 parse_option(o, "r", frame_rates[norm], options);
2260 parse_option(o, "ar", "48000", options);
2261 parse_option(o, "ac", "2", options);
2264 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2265 return AVERROR(EINVAL);
2270 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2272 av_free (vstats_filename);
2273 vstats_filename = av_strdup (arg);
2277 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2280 time_t today2 = time(NULL);
2281 struct tm *today = localtime(&today2);
2283 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2285 return opt_vstats_file(NULL, opt, filename);
2288 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2290 OptionsContext *o = optctx;
2291 return parse_option(o, "frames:v", arg, options);
2294 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2296 OptionsContext *o = optctx;
2297 return parse_option(o, "frames:a", arg, options);
2300 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2302 OptionsContext *o = optctx;
2303 return parse_option(o, "frames:d", arg, options);
2306 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2309 AVDictionary *cbak = codec_opts;
2310 AVDictionary *fbak = format_opts;
2314 ret = opt_default(NULL, opt, arg);
2316 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2317 av_dict_copy(&o->g->format_opts, format_opts, 0);
2318 av_dict_free(&codec_opts);
2319 av_dict_free(&format_opts);
2326 static int opt_preset(void *optctx, const char *opt, const char *arg)
2328 OptionsContext *o = optctx;
2330 char filename[1000], line[1000], tmp_line[1000];
2331 const char *codec_name = NULL;
2335 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2337 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2338 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2339 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2341 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2345 while (fgets(line, sizeof(line), f)) {
2346 char *key = tmp_line, *value, *endptr;
2348 if (strcspn(line, "#\n\r") == 0)
2350 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2351 if (!av_strtok(key, "=", &value) ||
2352 !av_strtok(value, "\r\n", &endptr)) {
2353 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2356 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2358 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2359 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2360 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2361 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2362 else if (opt_default_new(o, key, value) < 0) {
2363 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2364 filename, line, key, value);
2374 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2376 OptionsContext *o = optctx;
2377 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2378 int ret = parse_option(o, s, arg, options);
2383 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2385 OptionsContext *o = optctx;
2386 if(!strcmp(opt, "b")){
2387 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2388 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2391 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2395 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2397 OptionsContext *o = optctx;
2400 if(!strcmp(opt, "qscale")){
2401 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2402 return parse_option(o, "q:v", arg, options);
2404 s = av_asprintf("q%s", opt + 6);
2405 ret = parse_option(o, s, arg, options);
2410 static int opt_profile(void *optctx, const char *opt, const char *arg)
2412 OptionsContext *o = optctx;
2413 if(!strcmp(opt, "profile")){
2414 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2415 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2418 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2422 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2424 OptionsContext *o = optctx;
2425 return parse_option(o, "filter:v", arg, options);
2428 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2430 OptionsContext *o = optctx;
2431 return parse_option(o, "filter:a", arg, options);
2434 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2436 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2437 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2438 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2439 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2441 if (video_sync_method == VSYNC_AUTO)
2442 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2446 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2448 OptionsContext *o = optctx;
2449 char *tcr = av_asprintf("timecode=%s", arg);
2450 int ret = parse_option(o, "metadata:g", tcr, options);
2452 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2457 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2459 OptionsContext *o = optctx;
2460 char layout_str[32];
2463 int ret, channels, ac_str_size;
2466 layout = av_get_channel_layout(arg);
2468 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2469 return AVERROR(EINVAL);
2471 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2472 ret = opt_default_new(o, opt, layout_str);
2476 /* set 'ac' option based on channel layout */
2477 channels = av_get_channel_layout_nb_channels(layout);
2478 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2479 stream_str = strchr(opt, ':');
2480 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2481 ac_str = av_mallocz(ac_str_size);
2483 return AVERROR(ENOMEM);
2484 av_strlcpy(ac_str, "ac", 3);
2486 av_strlcat(ac_str, stream_str, ac_str_size);
2487 ret = parse_option(o, ac_str, layout_str, options);
2493 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2495 OptionsContext *o = optctx;
2496 return parse_option(o, "q:a", arg, options);
2499 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2501 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2502 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2503 return AVERROR(ENOMEM);
2504 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2505 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2506 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2507 return AVERROR(ENOMEM);
2511 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2513 uint8_t *graph_desc = read_file(arg);
2515 return AVERROR(EINVAL);
2517 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2518 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2519 return AVERROR(ENOMEM);
2520 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2521 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2525 void show_help_default(const char *opt, const char *arg)
2527 /* per-file options have at least one of those set */
2528 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2529 int show_advanced = 0, show_avoptions = 0;
2532 if (!strcmp(opt, "long"))
2534 else if (!strcmp(opt, "full"))
2535 show_advanced = show_avoptions = 1;
2537 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2542 printf("Getting help:\n"
2543 " -h -- print basic options\n"
2544 " -h long -- print more options\n"
2545 " -h full -- print all options (including all format and codec specific options, very long)\n"
2546 " See man %s for detailed description of the options.\n"
2547 "\n", program_name);
2549 show_help_options(options, "Print help / information / capabilities:",
2552 show_help_options(options, "Global options (affect whole program "
2553 "instead of just one file:",
2554 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2556 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2557 per_file | OPT_EXIT, 0);
2559 show_help_options(options, "Per-file main options:", 0,
2560 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2561 OPT_EXIT, per_file);
2563 show_help_options(options, "Advanced per-file options:",
2564 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2566 show_help_options(options, "Video options:",
2567 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2569 show_help_options(options, "Advanced Video options:",
2570 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2572 show_help_options(options, "Audio options:",
2573 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2575 show_help_options(options, "Advanced Audio options:",
2576 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2577 show_help_options(options, "Subtitle options:",
2578 OPT_SUBTITLE, 0, 0);
2581 if (show_avoptions) {
2582 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2583 show_help_children(avcodec_get_class(), flags);
2584 show_help_children(avformat_get_class(), flags);
2586 show_help_children(sws_get_class(), flags);
2588 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2589 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2593 void show_usage(void)
2595 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2596 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2597 av_log(NULL, AV_LOG_INFO, "\n");
2605 static const OptionGroupDef groups[] = {
2606 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2607 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2610 static int open_files(OptionGroupList *l, const char *inout,
2611 int (*open_file)(OptionsContext*, const char*))
2615 for (i = 0; i < l->nb_groups; i++) {
2616 OptionGroup *g = &l->groups[i];
2622 ret = parse_optgroup(&o, g);
2624 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2625 "%s.\n", inout, g->arg);
2629 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2630 ret = open_file(&o, g->arg);
2633 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2637 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2643 int ffmpeg_parse_options(int argc, char **argv)
2645 OptionParseContext octx;
2649 memset(&octx, 0, sizeof(octx));
2651 /* split the commandline into an internal representation */
2652 ret = split_commandline(&octx, argc, argv, options, groups,
2653 FF_ARRAY_ELEMS(groups));
2655 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2659 /* apply global options */
2660 ret = parse_optgroup(NULL, &octx.global_opts);
2662 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2666 /* open input files */
2667 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2669 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2673 /* open output files */
2674 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2676 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2681 uninit_parse_context(&octx);
2683 av_strerror(ret, error, sizeof(error));
2684 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2689 static int opt_progress(void *optctx, const char *opt, const char *arg)
2691 AVIOContext *avio = NULL;
2694 if (!strcmp(arg, "-"))
2696 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2698 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2699 arg, av_err2str(ret));
2702 progress_avio = avio;
2706 #define OFFSET(x) offsetof(OptionsContext, x)
2707 const OptionDef options[] = {
2709 #include "cmdutils_common_opts.h"
2710 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2711 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2712 "force format", "fmt" },
2713 { "y", OPT_BOOL, { &file_overwrite },
2714 "overwrite output files" },
2715 { "n", OPT_BOOL, { &no_file_overwrite },
2716 "never overwrite output files" },
2717 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2718 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2719 "codec name", "codec" },
2720 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2721 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2722 "codec name", "codec" },
2723 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2724 OPT_OUTPUT, { .off = OFFSET(presets) },
2725 "preset name", "preset" },
2726 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2727 OPT_OUTPUT, { .func_arg = opt_map },
2728 "set input stream mapping",
2729 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2730 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2731 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2732 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2733 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2734 "set metadata information of outfile from infile",
2735 "outfile[,metadata]:infile[,metadata]" },
2736 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2737 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2738 "set chapters mapping", "input_file_index" },
2739 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2740 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2741 "record or transcode \"duration\" seconds of audio/video",
2743 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2744 "record or transcode stop time", "time_stop" },
2745 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2746 "set the limit file size in bytes", "limit_size" },
2747 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2748 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2749 "set the start time offset", "time_off" },
2750 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2751 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2752 "enable/disable accurate seeking with -ss" },
2753 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2754 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2755 "set the input ts offset", "time_off" },
2756 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2757 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2758 "set the input ts scale", "scale" },
2759 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2760 "set the recording timestamp ('now' to set the current time)", "time" },
2761 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2762 "add metadata", "string=string" },
2763 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2764 OPT_OUTPUT, { .func_arg = opt_data_frames },
2765 "set the number of data frames to record", "number" },
2766 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2767 "add timings for benchmarking" },
2768 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2769 "add timings for each task" },
2770 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2771 "write program-readable progress information", "url" },
2772 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2773 "enable or disable interaction on standard input" },
2774 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2775 "set max runtime in seconds", "limit" },
2776 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2777 "dump each input packet" },
2778 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2779 "when dumping packets, also dump the payload" },
2780 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2781 OPT_INPUT, { .off = OFFSET(rate_emu) },
2782 "read input at native frame rate", "" },
2783 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2784 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2785 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2786 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2787 "video sync method", "" },
2788 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2789 "audio sync method", "" },
2790 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2791 "audio drift threshold", "threshold" },
2792 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2793 "copy timestamps" },
2794 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2795 "copy input stream time base when stream copying", "mode" },
2796 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2797 OPT_OUTPUT, { .off = OFFSET(shortest) },
2798 "finish encoding within shortest input" },
2799 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2800 OPT_OUTPUT, { .off = OFFSET(apad) },
2802 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2803 "timestamp discontinuity delta threshold", "threshold" },
2804 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2805 "timestamp error delta threshold", "threshold" },
2806 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2807 "exit on error", "error" },
2808 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2809 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2810 "copy initial non-keyframes" },
2811 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2812 "copy or discard frames before start time" },
2813 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2814 "set the number of frames to record", "number" },
2815 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2816 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2817 "force codec tag/fourcc", "fourcc/tag" },
2818 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2819 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2820 "use fixed quality scale (VBR)", "q" },
2821 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2822 OPT_OUTPUT, { .func_arg = opt_qscale },
2823 "use fixed quality scale (VBR)", "q" },
2824 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2825 "set profile", "profile" },
2826 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2827 "set stream filtergraph", "filter_graph" },
2828 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2829 "read stream filtergraph description from a file", "filename" },
2830 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2831 "reinit filtergraph on input parameter changes", "" },
2832 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2833 "create a complex filtergraph", "graph_description" },
2834 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2835 "create a complex filtergraph", "graph_description" },
2836 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2837 "read complex filtergraph description from a file", "filename" },
2838 { "stats", OPT_BOOL, { &print_stats },
2839 "print progress report during encoding", },
2840 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2841 OPT_OUTPUT, { .func_arg = opt_attach },
2842 "add an attachment to the output file", "filename" },
2843 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2844 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2845 "extract an attachment into a file", "filename" },
2846 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2847 "print timestamp debugging info" },
2848 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2849 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2852 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2853 "set the number of video frames to record", "number" },
2854 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2855 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2856 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2857 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2858 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2859 "set frame size (WxH or abbreviation)", "size" },
2860 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2861 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2862 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2863 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2864 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2865 "set pixel format", "format" },
2866 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2867 "set the number of bits per raw sample", "number" },
2868 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2869 "deprecated use -g 1" },
2870 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2872 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2873 "discard threshold", "n" },
2874 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2875 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2876 "rate control override for specific intervals", "override" },
2877 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2878 OPT_OUTPUT, { .func_arg = opt_video_codec },
2879 "force video codec ('copy' to copy stream)", "codec" },
2880 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2882 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2884 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2885 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2886 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2887 "select the pass number (1 to 3)", "n" },
2888 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2889 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2890 "select two pass log file name prefix", "prefix" },
2891 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2892 "this option is deprecated, use the yadif filter instead" },
2893 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2894 "calculate PSNR of compressed frames" },
2895 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2896 "dump video coding statistics to file" },
2897 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2898 "dump video coding statistics to file", "file" },
2899 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2900 "set video filters", "filter_graph" },
2901 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2902 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2903 "specify intra matrix coeffs", "matrix" },
2904 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2905 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2906 "specify inter matrix coeffs", "matrix" },
2907 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2908 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2909 "specify intra matrix coeffs", "matrix" },
2910 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2911 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2912 "top=1/bottom=0/auto=-1 field first", "" },
2913 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2914 "intra_dc_precision", "precision" },
2915 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2916 OPT_OUTPUT, { .func_arg = opt_old2new },
2917 "force video tag/fourcc", "fourcc/tag" },
2918 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2919 "show QP histogram" },
2920 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2921 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2922 "force the selected framerate, disable the best supported framerate selection" },
2923 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2924 OPT_OUTPUT, { .func_arg = opt_streamid },
2925 "set the value of an outfile streamid", "streamIndex:value" },
2926 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2927 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2928 "force key frames at specified timestamps", "timestamps" },
2929 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2930 "video bitrate (please use -b:v)", "bitrate" },
2931 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2932 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2933 "use HW accelerated decoding", "hwaccel name" },
2934 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2935 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2936 "select a device for HW acceleration" "devicename" },
2939 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2940 "set the number of audio frames to record", "number" },
2941 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2942 "set audio quality (codec-specific)", "quality", },
2943 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2944 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2945 "set audio sampling rate (in Hz)", "rate" },
2946 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2947 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2948 "set number of audio channels", "channels" },
2949 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2951 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2952 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2953 "force audio codec ('copy' to copy stream)", "codec" },
2954 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2955 OPT_OUTPUT, { .func_arg = opt_old2new },
2956 "force audio tag/fourcc", "fourcc/tag" },
2957 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2958 "change audio volume (256=normal)" , "volume" },
2959 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2960 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2961 "set sample format", "format" },
2962 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2963 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2964 "set channel layout", "layout" },
2965 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2966 "set audio filters", "filter_graph" },
2967 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2968 "set the maximum number of channels to try to guess the channel layout" },
2970 /* subtitle options */
2971 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2972 "disable subtitle" },
2973 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2974 "force subtitle codec ('copy' to copy stream)", "codec" },
2975 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2976 , "force subtitle tag/fourcc", "fourcc/tag" },
2977 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2978 "fix subtitles duration" },
2979 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2980 "set canvas size (WxH or abbreviation)", "size" },
2983 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2984 "deprecated, use -channel", "channel" },
2985 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2986 "deprecated, use -standard", "standard" },
2987 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2990 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2991 "set the maximum demux-decode delay", "seconds" },
2992 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2993 "set the initial demux-decode delay", "seconds" },
2994 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2995 "override the options from ffserver", "" },
2997 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2998 "A comma-separated list of bitstream filters", "bitstream_filters" },
2999 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3000 "deprecated", "audio bitstream_filters" },
3001 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3002 "deprecated", "video bitstream_filters" },
3004 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3005 "set the audio options to the indicated preset", "preset" },
3006 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3007 "set the video options to the indicated preset", "preset" },
3008 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3009 "set the subtitle options to the indicated preset", "preset" },
3010 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3011 "set options from indicated preset file", "filename" },
3012 /* data codec support */
3013 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3014 "force data codec ('copy' to copy stream)", "codec" },
3015 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },