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;
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;
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 if (!ost->stream_copy) {
1184 const char *p = NULL;
1185 char *frame_size = NULL;
1186 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1187 char *intra_matrix = NULL, *inter_matrix = NULL;
1191 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1192 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1193 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1197 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1198 if (frame_aspect_ratio) {
1200 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1201 q.num <= 0 || q.den <= 0) {
1202 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1205 ost->frame_aspect_ratio = q;
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 (!strcmp(filename, "-"))
1579 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1581 print_error(filename, err);
1584 file_oformat= oc->oformat;
1585 oc->interrupt_callback = int_cb;
1587 /* create streams for all unlabeled output pads */
1588 for (i = 0; i < nb_filtergraphs; i++) {
1589 FilterGraph *fg = filtergraphs[i];
1590 for (j = 0; j < fg->nb_outputs; j++) {
1591 OutputFilter *ofilter = fg->outputs[j];
1593 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1596 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1597 ofilter->out_tmp->pad_idx)) {
1598 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1599 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1600 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1602 init_output_filter(ofilter, o, oc);
1606 if (!strcmp(file_oformat->name, "ffm") &&
1607 av_strstart(filename, "http:", NULL)) {
1609 /* special case for files sent to ffserver: we get the stream
1610 parameters from ffserver */
1611 int err = read_ffserver_streams(o, oc, filename);
1613 print_error(filename, err);
1616 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1617 ost = output_streams[j];
1618 for (i = 0; i < nb_input_streams; i++) {
1619 ist = input_streams[i];
1620 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1622 ost->source_index= i;
1623 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1624 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1626 ist->st->discard = AVDISCARD_NONE;
1631 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));
1635 } else if (!o->nb_stream_maps) {
1636 char *subtitle_codec_name = NULL;
1637 /* pick the "best" stream of each type */
1639 /* video: highest resolution */
1640 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1641 int area = 0, idx = -1;
1642 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1643 for (i = 0; i < nb_input_streams; i++) {
1645 ist = input_streams[i];
1646 new_area = ist->st->codec->width * ist->st->codec->height;
1647 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1649 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1651 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1658 new_video_stream(o, oc, idx);
1661 /* audio: most channels */
1662 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1663 int channels = 0, idx = -1;
1664 for (i = 0; i < nb_input_streams; i++) {
1665 ist = input_streams[i];
1666 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1667 ist->st->codec->channels > channels) {
1668 channels = ist->st->codec->channels;
1673 new_audio_stream(o, oc, idx);
1676 /* subtitles: pick first */
1677 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1678 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1679 for (i = 0; i < nb_input_streams; i++)
1680 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1681 new_subtitle_stream(o, oc, i);
1685 /* do something with data? */
1687 for (i = 0; i < o->nb_stream_maps; i++) {
1688 StreamMap *map = &o->stream_maps[i];
1689 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1694 if (map->linklabel) {
1696 OutputFilter *ofilter = NULL;
1699 for (j = 0; j < nb_filtergraphs; j++) {
1700 fg = filtergraphs[j];
1701 for (k = 0; k < fg->nb_outputs; k++) {
1702 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1703 if (out && !strcmp(out->name, map->linklabel)) {
1704 ofilter = fg->outputs[k];
1711 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1712 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1715 init_output_filter(ofilter, o, oc);
1717 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1718 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1720 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1722 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1724 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1727 switch (ist->st->codec->codec_type) {
1728 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1729 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1730 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1731 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1732 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1734 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1735 map->file_index, map->stream_index);
1742 /* handle attached files */
1743 for (i = 0; i < o->nb_attachments; i++) {
1745 uint8_t *attachment;
1749 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1750 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1754 if ((len = avio_size(pb)) <= 0) {
1755 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1759 if (!(attachment = av_malloc(len))) {
1760 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1764 avio_read(pb, attachment, len);
1766 ost = new_attachment_stream(o, oc, -1);
1767 ost->stream_copy = 0;
1768 ost->attachment_filename = o->attachments[i];
1770 ost->st->codec->extradata = attachment;
1771 ost->st->codec->extradata_size = len;
1773 p = strrchr(o->attachments[i], '/');
1774 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1778 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1779 AVDictionaryEntry *e;
1780 ost = output_streams[i];
1782 if ((ost->stream_copy || ost->attachment_filename)
1783 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1784 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1785 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1789 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1790 o->stop_time = INT64_MAX;
1791 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1794 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1795 if (o->stop_time <= o->start_time) {
1796 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1797 o->stop_time = INT64_MAX;
1799 o->recording_time = o->stop_time - o->start_time;
1803 GROW_ARRAY(output_files, nb_output_files);
1804 of = av_mallocz(sizeof(*of));
1807 output_files[nb_output_files - 1] = of;
1810 of->ost_index = nb_output_streams - oc->nb_streams;
1811 of->recording_time = o->recording_time;
1812 if (o->recording_time != INT64_MAX)
1813 oc->duration = o->recording_time;
1814 of->start_time = o->start_time;
1815 of->limit_filesize = o->limit_filesize;
1816 of->shortest = o->shortest;
1817 av_dict_copy(&of->opts, o->g->format_opts, 0);
1820 /* check if all codec options have been used */
1821 unused_opts = strip_specifiers(o->g->codec_opts);
1822 for (i = of->ost_index; i < nb_output_streams; i++) {
1824 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1825 AV_DICT_IGNORE_SUFFIX)))
1826 av_dict_set(&unused_opts, e->key, NULL, 0);
1830 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1831 const AVClass *class = avcodec_get_class();
1832 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1833 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1836 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1837 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1838 "output file #%d (%s) is not an encoding option.\n", e->key,
1839 option->help ? option->help : "", nb_output_files - 1,
1844 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1845 "output file #%d (%s) has not been used for any stream. The most "
1846 "likely reason is either wrong type (e.g. a video option with "
1847 "no video streams) or that it is a private option of some encoder "
1848 "which was not actually used for any stream.\n", e->key,
1849 option->help ? option->help : "", nb_output_files - 1, filename);
1851 av_dict_free(&unused_opts);
1853 /* check filename in case of an image number is expected */
1854 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1855 if (!av_filename_number_test(oc->filename)) {
1856 print_error(oc->filename, AVERROR(EINVAL));
1861 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1862 /* test if it already exists to avoid losing precious files */
1863 assert_file_overwrite(filename);
1866 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1867 &oc->interrupt_callback,
1869 print_error(filename, err);
1872 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1873 assert_file_overwrite(filename);
1875 if (o->mux_preload) {
1877 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1878 av_dict_set(&of->opts, "preload", buf, 0);
1880 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1883 for (i = 0; i < o->nb_metadata_map; i++) {
1885 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1887 if (in_file_index >= nb_input_files) {
1888 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1891 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1892 in_file_index >= 0 ?
1893 input_files[in_file_index]->ctx : NULL, o);
1897 if (o->chapters_input_file >= nb_input_files) {
1898 if (o->chapters_input_file == INT_MAX) {
1899 /* copy chapters from the first input file that has them*/
1900 o->chapters_input_file = -1;
1901 for (i = 0; i < nb_input_files; i++)
1902 if (input_files[i]->ctx->nb_chapters) {
1903 o->chapters_input_file = i;
1907 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1908 o->chapters_input_file);
1912 if (o->chapters_input_file >= 0)
1913 copy_chapters(input_files[o->chapters_input_file], of,
1914 !o->metadata_chapters_manual);
1916 /* copy global metadata by default */
1917 if (!o->metadata_global_manual && nb_input_files){
1918 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1919 AV_DICT_DONT_OVERWRITE);
1920 if(o->recording_time != INT64_MAX)
1921 av_dict_set(&oc->metadata, "duration", NULL, 0);
1922 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1924 if (!o->metadata_streams_manual)
1925 for (i = of->ost_index; i < nb_output_streams; i++) {
1927 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1929 ist = input_streams[output_streams[i]->source_index];
1930 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1933 /* process manually set metadata */
1934 for (i = 0; i < o->nb_metadata; i++) {
1937 const char *stream_spec;
1938 int index = 0, j, ret = 0;
1940 val = strchr(o->metadata[i].u.str, '=');
1942 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1943 o->metadata[i].u.str);
1948 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1950 for (j = 0; j < oc->nb_streams; j++) {
1951 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1952 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1963 if (index < 0 || index >= oc->nb_chapters) {
1964 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1967 m = &oc->chapters[index]->metadata;
1970 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1973 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1980 static int opt_target(void *optctx, const char *opt, const char *arg)
1982 OptionsContext *o = optctx;
1983 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1984 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1986 if (!strncmp(arg, "pal-", 4)) {
1989 } else if (!strncmp(arg, "ntsc-", 5)) {
1992 } else if (!strncmp(arg, "film-", 5)) {
1996 /* Try to determine PAL/NTSC by peeking in the input files */
1997 if (nb_input_files) {
1999 for (j = 0; j < nb_input_files; j++) {
2000 for (i = 0; i < input_files[j]->nb_streams; i++) {
2001 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2002 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2004 fr = c->time_base.den * 1000 / c->time_base.num;
2008 } else if ((fr == 29970) || (fr == 23976)) {
2013 if (norm != UNKNOWN)
2017 if (norm != UNKNOWN)
2018 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2021 if (norm == UNKNOWN) {
2022 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2023 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2024 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2028 if (!strcmp(arg, "vcd")) {
2029 opt_video_codec(o, "c:v", "mpeg1video");
2030 opt_audio_codec(o, "c:a", "mp2");
2031 parse_option(o, "f", "vcd", options);
2032 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2034 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2035 parse_option(o, "r", frame_rates[norm], options);
2036 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2038 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2039 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2040 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2041 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2043 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2044 parse_option(o, "ar", "44100", options);
2045 parse_option(o, "ac", "2", options);
2047 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2048 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2050 /* We have to offset the PTS, so that it is consistent with the SCR.
2051 SCR starts at 36000, but the first two packs contain only padding
2052 and the first pack from the other stream, respectively, may also have
2053 been written before.
2054 So the real data starts at SCR 36000+3*1200. */
2055 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2056 } else if (!strcmp(arg, "svcd")) {
2058 opt_video_codec(o, "c:v", "mpeg2video");
2059 opt_audio_codec(o, "c:a", "mp2");
2060 parse_option(o, "f", "svcd", options);
2062 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2063 parse_option(o, "r", frame_rates[norm], options);
2064 parse_option(o, "pix_fmt", "yuv420p", options);
2065 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2067 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2068 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2069 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2070 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2071 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2073 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2074 parse_option(o, "ar", "44100", options);
2076 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2078 } else if (!strcmp(arg, "dvd")) {
2080 opt_video_codec(o, "c:v", "mpeg2video");
2081 opt_audio_codec(o, "c:a", "ac3");
2082 parse_option(o, "f", "dvd", options);
2084 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2085 parse_option(o, "r", frame_rates[norm], options);
2086 parse_option(o, "pix_fmt", "yuv420p", options);
2087 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2089 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2090 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2091 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2092 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2094 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.
2095 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2097 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2098 parse_option(o, "ar", "48000", options);
2100 } else if (!strncmp(arg, "dv", 2)) {
2102 parse_option(o, "f", "dv", options);
2104 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2105 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2106 norm == PAL ? "yuv420p" : "yuv411p", options);
2107 parse_option(o, "r", frame_rates[norm], options);
2109 parse_option(o, "ar", "48000", options);
2110 parse_option(o, "ac", "2", options);
2113 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2114 return AVERROR(EINVAL);
2119 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2121 av_free (vstats_filename);
2122 vstats_filename = av_strdup (arg);
2126 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2129 time_t today2 = time(NULL);
2130 struct tm *today = localtime(&today2);
2132 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2134 return opt_vstats_file(NULL, opt, filename);
2137 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2139 OptionsContext *o = optctx;
2140 return parse_option(o, "frames:v", arg, options);
2143 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2145 OptionsContext *o = optctx;
2146 return parse_option(o, "frames:a", arg, options);
2149 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2151 OptionsContext *o = optctx;
2152 return parse_option(o, "frames:d", arg, options);
2155 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2158 AVDictionary *cbak = codec_opts;
2159 AVDictionary *fbak = format_opts;
2163 ret = opt_default(NULL, opt, arg);
2165 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2166 av_dict_copy(&o->g->format_opts, format_opts, 0);
2167 av_dict_free(&codec_opts);
2168 av_dict_free(&format_opts);
2175 static int opt_preset(void *optctx, const char *opt, const char *arg)
2177 OptionsContext *o = optctx;
2179 char filename[1000], line[1000], tmp_line[1000];
2180 const char *codec_name = NULL;
2184 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2186 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2187 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2188 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2190 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2194 while (fgets(line, sizeof(line), f)) {
2195 char *key = tmp_line, *value, *endptr;
2197 if (strcspn(line, "#\n\r") == 0)
2199 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2200 if (!av_strtok(key, "=", &value) ||
2201 !av_strtok(value, "\r\n", &endptr)) {
2202 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2205 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2207 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2208 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2209 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2210 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2211 else if (opt_default_new(o, key, value) < 0) {
2212 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2213 filename, line, key, value);
2223 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2225 OptionsContext *o = optctx;
2226 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2227 int ret = parse_option(o, s, arg, options);
2232 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2234 OptionsContext *o = optctx;
2235 if(!strcmp(opt, "b")){
2236 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2237 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2240 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2244 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2246 OptionsContext *o = optctx;
2249 if(!strcmp(opt, "qscale")){
2250 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2251 return parse_option(o, "q:v", arg, options);
2253 s = av_asprintf("q%s", opt + 6);
2254 ret = parse_option(o, s, arg, options);
2259 static int opt_profile(void *optctx, const char *opt, const char *arg)
2261 OptionsContext *o = optctx;
2262 if(!strcmp(opt, "profile")){
2263 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2264 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2267 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2271 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2273 OptionsContext *o = optctx;
2274 return parse_option(o, "filter:v", arg, options);
2277 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2279 OptionsContext *o = optctx;
2280 return parse_option(o, "filter:a", arg, options);
2283 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2285 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2286 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2287 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2288 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2290 if (video_sync_method == VSYNC_AUTO)
2291 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2295 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2297 OptionsContext *o = optctx;
2298 char *tcr = av_asprintf("timecode=%s", arg);
2299 int ret = parse_option(o, "metadata:g", tcr, options);
2301 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2306 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2308 OptionsContext *o = optctx;
2309 char layout_str[32];
2312 int ret, channels, ac_str_size;
2315 layout = av_get_channel_layout(arg);
2317 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2318 return AVERROR(EINVAL);
2320 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2321 ret = opt_default_new(o, opt, layout_str);
2325 /* set 'ac' option based on channel layout */
2326 channels = av_get_channel_layout_nb_channels(layout);
2327 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2328 stream_str = strchr(opt, ':');
2329 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2330 ac_str = av_mallocz(ac_str_size);
2332 return AVERROR(ENOMEM);
2333 av_strlcpy(ac_str, "ac", 3);
2335 av_strlcat(ac_str, stream_str, ac_str_size);
2336 ret = parse_option(o, ac_str, layout_str, options);
2342 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2344 OptionsContext *o = optctx;
2345 return parse_option(o, "q:a", arg, options);
2348 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2350 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2351 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2352 return AVERROR(ENOMEM);
2353 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2354 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2355 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2356 return AVERROR(ENOMEM);
2360 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2362 uint8_t *graph_desc = read_file(arg);
2364 return AVERROR(EINVAL);
2366 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2367 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2368 return AVERROR(ENOMEM);
2369 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2370 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2374 void show_help_default(const char *opt, const char *arg)
2376 /* per-file options have at least one of those set */
2377 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2378 int show_advanced = 0, show_avoptions = 0;
2381 if (!strcmp(opt, "long"))
2383 else if (!strcmp(opt, "full"))
2384 show_advanced = show_avoptions = 1;
2386 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2391 printf("Getting help:\n"
2392 " -h -- print basic options\n"
2393 " -h long -- print more options\n"
2394 " -h full -- print all options (including all format and codec specific options, very long)\n"
2395 " See man %s for detailed description of the options.\n"
2396 "\n", program_name);
2398 show_help_options(options, "Print help / information / capabilities:",
2401 show_help_options(options, "Global options (affect whole program "
2402 "instead of just one file:",
2403 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2405 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2406 per_file | OPT_EXIT, 0);
2408 show_help_options(options, "Per-file main options:", 0,
2409 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2410 OPT_EXIT, per_file);
2412 show_help_options(options, "Advanced per-file options:",
2413 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2415 show_help_options(options, "Video options:",
2416 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2418 show_help_options(options, "Advanced Video options:",
2419 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2421 show_help_options(options, "Audio options:",
2422 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2424 show_help_options(options, "Advanced Audio options:",
2425 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2426 show_help_options(options, "Subtitle options:",
2427 OPT_SUBTITLE, 0, 0);
2430 if (show_avoptions) {
2431 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2432 show_help_children(avcodec_get_class(), flags);
2433 show_help_children(avformat_get_class(), flags);
2434 show_help_children(sws_get_class(), flags);
2435 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2436 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2440 void show_usage(void)
2442 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2443 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2444 av_log(NULL, AV_LOG_INFO, "\n");
2452 static const OptionGroupDef groups[] = {
2453 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2454 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2457 static int open_files(OptionGroupList *l, const char *inout,
2458 int (*open_file)(OptionsContext*, const char*))
2462 for (i = 0; i < l->nb_groups; i++) {
2463 OptionGroup *g = &l->groups[i];
2466 init_options(&o, !strcmp(inout, "input"));
2469 ret = parse_optgroup(&o, g);
2471 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2472 "%s.\n", inout, g->arg);
2476 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2477 ret = open_file(&o, g->arg);
2478 uninit_options(&o, !strcmp(inout, "input"));
2480 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2484 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2490 int ffmpeg_parse_options(int argc, char **argv)
2492 OptionParseContext octx;
2496 memset(&octx, 0, sizeof(octx));
2498 /* split the commandline into an internal representation */
2499 ret = split_commandline(&octx, argc, argv, options, groups,
2500 FF_ARRAY_ELEMS(groups));
2502 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2506 /* apply global options */
2507 ret = parse_optgroup(NULL, &octx.global_opts);
2509 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2513 /* open input files */
2514 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2516 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2520 /* open output files */
2521 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2523 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2528 uninit_parse_context(&octx);
2530 av_strerror(ret, error, sizeof(error));
2531 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2536 static int opt_progress(void *optctx, const char *opt, const char *arg)
2538 AVIOContext *avio = NULL;
2541 if (!strcmp(arg, "-"))
2543 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2545 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2546 arg, av_err2str(ret));
2549 progress_avio = avio;
2553 #define OFFSET(x) offsetof(OptionsContext, x)
2554 const OptionDef options[] = {
2556 #include "cmdutils_common_opts.h"
2557 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2558 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2559 "force format", "fmt" },
2560 { "y", OPT_BOOL, { &file_overwrite },
2561 "overwrite output files" },
2562 { "n", OPT_BOOL, { &no_file_overwrite },
2563 "do not overwrite output files" },
2564 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2565 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2566 "codec name", "codec" },
2567 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2568 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2569 "codec name", "codec" },
2570 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2571 OPT_OUTPUT, { .off = OFFSET(presets) },
2572 "preset name", "preset" },
2573 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2574 OPT_OUTPUT, { .func_arg = opt_map },
2575 "set input stream mapping",
2576 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2577 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2578 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2579 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2580 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2581 "set metadata information of outfile from infile",
2582 "outfile[,metadata]:infile[,metadata]" },
2583 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2584 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2585 "set chapters mapping", "input_file_index" },
2586 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2587 "record or transcode \"duration\" seconds of audio/video",
2589 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2590 "record or transcode stop time", "time_stop" },
2591 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2592 "set the limit file size in bytes", "limit_size" },
2593 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2594 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2595 "set the start time offset", "time_off" },
2596 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2597 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2598 "set the input ts offset", "time_off" },
2599 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2600 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2601 "set the input ts scale", "scale" },
2602 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2603 "set the recording timestamp ('now' to set the current time)", "time" },
2604 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2605 "add metadata", "string=string" },
2606 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2607 OPT_OUTPUT, { .func_arg = opt_data_frames },
2608 "set the number of data frames to record", "number" },
2609 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2610 "add timings for benchmarking" },
2611 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2612 "add timings for each task" },
2613 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2614 "write program-readable progress information", "url" },
2615 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2616 "enable or disable interaction on standard input" },
2617 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2618 "set max runtime in seconds", "limit" },
2619 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2620 "dump each input packet" },
2621 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2622 "when dumping packets, also dump the payload" },
2623 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2624 OPT_INPUT, { .off = OFFSET(rate_emu) },
2625 "read input at native frame rate", "" },
2626 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2627 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2628 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2629 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2630 "video sync method", "" },
2631 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2632 "audio sync method", "" },
2633 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2634 "audio drift threshold", "threshold" },
2635 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2636 "copy timestamps" },
2637 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2638 "copy input stream time base when stream copying", "mode" },
2639 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2640 OPT_OUTPUT, { .off = OFFSET(shortest) },
2641 "finish encoding within shortest input" },
2642 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2643 "timestamp discontinuity delta threshold", "threshold" },
2644 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2645 "timestamp error delta threshold", "threshold" },
2646 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2647 "exit on error", "error" },
2648 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2649 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2650 "copy initial non-keyframes" },
2651 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2652 "copy or discard frames before start time" },
2653 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2654 "set the number of frames to record", "number" },
2655 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2656 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2657 "force codec tag/fourcc", "fourcc/tag" },
2658 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2659 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2660 "use fixed quality scale (VBR)", "q" },
2661 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2662 OPT_OUTPUT, { .func_arg = opt_qscale },
2663 "use fixed quality scale (VBR)", "q" },
2664 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2665 "set profile", "profile" },
2666 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2667 "set stream filtergraph", "filter_graph" },
2668 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2669 "read stream filtergraph description from a file", "filename" },
2670 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2671 "reinit filtergraph on input parameter changes", "" },
2672 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2673 "create a complex filtergraph", "graph_description" },
2674 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2675 "create a complex filtergraph", "graph_description" },
2676 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2677 "read complex filtergraph description from a file", "filename" },
2678 { "stats", OPT_BOOL, { &print_stats },
2679 "print progress report during encoding", },
2680 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2681 OPT_OUTPUT, { .func_arg = opt_attach },
2682 "add an attachment to the output file", "filename" },
2683 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2684 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2685 "extract an attachment into a file", "filename" },
2686 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2687 "print timestamp debugging info" },
2690 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2691 "set the number of video frames to record", "number" },
2692 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2693 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2694 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2695 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2696 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2697 "set frame size (WxH or abbreviation)", "size" },
2698 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2699 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2700 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2701 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2702 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2703 "set pixel format", "format" },
2704 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2705 "set the number of bits per raw sample", "number" },
2706 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2707 "deprecated use -g 1" },
2708 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2710 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2711 "discard threshold", "n" },
2712 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2713 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2714 "rate control override for specific intervals", "override" },
2715 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2716 OPT_OUTPUT, { .func_arg = opt_video_codec },
2717 "force video codec ('copy' to copy stream)", "codec" },
2718 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2720 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2722 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2723 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2724 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2725 "select the pass number (1 to 3)", "n" },
2726 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2727 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2728 "select two pass log file name prefix", "prefix" },
2729 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2730 "this option is deprecated, use the yadif filter instead" },
2731 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2732 "calculate PSNR of compressed frames" },
2733 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2734 "dump video coding statistics to file" },
2735 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2736 "dump video coding statistics to file", "file" },
2737 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2738 "set video filters", "filter_graph" },
2739 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2740 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2741 "specify intra matrix coeffs", "matrix" },
2742 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2743 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2744 "specify inter matrix coeffs", "matrix" },
2745 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2746 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2747 "top=1/bottom=0/auto=-1 field first", "" },
2748 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2749 "intra_dc_precision", "precision" },
2750 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2751 OPT_OUTPUT, { .func_arg = opt_old2new },
2752 "force video tag/fourcc", "fourcc/tag" },
2753 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2754 "show QP histogram" },
2755 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2756 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2757 "force the selected framerate, disable the best supported framerate selection" },
2758 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2759 OPT_OUTPUT, { .func_arg = opt_streamid },
2760 "set the value of an outfile streamid", "streamIndex:value" },
2761 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2762 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2763 "force key frames at specified timestamps", "timestamps" },
2764 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2765 "video bitrate (please use -b:v)", "bitrate" },
2768 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2769 "set the number of audio frames to record", "number" },
2770 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2771 "set audio quality (codec-specific)", "quality", },
2772 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2773 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2774 "set audio sampling rate (in Hz)", "rate" },
2775 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2776 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2777 "set number of audio channels", "channels" },
2778 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2780 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2781 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2782 "force audio codec ('copy' to copy stream)", "codec" },
2783 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2784 OPT_OUTPUT, { .func_arg = opt_old2new },
2785 "force audio tag/fourcc", "fourcc/tag" },
2786 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2787 "change audio volume (256=normal)" , "volume" },
2788 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2789 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2790 "set sample format", "format" },
2791 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2792 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2793 "set channel layout", "layout" },
2794 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2795 "set audio filters", "filter_graph" },
2796 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2797 "set the maximum number of channels to try to guess the channel layout" },
2799 /* subtitle options */
2800 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2801 "disable subtitle" },
2802 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2803 "force subtitle codec ('copy' to copy stream)", "codec" },
2804 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2805 , "force subtitle tag/fourcc", "fourcc/tag" },
2806 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2807 "fix subtitles duration" },
2808 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2809 "set canvas size (WxH or abbreviation)", "size" },
2812 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2813 "deprecated, use -channel", "channel" },
2814 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2815 "deprecated, use -standard", "standard" },
2816 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2819 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2820 "set the maximum demux-decode delay", "seconds" },
2821 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2822 "set the initial demux-decode delay", "seconds" },
2824 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2825 "A comma-separated list of bitstream filters", "bitstream_filters" },
2826 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2827 "deprecated", "audio bitstream_filters" },
2828 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2829 "deprecated", "video bitstream_filters" },
2831 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2832 "set the audio options to the indicated preset", "preset" },
2833 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2834 "set the video options to the indicated preset", "preset" },
2835 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2836 "set the subtitle options to the indicated preset", "preset" },
2837 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2838 "set options from indicated preset file", "filename" },
2839 /* data codec support */
2840 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2841 "force data codec ('copy' to copy stream)", "codec" },
2842 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },