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;
1092 ost->last_mux_dts = AV_NOPTS_VALUE;
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, *frame_aspect_ratio = 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 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1185 if (frame_aspect_ratio) {
1187 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1188 q.num <= 0 || q.den <= 0) {
1189 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1192 ost->frame_aspect_ratio = q;
1195 if (!ost->stream_copy) {
1196 const char *p = NULL;
1197 char *frame_size = NULL;
1198 char *frame_pix_fmt = NULL;
1199 char *intra_matrix = NULL, *inter_matrix = NULL;
1203 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1204 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1205 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
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 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1338 ost->apad = av_strdup(ost->apad);
1340 ost->avfilter = get_ost_filters(o, oc, ost);
1344 /* check for channel mapping for this audio stream */
1345 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1346 AudioChannelMap *map = &o->audio_channel_maps[n];
1347 InputStream *ist = input_streams[ost->source_index];
1348 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1349 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1350 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1351 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1352 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1354 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1355 ost->file_index, ost->st->index);
1363 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1367 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1368 if (!ost->stream_copy) {
1369 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1376 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1378 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1379 ost->stream_copy = 1;
1384 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1388 AVCodecContext *subtitle_enc;
1390 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1392 subtitle_enc = st->codec;
1394 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1396 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1398 if (!ost->stream_copy) {
1399 char *frame_size = NULL;
1401 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1402 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1403 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1411 /* arg format is "output-stream-index:streamid-value". */
1412 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1414 OptionsContext *o = optctx;
1419 av_strlcpy(idx_str, arg, sizeof(idx_str));
1420 p = strchr(idx_str, ':');
1422 av_log(NULL, AV_LOG_FATAL,
1423 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1428 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1429 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1430 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1434 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1436 AVFormatContext *is = ifile->ctx;
1437 AVFormatContext *os = ofile->ctx;
1441 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1443 return AVERROR(ENOMEM);
1446 for (i = 0; i < is->nb_chapters; i++) {
1447 AVChapter *in_ch = is->chapters[i], *out_ch;
1448 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1449 AV_TIME_BASE_Q, in_ch->time_base);
1450 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1451 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1454 if (in_ch->end < ts_off)
1456 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1459 out_ch = av_mallocz(sizeof(AVChapter));
1461 return AVERROR(ENOMEM);
1463 out_ch->id = in_ch->id;
1464 out_ch->time_base = in_ch->time_base;
1465 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1466 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1469 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1471 os->chapters[os->nb_chapters++] = out_ch;
1476 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1479 AVFormatContext *ic = avformat_alloc_context();
1481 ic->interrupt_callback = int_cb;
1482 err = avformat_open_input(&ic, filename, NULL, NULL);
1485 /* copy stream format */
1486 for(i=0;i<ic->nb_streams;i++) {
1490 AVCodecContext *avctx;
1492 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1493 ost = new_output_stream(o, s, codec->type, -1);
1498 // FIXME: a more elegant solution is needed
1499 memcpy(st, ic->streams[i], sizeof(AVStream));
1501 st->info = av_malloc(sizeof(*st->info));
1502 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1504 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1506 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1507 choose_sample_fmt(st, codec);
1508 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1509 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1512 /* ffserver seeking with date=... needs a date reference */
1513 err = parse_option(o, "metadata", "creation_time=now", options);
1515 avformat_close_input(&ic);
1519 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1520 AVFormatContext *oc)
1524 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1525 ofilter->out_tmp->pad_idx)) {
1526 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1527 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1529 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1534 ost->source_index = -1;
1535 ost->filter = ofilter;
1539 if (ost->stream_copy) {
1540 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1541 "which is fed from a complex filtergraph. Filtering and streamcopy "
1542 "cannot be used together.\n", ost->file_index, ost->index);
1546 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1547 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1550 avfilter_inout_free(&ofilter->out_tmp);
1553 static int configure_complex_filters(void)
1557 for (i = 0; i < nb_filtergraphs; i++)
1558 if (!filtergraphs[i]->graph &&
1559 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1564 static int open_output_file(OptionsContext *o, const char *filename)
1566 AVFormatContext *oc;
1568 AVOutputFormat *file_oformat;
1572 AVDictionary *unused_opts = NULL;
1573 AVDictionaryEntry *e = NULL;
1575 if (configure_complex_filters() < 0) {
1576 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1580 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1581 o->stop_time = INT64_MAX;
1582 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1585 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1586 if (o->stop_time <= o->start_time) {
1587 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1588 o->stop_time = INT64_MAX;
1590 o->recording_time = o->stop_time - o->start_time;
1594 GROW_ARRAY(output_files, nb_output_files);
1595 of = av_mallocz(sizeof(*of));
1598 output_files[nb_output_files - 1] = of;
1600 of->ost_index = nb_output_streams;
1601 of->recording_time = o->recording_time;
1602 of->start_time = o->start_time;
1603 of->limit_filesize = o->limit_filesize;
1604 of->shortest = o->shortest;
1605 av_dict_copy(&of->opts, o->g->format_opts, 0);
1607 if (!strcmp(filename, "-"))
1610 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1612 print_error(filename, err);
1617 if (o->recording_time != INT64_MAX)
1618 oc->duration = o->recording_time;
1620 file_oformat= oc->oformat;
1621 oc->interrupt_callback = int_cb;
1623 /* create streams for all unlabeled output pads */
1624 for (i = 0; i < nb_filtergraphs; i++) {
1625 FilterGraph *fg = filtergraphs[i];
1626 for (j = 0; j < fg->nb_outputs; j++) {
1627 OutputFilter *ofilter = fg->outputs[j];
1629 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1632 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1633 ofilter->out_tmp->pad_idx)) {
1634 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1635 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1636 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1638 init_output_filter(ofilter, o, oc);
1642 if (!strcmp(file_oformat->name, "ffm") &&
1643 av_strstart(filename, "http:", NULL)) {
1645 /* special case for files sent to ffserver: we get the stream
1646 parameters from ffserver */
1647 int err = read_ffserver_streams(o, oc, filename);
1649 print_error(filename, err);
1652 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1653 ost = output_streams[j];
1654 for (i = 0; i < nb_input_streams; i++) {
1655 ist = input_streams[i];
1656 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1658 ost->source_index= i;
1659 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1660 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1662 ist->st->discard = AVDISCARD_NONE;
1667 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));
1671 } else if (!o->nb_stream_maps) {
1672 char *subtitle_codec_name = NULL;
1673 /* pick the "best" stream of each type */
1675 /* video: highest resolution */
1676 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1677 int area = 0, idx = -1;
1678 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1679 for (i = 0; i < nb_input_streams; i++) {
1681 ist = input_streams[i];
1682 new_area = ist->st->codec->width * ist->st->codec->height;
1683 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1685 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1687 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1694 new_video_stream(o, oc, idx);
1697 /* audio: most channels */
1698 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1699 int channels = 0, idx = -1;
1700 for (i = 0; i < nb_input_streams; i++) {
1701 ist = input_streams[i];
1702 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1703 ist->st->codec->channels > channels) {
1704 channels = ist->st->codec->channels;
1709 new_audio_stream(o, oc, idx);
1712 /* subtitles: pick first */
1713 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1714 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1715 for (i = 0; i < nb_input_streams; i++)
1716 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1717 new_subtitle_stream(o, oc, i);
1721 /* do something with data? */
1723 for (i = 0; i < o->nb_stream_maps; i++) {
1724 StreamMap *map = &o->stream_maps[i];
1729 if (map->linklabel) {
1731 OutputFilter *ofilter = NULL;
1734 for (j = 0; j < nb_filtergraphs; j++) {
1735 fg = filtergraphs[j];
1736 for (k = 0; k < fg->nb_outputs; k++) {
1737 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1738 if (out && !strcmp(out->name, map->linklabel)) {
1739 ofilter = fg->outputs[k];
1746 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1747 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1750 init_output_filter(ofilter, o, oc);
1752 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1754 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1755 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1757 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1759 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1761 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1764 switch (ist->st->codec->codec_type) {
1765 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1766 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1767 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1768 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1769 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1771 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1772 map->file_index, map->stream_index);
1779 /* handle attached files */
1780 for (i = 0; i < o->nb_attachments; i++) {
1782 uint8_t *attachment;
1786 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1787 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1791 if ((len = avio_size(pb)) <= 0) {
1792 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1796 if (!(attachment = av_malloc(len))) {
1797 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1801 avio_read(pb, attachment, len);
1803 ost = new_attachment_stream(o, oc, -1);
1804 ost->stream_copy = 0;
1805 ost->attachment_filename = o->attachments[i];
1807 ost->st->codec->extradata = attachment;
1808 ost->st->codec->extradata_size = len;
1810 p = strrchr(o->attachments[i], '/');
1811 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1815 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1816 AVDictionaryEntry *e;
1817 ost = output_streams[i];
1819 if ((ost->stream_copy || ost->attachment_filename)
1820 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1821 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1822 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1826 /* check if all codec options have been used */
1827 unused_opts = strip_specifiers(o->g->codec_opts);
1828 for (i = of->ost_index; i < nb_output_streams; i++) {
1830 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1831 AV_DICT_IGNORE_SUFFIX)))
1832 av_dict_set(&unused_opts, e->key, NULL, 0);
1836 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1837 const AVClass *class = avcodec_get_class();
1838 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1839 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1842 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1843 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1844 "output file #%d (%s) is not an encoding option.\n", e->key,
1845 option->help ? option->help : "", nb_output_files - 1,
1850 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1851 "output file #%d (%s) has not been used for any stream. The most "
1852 "likely reason is either wrong type (e.g. a video option with "
1853 "no video streams) or that it is a private option of some encoder "
1854 "which was not actually used for any stream.\n", e->key,
1855 option->help ? option->help : "", nb_output_files - 1, filename);
1857 av_dict_free(&unused_opts);
1859 /* check filename in case of an image number is expected */
1860 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1861 if (!av_filename_number_test(oc->filename)) {
1862 print_error(oc->filename, AVERROR(EINVAL));
1867 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1868 /* test if it already exists to avoid losing precious files */
1869 assert_file_overwrite(filename);
1872 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1873 &oc->interrupt_callback,
1875 print_error(filename, err);
1878 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1879 assert_file_overwrite(filename);
1881 if (o->mux_preload) {
1883 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1884 av_dict_set(&of->opts, "preload", buf, 0);
1886 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1889 for (i = 0; i < o->nb_metadata_map; i++) {
1891 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1893 if (in_file_index >= nb_input_files) {
1894 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1897 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1898 in_file_index >= 0 ?
1899 input_files[in_file_index]->ctx : NULL, o);
1903 if (o->chapters_input_file >= nb_input_files) {
1904 if (o->chapters_input_file == INT_MAX) {
1905 /* copy chapters from the first input file that has them*/
1906 o->chapters_input_file = -1;
1907 for (i = 0; i < nb_input_files; i++)
1908 if (input_files[i]->ctx->nb_chapters) {
1909 o->chapters_input_file = i;
1913 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1914 o->chapters_input_file);
1918 if (o->chapters_input_file >= 0)
1919 copy_chapters(input_files[o->chapters_input_file], of,
1920 !o->metadata_chapters_manual);
1922 /* copy global metadata by default */
1923 if (!o->metadata_global_manual && nb_input_files){
1924 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1925 AV_DICT_DONT_OVERWRITE);
1926 if(o->recording_time != INT64_MAX)
1927 av_dict_set(&oc->metadata, "duration", NULL, 0);
1928 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1930 if (!o->metadata_streams_manual)
1931 for (i = of->ost_index; i < nb_output_streams; i++) {
1933 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1935 ist = input_streams[output_streams[i]->source_index];
1936 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1939 /* process manually set metadata */
1940 for (i = 0; i < o->nb_metadata; i++) {
1943 const char *stream_spec;
1944 int index = 0, j, ret = 0;
1946 val = strchr(o->metadata[i].u.str, '=');
1948 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1949 o->metadata[i].u.str);
1954 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1956 for (j = 0; j < oc->nb_streams; j++) {
1957 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1958 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1969 if (index < 0 || index >= oc->nb_chapters) {
1970 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1973 m = &oc->chapters[index]->metadata;
1976 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1979 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1986 static int opt_target(void *optctx, const char *opt, const char *arg)
1988 OptionsContext *o = optctx;
1989 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1990 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1992 if (!strncmp(arg, "pal-", 4)) {
1995 } else if (!strncmp(arg, "ntsc-", 5)) {
1998 } else if (!strncmp(arg, "film-", 5)) {
2002 /* Try to determine PAL/NTSC by peeking in the input files */
2003 if (nb_input_files) {
2005 for (j = 0; j < nb_input_files; j++) {
2006 for (i = 0; i < input_files[j]->nb_streams; i++) {
2007 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2008 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2010 fr = c->time_base.den * 1000 / c->time_base.num;
2014 } else if ((fr == 29970) || (fr == 23976)) {
2019 if (norm != UNKNOWN)
2023 if (norm != UNKNOWN)
2024 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2027 if (norm == UNKNOWN) {
2028 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2029 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2030 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2034 if (!strcmp(arg, "vcd")) {
2035 opt_video_codec(o, "c:v", "mpeg1video");
2036 opt_audio_codec(o, "c:a", "mp2");
2037 parse_option(o, "f", "vcd", options);
2038 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2040 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2041 parse_option(o, "r", frame_rates[norm], options);
2042 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2044 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2045 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2046 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2047 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2049 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2050 parse_option(o, "ar", "44100", options);
2051 parse_option(o, "ac", "2", options);
2053 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2054 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2056 /* We have to offset the PTS, so that it is consistent with the SCR.
2057 SCR starts at 36000, but the first two packs contain only padding
2058 and the first pack from the other stream, respectively, may also have
2059 been written before.
2060 So the real data starts at SCR 36000+3*1200. */
2061 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2062 } else if (!strcmp(arg, "svcd")) {
2064 opt_video_codec(o, "c:v", "mpeg2video");
2065 opt_audio_codec(o, "c:a", "mp2");
2066 parse_option(o, "f", "svcd", options);
2068 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2069 parse_option(o, "r", frame_rates[norm], options);
2070 parse_option(o, "pix_fmt", "yuv420p", options);
2071 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2073 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2074 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2075 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2076 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2077 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2079 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2080 parse_option(o, "ar", "44100", options);
2082 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2084 } else if (!strcmp(arg, "dvd")) {
2086 opt_video_codec(o, "c:v", "mpeg2video");
2087 opt_audio_codec(o, "c:a", "ac3");
2088 parse_option(o, "f", "dvd", options);
2090 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2091 parse_option(o, "r", frame_rates[norm], options);
2092 parse_option(o, "pix_fmt", "yuv420p", options);
2093 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2095 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2096 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2097 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2098 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2100 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.
2101 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2103 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2104 parse_option(o, "ar", "48000", options);
2106 } else if (!strncmp(arg, "dv", 2)) {
2108 parse_option(o, "f", "dv", options);
2110 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2111 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2112 norm == PAL ? "yuv420p" : "yuv411p", options);
2113 parse_option(o, "r", frame_rates[norm], options);
2115 parse_option(o, "ar", "48000", options);
2116 parse_option(o, "ac", "2", options);
2119 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2120 return AVERROR(EINVAL);
2125 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2127 av_free (vstats_filename);
2128 vstats_filename = av_strdup (arg);
2132 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2135 time_t today2 = time(NULL);
2136 struct tm *today = localtime(&today2);
2138 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2140 return opt_vstats_file(NULL, opt, filename);
2143 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2145 OptionsContext *o = optctx;
2146 return parse_option(o, "frames:v", arg, options);
2149 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2151 OptionsContext *o = optctx;
2152 return parse_option(o, "frames:a", arg, options);
2155 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2157 OptionsContext *o = optctx;
2158 return parse_option(o, "frames:d", arg, options);
2161 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2164 AVDictionary *cbak = codec_opts;
2165 AVDictionary *fbak = format_opts;
2169 ret = opt_default(NULL, opt, arg);
2171 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2172 av_dict_copy(&o->g->format_opts, format_opts, 0);
2173 av_dict_free(&codec_opts);
2174 av_dict_free(&format_opts);
2181 static int opt_preset(void *optctx, const char *opt, const char *arg)
2183 OptionsContext *o = optctx;
2185 char filename[1000], line[1000], tmp_line[1000];
2186 const char *codec_name = NULL;
2190 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2192 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2193 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2194 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2196 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2200 while (fgets(line, sizeof(line), f)) {
2201 char *key = tmp_line, *value, *endptr;
2203 if (strcspn(line, "#\n\r") == 0)
2205 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2206 if (!av_strtok(key, "=", &value) ||
2207 !av_strtok(value, "\r\n", &endptr)) {
2208 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2211 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2213 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2214 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2215 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2216 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2217 else if (opt_default_new(o, key, value) < 0) {
2218 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2219 filename, line, key, value);
2229 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2231 OptionsContext *o = optctx;
2232 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2233 int ret = parse_option(o, s, arg, options);
2238 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2240 OptionsContext *o = optctx;
2241 if(!strcmp(opt, "b")){
2242 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2243 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2246 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2250 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2252 OptionsContext *o = optctx;
2255 if(!strcmp(opt, "qscale")){
2256 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2257 return parse_option(o, "q:v", arg, options);
2259 s = av_asprintf("q%s", opt + 6);
2260 ret = parse_option(o, s, arg, options);
2265 static int opt_profile(void *optctx, const char *opt, const char *arg)
2267 OptionsContext *o = optctx;
2268 if(!strcmp(opt, "profile")){
2269 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2270 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2273 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2277 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2279 OptionsContext *o = optctx;
2280 return parse_option(o, "filter:v", arg, options);
2283 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2285 OptionsContext *o = optctx;
2286 return parse_option(o, "filter:a", arg, options);
2289 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2291 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2292 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2293 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2294 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2296 if (video_sync_method == VSYNC_AUTO)
2297 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2301 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2303 OptionsContext *o = optctx;
2304 char *tcr = av_asprintf("timecode=%s", arg);
2305 int ret = parse_option(o, "metadata:g", tcr, options);
2307 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2312 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2314 OptionsContext *o = optctx;
2315 char layout_str[32];
2318 int ret, channels, ac_str_size;
2321 layout = av_get_channel_layout(arg);
2323 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2324 return AVERROR(EINVAL);
2326 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2327 ret = opt_default_new(o, opt, layout_str);
2331 /* set 'ac' option based on channel layout */
2332 channels = av_get_channel_layout_nb_channels(layout);
2333 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2334 stream_str = strchr(opt, ':');
2335 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2336 ac_str = av_mallocz(ac_str_size);
2338 return AVERROR(ENOMEM);
2339 av_strlcpy(ac_str, "ac", 3);
2341 av_strlcat(ac_str, stream_str, ac_str_size);
2342 ret = parse_option(o, ac_str, layout_str, options);
2348 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2350 OptionsContext *o = optctx;
2351 return parse_option(o, "q:a", arg, options);
2354 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2356 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2357 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2358 return AVERROR(ENOMEM);
2359 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2360 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2361 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2362 return AVERROR(ENOMEM);
2366 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2368 uint8_t *graph_desc = read_file(arg);
2370 return AVERROR(EINVAL);
2372 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2373 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2374 return AVERROR(ENOMEM);
2375 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2376 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2380 void show_help_default(const char *opt, const char *arg)
2382 /* per-file options have at least one of those set */
2383 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2384 int show_advanced = 0, show_avoptions = 0;
2387 if (!strcmp(opt, "long"))
2389 else if (!strcmp(opt, "full"))
2390 show_advanced = show_avoptions = 1;
2392 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2397 printf("Getting help:\n"
2398 " -h -- print basic options\n"
2399 " -h long -- print more options\n"
2400 " -h full -- print all options (including all format and codec specific options, very long)\n"
2401 " See man %s for detailed description of the options.\n"
2402 "\n", program_name);
2404 show_help_options(options, "Print help / information / capabilities:",
2407 show_help_options(options, "Global options (affect whole program "
2408 "instead of just one file:",
2409 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2411 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2412 per_file | OPT_EXIT, 0);
2414 show_help_options(options, "Per-file main options:", 0,
2415 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2416 OPT_EXIT, per_file);
2418 show_help_options(options, "Advanced per-file options:",
2419 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2421 show_help_options(options, "Video options:",
2422 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2424 show_help_options(options, "Advanced Video options:",
2425 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2427 show_help_options(options, "Audio options:",
2428 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2430 show_help_options(options, "Advanced Audio options:",
2431 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2432 show_help_options(options, "Subtitle options:",
2433 OPT_SUBTITLE, 0, 0);
2436 if (show_avoptions) {
2437 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2438 show_help_children(avcodec_get_class(), flags);
2439 show_help_children(avformat_get_class(), flags);
2440 show_help_children(sws_get_class(), flags);
2441 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2442 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2446 void show_usage(void)
2448 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2449 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2450 av_log(NULL, AV_LOG_INFO, "\n");
2458 static const OptionGroupDef groups[] = {
2459 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2460 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2463 static int open_files(OptionGroupList *l, const char *inout,
2464 int (*open_file)(OptionsContext*, const char*))
2468 for (i = 0; i < l->nb_groups; i++) {
2469 OptionGroup *g = &l->groups[i];
2472 init_options(&o, !strcmp(inout, "input"));
2475 ret = parse_optgroup(&o, g);
2477 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2478 "%s.\n", inout, g->arg);
2482 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2483 ret = open_file(&o, g->arg);
2484 uninit_options(&o, !strcmp(inout, "input"));
2486 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2490 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2496 int ffmpeg_parse_options(int argc, char **argv)
2498 OptionParseContext octx;
2502 memset(&octx, 0, sizeof(octx));
2504 /* split the commandline into an internal representation */
2505 ret = split_commandline(&octx, argc, argv, options, groups,
2506 FF_ARRAY_ELEMS(groups));
2508 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2512 /* apply global options */
2513 ret = parse_optgroup(NULL, &octx.global_opts);
2515 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2519 /* open input files */
2520 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2522 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2526 /* open output files */
2527 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2529 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2534 uninit_parse_context(&octx);
2536 av_strerror(ret, error, sizeof(error));
2537 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2542 static int opt_progress(void *optctx, const char *opt, const char *arg)
2544 AVIOContext *avio = NULL;
2547 if (!strcmp(arg, "-"))
2549 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2551 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2552 arg, av_err2str(ret));
2555 progress_avio = avio;
2559 #define OFFSET(x) offsetof(OptionsContext, x)
2560 const OptionDef options[] = {
2562 #include "cmdutils_common_opts.h"
2563 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2564 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2565 "force format", "fmt" },
2566 { "y", OPT_BOOL, { &file_overwrite },
2567 "overwrite output files" },
2568 { "n", OPT_BOOL, { &no_file_overwrite },
2569 "do not overwrite output files" },
2570 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2571 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2572 "codec name", "codec" },
2573 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2574 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2575 "codec name", "codec" },
2576 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2577 OPT_OUTPUT, { .off = OFFSET(presets) },
2578 "preset name", "preset" },
2579 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2580 OPT_OUTPUT, { .func_arg = opt_map },
2581 "set input stream mapping",
2582 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2583 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2584 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2585 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2586 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2587 "set metadata information of outfile from infile",
2588 "outfile[,metadata]:infile[,metadata]" },
2589 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2590 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2591 "set chapters mapping", "input_file_index" },
2592 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2593 "record or transcode \"duration\" seconds of audio/video",
2595 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2596 "record or transcode stop time", "time_stop" },
2597 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2598 "set the limit file size in bytes", "limit_size" },
2599 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2600 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2601 "set the start time offset", "time_off" },
2602 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2603 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2604 "set the input ts offset", "time_off" },
2605 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2606 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2607 "set the input ts scale", "scale" },
2608 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2609 "set the recording timestamp ('now' to set the current time)", "time" },
2610 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2611 "add metadata", "string=string" },
2612 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2613 OPT_OUTPUT, { .func_arg = opt_data_frames },
2614 "set the number of data frames to record", "number" },
2615 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2616 "add timings for benchmarking" },
2617 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2618 "add timings for each task" },
2619 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2620 "write program-readable progress information", "url" },
2621 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2622 "enable or disable interaction on standard input" },
2623 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2624 "set max runtime in seconds", "limit" },
2625 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2626 "dump each input packet" },
2627 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2628 "when dumping packets, also dump the payload" },
2629 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2630 OPT_INPUT, { .off = OFFSET(rate_emu) },
2631 "read input at native frame rate", "" },
2632 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2633 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2634 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2635 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2636 "video sync method", "" },
2637 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2638 "audio sync method", "" },
2639 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2640 "audio drift threshold", "threshold" },
2641 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2642 "copy timestamps" },
2643 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2644 "copy input stream time base when stream copying", "mode" },
2645 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2646 OPT_OUTPUT, { .off = OFFSET(shortest) },
2647 "finish encoding within shortest input" },
2648 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2649 OPT_OUTPUT, { .off = OFFSET(apad) },
2651 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2652 "timestamp discontinuity delta threshold", "threshold" },
2653 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2654 "timestamp error delta threshold", "threshold" },
2655 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2656 "exit on error", "error" },
2657 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2658 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2659 "copy initial non-keyframes" },
2660 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2661 "copy or discard frames before start time" },
2662 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2663 "set the number of frames to record", "number" },
2664 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2665 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2666 "force codec tag/fourcc", "fourcc/tag" },
2667 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2668 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2669 "use fixed quality scale (VBR)", "q" },
2670 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2671 OPT_OUTPUT, { .func_arg = opt_qscale },
2672 "use fixed quality scale (VBR)", "q" },
2673 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2674 "set profile", "profile" },
2675 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2676 "set stream filtergraph", "filter_graph" },
2677 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2678 "read stream filtergraph description from a file", "filename" },
2679 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2680 "reinit filtergraph on input parameter changes", "" },
2681 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2682 "create a complex filtergraph", "graph_description" },
2683 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2684 "create a complex filtergraph", "graph_description" },
2685 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2686 "read complex filtergraph description from a file", "filename" },
2687 { "stats", OPT_BOOL, { &print_stats },
2688 "print progress report during encoding", },
2689 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2690 OPT_OUTPUT, { .func_arg = opt_attach },
2691 "add an attachment to the output file", "filename" },
2692 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2693 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2694 "extract an attachment into a file", "filename" },
2695 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2696 "print timestamp debugging info" },
2699 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2700 "set the number of video frames to record", "number" },
2701 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2702 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2703 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2704 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2705 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2706 "set frame size (WxH or abbreviation)", "size" },
2707 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2708 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2709 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2710 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2711 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2712 "set pixel format", "format" },
2713 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2714 "set the number of bits per raw sample", "number" },
2715 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2716 "deprecated use -g 1" },
2717 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2719 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2720 "discard threshold", "n" },
2721 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2722 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2723 "rate control override for specific intervals", "override" },
2724 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2725 OPT_OUTPUT, { .func_arg = opt_video_codec },
2726 "force video codec ('copy' to copy stream)", "codec" },
2727 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2729 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2731 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2732 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2733 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2734 "select the pass number (1 to 3)", "n" },
2735 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2736 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2737 "select two pass log file name prefix", "prefix" },
2738 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2739 "this option is deprecated, use the yadif filter instead" },
2740 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2741 "calculate PSNR of compressed frames" },
2742 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2743 "dump video coding statistics to file" },
2744 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2745 "dump video coding statistics to file", "file" },
2746 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2747 "set video filters", "filter_graph" },
2748 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2749 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2750 "specify intra matrix coeffs", "matrix" },
2751 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2752 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2753 "specify inter matrix coeffs", "matrix" },
2754 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2755 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2756 "top=1/bottom=0/auto=-1 field first", "" },
2757 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2758 "intra_dc_precision", "precision" },
2759 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2760 OPT_OUTPUT, { .func_arg = opt_old2new },
2761 "force video tag/fourcc", "fourcc/tag" },
2762 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2763 "show QP histogram" },
2764 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2765 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2766 "force the selected framerate, disable the best supported framerate selection" },
2767 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2768 OPT_OUTPUT, { .func_arg = opt_streamid },
2769 "set the value of an outfile streamid", "streamIndex:value" },
2770 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2771 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2772 "force key frames at specified timestamps", "timestamps" },
2773 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2774 "video bitrate (please use -b:v)", "bitrate" },
2777 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2778 "set the number of audio frames to record", "number" },
2779 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2780 "set audio quality (codec-specific)", "quality", },
2781 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2782 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2783 "set audio sampling rate (in Hz)", "rate" },
2784 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2785 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2786 "set number of audio channels", "channels" },
2787 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2789 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2790 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2791 "force audio codec ('copy' to copy stream)", "codec" },
2792 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2793 OPT_OUTPUT, { .func_arg = opt_old2new },
2794 "force audio tag/fourcc", "fourcc/tag" },
2795 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2796 "change audio volume (256=normal)" , "volume" },
2797 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2798 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2799 "set sample format", "format" },
2800 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2801 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2802 "set channel layout", "layout" },
2803 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2804 "set audio filters", "filter_graph" },
2805 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2806 "set the maximum number of channels to try to guess the channel layout" },
2808 /* subtitle options */
2809 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2810 "disable subtitle" },
2811 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2812 "force subtitle codec ('copy' to copy stream)", "codec" },
2813 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2814 , "force subtitle tag/fourcc", "fourcc/tag" },
2815 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2816 "fix subtitles duration" },
2817 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2818 "set canvas size (WxH or abbreviation)", "size" },
2821 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2822 "deprecated, use -channel", "channel" },
2823 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2824 "deprecated, use -standard", "standard" },
2825 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2828 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2829 "set the maximum demux-decode delay", "seconds" },
2830 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2831 "set the initial demux-decode delay", "seconds" },
2833 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2834 "A comma-separated list of bitstream filters", "bitstream_filters" },
2835 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2836 "deprecated", "audio bitstream_filters" },
2837 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2838 "deprecated", "video bitstream_filters" },
2840 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2841 "set the audio options to the indicated preset", "preset" },
2842 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2843 "set the video options to the indicated preset", "preset" },
2844 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2845 "set the subtitle options to the indicated preset", "preset" },
2846 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2847 "set options from indicated preset file", "filename" },
2848 /* data codec support */
2849 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2850 "force data codec ('copy' to copy stream)", "codec" },
2851 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },