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"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 for (i = 0; i < o->nb_ ## name; i++) {\
61 char *spec = o->name[i].specifier;\
62 if (!strcmp(spec, mediatype))\
63 outvar = o->name[i].u.type;\
66 char *vstats_filename;
68 float audio_drift_threshold = 0.1;
69 float dts_delta_threshold = 10;
70 float dts_error_threshold = 3600*30;
72 int audio_volume = 256;
73 int audio_sync_method = 0;
74 int video_sync_method = VSYNC_AUTO;
75 int do_deinterlace = 0;
77 int do_benchmark_all = 0;
83 int exit_on_error = 0;
86 int stdin_interaction = 1;
87 int frame_bits_per_raw_sample = 0;
90 static int intra_only = 0;
91 static int file_overwrite = 0;
92 static int no_file_overwrite = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int do_psnr = 0;
96 static int input_sync;
98 static int64_t recording_time = INT64_MAX;
100 static void uninit_options(OptionsContext *o, int is_input)
102 const OptionDef *po = options;
105 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
107 void *dst = (uint8_t*)o + po->u.off;
109 if (po->flags & OPT_SPEC) {
110 SpecifierOpt **so = dst;
111 int i, *count = (int*)(so + 1);
112 for (i = 0; i < *count; i++) {
113 av_freep(&(*so)[i].specifier);
114 if (po->flags & OPT_STRING)
115 av_freep(&(*so)[i].u.str);
119 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
124 for (i = 0; i < o->nb_stream_maps; i++)
125 av_freep(&o->stream_maps[i].linklabel);
126 av_freep(&o->stream_maps);
127 av_freep(&o->audio_channel_maps);
128 av_freep(&o->streamid_map);
129 av_freep(&o->attachments);
132 recording_time = o->recording_time;
134 recording_time = INT64_MAX;
137 static void init_options(OptionsContext *o, int is_input)
139 memset(o, 0, sizeof(*o));
141 if (!is_input && recording_time != INT64_MAX) {
142 o->recording_time = recording_time;
143 av_log(NULL, AV_LOG_WARNING,
144 "-t is not an input option, keeping it for the next output;"
145 " consider fixing your command line.\n");
147 o->recording_time = INT64_MAX;
148 o->stop_time = INT64_MAX;
149 o->mux_max_delay = 0.7;
150 o->limit_filesize = UINT64_MAX;
151 o->chapters_input_file = INT_MAX;
154 /* return a copy of the input with the stream specifiers removed from the keys */
155 static AVDictionary *strip_specifiers(AVDictionary *dict)
157 AVDictionaryEntry *e = NULL;
158 AVDictionary *ret = NULL;
160 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
161 char *p = strchr(e->key, ':');
165 av_dict_set(&ret, e->key, e->value, 0);
172 static int opt_sameq(void *optctx, const char *opt, const char *arg)
174 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
175 "If you are looking for an option to preserve the quality (which is not "
176 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
178 return AVERROR(EINVAL);
181 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
183 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
184 return opt_default(optctx, "channel", arg);
187 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
189 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
190 return opt_default(optctx, "standard", arg);
193 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
195 OptionsContext *o = optctx;
196 return parse_option(o, "codec:a", arg, options);
199 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
201 OptionsContext *o = optctx;
202 return parse_option(o, "codec:v", arg, options);
205 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
207 OptionsContext *o = optctx;
208 return parse_option(o, "codec:s", arg, options);
211 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
213 OptionsContext *o = optctx;
214 return parse_option(o, "codec:d", arg, options);
217 static int opt_map(void *optctx, const char *opt, const char *arg)
219 OptionsContext *o = optctx;
221 int i, negative = 0, file_idx;
222 int sync_file_idx = -1, sync_stream_idx = 0;
230 map = av_strdup(arg);
232 /* parse sync stream first, just pick first matching stream */
233 if (sync = strchr(map, ',')) {
235 sync_file_idx = strtol(sync + 1, &sync, 0);
236 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
237 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
242 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
243 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
244 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
248 if (i == input_files[sync_file_idx]->nb_streams) {
249 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
250 "match any streams.\n", arg);
257 /* this mapping refers to lavfi output */
258 const char *c = map + 1;
259 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
260 m = &o->stream_maps[o->nb_stream_maps - 1];
261 m->linklabel = av_get_token(&c, "]");
263 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
267 file_idx = strtol(map, &p, 0);
268 if (file_idx >= nb_input_files || file_idx < 0) {
269 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
273 /* disable some already defined maps */
274 for (i = 0; i < o->nb_stream_maps; i++) {
275 m = &o->stream_maps[i];
276 if (file_idx == m->file_index &&
277 check_stream_specifier(input_files[m->file_index]->ctx,
278 input_files[m->file_index]->ctx->streams[m->stream_index],
279 *p == ':' ? p + 1 : p) > 0)
283 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
284 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
285 *p == ':' ? p + 1 : p) <= 0)
287 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
288 m = &o->stream_maps[o->nb_stream_maps - 1];
290 m->file_index = file_idx;
293 if (sync_file_idx >= 0) {
294 m->sync_file_index = sync_file_idx;
295 m->sync_stream_index = sync_stream_idx;
297 m->sync_file_index = file_idx;
298 m->sync_stream_index = i;
304 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
312 static int opt_attach(void *optctx, const char *opt, const char *arg)
314 OptionsContext *o = optctx;
315 GROW_ARRAY(o->attachments, o->nb_attachments);
316 o->attachments[o->nb_attachments - 1] = arg;
320 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
322 OptionsContext *o = optctx;
327 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
328 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
330 /* muted channel syntax */
331 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
332 if ((n == 1 || n == 3) && m->channel_idx == -1) {
333 m->file_idx = m->stream_idx = -1;
335 m->ofile_idx = m->ostream_idx = -1;
340 n = sscanf(arg, "%d.%d.%d:%d.%d",
341 &m->file_idx, &m->stream_idx, &m->channel_idx,
342 &m->ofile_idx, &m->ostream_idx);
344 if (n != 3 && n != 5) {
345 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
346 "[file.stream.channel|-1][:syncfile:syncstream]\n");
350 if (n != 5) // only file.stream.channel specified
351 m->ofile_idx = m->ostream_idx = -1;
354 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
355 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
359 if (m->stream_idx < 0 ||
360 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
361 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
362 m->file_idx, m->stream_idx);
365 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
366 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
367 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
368 m->file_idx, m->stream_idx);
371 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
372 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
373 m->file_idx, m->stream_idx, m->channel_idx);
380 * Parse a metadata specifier passed as 'arg' parameter.
381 * @param arg metadata string to parse
382 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
383 * @param index for type c/p, chapter/program index is written here
384 * @param stream_spec for type s, the stream specifier is written here
386 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
394 if (*(++arg) && *arg != ':') {
395 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
398 *stream_spec = *arg == ':' ? arg + 1 : "";
403 *index = strtol(++arg, NULL, 0);
406 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
413 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
415 AVDictionary **meta_in = NULL;
416 AVDictionary **meta_out = NULL;
418 char type_in, type_out;
419 const char *istream_spec = NULL, *ostream_spec = NULL;
420 int idx_in = 0, idx_out = 0;
422 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
423 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
426 if (type_out == 'g' || !*outspec)
427 o->metadata_global_manual = 1;
428 if (type_out == 's' || !*outspec)
429 o->metadata_streams_manual = 1;
430 if (type_out == 'c' || !*outspec)
431 o->metadata_chapters_manual = 1;
435 if (type_in == 'g' || type_out == 'g')
436 o->metadata_global_manual = 1;
437 if (type_in == 's' || type_out == 's')
438 o->metadata_streams_manual = 1;
439 if (type_in == 'c' || type_out == 'c')
440 o->metadata_chapters_manual = 1;
442 /* ic is NULL when just disabling automatic mappings */
446 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
447 if ((index) < 0 || (index) >= (nb_elems)) {\
448 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
453 #define SET_DICT(type, meta, context, index)\
456 meta = &context->metadata;\
459 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
460 meta = &context->chapters[index]->metadata;\
463 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
464 meta = &context->programs[index]->metadata;\
467 break; /* handled separately below */ \
468 default: av_assert0(0);\
471 SET_DICT(type_in, meta_in, ic, idx_in);
472 SET_DICT(type_out, meta_out, oc, idx_out);
474 /* for input streams choose first matching stream */
475 if (type_in == 's') {
476 for (i = 0; i < ic->nb_streams; i++) {
477 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
478 meta_in = &ic->streams[i]->metadata;
484 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
489 if (type_out == 's') {
490 for (i = 0; i < oc->nb_streams; i++) {
491 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
492 meta_out = &oc->streams[i]->metadata;
493 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
498 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
503 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
505 OptionsContext *o = optctx;
507 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
508 struct tm time = *gmtime((time_t*)&recording_timestamp);
509 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
510 parse_option(o, "metadata", buf, options);
512 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
513 "tag instead.\n", opt);
517 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
519 const AVCodecDescriptor *desc;
520 const char *codec_string = encoder ? "encoder" : "decoder";
524 avcodec_find_encoder_by_name(name) :
525 avcodec_find_decoder_by_name(name);
527 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
528 codec = encoder ? avcodec_find_encoder(desc->id) :
529 avcodec_find_decoder(desc->id);
531 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
532 codec_string, codec->name, desc->name);
536 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
539 if (codec->type != type) {
540 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
546 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
548 char *codec_name = NULL;
550 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
552 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
553 st->codec->codec_id = codec->id;
556 return avcodec_find_decoder(st->codec->codec_id);
559 /* Add all the streams from the given input file to the global
560 * list of input streams. */
561 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
564 char *next, *codec_tag = NULL;
566 for (i = 0; i < ic->nb_streams; i++) {
567 AVStream *st = ic->streams[i];
568 AVCodecContext *dec = st->codec;
569 InputStream *ist = av_mallocz(sizeof(*ist));
570 char *framerate = NULL;
575 GROW_ARRAY(input_streams, nb_input_streams);
576 input_streams[nb_input_streams - 1] = ist;
579 ist->file_index = nb_input_files;
581 st->discard = AVDISCARD_ALL;
584 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
586 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
588 uint32_t tag = strtol(codec_tag, &next, 0);
590 tag = AV_RL32(codec_tag);
591 st->codec->codec_tag = tag;
594 ist->dec = choose_decoder(o, ic, st);
595 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
597 ist->reinit_filters = -1;
598 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
600 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
602 switch (dec->codec_type) {
603 case AVMEDIA_TYPE_VIDEO:
605 ist->dec = avcodec_find_decoder(dec->codec_id);
607 dec->flags |= CODEC_FLAG_EMU_EDGE;
610 ist->resample_height = dec->height;
611 ist->resample_width = dec->width;
612 ist->resample_pix_fmt = dec->pix_fmt;
614 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
615 if (framerate && av_parse_video_rate(&ist->framerate,
617 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
622 ist->top_field_first = -1;
623 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
626 case AVMEDIA_TYPE_AUDIO:
627 ist->guess_layout_max = INT_MAX;
628 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
629 guess_input_channel_layout(ist);
631 ist->resample_sample_fmt = dec->sample_fmt;
632 ist->resample_sample_rate = dec->sample_rate;
633 ist->resample_channels = dec->channels;
634 ist->resample_channel_layout = dec->channel_layout;
637 case AVMEDIA_TYPE_DATA:
638 case AVMEDIA_TYPE_SUBTITLE: {
639 char *canvas_size = NULL;
641 ist->dec = avcodec_find_decoder(dec->codec_id);
642 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
643 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
645 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
646 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
651 case AVMEDIA_TYPE_ATTACHMENT:
652 case AVMEDIA_TYPE_UNKNOWN:
660 static void assert_file_overwrite(const char *filename)
662 if ((!file_overwrite || no_file_overwrite) &&
663 (strchr(filename, ':') == NULL || filename[1] == ':' ||
664 av_strstart(filename, "file:", NULL))) {
665 if (avio_check(filename, 0) == 0) {
666 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
667 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
670 signal(SIGINT, SIG_DFL);
672 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
678 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
685 static void dump_attachment(AVStream *st, const char *filename)
688 AVIOContext *out = NULL;
689 AVDictionaryEntry *e;
691 if (!st->codec->extradata_size) {
692 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
693 nb_input_files - 1, st->index);
696 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
699 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
700 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
704 assert_file_overwrite(filename);
706 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
707 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
712 avio_write(out, st->codec->extradata, st->codec->extradata_size);
717 static int open_input_file(OptionsContext *o, const char *filename)
721 AVInputFormat *file_iformat = NULL;
726 AVDictionary *unused_opts = NULL;
727 AVDictionaryEntry *e = NULL;
728 int orig_nb_streams; // number of streams before avformat_find_stream_info
729 char * video_codec_name = NULL;
730 char * audio_codec_name = NULL;
731 char *subtitle_codec_name = NULL;
734 if (!(file_iformat = av_find_input_format(o->format))) {
735 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
740 if (!strcmp(filename, "-"))
743 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
744 strcmp(filename, "/dev/stdin");
746 /* get default parameters from command line */
747 ic = avformat_alloc_context();
749 print_error(filename, AVERROR(ENOMEM));
752 if (o->nb_audio_sample_rate) {
753 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
754 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
756 if (o->nb_audio_channels) {
757 /* because we set audio_channels based on both the "ac" and
758 * "channel_layout" options, we need to check that the specified
759 * demuxer actually has the "channels" option before setting it */
760 if (file_iformat && file_iformat->priv_class &&
761 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
762 AV_OPT_SEARCH_FAKE_OBJ)) {
763 snprintf(buf, sizeof(buf), "%d",
764 o->audio_channels[o->nb_audio_channels - 1].u.i);
765 av_dict_set(&o->g->format_opts, "channels", buf, 0);
768 if (o->nb_frame_rates) {
769 /* set the format-level framerate option;
770 * this is important for video grabbers, e.g. x11 */
771 if (file_iformat && file_iformat->priv_class &&
772 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
773 AV_OPT_SEARCH_FAKE_OBJ)) {
774 av_dict_set(&o->g->format_opts, "framerate",
775 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
778 if (o->nb_frame_sizes) {
779 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
781 if (o->nb_frame_pix_fmts)
782 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
784 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
785 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
786 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
788 ic->video_codec_id = video_codec_name ?
789 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
790 ic->audio_codec_id = audio_codec_name ?
791 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
792 ic->subtitle_codec_id= subtitle_codec_name ?
793 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
794 ic->flags |= AVFMT_FLAG_NONBLOCK;
795 ic->interrupt_callback = int_cb;
797 /* open the input file with generic avformat function */
798 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
800 print_error(filename, err);
803 assert_avoptions(o->g->format_opts);
805 /* apply forced codec ids */
806 for (i = 0; i < ic->nb_streams; i++)
807 choose_decoder(o, ic, ic->streams[i]);
809 /* Set AVCodecContext options for avformat_find_stream_info */
810 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
811 orig_nb_streams = ic->nb_streams;
813 /* If not enough info to get the stream parameters, we decode the
814 first frames to get it. (used in mpeg case for example) */
815 ret = avformat_find_stream_info(ic, opts);
817 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
818 avformat_close_input(&ic);
822 timestamp = o->start_time;
823 /* add the stream start time */
824 if (ic->start_time != AV_NOPTS_VALUE)
825 timestamp += ic->start_time;
827 /* if seeking requested, we execute it */
828 if (o->start_time != 0) {
829 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
831 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
832 filename, (double)timestamp / AV_TIME_BASE);
836 /* update the current parameters so that they match the one of the input stream */
837 add_input_streams(o, ic);
839 /* dump the file content */
840 av_dump_format(ic, nb_input_files, filename, 0);
842 GROW_ARRAY(input_files, nb_input_files);
843 f = av_mallocz(sizeof(*f));
846 input_files[nb_input_files - 1] = f;
849 f->ist_index = nb_input_streams - ic->nb_streams;
850 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
851 f->nb_streams = ic->nb_streams;
852 f->rate_emu = o->rate_emu;
854 /* check if all codec options have been used */
855 unused_opts = strip_specifiers(o->g->codec_opts);
856 for (i = f->ist_index; i < nb_input_streams; i++) {
858 while ((e = av_dict_get(input_streams[i]->opts, "", e,
859 AV_DICT_IGNORE_SUFFIX)))
860 av_dict_set(&unused_opts, e->key, NULL, 0);
864 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
865 const AVClass *class = avcodec_get_class();
866 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
867 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
870 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
871 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
872 "input file #%d (%s) is not a decoding option.\n", e->key,
873 option->help ? option->help : "", nb_input_files - 1,
878 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
879 "input file #%d (%s) has not been used for any stream. The most "
880 "likely reason is either wrong type (e.g. a video option with "
881 "no video streams) or that it is a private option of some decoder "
882 "which was not actually used for any stream.\n", e->key,
883 option->help ? option->help : "", nb_input_files - 1, filename);
885 av_dict_free(&unused_opts);
887 for (i = 0; i < o->nb_dump_attachment; i++) {
890 for (j = 0; j < ic->nb_streams; j++) {
891 AVStream *st = ic->streams[j];
893 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
894 dump_attachment(st, o->dump_attachment[i].u.str);
898 for (i = 0; i < orig_nb_streams; i++)
899 av_dict_free(&opts[i]);
905 static uint8_t *get_line(AVIOContext *s)
911 if (avio_open_dyn_buf(&line) < 0) {
912 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
916 while ((c = avio_r8(s)) && c != '\n')
919 avio_close_dyn_buf(line, &buf);
924 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
928 const char *base[3] = { getenv("AVCONV_DATADIR"),
933 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
937 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
938 i != 1 ? "" : "/.avconv", codec_name, preset_name);
939 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
942 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
943 i != 1 ? "" : "/.avconv", preset_name);
944 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
950 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
952 char *codec_name = NULL;
954 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
956 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
957 NULL, ost->st->codec->codec_type);
958 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
959 } else if (!strcmp(codec_name, "copy"))
960 ost->stream_copy = 1;
962 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
963 ost->st->codec->codec_id = ost->enc->id;
967 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
970 AVStream *st = avformat_new_stream(oc, NULL);
971 int idx = oc->nb_streams - 1, ret = 0;
972 char *bsf = NULL, *next, *codec_tag = NULL;
973 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
978 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
982 if (oc->nb_streams - 1 < o->nb_streamid_map)
983 st->id = o->streamid_map[oc->nb_streams - 1];
985 GROW_ARRAY(output_streams, nb_output_streams);
986 if (!(ost = av_mallocz(sizeof(*ost))))
988 output_streams[nb_output_streams - 1] = ost;
990 ost->file_index = nb_output_files;
993 st->codec->codec_type = type;
994 choose_encoder(o, oc, ost);
996 AVIOContext *s = NULL;
997 char *buf = NULL, *arg = NULL, *preset = NULL;
999 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1001 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1002 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1005 if (!buf[0] || buf[0] == '#') {
1009 if (!(arg = strchr(buf, '='))) {
1010 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1014 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1016 } while (!s->eof_reached);
1020 av_log(NULL, AV_LOG_FATAL,
1021 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1022 preset, ost->file_index, ost->index);
1026 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1029 avcodec_get_context_defaults3(st->codec, ost->enc);
1030 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1032 ost->max_frames = INT64_MAX;
1033 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1034 for (i = 0; i<o->nb_max_frames; i++) {
1035 char *p = o->max_frames[i].specifier;
1036 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1037 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1042 ost->copy_prior_start = -1;
1043 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1045 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1047 if (next = strchr(bsf, ','))
1049 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1050 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1054 bsfc_prev->next = bsfc;
1056 ost->bitstream_filters = bsfc;
1062 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1064 uint32_t tag = strtol(codec_tag, &next, 0);
1066 tag = AV_RL32(codec_tag);
1067 st->codec->codec_tag = tag;
1070 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1072 st->codec->flags |= CODEC_FLAG_QSCALE;
1073 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1076 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1077 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1079 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1081 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1082 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1083 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1085 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1087 ost->source_index = source_index;
1088 if (source_index >= 0) {
1089 ost->sync_ist = input_streams[source_index];
1090 input_streams[source_index]->discard = 0;
1091 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1097 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1100 const char *p = str;
1107 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1114 /* read file contents into a string */
1115 static uint8_t *read_file(const char *filename)
1117 AVIOContext *pb = NULL;
1118 AVIOContext *dyn_buf = NULL;
1119 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1120 uint8_t buf[1024], *str;
1123 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1127 ret = avio_open_dyn_buf(&dyn_buf);
1132 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1133 avio_write(dyn_buf, buf, ret);
1134 avio_w8(dyn_buf, 0);
1137 ret = avio_close_dyn_buf(dyn_buf, &str);
1143 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1146 AVStream *st = ost->st;
1147 char *filter = NULL, *filter_script = NULL;
1149 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1150 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1152 if (filter_script && filter) {
1153 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1154 "output stream #%d:%d.\n", nb_output_files, st->index);
1159 return read_file(filter_script);
1161 return av_strdup(filter);
1163 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1167 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1171 AVCodecContext *video_enc;
1172 char *frame_rate = NULL;
1174 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1176 video_enc = st->codec;
1178 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1179 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1180 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1184 if (!ost->stream_copy) {
1185 const char *p = NULL;
1186 char *frame_size = NULL;
1187 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1188 char *intra_matrix = NULL, *inter_matrix = NULL;
1192 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1193 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1194 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1198 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1199 if (frame_aspect_ratio) {
1201 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1202 q.num <= 0 || q.den <= 0) {
1203 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1206 ost->frame_aspect_ratio = q;
1209 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1210 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1211 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1212 ost->keep_pix_fmt = 1;
1213 if (!*++frame_pix_fmt)
1214 frame_pix_fmt = NULL;
1216 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1217 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1220 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1223 video_enc->gop_size = 0;
1224 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1226 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1227 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1230 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1232 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1234 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1235 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1238 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1241 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1242 for (i = 0; p; i++) {
1244 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1246 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1249 /* FIXME realloc failure */
1250 video_enc->rc_override =
1251 av_realloc(video_enc->rc_override,
1252 sizeof(RcOverride) * (i + 1));
1253 video_enc->rc_override[i].start_frame = start;
1254 video_enc->rc_override[i].end_frame = end;
1256 video_enc->rc_override[i].qscale = q;
1257 video_enc->rc_override[i].quality_factor = 1.0;
1260 video_enc->rc_override[i].qscale = 0;
1261 video_enc->rc_override[i].quality_factor = -q/100.0;
1266 video_enc->rc_override_count = i;
1267 video_enc->intra_dc_precision = intra_dc_precision - 8;
1270 video_enc->flags|= CODEC_FLAG_PSNR;
1273 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1276 video_enc->flags |= CODEC_FLAG_PASS1;
1277 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1280 video_enc->flags |= CODEC_FLAG_PASS2;
1281 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1285 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1286 if (ost->logfile_prefix &&
1287 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1290 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1291 if (ost->forced_keyframes)
1292 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1294 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1296 ost->top_field_first = -1;
1297 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1300 ost->avfilter = get_ost_filters(o, oc, ost);
1304 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1310 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1315 AVCodecContext *audio_enc;
1317 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1320 audio_enc = st->codec;
1321 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1323 if (!ost->stream_copy) {
1324 char *sample_fmt = NULL;
1326 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1328 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1330 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1331 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1335 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1337 ost->avfilter = get_ost_filters(o, oc, ost);
1341 /* check for channel mapping for this audio stream */
1342 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1343 AudioChannelMap *map = &o->audio_channel_maps[n];
1344 InputStream *ist = input_streams[ost->source_index];
1345 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1346 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1347 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1348 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1349 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1351 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1352 ost->file_index, ost->st->index);
1360 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1364 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1365 if (!ost->stream_copy) {
1366 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1373 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1375 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1376 ost->stream_copy = 1;
1381 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1385 AVCodecContext *subtitle_enc;
1387 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1389 subtitle_enc = st->codec;
1391 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1393 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1395 if (!ost->stream_copy) {
1396 char *frame_size = NULL;
1398 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1399 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1400 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1408 /* arg format is "output-stream-index:streamid-value". */
1409 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1411 OptionsContext *o = optctx;
1416 av_strlcpy(idx_str, arg, sizeof(idx_str));
1417 p = strchr(idx_str, ':');
1419 av_log(NULL, AV_LOG_FATAL,
1420 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1425 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1426 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1427 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1431 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1433 AVFormatContext *is = ifile->ctx;
1434 AVFormatContext *os = ofile->ctx;
1438 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1440 return AVERROR(ENOMEM);
1443 for (i = 0; i < is->nb_chapters; i++) {
1444 AVChapter *in_ch = is->chapters[i], *out_ch;
1445 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1446 AV_TIME_BASE_Q, in_ch->time_base);
1447 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1448 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1451 if (in_ch->end < ts_off)
1453 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1456 out_ch = av_mallocz(sizeof(AVChapter));
1458 return AVERROR(ENOMEM);
1460 out_ch->id = in_ch->id;
1461 out_ch->time_base = in_ch->time_base;
1462 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1463 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1466 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1468 os->chapters[os->nb_chapters++] = out_ch;
1473 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1476 AVFormatContext *ic = avformat_alloc_context();
1478 ic->interrupt_callback = int_cb;
1479 err = avformat_open_input(&ic, filename, NULL, NULL);
1482 /* copy stream format */
1483 for(i=0;i<ic->nb_streams;i++) {
1487 AVCodecContext *avctx;
1489 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1490 ost = new_output_stream(o, s, codec->type, -1);
1495 // FIXME: a more elegant solution is needed
1496 memcpy(st, ic->streams[i], sizeof(AVStream));
1498 st->info = av_malloc(sizeof(*st->info));
1499 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1501 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1503 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1504 choose_sample_fmt(st, codec);
1505 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1506 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1509 /* ffserver seeking with date=... needs a date reference */
1510 err = parse_option(o, "metadata", "creation_time=now", options);
1512 avformat_close_input(&ic);
1516 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1517 AVFormatContext *oc)
1521 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1522 ofilter->out_tmp->pad_idx)) {
1523 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1524 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1526 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1531 ost->source_index = -1;
1532 ost->filter = ofilter;
1536 if (ost->stream_copy) {
1537 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1538 "which is fed from a complex filtergraph. Filtering and streamcopy "
1539 "cannot be used together.\n", ost->file_index, ost->index);
1543 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1544 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1547 avfilter_inout_free(&ofilter->out_tmp);
1550 static int configure_complex_filters(void)
1554 for (i = 0; i < nb_filtergraphs; i++)
1555 if (!filtergraphs[i]->graph &&
1556 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1561 static int open_output_file(OptionsContext *o, const char *filename)
1563 AVFormatContext *oc;
1565 AVOutputFormat *file_oformat;
1569 AVDictionary *unused_opts = NULL;
1570 AVDictionaryEntry *e = NULL;
1572 if (configure_complex_filters() < 0) {
1573 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1577 if (!strcmp(filename, "-"))
1580 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1582 print_error(filename, err);
1585 file_oformat= oc->oformat;
1586 oc->interrupt_callback = int_cb;
1588 /* create streams for all unlabeled output pads */
1589 for (i = 0; i < nb_filtergraphs; i++) {
1590 FilterGraph *fg = filtergraphs[i];
1591 for (j = 0; j < fg->nb_outputs; j++) {
1592 OutputFilter *ofilter = fg->outputs[j];
1594 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1597 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1598 ofilter->out_tmp->pad_idx)) {
1599 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1600 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1601 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1603 init_output_filter(ofilter, o, oc);
1607 if (!strcmp(file_oformat->name, "ffm") &&
1608 av_strstart(filename, "http:", NULL)) {
1610 /* special case for files sent to ffserver: we get the stream
1611 parameters from ffserver */
1612 int err = read_ffserver_streams(o, oc, filename);
1614 print_error(filename, err);
1617 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1618 ost = output_streams[j];
1619 for (i = 0; i < nb_input_streams; i++) {
1620 ist = input_streams[i];
1621 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1623 ost->source_index= i;
1624 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1625 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1627 ist->st->discard = AVDISCARD_NONE;
1632 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));
1636 } else if (!o->nb_stream_maps) {
1637 char *subtitle_codec_name = NULL;
1638 /* pick the "best" stream of each type */
1640 /* video: highest resolution */
1641 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1642 int area = 0, idx = -1;
1643 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1644 for (i = 0; i < nb_input_streams; i++) {
1646 ist = input_streams[i];
1647 new_area = ist->st->codec->width * ist->st->codec->height;
1648 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1650 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1652 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1659 new_video_stream(o, oc, idx);
1662 /* audio: most channels */
1663 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1664 int channels = 0, idx = -1;
1665 for (i = 0; i < nb_input_streams; i++) {
1666 ist = input_streams[i];
1667 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1668 ist->st->codec->channels > channels) {
1669 channels = ist->st->codec->channels;
1674 new_audio_stream(o, oc, idx);
1677 /* subtitles: pick first */
1678 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1679 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1680 for (i = 0; i < nb_input_streams; i++)
1681 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1682 new_subtitle_stream(o, oc, i);
1686 /* do something with data? */
1688 for (i = 0; i < o->nb_stream_maps; i++) {
1689 StreamMap *map = &o->stream_maps[i];
1690 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1695 if (map->linklabel) {
1697 OutputFilter *ofilter = NULL;
1700 for (j = 0; j < nb_filtergraphs; j++) {
1701 fg = filtergraphs[j];
1702 for (k = 0; k < fg->nb_outputs; k++) {
1703 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1704 if (out && !strcmp(out->name, map->linklabel)) {
1705 ofilter = fg->outputs[k];
1712 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1713 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1716 init_output_filter(ofilter, o, oc);
1718 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1719 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1721 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1723 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1725 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1728 switch (ist->st->codec->codec_type) {
1729 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1730 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1731 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1732 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1733 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1735 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1736 map->file_index, map->stream_index);
1743 /* handle attached files */
1744 for (i = 0; i < o->nb_attachments; i++) {
1746 uint8_t *attachment;
1750 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1751 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1755 if ((len = avio_size(pb)) <= 0) {
1756 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1760 if (!(attachment = av_malloc(len))) {
1761 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1765 avio_read(pb, attachment, len);
1767 ost = new_attachment_stream(o, oc, -1);
1768 ost->stream_copy = 0;
1769 ost->attachment_filename = o->attachments[i];
1771 ost->st->codec->extradata = attachment;
1772 ost->st->codec->extradata_size = len;
1774 p = strrchr(o->attachments[i], '/');
1775 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1779 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1780 AVDictionaryEntry *e;
1781 ost = output_streams[i];
1783 if ((ost->stream_copy || ost->attachment_filename)
1784 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1785 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1786 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1790 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1791 o->stop_time = INT64_MAX;
1792 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1795 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1796 if (o->stop_time <= o->start_time) {
1797 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1798 o->stop_time = INT64_MAX;
1800 o->recording_time = o->stop_time - o->start_time;
1804 GROW_ARRAY(output_files, nb_output_files);
1805 of = av_mallocz(sizeof(*of));
1808 output_files[nb_output_files - 1] = of;
1811 of->ost_index = nb_output_streams - oc->nb_streams;
1812 of->recording_time = o->recording_time;
1813 if (o->recording_time != INT64_MAX)
1814 oc->duration = o->recording_time;
1815 of->start_time = o->start_time;
1816 of->limit_filesize = o->limit_filesize;
1817 of->shortest = o->shortest;
1818 av_dict_copy(&of->opts, o->g->format_opts, 0);
1821 /* check if all codec options have been used */
1822 unused_opts = strip_specifiers(o->g->codec_opts);
1823 for (i = of->ost_index; i < nb_output_streams; i++) {
1825 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1826 AV_DICT_IGNORE_SUFFIX)))
1827 av_dict_set(&unused_opts, e->key, NULL, 0);
1831 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1832 const AVClass *class = avcodec_get_class();
1833 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1834 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1837 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1838 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1839 "output file #%d (%s) is not an encoding option.\n", e->key,
1840 option->help ? option->help : "", nb_output_files - 1,
1845 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1846 "output file #%d (%s) has not been used for any stream. The most "
1847 "likely reason is either wrong type (e.g. a video option with "
1848 "no video streams) or that it is a private option of some encoder "
1849 "which was not actually used for any stream.\n", e->key,
1850 option->help ? option->help : "", nb_output_files - 1, filename);
1852 av_dict_free(&unused_opts);
1854 /* check filename in case of an image number is expected */
1855 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1856 if (!av_filename_number_test(oc->filename)) {
1857 print_error(oc->filename, AVERROR(EINVAL));
1862 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1863 /* test if it already exists to avoid losing precious files */
1864 assert_file_overwrite(filename);
1867 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1868 &oc->interrupt_callback,
1870 print_error(filename, err);
1873 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1874 assert_file_overwrite(filename);
1876 if (o->mux_preload) {
1878 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1879 av_dict_set(&of->opts, "preload", buf, 0);
1881 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1884 for (i = 0; i < o->nb_metadata_map; i++) {
1886 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1888 if (in_file_index >= nb_input_files) {
1889 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1892 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1893 in_file_index >= 0 ?
1894 input_files[in_file_index]->ctx : NULL, o);
1898 if (o->chapters_input_file >= nb_input_files) {
1899 if (o->chapters_input_file == INT_MAX) {
1900 /* copy chapters from the first input file that has them*/
1901 o->chapters_input_file = -1;
1902 for (i = 0; i < nb_input_files; i++)
1903 if (input_files[i]->ctx->nb_chapters) {
1904 o->chapters_input_file = i;
1908 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1909 o->chapters_input_file);
1913 if (o->chapters_input_file >= 0)
1914 copy_chapters(input_files[o->chapters_input_file], of,
1915 !o->metadata_chapters_manual);
1917 /* copy global metadata by default */
1918 if (!o->metadata_global_manual && nb_input_files){
1919 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1920 AV_DICT_DONT_OVERWRITE);
1921 if(o->recording_time != INT64_MAX)
1922 av_dict_set(&oc->metadata, "duration", NULL, 0);
1923 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1925 if (!o->metadata_streams_manual)
1926 for (i = of->ost_index; i < nb_output_streams; i++) {
1928 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1930 ist = input_streams[output_streams[i]->source_index];
1931 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1934 /* process manually set metadata */
1935 for (i = 0; i < o->nb_metadata; i++) {
1938 const char *stream_spec;
1939 int index = 0, j, ret = 0;
1941 val = strchr(o->metadata[i].u.str, '=');
1943 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1944 o->metadata[i].u.str);
1949 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1951 for (j = 0; j < oc->nb_streams; j++) {
1952 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1953 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1964 if (index < 0 || index >= oc->nb_chapters) {
1965 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1968 m = &oc->chapters[index]->metadata;
1971 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1974 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1981 static int opt_target(void *optctx, const char *opt, const char *arg)
1983 OptionsContext *o = optctx;
1984 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1985 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1987 if (!strncmp(arg, "pal-", 4)) {
1990 } else if (!strncmp(arg, "ntsc-", 5)) {
1993 } else if (!strncmp(arg, "film-", 5)) {
1997 /* Try to determine PAL/NTSC by peeking in the input files */
1998 if (nb_input_files) {
2000 for (j = 0; j < nb_input_files; j++) {
2001 for (i = 0; i < input_files[j]->nb_streams; i++) {
2002 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2003 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2005 fr = c->time_base.den * 1000 / c->time_base.num;
2009 } else if ((fr == 29970) || (fr == 23976)) {
2014 if (norm != UNKNOWN)
2018 if (norm != UNKNOWN)
2019 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2022 if (norm == UNKNOWN) {
2023 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2024 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2025 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2029 if (!strcmp(arg, "vcd")) {
2030 opt_video_codec(o, "c:v", "mpeg1video");
2031 opt_audio_codec(o, "c:a", "mp2");
2032 parse_option(o, "f", "vcd", options);
2033 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2035 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2036 parse_option(o, "r", frame_rates[norm], options);
2037 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2039 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2040 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2041 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2042 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2044 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2045 parse_option(o, "ar", "44100", options);
2046 parse_option(o, "ac", "2", options);
2048 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2049 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2051 /* We have to offset the PTS, so that it is consistent with the SCR.
2052 SCR starts at 36000, but the first two packs contain only padding
2053 and the first pack from the other stream, respectively, may also have
2054 been written before.
2055 So the real data starts at SCR 36000+3*1200. */
2056 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2057 } else if (!strcmp(arg, "svcd")) {
2059 opt_video_codec(o, "c:v", "mpeg2video");
2060 opt_audio_codec(o, "c:a", "mp2");
2061 parse_option(o, "f", "svcd", options);
2063 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2064 parse_option(o, "r", frame_rates[norm], options);
2065 parse_option(o, "pix_fmt", "yuv420p", options);
2066 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2068 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2069 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2070 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2071 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2072 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2074 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2075 parse_option(o, "ar", "44100", options);
2077 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2079 } else if (!strcmp(arg, "dvd")) {
2081 opt_video_codec(o, "c:v", "mpeg2video");
2082 opt_audio_codec(o, "c:a", "ac3");
2083 parse_option(o, "f", "dvd", options);
2085 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2086 parse_option(o, "r", frame_rates[norm], options);
2087 parse_option(o, "pix_fmt", "yuv420p", options);
2088 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2090 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2091 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2092 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2093 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2095 av_dict_set(&o->g->format_opts, "packetsize", "2048", 0); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2096 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2098 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2099 parse_option(o, "ar", "48000", options);
2101 } else if (!strncmp(arg, "dv", 2)) {
2103 parse_option(o, "f", "dv", options);
2105 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2106 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2107 norm == PAL ? "yuv420p" : "yuv411p", options);
2108 parse_option(o, "r", frame_rates[norm], options);
2110 parse_option(o, "ar", "48000", options);
2111 parse_option(o, "ac", "2", options);
2114 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2115 return AVERROR(EINVAL);
2120 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2122 av_free (vstats_filename);
2123 vstats_filename = av_strdup (arg);
2127 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2130 time_t today2 = time(NULL);
2131 struct tm *today = localtime(&today2);
2133 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2135 return opt_vstats_file(NULL, opt, filename);
2138 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2140 OptionsContext *o = optctx;
2141 return parse_option(o, "frames:v", arg, options);
2144 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2146 OptionsContext *o = optctx;
2147 return parse_option(o, "frames:a", arg, options);
2150 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2152 OptionsContext *o = optctx;
2153 return parse_option(o, "frames:d", arg, options);
2156 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2159 AVDictionary *cbak = codec_opts;
2160 AVDictionary *fbak = format_opts;
2164 ret = opt_default(NULL, opt, arg);
2166 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2167 av_dict_copy(&o->g->format_opts, format_opts, 0);
2168 av_dict_free(&codec_opts);
2169 av_dict_free(&format_opts);
2176 static int opt_preset(void *optctx, const char *opt, const char *arg)
2178 OptionsContext *o = optctx;
2180 char filename[1000], line[1000], tmp_line[1000];
2181 const char *codec_name = NULL;
2185 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2187 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2188 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2189 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2191 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2195 while (fgets(line, sizeof(line), f)) {
2196 char *key = tmp_line, *value, *endptr;
2198 if (strcspn(line, "#\n\r") == 0)
2200 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2201 if (!av_strtok(key, "=", &value) ||
2202 !av_strtok(value, "\r\n", &endptr)) {
2203 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2206 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2208 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2209 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2210 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2211 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2212 else if (opt_default_new(o, key, value) < 0) {
2213 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2214 filename, line, key, value);
2224 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2226 OptionsContext *o = optctx;
2227 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2228 int ret = parse_option(o, s, arg, options);
2233 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2235 OptionsContext *o = optctx;
2236 if(!strcmp(opt, "b")){
2237 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2238 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2241 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2245 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2247 OptionsContext *o = optctx;
2250 if(!strcmp(opt, "qscale")){
2251 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2252 return parse_option(o, "q:v", arg, options);
2254 s = av_asprintf("q%s", opt + 6);
2255 ret = parse_option(o, s, arg, options);
2260 static int opt_profile(void *optctx, const char *opt, const char *arg)
2262 OptionsContext *o = optctx;
2263 if(!strcmp(opt, "profile")){
2264 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2265 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2268 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2272 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2274 OptionsContext *o = optctx;
2275 return parse_option(o, "filter:v", arg, options);
2278 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2280 OptionsContext *o = optctx;
2281 return parse_option(o, "filter:a", arg, options);
2284 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2286 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2287 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2288 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2289 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2291 if (video_sync_method == VSYNC_AUTO)
2292 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2296 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2298 OptionsContext *o = optctx;
2299 char *tcr = av_asprintf("timecode=%s", arg);
2300 int ret = parse_option(o, "metadata:g", tcr, options);
2302 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2307 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2309 OptionsContext *o = optctx;
2310 char layout_str[32];
2313 int ret, channels, ac_str_size;
2316 layout = av_get_channel_layout(arg);
2318 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2319 return AVERROR(EINVAL);
2321 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2322 ret = opt_default_new(o, opt, layout_str);
2326 /* set 'ac' option based on channel layout */
2327 channels = av_get_channel_layout_nb_channels(layout);
2328 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2329 stream_str = strchr(opt, ':');
2330 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2331 ac_str = av_mallocz(ac_str_size);
2333 return AVERROR(ENOMEM);
2334 av_strlcpy(ac_str, "ac", 3);
2336 av_strlcat(ac_str, stream_str, ac_str_size);
2337 ret = parse_option(o, ac_str, layout_str, options);
2343 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2345 OptionsContext *o = optctx;
2346 return parse_option(o, "q:a", arg, options);
2349 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2351 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2352 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2353 return AVERROR(ENOMEM);
2354 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2355 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2356 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2357 return AVERROR(ENOMEM);
2361 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2363 uint8_t *graph_desc = read_file(arg);
2365 return AVERROR(EINVAL);
2367 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2368 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2369 return AVERROR(ENOMEM);
2370 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2371 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2375 void show_help_default(const char *opt, const char *arg)
2377 /* per-file options have at least one of those set */
2378 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2379 int show_advanced = 0, show_avoptions = 0;
2382 if (!strcmp(opt, "long"))
2384 else if (!strcmp(opt, "full"))
2385 show_advanced = show_avoptions = 1;
2387 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2392 printf("Getting help:\n"
2393 " -h -- print basic options\n"
2394 " -h long -- print more options\n"
2395 " -h full -- print all options (including all format and codec specific options, very long)\n"
2396 " See man %s for detailed description of the options.\n"
2397 "\n", program_name);
2399 show_help_options(options, "Print help / information / capabilities:",
2402 show_help_options(options, "Global options (affect whole program "
2403 "instead of just one file:",
2404 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2406 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2407 per_file | OPT_EXIT, 0);
2409 show_help_options(options, "Per-file main options:", 0,
2410 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2411 OPT_EXIT, per_file);
2413 show_help_options(options, "Advanced per-file options:",
2414 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2416 show_help_options(options, "Video options:",
2417 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2419 show_help_options(options, "Advanced Video options:",
2420 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2422 show_help_options(options, "Audio options:",
2423 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2425 show_help_options(options, "Advanced Audio options:",
2426 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2427 show_help_options(options, "Subtitle options:",
2428 OPT_SUBTITLE, 0, 0);
2431 if (show_avoptions) {
2432 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2433 show_help_children(avcodec_get_class(), flags);
2434 show_help_children(avformat_get_class(), flags);
2435 show_help_children(sws_get_class(), flags);
2436 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2437 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2441 void show_usage(void)
2443 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2444 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2445 av_log(NULL, AV_LOG_INFO, "\n");
2453 static const OptionGroupDef groups[] = {
2454 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2455 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2458 static int open_files(OptionGroupList *l, const char *inout,
2459 int (*open_file)(OptionsContext*, const char*))
2463 for (i = 0; i < l->nb_groups; i++) {
2464 OptionGroup *g = &l->groups[i];
2467 init_options(&o, !strcmp(inout, "input"));
2470 ret = parse_optgroup(&o, g);
2472 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2473 "%s.\n", inout, g->arg);
2477 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2478 ret = open_file(&o, g->arg);
2479 uninit_options(&o, !strcmp(inout, "input"));
2481 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2485 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2491 int ffmpeg_parse_options(int argc, char **argv)
2493 OptionParseContext octx;
2497 memset(&octx, 0, sizeof(octx));
2499 /* split the commandline into an internal representation */
2500 ret = split_commandline(&octx, argc, argv, options, groups,
2501 FF_ARRAY_ELEMS(groups));
2503 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2507 /* apply global options */
2508 ret = parse_optgroup(NULL, &octx.global_opts);
2510 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2514 /* open input files */
2515 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2517 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2521 /* open output files */
2522 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2524 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2529 uninit_parse_context(&octx);
2531 av_strerror(ret, error, sizeof(error));
2532 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2537 static int opt_progress(void *optctx, const char *opt, const char *arg)
2539 AVIOContext *avio = NULL;
2542 if (!strcmp(arg, "-"))
2544 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2546 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2547 arg, av_err2str(ret));
2550 progress_avio = avio;
2554 #define OFFSET(x) offsetof(OptionsContext, x)
2555 const OptionDef options[] = {
2557 #include "cmdutils_common_opts.h"
2558 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2559 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2560 "force format", "fmt" },
2561 { "y", OPT_BOOL, { &file_overwrite },
2562 "overwrite output files" },
2563 { "n", OPT_BOOL, { &no_file_overwrite },
2564 "do not overwrite output files" },
2565 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2566 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2567 "codec name", "codec" },
2568 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2569 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2570 "codec name", "codec" },
2571 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2572 OPT_OUTPUT, { .off = OFFSET(presets) },
2573 "preset name", "preset" },
2574 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2575 OPT_OUTPUT, { .func_arg = opt_map },
2576 "set input stream mapping",
2577 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2578 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2579 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2580 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2581 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2582 "set metadata information of outfile from infile",
2583 "outfile[,metadata]:infile[,metadata]" },
2584 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2585 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2586 "set chapters mapping", "input_file_index" },
2587 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2588 "record or transcode \"duration\" seconds of audio/video",
2590 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2591 "record or transcode stop time", "time_stop" },
2592 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2593 "set the limit file size in bytes", "limit_size" },
2594 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2595 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2596 "set the start time offset", "time_off" },
2597 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2598 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2599 "set the input ts offset", "time_off" },
2600 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2601 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2602 "set the input ts scale", "scale" },
2603 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2604 "set the recording timestamp ('now' to set the current time)", "time" },
2605 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2606 "add metadata", "string=string" },
2607 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2608 OPT_OUTPUT, { .func_arg = opt_data_frames },
2609 "set the number of data frames to record", "number" },
2610 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2611 "add timings for benchmarking" },
2612 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2613 "add timings for each task" },
2614 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2615 "write program-readable progress information", "url" },
2616 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2617 "enable or disable interaction on standard input" },
2618 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2619 "set max runtime in seconds", "limit" },
2620 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2621 "dump each input packet" },
2622 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2623 "when dumping packets, also dump the payload" },
2624 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2625 OPT_INPUT, { .off = OFFSET(rate_emu) },
2626 "read input at native frame rate", "" },
2627 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2628 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2629 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2630 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2631 "video sync method", "" },
2632 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2633 "audio sync method", "" },
2634 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2635 "audio drift threshold", "threshold" },
2636 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2637 "copy timestamps" },
2638 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2639 "copy input stream time base when stream copying", "mode" },
2640 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2641 OPT_OUTPUT, { .off = OFFSET(shortest) },
2642 "finish encoding within shortest input" },
2643 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2644 "timestamp discontinuity delta threshold", "threshold" },
2645 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2646 "timestamp error delta threshold", "threshold" },
2647 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2648 "exit on error", "error" },
2649 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2650 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2651 "copy initial non-keyframes" },
2652 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2653 "copy or discard frames before start time" },
2654 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2655 "set the number of frames to record", "number" },
2656 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2657 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2658 "force codec tag/fourcc", "fourcc/tag" },
2659 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2660 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2661 "use fixed quality scale (VBR)", "q" },
2662 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2663 OPT_OUTPUT, { .func_arg = opt_qscale },
2664 "use fixed quality scale (VBR)", "q" },
2665 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2666 "set profile", "profile" },
2667 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2668 "set stream filtergraph", "filter_graph" },
2669 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2670 "read stream filtergraph description from a file", "filename" },
2671 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2672 "reinit filtergraph on input parameter changes", "" },
2673 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2674 "create a complex filtergraph", "graph_description" },
2675 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2676 "create a complex filtergraph", "graph_description" },
2677 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2678 "read complex filtergraph description from a file", "filename" },
2679 { "stats", OPT_BOOL, { &print_stats },
2680 "print progress report during encoding", },
2681 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2682 OPT_OUTPUT, { .func_arg = opt_attach },
2683 "add an attachment to the output file", "filename" },
2684 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2685 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2686 "extract an attachment into a file", "filename" },
2687 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2688 "print timestamp debugging info" },
2691 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2692 "set the number of video frames to record", "number" },
2693 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2694 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2695 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2696 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2697 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2698 "set frame size (WxH or abbreviation)", "size" },
2699 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2700 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2701 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2702 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2703 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2704 "set pixel format", "format" },
2705 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2706 "set the number of bits per raw sample", "number" },
2707 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2708 "deprecated use -g 1" },
2709 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2711 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2712 "discard threshold", "n" },
2713 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2714 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2715 "rate control override for specific intervals", "override" },
2716 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2717 OPT_OUTPUT, { .func_arg = opt_video_codec },
2718 "force video codec ('copy' to copy stream)", "codec" },
2719 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2721 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2723 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2724 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2725 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2726 "select the pass number (1 to 3)", "n" },
2727 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2728 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2729 "select two pass log file name prefix", "prefix" },
2730 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2731 "this option is deprecated, use the yadif filter instead" },
2732 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2733 "calculate PSNR of compressed frames" },
2734 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2735 "dump video coding statistics to file" },
2736 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2737 "dump video coding statistics to file", "file" },
2738 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2739 "set video filters", "filter_graph" },
2740 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2741 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2742 "specify intra matrix coeffs", "matrix" },
2743 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2744 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2745 "specify inter matrix coeffs", "matrix" },
2746 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2747 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2748 "top=1/bottom=0/auto=-1 field first", "" },
2749 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2750 "intra_dc_precision", "precision" },
2751 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2752 OPT_OUTPUT, { .func_arg = opt_old2new },
2753 "force video tag/fourcc", "fourcc/tag" },
2754 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2755 "show QP histogram" },
2756 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2757 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2758 "force the selected framerate, disable the best supported framerate selection" },
2759 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2760 OPT_OUTPUT, { .func_arg = opt_streamid },
2761 "set the value of an outfile streamid", "streamIndex:value" },
2762 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2763 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2764 "force key frames at specified timestamps", "timestamps" },
2765 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2766 "video bitrate (please use -b:v)", "bitrate" },
2769 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2770 "set the number of audio frames to record", "number" },
2771 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2772 "set audio quality (codec-specific)", "quality", },
2773 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2774 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2775 "set audio sampling rate (in Hz)", "rate" },
2776 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2777 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2778 "set number of audio channels", "channels" },
2779 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2781 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2782 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2783 "force audio codec ('copy' to copy stream)", "codec" },
2784 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2785 OPT_OUTPUT, { .func_arg = opt_old2new },
2786 "force audio tag/fourcc", "fourcc/tag" },
2787 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2788 "change audio volume (256=normal)" , "volume" },
2789 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2790 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2791 "set sample format", "format" },
2792 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2793 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2794 "set channel layout", "layout" },
2795 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2796 "set audio filters", "filter_graph" },
2797 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2798 "set the maximum number of channels to try to guess the channel layout" },
2800 /* subtitle options */
2801 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2802 "disable subtitle" },
2803 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2804 "force subtitle codec ('copy' to copy stream)", "codec" },
2805 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2806 , "force subtitle tag/fourcc", "fourcc/tag" },
2807 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2808 "fix subtitles duration" },
2809 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2810 "set canvas size (WxH or abbreviation)", "size" },
2813 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2814 "deprecated, use -channel", "channel" },
2815 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2816 "deprecated, use -standard", "standard" },
2817 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2820 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2821 "set the maximum demux-decode delay", "seconds" },
2822 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2823 "set the initial demux-decode delay", "seconds" },
2825 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2826 "A comma-separated list of bitstream filters", "bitstream_filters" },
2827 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2828 "deprecated", "audio bitstream_filters" },
2829 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2830 "deprecated", "video bitstream_filters" },
2832 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2833 "set the audio options to the indicated preset", "preset" },
2834 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2835 "set the video options to the indicated preset", "preset" },
2836 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2837 "set the subtitle options to the indicated preset", "preset" },
2838 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2839 "set options from indicated preset file", "filename" },
2840 /* data codec support */
2841 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2842 "force data codec ('copy' to copy stream)", "codec" },
2843 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },