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;\
65 char *vstats_filename;
67 float audio_drift_threshold = 0.1;
68 float dts_delta_threshold = 10;
69 float dts_error_threshold = 3600*30;
71 int audio_volume = 256;
72 int audio_sync_method = 0;
73 int video_sync_method = VSYNC_AUTO;
74 int do_deinterlace = 0;
76 int do_benchmark_all = 0;
82 int exit_on_error = 0;
85 int stdin_interaction = 1;
86 int frame_bits_per_raw_sample = 0;
89 static int intra_only = 0;
90 static int file_overwrite = 0;
91 static int no_file_overwrite = 0;
92 static int video_discard = 0;
93 static int intra_dc_precision = 8;
94 static int do_psnr = 0;
95 static int input_sync;
97 static int64_t recording_time = INT64_MAX;
99 static void uninit_options(OptionsContext *o, int is_input)
101 const OptionDef *po = options;
104 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
106 void *dst = (uint8_t*)o + po->u.off;
108 if (po->flags & OPT_SPEC) {
109 SpecifierOpt **so = dst;
110 int i, *count = (int*)(so + 1);
111 for (i = 0; i < *count; i++) {
112 av_freep(&(*so)[i].specifier);
113 if (po->flags & OPT_STRING)
114 av_freep(&(*so)[i].u.str);
118 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
123 for (i = 0; i < o->nb_stream_maps; i++)
124 av_freep(&o->stream_maps[i].linklabel);
125 av_freep(&o->stream_maps);
126 av_freep(&o->audio_channel_maps);
127 av_freep(&o->streamid_map);
128 av_freep(&o->attachments);
131 recording_time = o->recording_time;
133 recording_time = INT64_MAX;
136 static void init_options(OptionsContext *o, int is_input)
138 memset(o, 0, sizeof(*o));
140 if (!is_input && recording_time != INT64_MAX) {
141 o->recording_time = recording_time;
142 av_log(NULL, AV_LOG_WARNING,
143 "-t is not an input option, keeping it for the next output;"
144 " consider fixing your command line.\n");
146 o->recording_time = INT64_MAX;
147 o->stop_time = INT64_MAX;
148 o->mux_max_delay = 0.7;
149 o->limit_filesize = UINT64_MAX;
150 o->chapters_input_file = INT_MAX;
153 /* return a copy of the input with the stream specifiers removed from the keys */
154 static AVDictionary *strip_specifiers(AVDictionary *dict)
156 AVDictionaryEntry *e = NULL;
157 AVDictionary *ret = NULL;
159 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
160 char *p = strchr(e->key, ':');
164 av_dict_set(&ret, e->key, e->value, 0);
171 static int opt_sameq(void *optctx, const char *opt, const char *arg)
173 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
174 "If you are looking for an option to preserve the quality (which is not "
175 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
177 return AVERROR(EINVAL);
180 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
182 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
183 return opt_default(optctx, "channel", arg);
186 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
188 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
189 return opt_default(optctx, "standard", arg);
192 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
194 OptionsContext *o = optctx;
195 return parse_option(o, "codec:a", arg, options);
198 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
200 OptionsContext *o = optctx;
201 return parse_option(o, "codec:v", arg, options);
204 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
206 OptionsContext *o = optctx;
207 return parse_option(o, "codec:s", arg, options);
210 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
212 OptionsContext *o = optctx;
213 return parse_option(o, "codec:d", arg, options);
216 static int opt_map(void *optctx, const char *opt, const char *arg)
218 OptionsContext *o = optctx;
220 int i, negative = 0, file_idx;
221 int sync_file_idx = -1, sync_stream_idx = 0;
229 map = av_strdup(arg);
231 /* parse sync stream first, just pick first matching stream */
232 if (sync = strchr(map, ',')) {
234 sync_file_idx = strtol(sync + 1, &sync, 0);
235 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
236 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
241 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
242 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
243 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
247 if (i == input_files[sync_file_idx]->nb_streams) {
248 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
249 "match any streams.\n", arg);
256 /* this mapping refers to lavfi output */
257 const char *c = map + 1;
258 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
259 m = &o->stream_maps[o->nb_stream_maps - 1];
260 m->linklabel = av_get_token(&c, "]");
262 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
266 file_idx = strtol(map, &p, 0);
267 if (file_idx >= nb_input_files || file_idx < 0) {
268 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
272 /* disable some already defined maps */
273 for (i = 0; i < o->nb_stream_maps; i++) {
274 m = &o->stream_maps[i];
275 if (file_idx == m->file_index &&
276 check_stream_specifier(input_files[m->file_index]->ctx,
277 input_files[m->file_index]->ctx->streams[m->stream_index],
278 *p == ':' ? p + 1 : p) > 0)
282 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
283 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
284 *p == ':' ? p + 1 : p) <= 0)
286 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
287 m = &o->stream_maps[o->nb_stream_maps - 1];
289 m->file_index = file_idx;
292 if (sync_file_idx >= 0) {
293 m->sync_file_index = sync_file_idx;
294 m->sync_stream_index = sync_stream_idx;
296 m->sync_file_index = file_idx;
297 m->sync_stream_index = i;
303 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
311 static int opt_attach(void *optctx, const char *opt, const char *arg)
313 OptionsContext *o = optctx;
314 GROW_ARRAY(o->attachments, o->nb_attachments);
315 o->attachments[o->nb_attachments - 1] = arg;
319 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
321 OptionsContext *o = optctx;
326 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
327 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
329 /* muted channel syntax */
330 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
331 if ((n == 1 || n == 3) && m->channel_idx == -1) {
332 m->file_idx = m->stream_idx = -1;
334 m->ofile_idx = m->ostream_idx = -1;
339 n = sscanf(arg, "%d.%d.%d:%d.%d",
340 &m->file_idx, &m->stream_idx, &m->channel_idx,
341 &m->ofile_idx, &m->ostream_idx);
343 if (n != 3 && n != 5) {
344 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
345 "[file.stream.channel|-1][:syncfile:syncstream]\n");
349 if (n != 5) // only file.stream.channel specified
350 m->ofile_idx = m->ostream_idx = -1;
353 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
354 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
358 if (m->stream_idx < 0 ||
359 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
360 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
361 m->file_idx, m->stream_idx);
364 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
365 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
366 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
367 m->file_idx, m->stream_idx);
370 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
371 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
372 m->file_idx, m->stream_idx, m->channel_idx);
379 * Parse a metadata specifier passed as 'arg' parameter.
380 * @param arg metadata string to parse
381 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
382 * @param index for type c/p, chapter/program index is written here
383 * @param stream_spec for type s, the stream specifier is written here
385 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
393 if (*(++arg) && *arg != ':') {
394 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
397 *stream_spec = *arg == ':' ? arg + 1 : "";
402 *index = strtol(++arg, NULL, 0);
405 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
412 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
414 AVDictionary **meta_in = NULL;
415 AVDictionary **meta_out = NULL;
417 char type_in, type_out;
418 const char *istream_spec = NULL, *ostream_spec = NULL;
419 int idx_in = 0, idx_out = 0;
421 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
422 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
425 if (type_out == 'g' || !*outspec)
426 o->metadata_global_manual = 1;
427 if (type_out == 's' || !*outspec)
428 o->metadata_streams_manual = 1;
429 if (type_out == 'c' || !*outspec)
430 o->metadata_chapters_manual = 1;
434 if (type_in == 'g' || type_out == 'g')
435 o->metadata_global_manual = 1;
436 if (type_in == 's' || type_out == 's')
437 o->metadata_streams_manual = 1;
438 if (type_in == 'c' || type_out == 'c')
439 o->metadata_chapters_manual = 1;
441 /* ic is NULL when just disabling automatic mappings */
445 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
446 if ((index) < 0 || (index) >= (nb_elems)) {\
447 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
452 #define SET_DICT(type, meta, context, index)\
455 meta = &context->metadata;\
458 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
459 meta = &context->chapters[index]->metadata;\
462 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
463 meta = &context->programs[index]->metadata;\
466 break; /* handled separately below */ \
467 default: av_assert0(0);\
470 SET_DICT(type_in, meta_in, ic, idx_in);
471 SET_DICT(type_out, meta_out, oc, idx_out);
473 /* for input streams choose first matching stream */
474 if (type_in == 's') {
475 for (i = 0; i < ic->nb_streams; i++) {
476 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
477 meta_in = &ic->streams[i]->metadata;
483 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
488 if (type_out == 's') {
489 for (i = 0; i < oc->nb_streams; i++) {
490 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
491 meta_out = &oc->streams[i]->metadata;
492 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
497 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
502 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
504 OptionsContext *o = optctx;
506 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
507 struct tm time = *gmtime((time_t*)&recording_timestamp);
508 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
509 parse_option(o, "metadata", buf, options);
511 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
512 "tag instead.\n", opt);
516 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
518 const AVCodecDescriptor *desc;
519 const char *codec_string = encoder ? "encoder" : "decoder";
523 avcodec_find_encoder_by_name(name) :
524 avcodec_find_decoder_by_name(name);
526 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
527 codec = encoder ? avcodec_find_encoder(desc->id) :
528 avcodec_find_decoder(desc->id);
530 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
531 codec_string, codec->name, desc->name);
535 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
538 if (codec->type != type) {
539 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
545 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
547 char *codec_name = NULL;
549 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
551 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
552 st->codec->codec_id = codec->id;
555 return avcodec_find_decoder(st->codec->codec_id);
558 /* Add all the streams from the given input file to the global
559 * list of input streams. */
560 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
563 char *next, *codec_tag = NULL;
565 for (i = 0; i < ic->nb_streams; i++) {
566 AVStream *st = ic->streams[i];
567 AVCodecContext *dec = st->codec;
568 InputStream *ist = av_mallocz(sizeof(*ist));
569 char *framerate = NULL;
574 GROW_ARRAY(input_streams, nb_input_streams);
575 input_streams[nb_input_streams - 1] = ist;
578 ist->file_index = nb_input_files;
580 st->discard = AVDISCARD_ALL;
583 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
585 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
587 uint32_t tag = strtol(codec_tag, &next, 0);
589 tag = AV_RL32(codec_tag);
590 st->codec->codec_tag = tag;
593 ist->dec = choose_decoder(o, ic, st);
594 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
596 ist->reinit_filters = -1;
597 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
599 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
601 switch (dec->codec_type) {
602 case AVMEDIA_TYPE_VIDEO:
604 ist->dec = avcodec_find_decoder(dec->codec_id);
606 dec->flags |= CODEC_FLAG_EMU_EDGE;
609 ist->resample_height = dec->height;
610 ist->resample_width = dec->width;
611 ist->resample_pix_fmt = dec->pix_fmt;
613 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
614 if (framerate && av_parse_video_rate(&ist->framerate,
616 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
621 ist->top_field_first = -1;
622 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
625 case AVMEDIA_TYPE_AUDIO:
626 ist->guess_layout_max = INT_MAX;
627 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
628 guess_input_channel_layout(ist);
630 ist->resample_sample_fmt = dec->sample_fmt;
631 ist->resample_sample_rate = dec->sample_rate;
632 ist->resample_channels = dec->channels;
633 ist->resample_channel_layout = dec->channel_layout;
636 case AVMEDIA_TYPE_DATA:
637 case AVMEDIA_TYPE_SUBTITLE: {
638 char *canvas_size = NULL;
640 ist->dec = avcodec_find_decoder(dec->codec_id);
641 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
642 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
644 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
645 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
650 case AVMEDIA_TYPE_ATTACHMENT:
651 case AVMEDIA_TYPE_UNKNOWN:
659 static void assert_file_overwrite(const char *filename)
661 if ((!file_overwrite || no_file_overwrite) &&
662 (strchr(filename, ':') == NULL || filename[1] == ':' ||
663 av_strstart(filename, "file:", NULL))) {
664 if (avio_check(filename, 0) == 0) {
665 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
666 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
669 signal(SIGINT, SIG_DFL);
671 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
677 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
684 static void dump_attachment(AVStream *st, const char *filename)
687 AVIOContext *out = NULL;
688 AVDictionaryEntry *e;
690 if (!st->codec->extradata_size) {
691 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
692 nb_input_files - 1, st->index);
695 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
698 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
699 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
703 assert_file_overwrite(filename);
705 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
706 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
711 avio_write(out, st->codec->extradata, st->codec->extradata_size);
716 static int open_input_file(OptionsContext *o, const char *filename)
720 AVInputFormat *file_iformat = NULL;
725 AVDictionary *unused_opts = NULL;
726 AVDictionaryEntry *e = NULL;
727 int orig_nb_streams; // number of streams before avformat_find_stream_info
728 char * video_codec_name = NULL;
729 char * audio_codec_name = NULL;
730 char *subtitle_codec_name = NULL;
733 if (!(file_iformat = av_find_input_format(o->format))) {
734 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
739 if (!strcmp(filename, "-"))
742 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
743 strcmp(filename, "/dev/stdin");
745 /* get default parameters from command line */
746 ic = avformat_alloc_context();
748 print_error(filename, AVERROR(ENOMEM));
751 if (o->nb_audio_sample_rate) {
752 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
753 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
755 if (o->nb_audio_channels) {
756 /* because we set audio_channels based on both the "ac" and
757 * "channel_layout" options, we need to check that the specified
758 * demuxer actually has the "channels" option before setting it */
759 if (file_iformat && file_iformat->priv_class &&
760 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
761 AV_OPT_SEARCH_FAKE_OBJ)) {
762 snprintf(buf, sizeof(buf), "%d",
763 o->audio_channels[o->nb_audio_channels - 1].u.i);
764 av_dict_set(&o->g->format_opts, "channels", buf, 0);
767 if (o->nb_frame_rates) {
768 /* set the format-level framerate option;
769 * this is important for video grabbers, e.g. x11 */
770 if (file_iformat && file_iformat->priv_class &&
771 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
772 AV_OPT_SEARCH_FAKE_OBJ)) {
773 av_dict_set(&o->g->format_opts, "framerate",
774 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
777 if (o->nb_frame_sizes) {
778 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
780 if (o->nb_frame_pix_fmts)
781 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
783 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
784 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
785 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
787 ic->video_codec_id = video_codec_name ?
788 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
789 ic->audio_codec_id = audio_codec_name ?
790 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
791 ic->subtitle_codec_id= subtitle_codec_name ?
792 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
793 ic->flags |= AVFMT_FLAG_NONBLOCK;
794 ic->interrupt_callback = int_cb;
796 /* open the input file with generic avformat function */
797 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
799 print_error(filename, err);
802 assert_avoptions(o->g->format_opts);
804 /* apply forced codec ids */
805 for (i = 0; i < ic->nb_streams; i++)
806 choose_decoder(o, ic, ic->streams[i]);
808 /* Set AVCodecContext options for avformat_find_stream_info */
809 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
810 orig_nb_streams = ic->nb_streams;
812 /* If not enough info to get the stream parameters, we decode the
813 first frames to get it. (used in mpeg case for example) */
814 ret = avformat_find_stream_info(ic, opts);
816 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
817 avformat_close_input(&ic);
821 timestamp = o->start_time;
822 /* add the stream start time */
823 if (ic->start_time != AV_NOPTS_VALUE)
824 timestamp += ic->start_time;
826 /* if seeking requested, we execute it */
827 if (o->start_time != 0) {
828 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
830 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
831 filename, (double)timestamp / AV_TIME_BASE);
835 /* update the current parameters so that they match the one of the input stream */
836 add_input_streams(o, ic);
838 /* dump the file content */
839 av_dump_format(ic, nb_input_files, filename, 0);
841 GROW_ARRAY(input_files, nb_input_files);
842 f = av_mallocz(sizeof(*f));
845 input_files[nb_input_files - 1] = f;
848 f->ist_index = nb_input_streams - ic->nb_streams;
849 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
850 f->nb_streams = ic->nb_streams;
851 f->rate_emu = o->rate_emu;
853 /* check if all codec options have been used */
854 unused_opts = strip_specifiers(o->g->codec_opts);
855 for (i = f->ist_index; i < nb_input_streams; i++) {
857 while ((e = av_dict_get(input_streams[i]->opts, "", e,
858 AV_DICT_IGNORE_SUFFIX)))
859 av_dict_set(&unused_opts, e->key, NULL, 0);
863 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
864 const AVClass *class = avcodec_get_class();
865 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
866 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
869 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
870 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
871 "input file #%d (%s) is not a decoding option.\n", e->key,
872 option->help ? option->help : "", nb_input_files - 1,
877 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
878 "input file #%d (%s) has not been used for any stream. The most "
879 "likely reason is either wrong type (e.g. a video option with "
880 "no video streams) or that it is a private option of some decoder "
881 "which was not actually used for any stream.\n", e->key,
882 option->help ? option->help : "", nb_input_files - 1, filename);
884 av_dict_free(&unused_opts);
886 for (i = 0; i < o->nb_dump_attachment; i++) {
889 for (j = 0; j < ic->nb_streams; j++) {
890 AVStream *st = ic->streams[j];
892 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
893 dump_attachment(st, o->dump_attachment[i].u.str);
897 for (i = 0; i < orig_nb_streams; i++)
898 av_dict_free(&opts[i]);
904 static uint8_t *get_line(AVIOContext *s)
910 if (avio_open_dyn_buf(&line) < 0) {
911 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
915 while ((c = avio_r8(s)) && c != '\n')
918 avio_close_dyn_buf(line, &buf);
923 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
927 const char *base[3] = { getenv("AVCONV_DATADIR"),
932 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
936 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
937 i != 1 ? "" : "/.avconv", codec_name, preset_name);
938 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
941 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
942 i != 1 ? "" : "/.avconv", preset_name);
943 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
949 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
951 char *codec_name = NULL;
953 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
955 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
956 NULL, ost->st->codec->codec_type);
957 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
958 } else if (!strcmp(codec_name, "copy"))
959 ost->stream_copy = 1;
961 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
962 ost->st->codec->codec_id = ost->enc->id;
966 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
969 AVStream *st = avformat_new_stream(oc, NULL);
970 int idx = oc->nb_streams - 1, ret = 0;
971 char *bsf = NULL, *next, *codec_tag = NULL;
972 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
977 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
981 if (oc->nb_streams - 1 < o->nb_streamid_map)
982 st->id = o->streamid_map[oc->nb_streams - 1];
984 GROW_ARRAY(output_streams, nb_output_streams);
985 if (!(ost = av_mallocz(sizeof(*ost))))
987 output_streams[nb_output_streams - 1] = ost;
989 ost->file_index = nb_output_files - 1;
992 st->codec->codec_type = type;
993 choose_encoder(o, oc, ost);
995 AVIOContext *s = NULL;
996 char *buf = NULL, *arg = NULL, *preset = NULL;
998 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1000 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1001 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1004 if (!buf[0] || buf[0] == '#') {
1008 if (!(arg = strchr(buf, '='))) {
1009 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1013 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1015 } while (!s->eof_reached);
1019 av_log(NULL, AV_LOG_FATAL,
1020 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1021 preset, ost->file_index, ost->index);
1025 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1028 avcodec_get_context_defaults3(st->codec, ost->enc);
1029 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1031 ost->max_frames = INT64_MAX;
1032 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1033 for (i = 0; i<o->nb_max_frames; i++) {
1034 char *p = o->max_frames[i].specifier;
1035 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1036 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1041 ost->copy_prior_start = -1;
1042 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1044 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1046 if (next = strchr(bsf, ','))
1048 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1049 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1053 bsfc_prev->next = bsfc;
1055 ost->bitstream_filters = bsfc;
1061 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1063 uint32_t tag = strtol(codec_tag, &next, 0);
1065 tag = AV_RL32(codec_tag);
1066 st->codec->codec_tag = tag;
1069 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1071 st->codec->flags |= CODEC_FLAG_QSCALE;
1072 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1075 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1076 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1078 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1080 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1081 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1082 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1084 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1086 ost->source_index = source_index;
1087 if (source_index >= 0) {
1088 ost->sync_ist = input_streams[source_index];
1089 input_streams[source_index]->discard = 0;
1090 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1096 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1099 const char *p = str;
1106 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1113 /* read file contents into a string */
1114 static uint8_t *read_file(const char *filename)
1116 AVIOContext *pb = NULL;
1117 AVIOContext *dyn_buf = NULL;
1118 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1119 uint8_t buf[1024], *str;
1122 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1126 ret = avio_open_dyn_buf(&dyn_buf);
1131 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1132 avio_write(dyn_buf, buf, ret);
1133 avio_w8(dyn_buf, 0);
1136 ret = avio_close_dyn_buf(dyn_buf, &str);
1142 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1145 AVStream *st = ost->st;
1146 char *filter = NULL, *filter_script = NULL;
1148 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1149 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1151 if (filter_script && filter) {
1152 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1153 "output stream #%d:%d.\n", nb_output_files, st->index);
1158 return read_file(filter_script);
1160 return av_strdup(filter);
1162 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1166 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1170 AVCodecContext *video_enc;
1171 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1173 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1175 video_enc = st->codec;
1177 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1178 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1179 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1183 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1184 if (frame_aspect_ratio) {
1186 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1187 q.num <= 0 || q.den <= 0) {
1188 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1191 ost->frame_aspect_ratio = q;
1194 if (!ost->stream_copy) {
1195 const char *p = NULL;
1196 char *frame_size = NULL;
1197 char *frame_pix_fmt = NULL;
1198 char *intra_matrix = NULL, *inter_matrix = NULL;
1202 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1203 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1204 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1208 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1209 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1210 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1211 ost->keep_pix_fmt = 1;
1212 if (!*++frame_pix_fmt)
1213 frame_pix_fmt = NULL;
1215 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1216 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1219 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1222 video_enc->gop_size = 0;
1223 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1225 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1226 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1229 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1231 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1233 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1234 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1237 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1240 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1241 for (i = 0; p; i++) {
1243 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1245 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1248 /* FIXME realloc failure */
1249 video_enc->rc_override =
1250 av_realloc(video_enc->rc_override,
1251 sizeof(RcOverride) * (i + 1));
1252 video_enc->rc_override[i].start_frame = start;
1253 video_enc->rc_override[i].end_frame = end;
1255 video_enc->rc_override[i].qscale = q;
1256 video_enc->rc_override[i].quality_factor = 1.0;
1259 video_enc->rc_override[i].qscale = 0;
1260 video_enc->rc_override[i].quality_factor = -q/100.0;
1265 video_enc->rc_override_count = i;
1266 video_enc->intra_dc_precision = intra_dc_precision - 8;
1269 video_enc->flags|= CODEC_FLAG_PSNR;
1272 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1275 video_enc->flags |= CODEC_FLAG_PASS1;
1276 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1279 video_enc->flags |= CODEC_FLAG_PASS2;
1280 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1284 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1285 if (ost->logfile_prefix &&
1286 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1289 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1290 if (ost->forced_keyframes)
1291 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1293 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1295 ost->top_field_first = -1;
1296 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1299 ost->avfilter = get_ost_filters(o, oc, ost);
1303 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1309 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1314 AVCodecContext *audio_enc;
1316 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1319 audio_enc = st->codec;
1320 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1322 if (!ost->stream_copy) {
1323 char *sample_fmt = NULL;
1325 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1327 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1329 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1330 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1334 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1336 ost->avfilter = get_ost_filters(o, oc, ost);
1340 /* check for channel mapping for this audio stream */
1341 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1342 AudioChannelMap *map = &o->audio_channel_maps[n];
1343 InputStream *ist = input_streams[ost->source_index];
1344 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1345 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1346 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1347 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1348 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1350 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1351 ost->file_index, ost->st->index);
1359 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1363 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1364 if (!ost->stream_copy) {
1365 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1372 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1374 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1375 ost->stream_copy = 1;
1380 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1384 AVCodecContext *subtitle_enc;
1386 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1388 subtitle_enc = st->codec;
1390 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1392 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1394 if (!ost->stream_copy) {
1395 char *frame_size = NULL;
1397 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1398 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1399 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1407 /* arg format is "output-stream-index:streamid-value". */
1408 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1410 OptionsContext *o = optctx;
1415 av_strlcpy(idx_str, arg, sizeof(idx_str));
1416 p = strchr(idx_str, ':');
1418 av_log(NULL, AV_LOG_FATAL,
1419 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1424 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1425 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1426 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1430 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1432 AVFormatContext *is = ifile->ctx;
1433 AVFormatContext *os = ofile->ctx;
1437 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1439 return AVERROR(ENOMEM);
1442 for (i = 0; i < is->nb_chapters; i++) {
1443 AVChapter *in_ch = is->chapters[i], *out_ch;
1444 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1445 AV_TIME_BASE_Q, in_ch->time_base);
1446 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1447 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1450 if (in_ch->end < ts_off)
1452 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1455 out_ch = av_mallocz(sizeof(AVChapter));
1457 return AVERROR(ENOMEM);
1459 out_ch->id = in_ch->id;
1460 out_ch->time_base = in_ch->time_base;
1461 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1462 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1465 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1467 os->chapters[os->nb_chapters++] = out_ch;
1472 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1475 AVFormatContext *ic = avformat_alloc_context();
1477 ic->interrupt_callback = int_cb;
1478 err = avformat_open_input(&ic, filename, NULL, NULL);
1481 /* copy stream format */
1482 for(i=0;i<ic->nb_streams;i++) {
1486 AVCodecContext *avctx;
1488 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1489 ost = new_output_stream(o, s, codec->type, -1);
1494 // FIXME: a more elegant solution is needed
1495 memcpy(st, ic->streams[i], sizeof(AVStream));
1497 st->info = av_malloc(sizeof(*st->info));
1498 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1500 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1502 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1503 choose_sample_fmt(st, codec);
1504 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1505 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1508 /* ffserver seeking with date=... needs a date reference */
1509 err = parse_option(o, "metadata", "creation_time=now", options);
1511 avformat_close_input(&ic);
1515 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1516 AVFormatContext *oc)
1520 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1521 ofilter->out_tmp->pad_idx)) {
1522 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1523 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1525 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1530 ost->source_index = -1;
1531 ost->filter = ofilter;
1535 if (ost->stream_copy) {
1536 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1537 "which is fed from a complex filtergraph. Filtering and streamcopy "
1538 "cannot be used together.\n", ost->file_index, ost->index);
1542 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1543 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1546 avfilter_inout_free(&ofilter->out_tmp);
1549 static int configure_complex_filters(void)
1553 for (i = 0; i < nb_filtergraphs; i++)
1554 if (!filtergraphs[i]->graph &&
1555 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1560 static int open_output_file(OptionsContext *o, const char *filename)
1562 AVFormatContext *oc;
1564 AVOutputFormat *file_oformat;
1568 AVDictionary *unused_opts = NULL;
1569 AVDictionaryEntry *e = NULL;
1571 if (configure_complex_filters() < 0) {
1572 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1576 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1577 o->stop_time = INT64_MAX;
1578 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1581 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1582 if (o->stop_time <= o->start_time) {
1583 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1584 o->stop_time = INT64_MAX;
1586 o->recording_time = o->stop_time - o->start_time;
1590 GROW_ARRAY(output_files, nb_output_files);
1591 of = av_mallocz(sizeof(*of));
1594 output_files[nb_output_files - 1] = of;
1596 of->ost_index = nb_output_streams;
1597 of->recording_time = o->recording_time;
1598 of->start_time = o->start_time;
1599 of->limit_filesize = o->limit_filesize;
1600 of->shortest = o->shortest;
1601 av_dict_copy(&of->opts, o->g->format_opts, 0);
1603 if (!strcmp(filename, "-"))
1606 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1608 print_error(filename, err);
1613 if (o->recording_time != INT64_MAX)
1614 oc->duration = o->recording_time;
1616 file_oformat= oc->oformat;
1617 oc->interrupt_callback = int_cb;
1619 /* create streams for all unlabeled output pads */
1620 for (i = 0; i < nb_filtergraphs; i++) {
1621 FilterGraph *fg = filtergraphs[i];
1622 for (j = 0; j < fg->nb_outputs; j++) {
1623 OutputFilter *ofilter = fg->outputs[j];
1625 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1628 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1629 ofilter->out_tmp->pad_idx)) {
1630 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1631 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1632 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1634 init_output_filter(ofilter, o, oc);
1638 if (!strcmp(file_oformat->name, "ffm") &&
1639 av_strstart(filename, "http:", NULL)) {
1641 /* special case for files sent to ffserver: we get the stream
1642 parameters from ffserver */
1643 int err = read_ffserver_streams(o, oc, filename);
1645 print_error(filename, err);
1648 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1649 ost = output_streams[j];
1650 for (i = 0; i < nb_input_streams; i++) {
1651 ist = input_streams[i];
1652 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1654 ost->source_index= i;
1655 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1656 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1658 ist->st->discard = AVDISCARD_NONE;
1663 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));
1667 } else if (!o->nb_stream_maps) {
1668 char *subtitle_codec_name = NULL;
1669 /* pick the "best" stream of each type */
1671 /* video: highest resolution */
1672 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1673 int area = 0, idx = -1;
1674 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1675 for (i = 0; i < nb_input_streams; i++) {
1677 ist = input_streams[i];
1678 new_area = ist->st->codec->width * ist->st->codec->height;
1679 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1681 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1683 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1690 new_video_stream(o, oc, idx);
1693 /* audio: most channels */
1694 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1695 int channels = 0, idx = -1;
1696 for (i = 0; i < nb_input_streams; i++) {
1697 ist = input_streams[i];
1698 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1699 ist->st->codec->channels > channels) {
1700 channels = ist->st->codec->channels;
1705 new_audio_stream(o, oc, idx);
1708 /* subtitles: pick first */
1709 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1710 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1711 for (i = 0; i < nb_input_streams; i++)
1712 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1713 new_subtitle_stream(o, oc, i);
1717 /* do something with data? */
1719 for (i = 0; i < o->nb_stream_maps; i++) {
1720 StreamMap *map = &o->stream_maps[i];
1721 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1726 if (map->linklabel) {
1728 OutputFilter *ofilter = NULL;
1731 for (j = 0; j < nb_filtergraphs; j++) {
1732 fg = filtergraphs[j];
1733 for (k = 0; k < fg->nb_outputs; k++) {
1734 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1735 if (out && !strcmp(out->name, map->linklabel)) {
1736 ofilter = fg->outputs[k];
1743 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1744 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1747 init_output_filter(ofilter, o, oc);
1749 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1750 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1752 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1754 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1756 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1759 switch (ist->st->codec->codec_type) {
1760 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1761 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1762 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1763 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1764 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1766 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1767 map->file_index, map->stream_index);
1774 /* handle attached files */
1775 for (i = 0; i < o->nb_attachments; i++) {
1777 uint8_t *attachment;
1781 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1782 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1786 if ((len = avio_size(pb)) <= 0) {
1787 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1791 if (!(attachment = av_malloc(len))) {
1792 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1796 avio_read(pb, attachment, len);
1798 ost = new_attachment_stream(o, oc, -1);
1799 ost->stream_copy = 0;
1800 ost->attachment_filename = o->attachments[i];
1802 ost->st->codec->extradata = attachment;
1803 ost->st->codec->extradata_size = len;
1805 p = strrchr(o->attachments[i], '/');
1806 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1810 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1811 AVDictionaryEntry *e;
1812 ost = output_streams[i];
1814 if ((ost->stream_copy || ost->attachment_filename)
1815 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1816 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1817 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 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_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | 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) },