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;
96 static int override_ffserver = 0;
98 static int64_t recording_time = INT64_MAX;
100 static void uninit_options(OptionsContext *o, int is_input)
102 const OptionDef *po = options;
105 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
107 void *dst = (uint8_t*)o + po->u.off;
109 if (po->flags & OPT_SPEC) {
110 SpecifierOpt **so = dst;
111 int i, *count = (int*)(so + 1);
112 for (i = 0; i < *count; i++) {
113 av_freep(&(*so)[i].specifier);
114 if (po->flags & OPT_STRING)
115 av_freep(&(*so)[i].u.str);
119 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
124 for (i = 0; i < o->nb_stream_maps; i++)
125 av_freep(&o->stream_maps[i].linklabel);
126 av_freep(&o->stream_maps);
127 av_freep(&o->audio_channel_maps);
128 av_freep(&o->streamid_map);
129 av_freep(&o->attachments);
132 recording_time = o->recording_time;
134 recording_time = INT64_MAX;
137 static void init_options(OptionsContext *o, int is_input)
139 memset(o, 0, sizeof(*o));
141 if (!is_input && recording_time != INT64_MAX) {
142 o->recording_time = recording_time;
143 av_log(NULL, AV_LOG_WARNING,
144 "-t is not an input option, keeping it for the next output;"
145 " consider fixing your command line.\n");
147 o->recording_time = INT64_MAX;
148 o->stop_time = INT64_MAX;
149 o->mux_max_delay = 0.7;
150 o->limit_filesize = UINT64_MAX;
151 o->chapters_input_file = INT_MAX;
154 /* return a copy of the input with the stream specifiers removed from the keys */
155 static AVDictionary *strip_specifiers(AVDictionary *dict)
157 AVDictionaryEntry *e = NULL;
158 AVDictionary *ret = NULL;
160 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
161 char *p = strchr(e->key, ':');
165 av_dict_set(&ret, e->key, e->value, 0);
172 static int opt_sameq(void *optctx, const char *opt, const char *arg)
174 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
175 "If you are looking for an option to preserve the quality (which is not "
176 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
178 return AVERROR(EINVAL);
181 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
183 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
184 return opt_default(optctx, "channel", arg);
187 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
189 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
190 return opt_default(optctx, "standard", arg);
193 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
195 OptionsContext *o = optctx;
196 return parse_option(o, "codec:a", arg, options);
199 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
201 OptionsContext *o = optctx;
202 return parse_option(o, "codec:v", arg, options);
205 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
207 OptionsContext *o = optctx;
208 return parse_option(o, "codec:s", arg, options);
211 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
213 OptionsContext *o = optctx;
214 return parse_option(o, "codec:d", arg, options);
217 static int opt_map(void *optctx, const char *opt, const char *arg)
219 OptionsContext *o = optctx;
221 int i, negative = 0, file_idx;
222 int sync_file_idx = -1, sync_stream_idx = 0;
230 map = av_strdup(arg);
232 /* parse sync stream first, just pick first matching stream */
233 if (sync = strchr(map, ',')) {
235 sync_file_idx = strtol(sync + 1, &sync, 0);
236 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
237 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
242 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
243 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
244 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
248 if (i == input_files[sync_file_idx]->nb_streams) {
249 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
250 "match any streams.\n", arg);
257 /* this mapping refers to lavfi output */
258 const char *c = map + 1;
259 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
260 m = &o->stream_maps[o->nb_stream_maps - 1];
261 m->linklabel = av_get_token(&c, "]");
263 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
267 file_idx = strtol(map, &p, 0);
268 if (file_idx >= nb_input_files || file_idx < 0) {
269 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
273 /* disable some already defined maps */
274 for (i = 0; i < o->nb_stream_maps; i++) {
275 m = &o->stream_maps[i];
276 if (file_idx == m->file_index &&
277 check_stream_specifier(input_files[m->file_index]->ctx,
278 input_files[m->file_index]->ctx->streams[m->stream_index],
279 *p == ':' ? p + 1 : p) > 0)
283 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
284 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
285 *p == ':' ? p + 1 : p) <= 0)
287 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
288 m = &o->stream_maps[o->nb_stream_maps - 1];
290 m->file_index = file_idx;
293 if (sync_file_idx >= 0) {
294 m->sync_file_index = sync_file_idx;
295 m->sync_stream_index = sync_stream_idx;
297 m->sync_file_index = file_idx;
298 m->sync_stream_index = i;
304 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
312 static int opt_attach(void *optctx, const char *opt, const char *arg)
314 OptionsContext *o = optctx;
315 GROW_ARRAY(o->attachments, o->nb_attachments);
316 o->attachments[o->nb_attachments - 1] = arg;
320 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
322 OptionsContext *o = optctx;
327 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
328 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
330 /* muted channel syntax */
331 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
332 if ((n == 1 || n == 3) && m->channel_idx == -1) {
333 m->file_idx = m->stream_idx = -1;
335 m->ofile_idx = m->ostream_idx = -1;
340 n = sscanf(arg, "%d.%d.%d:%d.%d",
341 &m->file_idx, &m->stream_idx, &m->channel_idx,
342 &m->ofile_idx, &m->ostream_idx);
344 if (n != 3 && n != 5) {
345 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
346 "[file.stream.channel|-1][:syncfile:syncstream]\n");
350 if (n != 5) // only file.stream.channel specified
351 m->ofile_idx = m->ostream_idx = -1;
354 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
355 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
359 if (m->stream_idx < 0 ||
360 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
361 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
362 m->file_idx, m->stream_idx);
365 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
366 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
367 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
368 m->file_idx, m->stream_idx);
371 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
372 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
373 m->file_idx, m->stream_idx, m->channel_idx);
380 * Parse a metadata specifier passed as 'arg' parameter.
381 * @param arg metadata string to parse
382 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
383 * @param index for type c/p, chapter/program index is written here
384 * @param stream_spec for type s, the stream specifier is written here
386 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
394 if (*(++arg) && *arg != ':') {
395 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
398 *stream_spec = *arg == ':' ? arg + 1 : "";
403 *index = strtol(++arg, NULL, 0);
406 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
413 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
415 AVDictionary **meta_in = NULL;
416 AVDictionary **meta_out = NULL;
418 char type_in, type_out;
419 const char *istream_spec = NULL, *ostream_spec = NULL;
420 int idx_in = 0, idx_out = 0;
422 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
423 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
426 if (type_out == 'g' || !*outspec)
427 o->metadata_global_manual = 1;
428 if (type_out == 's' || !*outspec)
429 o->metadata_streams_manual = 1;
430 if (type_out == 'c' || !*outspec)
431 o->metadata_chapters_manual = 1;
435 if (type_in == 'g' || type_out == 'g')
436 o->metadata_global_manual = 1;
437 if (type_in == 's' || type_out == 's')
438 o->metadata_streams_manual = 1;
439 if (type_in == 'c' || type_out == 'c')
440 o->metadata_chapters_manual = 1;
442 /* ic is NULL when just disabling automatic mappings */
446 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
447 if ((index) < 0 || (index) >= (nb_elems)) {\
448 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
453 #define SET_DICT(type, meta, context, index)\
456 meta = &context->metadata;\
459 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
460 meta = &context->chapters[index]->metadata;\
463 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
464 meta = &context->programs[index]->metadata;\
467 break; /* handled separately below */ \
468 default: av_assert0(0);\
471 SET_DICT(type_in, meta_in, ic, idx_in);
472 SET_DICT(type_out, meta_out, oc, idx_out);
474 /* for input streams choose first matching stream */
475 if (type_in == 's') {
476 for (i = 0; i < ic->nb_streams; i++) {
477 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
478 meta_in = &ic->streams[i]->metadata;
484 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
489 if (type_out == 's') {
490 for (i = 0; i < oc->nb_streams; i++) {
491 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
492 meta_out = &oc->streams[i]->metadata;
493 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
498 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
503 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
505 OptionsContext *o = optctx;
507 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
508 struct tm time = *gmtime((time_t*)&recording_timestamp);
509 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
510 parse_option(o, "metadata", buf, options);
512 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
513 "tag instead.\n", opt);
517 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
519 const AVCodecDescriptor *desc;
520 const char *codec_string = encoder ? "encoder" : "decoder";
524 avcodec_find_encoder_by_name(name) :
525 avcodec_find_decoder_by_name(name);
527 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
528 codec = encoder ? avcodec_find_encoder(desc->id) :
529 avcodec_find_decoder(desc->id);
531 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
532 codec_string, codec->name, desc->name);
536 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
539 if (codec->type != type) {
540 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
546 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
548 char *codec_name = NULL;
550 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
552 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
553 st->codec->codec_id = codec->id;
556 return avcodec_find_decoder(st->codec->codec_id);
559 /* Add all the streams from the given input file to the global
560 * list of input streams. */
561 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
564 char *next, *codec_tag = NULL;
566 for (i = 0; i < ic->nb_streams; i++) {
567 AVStream *st = ic->streams[i];
568 AVCodecContext *dec = st->codec;
569 InputStream *ist = av_mallocz(sizeof(*ist));
570 char *framerate = NULL;
575 GROW_ARRAY(input_streams, nb_input_streams);
576 input_streams[nb_input_streams - 1] = ist;
579 ist->file_index = nb_input_files;
581 st->discard = AVDISCARD_ALL;
584 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
586 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
588 uint32_t tag = strtol(codec_tag, &next, 0);
590 tag = AV_RL32(codec_tag);
591 st->codec->codec_tag = tag;
594 ist->dec = choose_decoder(o, ic, st);
595 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
597 ist->reinit_filters = -1;
598 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
600 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
602 switch (dec->codec_type) {
603 case AVMEDIA_TYPE_VIDEO:
605 ist->dec = avcodec_find_decoder(dec->codec_id);
607 dec->flags |= CODEC_FLAG_EMU_EDGE;
610 ist->resample_height = dec->height;
611 ist->resample_width = dec->width;
612 ist->resample_pix_fmt = dec->pix_fmt;
614 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
615 if (framerate && av_parse_video_rate(&ist->framerate,
617 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
622 ist->top_field_first = -1;
623 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
626 case AVMEDIA_TYPE_AUDIO:
627 ist->guess_layout_max = INT_MAX;
628 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
629 guess_input_channel_layout(ist);
631 ist->resample_sample_fmt = dec->sample_fmt;
632 ist->resample_sample_rate = dec->sample_rate;
633 ist->resample_channels = dec->channels;
634 ist->resample_channel_layout = dec->channel_layout;
637 case AVMEDIA_TYPE_DATA:
638 case AVMEDIA_TYPE_SUBTITLE: {
639 char *canvas_size = NULL;
641 ist->dec = avcodec_find_decoder(dec->codec_id);
642 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
643 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
645 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
646 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
651 case AVMEDIA_TYPE_ATTACHMENT:
652 case AVMEDIA_TYPE_UNKNOWN:
660 static void assert_file_overwrite(const char *filename)
662 if ((!file_overwrite || no_file_overwrite) &&
663 (strchr(filename, ':') == NULL || filename[1] == ':' ||
664 av_strstart(filename, "file:", NULL))) {
665 if (avio_check(filename, 0) == 0) {
666 if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
667 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
670 signal(SIGINT, SIG_DFL);
672 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
678 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
685 static void dump_attachment(AVStream *st, const char *filename)
688 AVIOContext *out = NULL;
689 AVDictionaryEntry *e;
691 if (!st->codec->extradata_size) {
692 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
693 nb_input_files - 1, st->index);
696 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
699 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
700 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
704 assert_file_overwrite(filename);
706 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
707 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
712 avio_write(out, st->codec->extradata, st->codec->extradata_size);
717 static int open_input_file(OptionsContext *o, const char *filename)
721 AVInputFormat *file_iformat = NULL;
726 AVDictionary *unused_opts = NULL;
727 AVDictionaryEntry *e = NULL;
728 int orig_nb_streams; // number of streams before avformat_find_stream_info
729 char * video_codec_name = NULL;
730 char * audio_codec_name = NULL;
731 char *subtitle_codec_name = NULL;
734 if (!(file_iformat = av_find_input_format(o->format))) {
735 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
740 if (!strcmp(filename, "-"))
743 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
744 strcmp(filename, "/dev/stdin");
746 /* get default parameters from command line */
747 ic = avformat_alloc_context();
749 print_error(filename, AVERROR(ENOMEM));
752 if (o->nb_audio_sample_rate) {
753 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
754 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
756 if (o->nb_audio_channels) {
757 /* because we set audio_channels based on both the "ac" and
758 * "channel_layout" options, we need to check that the specified
759 * demuxer actually has the "channels" option before setting it */
760 if (file_iformat && file_iformat->priv_class &&
761 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
762 AV_OPT_SEARCH_FAKE_OBJ)) {
763 snprintf(buf, sizeof(buf), "%d",
764 o->audio_channels[o->nb_audio_channels - 1].u.i);
765 av_dict_set(&o->g->format_opts, "channels", buf, 0);
768 if (o->nb_frame_rates) {
769 /* set the format-level framerate option;
770 * this is important for video grabbers, e.g. x11 */
771 if (file_iformat && file_iformat->priv_class &&
772 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
773 AV_OPT_SEARCH_FAKE_OBJ)) {
774 av_dict_set(&o->g->format_opts, "framerate",
775 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
778 if (o->nb_frame_sizes) {
779 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
781 if (o->nb_frame_pix_fmts)
782 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
784 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
785 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
786 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
788 ic->video_codec_id = video_codec_name ?
789 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
790 ic->audio_codec_id = audio_codec_name ?
791 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
792 ic->subtitle_codec_id= subtitle_codec_name ?
793 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
794 ic->flags |= AVFMT_FLAG_NONBLOCK;
795 ic->interrupt_callback = int_cb;
797 /* open the input file with generic avformat function */
798 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
800 print_error(filename, err);
803 assert_avoptions(o->g->format_opts);
805 /* apply forced codec ids */
806 for (i = 0; i < ic->nb_streams; i++)
807 choose_decoder(o, ic, ic->streams[i]);
809 /* Set AVCodecContext options for avformat_find_stream_info */
810 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
811 orig_nb_streams = ic->nb_streams;
813 /* If not enough info to get the stream parameters, we decode the
814 first frames to get it. (used in mpeg case for example) */
815 ret = avformat_find_stream_info(ic, opts);
817 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
818 avformat_close_input(&ic);
822 timestamp = o->start_time;
823 /* add the stream start time */
824 if (ic->start_time != AV_NOPTS_VALUE)
825 timestamp += ic->start_time;
827 /* if seeking requested, we execute it */
828 if (o->start_time != 0) {
829 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
831 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
832 filename, (double)timestamp / AV_TIME_BASE);
836 /* update the current parameters so that they match the one of the input stream */
837 add_input_streams(o, ic);
839 /* dump the file content */
840 av_dump_format(ic, nb_input_files, filename, 0);
842 GROW_ARRAY(input_files, nb_input_files);
843 f = av_mallocz(sizeof(*f));
846 input_files[nb_input_files - 1] = f;
849 f->ist_index = nb_input_streams - ic->nb_streams;
850 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
851 f->nb_streams = ic->nb_streams;
852 f->rate_emu = o->rate_emu;
854 /* check if all codec options have been used */
855 unused_opts = strip_specifiers(o->g->codec_opts);
856 for (i = f->ist_index; i < nb_input_streams; i++) {
858 while ((e = av_dict_get(input_streams[i]->opts, "", e,
859 AV_DICT_IGNORE_SUFFIX)))
860 av_dict_set(&unused_opts, e->key, NULL, 0);
864 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
865 const AVClass *class = avcodec_get_class();
866 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
867 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
870 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
871 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
872 "input file #%d (%s) is not a decoding option.\n", e->key,
873 option->help ? option->help : "", nb_input_files - 1,
878 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
879 "input file #%d (%s) has not been used for any stream. The most "
880 "likely reason is either wrong type (e.g. a video option with "
881 "no video streams) or that it is a private option of some decoder "
882 "which was not actually used for any stream.\n", e->key,
883 option->help ? option->help : "", nb_input_files - 1, filename);
885 av_dict_free(&unused_opts);
887 for (i = 0; i < o->nb_dump_attachment; i++) {
890 for (j = 0; j < ic->nb_streams; j++) {
891 AVStream *st = ic->streams[j];
893 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
894 dump_attachment(st, o->dump_attachment[i].u.str);
898 for (i = 0; i < orig_nb_streams; i++)
899 av_dict_free(&opts[i]);
905 static uint8_t *get_line(AVIOContext *s)
911 if (avio_open_dyn_buf(&line) < 0) {
912 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
916 while ((c = avio_r8(s)) && c != '\n')
919 avio_close_dyn_buf(line, &buf);
924 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
928 const char *base[3] = { getenv("AVCONV_DATADIR"),
933 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
937 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
938 i != 1 ? "" : "/.avconv", codec_name, preset_name);
939 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
942 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
943 i != 1 ? "" : "/.avconv", preset_name);
944 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
950 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
952 char *codec_name = NULL;
954 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
956 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
957 NULL, ost->st->codec->codec_type);
958 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
959 } else if (!strcmp(codec_name, "copy"))
960 ost->stream_copy = 1;
962 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
963 ost->st->codec->codec_id = ost->enc->id;
967 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
970 AVStream *st = avformat_new_stream(oc, NULL);
971 int idx = oc->nb_streams - 1, ret = 0;
972 char *bsf = NULL, *next, *codec_tag = NULL;
973 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
978 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
982 if (oc->nb_streams - 1 < o->nb_streamid_map)
983 st->id = o->streamid_map[oc->nb_streams - 1];
985 GROW_ARRAY(output_streams, nb_output_streams);
986 if (!(ost = av_mallocz(sizeof(*ost))))
988 output_streams[nb_output_streams - 1] = ost;
990 ost->file_index = nb_output_files - 1;
993 st->codec->codec_type = type;
994 choose_encoder(o, oc, ost);
996 AVIOContext *s = NULL;
997 char *buf = NULL, *arg = NULL, *preset = NULL;
999 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1001 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1002 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1005 if (!buf[0] || buf[0] == '#') {
1009 if (!(arg = strchr(buf, '='))) {
1010 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1014 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1016 } while (!s->eof_reached);
1020 av_log(NULL, AV_LOG_FATAL,
1021 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1022 preset, ost->file_index, ost->index);
1026 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1029 avcodec_get_context_defaults3(st->codec, ost->enc);
1030 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1032 ost->max_frames = INT64_MAX;
1033 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1034 for (i = 0; i<o->nb_max_frames; i++) {
1035 char *p = o->max_frames[i].specifier;
1036 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1037 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1042 ost->copy_prior_start = -1;
1043 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1045 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1047 if (next = strchr(bsf, ','))
1049 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1050 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1054 bsfc_prev->next = bsfc;
1056 ost->bitstream_filters = bsfc;
1062 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1064 uint32_t tag = strtol(codec_tag, &next, 0);
1066 tag = AV_RL32(codec_tag);
1067 st->codec->codec_tag = tag;
1070 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1072 st->codec->flags |= CODEC_FLAG_QSCALE;
1073 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1076 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1077 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1079 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1081 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1082 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1083 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1085 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1087 ost->source_index = source_index;
1088 if (source_index >= 0) {
1089 ost->sync_ist = input_streams[source_index];
1090 input_streams[source_index]->discard = 0;
1091 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1093 ost->last_mux_dts = AV_NOPTS_VALUE;
1098 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1101 const char *p = str;
1108 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1115 /* read file contents into a string */
1116 static uint8_t *read_file(const char *filename)
1118 AVIOContext *pb = NULL;
1119 AVIOContext *dyn_buf = NULL;
1120 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1121 uint8_t buf[1024], *str;
1124 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1128 ret = avio_open_dyn_buf(&dyn_buf);
1133 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1134 avio_write(dyn_buf, buf, ret);
1135 avio_w8(dyn_buf, 0);
1138 ret = avio_close_dyn_buf(dyn_buf, &str);
1144 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1147 AVStream *st = ost->st;
1148 char *filter = NULL, *filter_script = NULL;
1150 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1151 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1153 if (filter_script && filter) {
1154 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1155 "output stream #%d:%d.\n", nb_output_files, st->index);
1160 return read_file(filter_script);
1162 return av_strdup(filter);
1164 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1168 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1172 AVCodecContext *video_enc;
1173 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1175 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1177 video_enc = st->codec;
1179 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1180 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1181 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1185 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1186 if (frame_aspect_ratio) {
1188 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1189 q.num <= 0 || q.den <= 0) {
1190 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1193 ost->frame_aspect_ratio = q;
1196 if (!ost->stream_copy) {
1197 const char *p = NULL;
1198 char *frame_size = NULL;
1199 char *frame_pix_fmt = NULL;
1200 char *intra_matrix = NULL, *inter_matrix = NULL;
1204 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1205 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1206 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1210 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1211 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1212 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1213 ost->keep_pix_fmt = 1;
1214 if (!*++frame_pix_fmt)
1215 frame_pix_fmt = NULL;
1217 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1218 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1221 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1224 video_enc->gop_size = 0;
1225 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1227 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1228 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1231 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1233 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1235 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1236 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1239 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1242 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1243 for (i = 0; p; i++) {
1245 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1247 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1250 /* FIXME realloc failure */
1251 video_enc->rc_override =
1252 av_realloc(video_enc->rc_override,
1253 sizeof(RcOverride) * (i + 1));
1254 video_enc->rc_override[i].start_frame = start;
1255 video_enc->rc_override[i].end_frame = end;
1257 video_enc->rc_override[i].qscale = q;
1258 video_enc->rc_override[i].quality_factor = 1.0;
1261 video_enc->rc_override[i].qscale = 0;
1262 video_enc->rc_override[i].quality_factor = -q/100.0;
1267 video_enc->rc_override_count = i;
1268 video_enc->intra_dc_precision = intra_dc_precision - 8;
1271 video_enc->flags|= CODEC_FLAG_PSNR;
1274 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1277 video_enc->flags |= CODEC_FLAG_PASS1;
1278 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1281 video_enc->flags |= CODEC_FLAG_PASS2;
1282 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1286 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1287 if (ost->logfile_prefix &&
1288 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1291 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1292 if (ost->forced_keyframes)
1293 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1295 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1297 ost->top_field_first = -1;
1298 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1301 ost->avfilter = get_ost_filters(o, oc, ost);
1305 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1311 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1316 AVCodecContext *audio_enc;
1318 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1321 audio_enc = st->codec;
1322 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1324 if (!ost->stream_copy) {
1325 char *sample_fmt = NULL;
1327 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1329 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1331 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1332 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1336 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1338 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1339 ost->apad = av_strdup(ost->apad);
1341 ost->avfilter = get_ost_filters(o, oc, ost);
1345 /* check for channel mapping for this audio stream */
1346 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1347 AudioChannelMap *map = &o->audio_channel_maps[n];
1348 InputStream *ist = input_streams[ost->source_index];
1349 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1350 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1351 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1352 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1353 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1355 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1356 ost->file_index, ost->st->index);
1364 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1368 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1369 if (!ost->stream_copy) {
1370 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1377 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1379 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1380 ost->stream_copy = 1;
1385 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1389 AVCodecContext *subtitle_enc;
1391 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1393 subtitle_enc = st->codec;
1395 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1397 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1399 if (!ost->stream_copy) {
1400 char *frame_size = NULL;
1402 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1403 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1404 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1412 /* arg format is "output-stream-index:streamid-value". */
1413 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1415 OptionsContext *o = optctx;
1420 av_strlcpy(idx_str, arg, sizeof(idx_str));
1421 p = strchr(idx_str, ':');
1423 av_log(NULL, AV_LOG_FATAL,
1424 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1429 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1430 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1431 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1435 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1437 AVFormatContext *is = ifile->ctx;
1438 AVFormatContext *os = ofile->ctx;
1442 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1444 return AVERROR(ENOMEM);
1447 for (i = 0; i < is->nb_chapters; i++) {
1448 AVChapter *in_ch = is->chapters[i], *out_ch;
1449 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1450 AV_TIME_BASE_Q, in_ch->time_base);
1451 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1452 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1455 if (in_ch->end < ts_off)
1457 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1460 out_ch = av_mallocz(sizeof(AVChapter));
1462 return AVERROR(ENOMEM);
1464 out_ch->id = in_ch->id;
1465 out_ch->time_base = in_ch->time_base;
1466 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1467 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1470 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1472 os->chapters[os->nb_chapters++] = out_ch;
1477 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1480 AVFormatContext *ic = avformat_alloc_context();
1482 ic->interrupt_callback = int_cb;
1483 err = avformat_open_input(&ic, filename, NULL, NULL);
1486 /* copy stream format */
1487 for(i=0;i<ic->nb_streams;i++) {
1491 AVCodecContext *avctx;
1493 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1494 ost = new_output_stream(o, s, codec->type, -1);
1499 // FIXME: a more elegant solution is needed
1500 memcpy(st, ic->streams[i], sizeof(AVStream));
1502 st->info = av_malloc(sizeof(*st->info));
1503 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1505 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1507 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1508 choose_sample_fmt(st, codec);
1509 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1510 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1513 avformat_close_input(&ic);
1517 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1518 AVFormatContext *oc)
1522 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1523 ofilter->out_tmp->pad_idx)) {
1524 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1525 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1527 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1532 ost->source_index = -1;
1533 ost->filter = ofilter;
1537 if (ost->stream_copy) {
1538 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1539 "which is fed from a complex filtergraph. Filtering and streamcopy "
1540 "cannot be used together.\n", ost->file_index, ost->index);
1544 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1545 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1548 avfilter_inout_free(&ofilter->out_tmp);
1551 static int configure_complex_filters(void)
1555 for (i = 0; i < nb_filtergraphs; i++)
1556 if (!filtergraphs[i]->graph &&
1557 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1562 static int open_output_file(OptionsContext *o, const char *filename)
1564 AVFormatContext *oc;
1566 AVOutputFormat *file_oformat;
1570 AVDictionary *unused_opts = NULL;
1571 AVDictionaryEntry *e = NULL;
1573 if (configure_complex_filters() < 0) {
1574 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1578 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1579 o->stop_time = INT64_MAX;
1580 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1583 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1584 if (o->stop_time <= o->start_time) {
1585 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1586 o->stop_time = INT64_MAX;
1588 o->recording_time = o->stop_time - o->start_time;
1592 GROW_ARRAY(output_files, nb_output_files);
1593 of = av_mallocz(sizeof(*of));
1596 output_files[nb_output_files - 1] = of;
1598 of->ost_index = nb_output_streams;
1599 of->recording_time = o->recording_time;
1600 of->start_time = o->start_time;
1601 of->limit_filesize = o->limit_filesize;
1602 of->shortest = o->shortest;
1603 av_dict_copy(&of->opts, o->g->format_opts, 0);
1605 if (!strcmp(filename, "-"))
1608 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1610 print_error(filename, err);
1615 if (o->recording_time != INT64_MAX)
1616 oc->duration = o->recording_time;
1618 file_oformat= oc->oformat;
1619 oc->interrupt_callback = int_cb;
1621 /* create streams for all unlabeled output pads */
1622 for (i = 0; i < nb_filtergraphs; i++) {
1623 FilterGraph *fg = filtergraphs[i];
1624 for (j = 0; j < fg->nb_outputs; j++) {
1625 OutputFilter *ofilter = fg->outputs[j];
1627 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1630 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1631 ofilter->out_tmp->pad_idx)) {
1632 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1633 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1634 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1636 init_output_filter(ofilter, o, oc);
1640 /* ffserver seeking with date=... needs a date reference */
1641 if (!strcmp(file_oformat->name, "ffm") &&
1642 av_strstart(filename, "http:", NULL)) {
1643 int err = parse_option(o, "metadata", "creation_time=now", options);
1645 print_error(filename, err);
1650 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1651 av_strstart(filename, "http:", NULL)) {
1653 /* special case for files sent to ffserver: we get the stream
1654 parameters from ffserver */
1655 int err = read_ffserver_streams(o, oc, filename);
1657 print_error(filename, err);
1660 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1661 ost = output_streams[j];
1662 for (i = 0; i < nb_input_streams; i++) {
1663 ist = input_streams[i];
1664 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1666 ost->source_index= i;
1667 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1668 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1670 ist->st->discard = AVDISCARD_NONE;
1675 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));
1679 } else if (!o->nb_stream_maps) {
1680 char *subtitle_codec_name = NULL;
1681 /* pick the "best" stream of each type */
1683 /* video: highest resolution */
1684 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1685 int area = 0, idx = -1;
1686 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1687 for (i = 0; i < nb_input_streams; i++) {
1689 ist = input_streams[i];
1690 new_area = ist->st->codec->width * ist->st->codec->height;
1691 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1693 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1695 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1702 new_video_stream(o, oc, idx);
1705 /* audio: most channels */
1706 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1707 int channels = 0, idx = -1;
1708 for (i = 0; i < nb_input_streams; i++) {
1709 ist = input_streams[i];
1710 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1711 ist->st->codec->channels > channels) {
1712 channels = ist->st->codec->channels;
1717 new_audio_stream(o, oc, idx);
1720 /* subtitles: pick first */
1721 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1722 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1723 for (i = 0; i < nb_input_streams; i++)
1724 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1725 new_subtitle_stream(o, oc, i);
1729 /* do something with data? */
1731 for (i = 0; i < o->nb_stream_maps; i++) {
1732 StreamMap *map = &o->stream_maps[i];
1737 if (map->linklabel) {
1739 OutputFilter *ofilter = NULL;
1742 for (j = 0; j < nb_filtergraphs; j++) {
1743 fg = filtergraphs[j];
1744 for (k = 0; k < fg->nb_outputs; k++) {
1745 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1746 if (out && !strcmp(out->name, map->linklabel)) {
1747 ofilter = fg->outputs[k];
1754 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1755 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1758 init_output_filter(ofilter, o, oc);
1760 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1762 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1763 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1765 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1767 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1769 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1772 switch (ist->st->codec->codec_type) {
1773 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1774 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1775 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1776 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1777 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1779 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1780 map->file_index, map->stream_index);
1787 /* handle attached files */
1788 for (i = 0; i < o->nb_attachments; i++) {
1790 uint8_t *attachment;
1794 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1795 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1799 if ((len = avio_size(pb)) <= 0) {
1800 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1804 if (!(attachment = av_malloc(len))) {
1805 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1809 avio_read(pb, attachment, len);
1811 ost = new_attachment_stream(o, oc, -1);
1812 ost->stream_copy = 0;
1813 ost->attachment_filename = o->attachments[i];
1815 ost->st->codec->extradata = attachment;
1816 ost->st->codec->extradata_size = len;
1818 p = strrchr(o->attachments[i], '/');
1819 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1823 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1824 AVDictionaryEntry *e;
1825 ost = output_streams[i];
1827 if ((ost->stream_copy || ost->attachment_filename)
1828 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1829 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1830 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1834 /* check if all codec options have been used */
1835 unused_opts = strip_specifiers(o->g->codec_opts);
1836 for (i = of->ost_index; i < nb_output_streams; i++) {
1838 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1839 AV_DICT_IGNORE_SUFFIX)))
1840 av_dict_set(&unused_opts, e->key, NULL, 0);
1844 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1845 const AVClass *class = avcodec_get_class();
1846 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1847 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1850 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1851 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1852 "output file #%d (%s) is not an encoding option.\n", e->key,
1853 option->help ? option->help : "", nb_output_files - 1,
1858 // gop_timecode is injected by generic code but not always used
1859 if (!strcmp(e->key, "gop_timecode"))
1862 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1863 "output file #%d (%s) has not been used for any stream. The most "
1864 "likely reason is either wrong type (e.g. a video option with "
1865 "no video streams) or that it is a private option of some encoder "
1866 "which was not actually used for any stream.\n", e->key,
1867 option->help ? option->help : "", nb_output_files - 1, filename);
1869 av_dict_free(&unused_opts);
1871 /* check filename in case of an image number is expected */
1872 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1873 if (!av_filename_number_test(oc->filename)) {
1874 print_error(oc->filename, AVERROR(EINVAL));
1879 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1880 /* test if it already exists to avoid losing precious files */
1881 assert_file_overwrite(filename);
1884 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1885 &oc->interrupt_callback,
1887 print_error(filename, err);
1890 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1891 assert_file_overwrite(filename);
1893 if (o->mux_preload) {
1895 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1896 av_dict_set(&of->opts, "preload", buf, 0);
1898 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1901 for (i = 0; i < o->nb_metadata_map; i++) {
1903 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1905 if (in_file_index >= nb_input_files) {
1906 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1909 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1910 in_file_index >= 0 ?
1911 input_files[in_file_index]->ctx : NULL, o);
1915 if (o->chapters_input_file >= nb_input_files) {
1916 if (o->chapters_input_file == INT_MAX) {
1917 /* copy chapters from the first input file that has them*/
1918 o->chapters_input_file = -1;
1919 for (i = 0; i < nb_input_files; i++)
1920 if (input_files[i]->ctx->nb_chapters) {
1921 o->chapters_input_file = i;
1925 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1926 o->chapters_input_file);
1930 if (o->chapters_input_file >= 0)
1931 copy_chapters(input_files[o->chapters_input_file], of,
1932 !o->metadata_chapters_manual);
1934 /* copy global metadata by default */
1935 if (!o->metadata_global_manual && nb_input_files){
1936 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1937 AV_DICT_DONT_OVERWRITE);
1938 if(o->recording_time != INT64_MAX)
1939 av_dict_set(&oc->metadata, "duration", NULL, 0);
1940 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1942 if (!o->metadata_streams_manual)
1943 for (i = of->ost_index; i < nb_output_streams; i++) {
1945 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1947 ist = input_streams[output_streams[i]->source_index];
1948 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1951 /* process manually set metadata */
1952 for (i = 0; i < o->nb_metadata; i++) {
1955 const char *stream_spec;
1956 int index = 0, j, ret = 0;
1958 val = strchr(o->metadata[i].u.str, '=');
1960 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1961 o->metadata[i].u.str);
1966 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1968 for (j = 0; j < oc->nb_streams; j++) {
1969 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1970 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1981 if (index < 0 || index >= oc->nb_chapters) {
1982 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1985 m = &oc->chapters[index]->metadata;
1988 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1991 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1998 static int opt_target(void *optctx, const char *opt, const char *arg)
2000 OptionsContext *o = optctx;
2001 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2002 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2004 if (!strncmp(arg, "pal-", 4)) {
2007 } else if (!strncmp(arg, "ntsc-", 5)) {
2010 } else if (!strncmp(arg, "film-", 5)) {
2014 /* Try to determine PAL/NTSC by peeking in the input files */
2015 if (nb_input_files) {
2017 for (j = 0; j < nb_input_files; j++) {
2018 for (i = 0; i < input_files[j]->nb_streams; i++) {
2019 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2020 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2022 fr = c->time_base.den * 1000 / c->time_base.num;
2026 } else if ((fr == 29970) || (fr == 23976)) {
2031 if (norm != UNKNOWN)
2035 if (norm != UNKNOWN)
2036 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2039 if (norm == UNKNOWN) {
2040 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2041 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2042 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2046 if (!strcmp(arg, "vcd")) {
2047 opt_video_codec(o, "c:v", "mpeg1video");
2048 opt_audio_codec(o, "c:a", "mp2");
2049 parse_option(o, "f", "vcd", options);
2050 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2052 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2053 parse_option(o, "r", frame_rates[norm], options);
2054 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2056 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2057 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2058 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2059 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2061 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2062 parse_option(o, "ar", "44100", options);
2063 parse_option(o, "ac", "2", options);
2065 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2066 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2068 /* We have to offset the PTS, so that it is consistent with the SCR.
2069 SCR starts at 36000, but the first two packs contain only padding
2070 and the first pack from the other stream, respectively, may also have
2071 been written before.
2072 So the real data starts at SCR 36000+3*1200. */
2073 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2074 } else if (!strcmp(arg, "svcd")) {
2076 opt_video_codec(o, "c:v", "mpeg2video");
2077 opt_audio_codec(o, "c:a", "mp2");
2078 parse_option(o, "f", "svcd", options);
2080 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2081 parse_option(o, "r", frame_rates[norm], options);
2082 parse_option(o, "pix_fmt", "yuv420p", options);
2083 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2085 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2086 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2087 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2088 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2089 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2091 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2092 parse_option(o, "ar", "44100", options);
2094 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2096 } else if (!strcmp(arg, "dvd")) {
2098 opt_video_codec(o, "c:v", "mpeg2video");
2099 opt_audio_codec(o, "c:a", "ac3");
2100 parse_option(o, "f", "dvd", options);
2102 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2103 parse_option(o, "r", frame_rates[norm], options);
2104 parse_option(o, "pix_fmt", "yuv420p", options);
2105 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2107 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2108 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2109 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2110 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2112 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.
2113 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2115 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2116 parse_option(o, "ar", "48000", options);
2118 } else if (!strncmp(arg, "dv", 2)) {
2120 parse_option(o, "f", "dv", options);
2122 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2123 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2124 norm == PAL ? "yuv420p" : "yuv411p", options);
2125 parse_option(o, "r", frame_rates[norm], options);
2127 parse_option(o, "ar", "48000", options);
2128 parse_option(o, "ac", "2", options);
2131 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2132 return AVERROR(EINVAL);
2137 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2139 av_free (vstats_filename);
2140 vstats_filename = av_strdup (arg);
2144 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2147 time_t today2 = time(NULL);
2148 struct tm *today = localtime(&today2);
2150 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2152 return opt_vstats_file(NULL, opt, filename);
2155 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2157 OptionsContext *o = optctx;
2158 return parse_option(o, "frames:v", arg, options);
2161 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2163 OptionsContext *o = optctx;
2164 return parse_option(o, "frames:a", arg, options);
2167 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2169 OptionsContext *o = optctx;
2170 return parse_option(o, "frames:d", arg, options);
2173 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2176 AVDictionary *cbak = codec_opts;
2177 AVDictionary *fbak = format_opts;
2181 ret = opt_default(NULL, opt, arg);
2183 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2184 av_dict_copy(&o->g->format_opts, format_opts, 0);
2185 av_dict_free(&codec_opts);
2186 av_dict_free(&format_opts);
2193 static int opt_preset(void *optctx, const char *opt, const char *arg)
2195 OptionsContext *o = optctx;
2197 char filename[1000], line[1000], tmp_line[1000];
2198 const char *codec_name = NULL;
2202 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2204 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2205 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2206 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2208 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2212 while (fgets(line, sizeof(line), f)) {
2213 char *key = tmp_line, *value, *endptr;
2215 if (strcspn(line, "#\n\r") == 0)
2217 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2218 if (!av_strtok(key, "=", &value) ||
2219 !av_strtok(value, "\r\n", &endptr)) {
2220 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2223 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2225 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2226 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2227 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2228 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2229 else if (opt_default_new(o, key, value) < 0) {
2230 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2231 filename, line, key, value);
2241 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2243 OptionsContext *o = optctx;
2244 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2245 int ret = parse_option(o, s, arg, options);
2250 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2252 OptionsContext *o = optctx;
2253 if(!strcmp(opt, "b")){
2254 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2255 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2258 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2262 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2264 OptionsContext *o = optctx;
2267 if(!strcmp(opt, "qscale")){
2268 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2269 return parse_option(o, "q:v", arg, options);
2271 s = av_asprintf("q%s", opt + 6);
2272 ret = parse_option(o, s, arg, options);
2277 static int opt_profile(void *optctx, const char *opt, const char *arg)
2279 OptionsContext *o = optctx;
2280 if(!strcmp(opt, "profile")){
2281 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2282 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2285 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2289 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2291 OptionsContext *o = optctx;
2292 return parse_option(o, "filter:v", arg, options);
2295 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2297 OptionsContext *o = optctx;
2298 return parse_option(o, "filter:a", arg, options);
2301 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2303 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2304 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2305 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2306 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2308 if (video_sync_method == VSYNC_AUTO)
2309 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2313 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2315 OptionsContext *o = optctx;
2316 char *tcr = av_asprintf("timecode=%s", arg);
2317 int ret = parse_option(o, "metadata:g", tcr, options);
2319 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2324 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2326 OptionsContext *o = optctx;
2327 char layout_str[32];
2330 int ret, channels, ac_str_size;
2333 layout = av_get_channel_layout(arg);
2335 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2336 return AVERROR(EINVAL);
2338 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2339 ret = opt_default_new(o, opt, layout_str);
2343 /* set 'ac' option based on channel layout */
2344 channels = av_get_channel_layout_nb_channels(layout);
2345 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2346 stream_str = strchr(opt, ':');
2347 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2348 ac_str = av_mallocz(ac_str_size);
2350 return AVERROR(ENOMEM);
2351 av_strlcpy(ac_str, "ac", 3);
2353 av_strlcat(ac_str, stream_str, ac_str_size);
2354 ret = parse_option(o, ac_str, layout_str, options);
2360 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2362 OptionsContext *o = optctx;
2363 return parse_option(o, "q:a", arg, options);
2366 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2368 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2369 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2370 return AVERROR(ENOMEM);
2371 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2372 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2373 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2374 return AVERROR(ENOMEM);
2378 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2380 uint8_t *graph_desc = read_file(arg);
2382 return AVERROR(EINVAL);
2384 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2385 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2386 return AVERROR(ENOMEM);
2387 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2388 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2392 void show_help_default(const char *opt, const char *arg)
2394 /* per-file options have at least one of those set */
2395 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2396 int show_advanced = 0, show_avoptions = 0;
2399 if (!strcmp(opt, "long"))
2401 else if (!strcmp(opt, "full"))
2402 show_advanced = show_avoptions = 1;
2404 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2409 printf("Getting help:\n"
2410 " -h -- print basic options\n"
2411 " -h long -- print more options\n"
2412 " -h full -- print all options (including all format and codec specific options, very long)\n"
2413 " See man %s for detailed description of the options.\n"
2414 "\n", program_name);
2416 show_help_options(options, "Print help / information / capabilities:",
2419 show_help_options(options, "Global options (affect whole program "
2420 "instead of just one file:",
2421 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2423 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2424 per_file | OPT_EXIT, 0);
2426 show_help_options(options, "Per-file main options:", 0,
2427 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2428 OPT_EXIT, per_file);
2430 show_help_options(options, "Advanced per-file options:",
2431 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2433 show_help_options(options, "Video options:",
2434 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2436 show_help_options(options, "Advanced Video options:",
2437 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2439 show_help_options(options, "Audio options:",
2440 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2442 show_help_options(options, "Advanced Audio options:",
2443 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2444 show_help_options(options, "Subtitle options:",
2445 OPT_SUBTITLE, 0, 0);
2448 if (show_avoptions) {
2449 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2450 show_help_children(avcodec_get_class(), flags);
2451 show_help_children(avformat_get_class(), flags);
2452 show_help_children(sws_get_class(), flags);
2453 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2454 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2458 void show_usage(void)
2460 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2461 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2462 av_log(NULL, AV_LOG_INFO, "\n");
2470 static const OptionGroupDef groups[] = {
2471 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2472 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2475 static int open_files(OptionGroupList *l, const char *inout,
2476 int (*open_file)(OptionsContext*, const char*))
2480 for (i = 0; i < l->nb_groups; i++) {
2481 OptionGroup *g = &l->groups[i];
2484 init_options(&o, !strcmp(inout, "input"));
2487 ret = parse_optgroup(&o, g);
2489 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2490 "%s.\n", inout, g->arg);
2494 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2495 ret = open_file(&o, g->arg);
2496 uninit_options(&o, !strcmp(inout, "input"));
2498 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2502 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2508 int ffmpeg_parse_options(int argc, char **argv)
2510 OptionParseContext octx;
2514 memset(&octx, 0, sizeof(octx));
2516 /* split the commandline into an internal representation */
2517 ret = split_commandline(&octx, argc, argv, options, groups,
2518 FF_ARRAY_ELEMS(groups));
2520 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2524 /* apply global options */
2525 ret = parse_optgroup(NULL, &octx.global_opts);
2527 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2531 /* open input files */
2532 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2534 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2538 /* open output files */
2539 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2541 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2546 uninit_parse_context(&octx);
2548 av_strerror(ret, error, sizeof(error));
2549 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2554 static int opt_progress(void *optctx, const char *opt, const char *arg)
2556 AVIOContext *avio = NULL;
2559 if (!strcmp(arg, "-"))
2561 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2563 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2564 arg, av_err2str(ret));
2567 progress_avio = avio;
2571 #define OFFSET(x) offsetof(OptionsContext, x)
2572 const OptionDef options[] = {
2574 #include "cmdutils_common_opts.h"
2575 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2576 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2577 "force format", "fmt" },
2578 { "y", OPT_BOOL, { &file_overwrite },
2579 "overwrite output files" },
2580 { "n", OPT_BOOL, { &no_file_overwrite },
2581 "do not overwrite output files" },
2582 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2583 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2584 "codec name", "codec" },
2585 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2586 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2587 "codec name", "codec" },
2588 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2589 OPT_OUTPUT, { .off = OFFSET(presets) },
2590 "preset name", "preset" },
2591 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2592 OPT_OUTPUT, { .func_arg = opt_map },
2593 "set input stream mapping",
2594 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2595 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2596 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2597 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2598 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2599 "set metadata information of outfile from infile",
2600 "outfile[,metadata]:infile[,metadata]" },
2601 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2602 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2603 "set chapters mapping", "input_file_index" },
2604 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2605 "record or transcode \"duration\" seconds of audio/video",
2607 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2608 "record or transcode stop time", "time_stop" },
2609 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2610 "set the limit file size in bytes", "limit_size" },
2611 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2612 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2613 "set the start time offset", "time_off" },
2614 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2615 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2616 "set the input ts offset", "time_off" },
2617 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2618 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2619 "set the input ts scale", "scale" },
2620 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2621 "set the recording timestamp ('now' to set the current time)", "time" },
2622 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2623 "add metadata", "string=string" },
2624 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2625 OPT_OUTPUT, { .func_arg = opt_data_frames },
2626 "set the number of data frames to record", "number" },
2627 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2628 "add timings for benchmarking" },
2629 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2630 "add timings for each task" },
2631 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2632 "write program-readable progress information", "url" },
2633 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2634 "enable or disable interaction on standard input" },
2635 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2636 "set max runtime in seconds", "limit" },
2637 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2638 "dump each input packet" },
2639 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2640 "when dumping packets, also dump the payload" },
2641 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2642 OPT_INPUT, { .off = OFFSET(rate_emu) },
2643 "read input at native frame rate", "" },
2644 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2645 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2646 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2647 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2648 "video sync method", "" },
2649 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2650 "audio sync method", "" },
2651 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2652 "audio drift threshold", "threshold" },
2653 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2654 "copy timestamps" },
2655 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2656 "copy input stream time base when stream copying", "mode" },
2657 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2658 OPT_OUTPUT, { .off = OFFSET(shortest) },
2659 "finish encoding within shortest input" },
2660 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2661 OPT_OUTPUT, { .off = OFFSET(apad) },
2663 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2664 "timestamp discontinuity delta threshold", "threshold" },
2665 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2666 "timestamp error delta threshold", "threshold" },
2667 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2668 "exit on error", "error" },
2669 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2670 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2671 "copy initial non-keyframes" },
2672 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2673 "copy or discard frames before start time" },
2674 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2675 "set the number of frames to record", "number" },
2676 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2677 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2678 "force codec tag/fourcc", "fourcc/tag" },
2679 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2680 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2681 "use fixed quality scale (VBR)", "q" },
2682 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2683 OPT_OUTPUT, { .func_arg = opt_qscale },
2684 "use fixed quality scale (VBR)", "q" },
2685 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2686 "set profile", "profile" },
2687 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2688 "set stream filtergraph", "filter_graph" },
2689 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2690 "read stream filtergraph description from a file", "filename" },
2691 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2692 "reinit filtergraph on input parameter changes", "" },
2693 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2694 "create a complex filtergraph", "graph_description" },
2695 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2696 "create a complex filtergraph", "graph_description" },
2697 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2698 "read complex filtergraph description from a file", "filename" },
2699 { "stats", OPT_BOOL, { &print_stats },
2700 "print progress report during encoding", },
2701 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2702 OPT_OUTPUT, { .func_arg = opt_attach },
2703 "add an attachment to the output file", "filename" },
2704 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2705 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2706 "extract an attachment into a file", "filename" },
2707 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2708 "print timestamp debugging info" },
2711 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2712 "set the number of video frames to record", "number" },
2713 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2714 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2715 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2716 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2717 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2718 "set frame size (WxH or abbreviation)", "size" },
2719 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2720 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2721 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2722 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2723 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2724 "set pixel format", "format" },
2725 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2726 "set the number of bits per raw sample", "number" },
2727 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2728 "deprecated use -g 1" },
2729 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2731 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2732 "discard threshold", "n" },
2733 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2734 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2735 "rate control override for specific intervals", "override" },
2736 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2737 OPT_OUTPUT, { .func_arg = opt_video_codec },
2738 "force video codec ('copy' to copy stream)", "codec" },
2739 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2741 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2743 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2744 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2745 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2746 "select the pass number (1 to 3)", "n" },
2747 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2748 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2749 "select two pass log file name prefix", "prefix" },
2750 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2751 "this option is deprecated, use the yadif filter instead" },
2752 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2753 "calculate PSNR of compressed frames" },
2754 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2755 "dump video coding statistics to file" },
2756 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2757 "dump video coding statistics to file", "file" },
2758 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2759 "set video filters", "filter_graph" },
2760 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2761 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2762 "specify intra matrix coeffs", "matrix" },
2763 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2764 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2765 "specify inter matrix coeffs", "matrix" },
2766 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2767 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2768 "top=1/bottom=0/auto=-1 field first", "" },
2769 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2770 "intra_dc_precision", "precision" },
2771 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2772 OPT_OUTPUT, { .func_arg = opt_old2new },
2773 "force video tag/fourcc", "fourcc/tag" },
2774 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2775 "show QP histogram" },
2776 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2777 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2778 "force the selected framerate, disable the best supported framerate selection" },
2779 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2780 OPT_OUTPUT, { .func_arg = opt_streamid },
2781 "set the value of an outfile streamid", "streamIndex:value" },
2782 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2783 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2784 "force key frames at specified timestamps", "timestamps" },
2785 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2786 "video bitrate (please use -b:v)", "bitrate" },
2789 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2790 "set the number of audio frames to record", "number" },
2791 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2792 "set audio quality (codec-specific)", "quality", },
2793 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2794 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2795 "set audio sampling rate (in Hz)", "rate" },
2796 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2797 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2798 "set number of audio channels", "channels" },
2799 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2801 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2802 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2803 "force audio codec ('copy' to copy stream)", "codec" },
2804 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2805 OPT_OUTPUT, { .func_arg = opt_old2new },
2806 "force audio tag/fourcc", "fourcc/tag" },
2807 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2808 "change audio volume (256=normal)" , "volume" },
2809 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2810 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2811 "set sample format", "format" },
2812 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2813 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2814 "set channel layout", "layout" },
2815 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2816 "set audio filters", "filter_graph" },
2817 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2818 "set the maximum number of channels to try to guess the channel layout" },
2820 /* subtitle options */
2821 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2822 "disable subtitle" },
2823 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2824 "force subtitle codec ('copy' to copy stream)", "codec" },
2825 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2826 , "force subtitle tag/fourcc", "fourcc/tag" },
2827 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2828 "fix subtitles duration" },
2829 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2830 "set canvas size (WxH or abbreviation)", "size" },
2833 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2834 "deprecated, use -channel", "channel" },
2835 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2836 "deprecated, use -standard", "standard" },
2837 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2840 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2841 "set the maximum demux-decode delay", "seconds" },
2842 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2843 "set the initial demux-decode delay", "seconds" },
2844 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2845 "override the options from ffserver", "" },
2847 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2848 "A comma-separated list of bitstream filters", "bitstream_filters" },
2849 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2850 "deprecated", "audio bitstream_filters" },
2851 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2852 "deprecated", "video bitstream_filters" },
2854 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2855 "set the audio options to the indicated preset", "preset" },
2856 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2857 "set the video options to the indicated preset", "preset" },
2858 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2859 "set the subtitle options to the indicated preset", "preset" },
2860 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2861 "set options from indicated preset file", "filename" },
2862 /* data codec support */
2863 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2864 "force data codec ('copy' to copy stream)", "codec" },
2865 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },