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 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
667 if (!file_overwrite &&
668 (strchr(filename, ':') == NULL || filename[1] == ':' ||
669 av_strstart(filename, "file:", NULL))) {
670 if (avio_check(filename, 0) == 0) {
671 if (stdin_interaction && !no_file_overwrite) {
672 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
675 signal(SIGINT, SIG_DFL);
677 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
683 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
690 static void dump_attachment(AVStream *st, const char *filename)
693 AVIOContext *out = NULL;
694 AVDictionaryEntry *e;
696 if (!st->codec->extradata_size) {
697 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
698 nb_input_files - 1, st->index);
701 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
704 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
705 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
709 assert_file_overwrite(filename);
711 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
712 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
717 avio_write(out, st->codec->extradata, st->codec->extradata_size);
722 static int open_input_file(OptionsContext *o, const char *filename)
726 AVInputFormat *file_iformat = NULL;
731 AVDictionary *unused_opts = NULL;
732 AVDictionaryEntry *e = NULL;
733 int orig_nb_streams; // number of streams before avformat_find_stream_info
734 char * video_codec_name = NULL;
735 char * audio_codec_name = NULL;
736 char *subtitle_codec_name = NULL;
739 if (!(file_iformat = av_find_input_format(o->format))) {
740 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
745 if (!strcmp(filename, "-"))
748 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
749 strcmp(filename, "/dev/stdin");
751 /* get default parameters from command line */
752 ic = avformat_alloc_context();
754 print_error(filename, AVERROR(ENOMEM));
757 if (o->nb_audio_sample_rate) {
758 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
759 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
761 if (o->nb_audio_channels) {
762 /* because we set audio_channels based on both the "ac" and
763 * "channel_layout" options, we need to check that the specified
764 * demuxer actually has the "channels" option before setting it */
765 if (file_iformat && file_iformat->priv_class &&
766 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
767 AV_OPT_SEARCH_FAKE_OBJ)) {
768 snprintf(buf, sizeof(buf), "%d",
769 o->audio_channels[o->nb_audio_channels - 1].u.i);
770 av_dict_set(&o->g->format_opts, "channels", buf, 0);
773 if (o->nb_frame_rates) {
774 /* set the format-level framerate option;
775 * this is important for video grabbers, e.g. x11 */
776 if (file_iformat && file_iformat->priv_class &&
777 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
778 AV_OPT_SEARCH_FAKE_OBJ)) {
779 av_dict_set(&o->g->format_opts, "framerate",
780 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
783 if (o->nb_frame_sizes) {
784 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
786 if (o->nb_frame_pix_fmts)
787 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
789 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
790 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
791 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
793 ic->video_codec_id = video_codec_name ?
794 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
795 ic->audio_codec_id = audio_codec_name ?
796 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
797 ic->subtitle_codec_id= subtitle_codec_name ?
798 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
799 ic->flags |= AVFMT_FLAG_NONBLOCK;
800 ic->interrupt_callback = int_cb;
802 /* open the input file with generic avformat function */
803 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
805 print_error(filename, err);
808 assert_avoptions(o->g->format_opts);
810 /* apply forced codec ids */
811 for (i = 0; i < ic->nb_streams; i++)
812 choose_decoder(o, ic, ic->streams[i]);
814 /* Set AVCodecContext options for avformat_find_stream_info */
815 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
816 orig_nb_streams = ic->nb_streams;
818 /* If not enough info to get the stream parameters, we decode the
819 first frames to get it. (used in mpeg case for example) */
820 ret = avformat_find_stream_info(ic, opts);
822 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
823 avformat_close_input(&ic);
827 timestamp = o->start_time;
828 /* add the stream start time */
829 if (ic->start_time != AV_NOPTS_VALUE)
830 timestamp += ic->start_time;
832 /* if seeking requested, we execute it */
833 if (o->start_time != 0) {
834 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
836 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
837 filename, (double)timestamp / AV_TIME_BASE);
841 /* update the current parameters so that they match the one of the input stream */
842 add_input_streams(o, ic);
844 /* dump the file content */
845 av_dump_format(ic, nb_input_files, filename, 0);
847 GROW_ARRAY(input_files, nb_input_files);
848 f = av_mallocz(sizeof(*f));
851 input_files[nb_input_files - 1] = f;
854 f->ist_index = nb_input_streams - ic->nb_streams;
855 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
856 f->nb_streams = ic->nb_streams;
857 f->rate_emu = o->rate_emu;
859 /* check if all codec options have been used */
860 unused_opts = strip_specifiers(o->g->codec_opts);
861 for (i = f->ist_index; i < nb_input_streams; i++) {
863 while ((e = av_dict_get(input_streams[i]->opts, "", e,
864 AV_DICT_IGNORE_SUFFIX)))
865 av_dict_set(&unused_opts, e->key, NULL, 0);
869 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
870 const AVClass *class = avcodec_get_class();
871 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
872 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
875 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
876 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
877 "input file #%d (%s) is not a decoding option.\n", e->key,
878 option->help ? option->help : "", nb_input_files - 1,
883 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
884 "input file #%d (%s) has not been used for any stream. The most "
885 "likely reason is either wrong type (e.g. a video option with "
886 "no video streams) or that it is a private option of some decoder "
887 "which was not actually used for any stream.\n", e->key,
888 option->help ? option->help : "", nb_input_files - 1, filename);
890 av_dict_free(&unused_opts);
892 for (i = 0; i < o->nb_dump_attachment; i++) {
895 for (j = 0; j < ic->nb_streams; j++) {
896 AVStream *st = ic->streams[j];
898 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
899 dump_attachment(st, o->dump_attachment[i].u.str);
903 for (i = 0; i < orig_nb_streams; i++)
904 av_dict_free(&opts[i]);
910 static uint8_t *get_line(AVIOContext *s)
916 if (avio_open_dyn_buf(&line) < 0) {
917 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
921 while ((c = avio_r8(s)) && c != '\n')
924 avio_close_dyn_buf(line, &buf);
929 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
933 const char *base[3] = { getenv("AVCONV_DATADIR"),
938 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
942 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
943 i != 1 ? "" : "/.avconv", codec_name, preset_name);
944 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
947 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
948 i != 1 ? "" : "/.avconv", preset_name);
949 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
955 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
957 char *codec_name = NULL;
959 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
961 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
962 NULL, ost->st->codec->codec_type);
963 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
964 } else if (!strcmp(codec_name, "copy"))
965 ost->stream_copy = 1;
967 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
968 ost->st->codec->codec_id = ost->enc->id;
972 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
975 AVStream *st = avformat_new_stream(oc, NULL);
976 int idx = oc->nb_streams - 1, ret = 0;
977 char *bsf = NULL, *next, *codec_tag = NULL;
978 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
983 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
987 if (oc->nb_streams - 1 < o->nb_streamid_map)
988 st->id = o->streamid_map[oc->nb_streams - 1];
990 GROW_ARRAY(output_streams, nb_output_streams);
991 if (!(ost = av_mallocz(sizeof(*ost))))
993 output_streams[nb_output_streams - 1] = ost;
995 ost->file_index = nb_output_files - 1;
998 st->codec->codec_type = type;
999 choose_encoder(o, oc, ost);
1001 AVIOContext *s = NULL;
1002 char *buf = NULL, *arg = NULL, *preset = NULL;
1004 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1006 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1007 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1010 if (!buf[0] || buf[0] == '#') {
1014 if (!(arg = strchr(buf, '='))) {
1015 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1019 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1021 } while (!s->eof_reached);
1025 av_log(NULL, AV_LOG_FATAL,
1026 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1027 preset, ost->file_index, ost->index);
1031 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1034 avcodec_get_context_defaults3(st->codec, ost->enc);
1035 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1037 ost->max_frames = INT64_MAX;
1038 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1039 for (i = 0; i<o->nb_max_frames; i++) {
1040 char *p = o->max_frames[i].specifier;
1041 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1042 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1047 ost->copy_prior_start = -1;
1048 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1050 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1052 if (next = strchr(bsf, ','))
1054 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1055 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1059 bsfc_prev->next = bsfc;
1061 ost->bitstream_filters = bsfc;
1067 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1069 uint32_t tag = strtol(codec_tag, &next, 0);
1071 tag = AV_RL32(codec_tag);
1072 st->codec->codec_tag = tag;
1075 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1077 st->codec->flags |= CODEC_FLAG_QSCALE;
1078 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1081 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1082 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1084 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1086 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1087 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1088 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1090 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1092 ost->source_index = source_index;
1093 if (source_index >= 0) {
1094 ost->sync_ist = input_streams[source_index];
1095 input_streams[source_index]->discard = 0;
1096 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1098 ost->last_mux_dts = AV_NOPTS_VALUE;
1103 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1106 const char *p = str;
1113 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1120 /* read file contents into a string */
1121 static uint8_t *read_file(const char *filename)
1123 AVIOContext *pb = NULL;
1124 AVIOContext *dyn_buf = NULL;
1125 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1126 uint8_t buf[1024], *str;
1129 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1133 ret = avio_open_dyn_buf(&dyn_buf);
1138 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1139 avio_write(dyn_buf, buf, ret);
1140 avio_w8(dyn_buf, 0);
1143 ret = avio_close_dyn_buf(dyn_buf, &str);
1149 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1152 AVStream *st = ost->st;
1153 char *filter = NULL, *filter_script = NULL;
1155 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1156 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1158 if (filter_script && filter) {
1159 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1160 "output stream #%d:%d.\n", nb_output_files, st->index);
1165 return read_file(filter_script);
1167 return av_strdup(filter);
1169 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1173 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1177 AVCodecContext *video_enc;
1178 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1180 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1182 video_enc = st->codec;
1184 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1185 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1186 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1190 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1191 if (frame_aspect_ratio) {
1193 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1194 q.num <= 0 || q.den <= 0) {
1195 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1198 ost->frame_aspect_ratio = q;
1201 if (!ost->stream_copy) {
1202 const char *p = NULL;
1203 char *frame_size = NULL;
1204 char *frame_pix_fmt = NULL;
1205 char *intra_matrix = NULL, *inter_matrix = NULL;
1209 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1210 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1211 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1215 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1216 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1217 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1218 ost->keep_pix_fmt = 1;
1219 if (!*++frame_pix_fmt)
1220 frame_pix_fmt = NULL;
1222 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1223 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1226 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1229 video_enc->gop_size = 0;
1230 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1232 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1233 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1236 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1238 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1240 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1241 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1244 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1247 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1248 for (i = 0; p; i++) {
1250 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1252 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1255 /* FIXME realloc failure */
1256 video_enc->rc_override =
1257 av_realloc(video_enc->rc_override,
1258 sizeof(RcOverride) * (i + 1));
1259 video_enc->rc_override[i].start_frame = start;
1260 video_enc->rc_override[i].end_frame = end;
1262 video_enc->rc_override[i].qscale = q;
1263 video_enc->rc_override[i].quality_factor = 1.0;
1266 video_enc->rc_override[i].qscale = 0;
1267 video_enc->rc_override[i].quality_factor = -q/100.0;
1272 video_enc->rc_override_count = i;
1273 video_enc->intra_dc_precision = intra_dc_precision - 8;
1276 video_enc->flags|= CODEC_FLAG_PSNR;
1279 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1282 video_enc->flags |= CODEC_FLAG_PASS1;
1283 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1286 video_enc->flags |= CODEC_FLAG_PASS2;
1287 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1291 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1292 if (ost->logfile_prefix &&
1293 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1296 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1297 if (ost->forced_keyframes)
1298 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1300 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1302 ost->top_field_first = -1;
1303 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1306 ost->avfilter = get_ost_filters(o, oc, ost);
1310 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1316 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1321 AVCodecContext *audio_enc;
1323 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1326 audio_enc = st->codec;
1327 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1329 if (!ost->stream_copy) {
1330 char *sample_fmt = NULL;
1332 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1334 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1336 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1337 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1341 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1343 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1344 ost->apad = av_strdup(ost->apad);
1346 ost->avfilter = get_ost_filters(o, oc, ost);
1350 /* check for channel mapping for this audio stream */
1351 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1352 AudioChannelMap *map = &o->audio_channel_maps[n];
1353 InputStream *ist = input_streams[ost->source_index];
1354 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1355 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1356 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1357 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1358 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1360 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1361 ost->file_index, ost->st->index);
1369 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1373 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1374 if (!ost->stream_copy) {
1375 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1382 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1384 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1385 ost->stream_copy = 1;
1390 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1394 AVCodecContext *subtitle_enc;
1396 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1398 subtitle_enc = st->codec;
1400 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1402 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1404 if (!ost->stream_copy) {
1405 char *frame_size = NULL;
1407 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1408 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1409 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1417 /* arg format is "output-stream-index:streamid-value". */
1418 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1420 OptionsContext *o = optctx;
1425 av_strlcpy(idx_str, arg, sizeof(idx_str));
1426 p = strchr(idx_str, ':');
1428 av_log(NULL, AV_LOG_FATAL,
1429 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1434 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1435 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1436 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1440 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1442 AVFormatContext *is = ifile->ctx;
1443 AVFormatContext *os = ofile->ctx;
1447 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1449 return AVERROR(ENOMEM);
1452 for (i = 0; i < is->nb_chapters; i++) {
1453 AVChapter *in_ch = is->chapters[i], *out_ch;
1454 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1455 AV_TIME_BASE_Q, in_ch->time_base);
1456 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1457 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1460 if (in_ch->end < ts_off)
1462 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1465 out_ch = av_mallocz(sizeof(AVChapter));
1467 return AVERROR(ENOMEM);
1469 out_ch->id = in_ch->id;
1470 out_ch->time_base = in_ch->time_base;
1471 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1472 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1475 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1477 os->chapters[os->nb_chapters++] = out_ch;
1482 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1485 AVFormatContext *ic = avformat_alloc_context();
1487 ic->interrupt_callback = int_cb;
1488 err = avformat_open_input(&ic, filename, NULL, NULL);
1491 /* copy stream format */
1492 for(i=0;i<ic->nb_streams;i++) {
1496 AVCodecContext *avctx;
1498 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1499 ost = new_output_stream(o, s, codec->type, -1);
1504 // FIXME: a more elegant solution is needed
1505 memcpy(st, ic->streams[i], sizeof(AVStream));
1507 st->info = av_malloc(sizeof(*st->info));
1508 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1510 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1512 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1513 choose_sample_fmt(st, codec);
1514 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1515 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1518 avformat_close_input(&ic);
1522 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1523 AVFormatContext *oc)
1527 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1528 ofilter->out_tmp->pad_idx)) {
1529 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1530 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1532 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1537 ost->source_index = -1;
1538 ost->filter = ofilter;
1542 if (ost->stream_copy) {
1543 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1544 "which is fed from a complex filtergraph. Filtering and streamcopy "
1545 "cannot be used together.\n", ost->file_index, ost->index);
1549 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1550 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1553 avfilter_inout_free(&ofilter->out_tmp);
1556 static int configure_complex_filters(void)
1560 for (i = 0; i < nb_filtergraphs; i++)
1561 if (!filtergraphs[i]->graph &&
1562 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1567 static int open_output_file(OptionsContext *o, const char *filename)
1569 AVFormatContext *oc;
1571 AVOutputFormat *file_oformat;
1575 AVDictionary *unused_opts = NULL;
1576 AVDictionaryEntry *e = NULL;
1578 if (configure_complex_filters() < 0) {
1579 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1583 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1584 o->stop_time = INT64_MAX;
1585 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1588 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1589 if (o->stop_time <= o->start_time) {
1590 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1591 o->stop_time = INT64_MAX;
1593 o->recording_time = o->stop_time - o->start_time;
1597 GROW_ARRAY(output_files, nb_output_files);
1598 of = av_mallocz(sizeof(*of));
1601 output_files[nb_output_files - 1] = of;
1603 of->ost_index = nb_output_streams;
1604 of->recording_time = o->recording_time;
1605 of->start_time = o->start_time;
1606 of->limit_filesize = o->limit_filesize;
1607 of->shortest = o->shortest;
1608 av_dict_copy(&of->opts, o->g->format_opts, 0);
1610 if (!strcmp(filename, "-"))
1613 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1615 print_error(filename, err);
1620 if (o->recording_time != INT64_MAX)
1621 oc->duration = o->recording_time;
1623 file_oformat= oc->oformat;
1624 oc->interrupt_callback = int_cb;
1626 /* create streams for all unlabeled output pads */
1627 for (i = 0; i < nb_filtergraphs; i++) {
1628 FilterGraph *fg = filtergraphs[i];
1629 for (j = 0; j < fg->nb_outputs; j++) {
1630 OutputFilter *ofilter = fg->outputs[j];
1632 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1635 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1636 ofilter->out_tmp->pad_idx)) {
1637 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1638 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1639 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1641 init_output_filter(ofilter, o, oc);
1645 /* ffserver seeking with date=... needs a date reference */
1646 if (!strcmp(file_oformat->name, "ffm") &&
1647 av_strstart(filename, "http:", NULL)) {
1648 int err = parse_option(o, "metadata", "creation_time=now", options);
1650 print_error(filename, err);
1655 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1656 av_strstart(filename, "http:", NULL)) {
1658 /* special case for files sent to ffserver: we get the stream
1659 parameters from ffserver */
1660 int err = read_ffserver_streams(o, oc, filename);
1662 print_error(filename, err);
1665 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1666 ost = output_streams[j];
1667 for (i = 0; i < nb_input_streams; i++) {
1668 ist = input_streams[i];
1669 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1671 ost->source_index= i;
1672 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1673 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1675 ist->st->discard = AVDISCARD_NONE;
1680 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));
1684 } else if (!o->nb_stream_maps) {
1685 char *subtitle_codec_name = NULL;
1686 /* pick the "best" stream of each type */
1688 /* video: highest resolution */
1689 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1690 int area = 0, idx = -1;
1691 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1692 for (i = 0; i < nb_input_streams; i++) {
1694 ist = input_streams[i];
1695 new_area = ist->st->codec->width * ist->st->codec->height;
1696 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1698 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1700 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1707 new_video_stream(o, oc, idx);
1710 /* audio: most channels */
1711 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1712 int channels = 0, idx = -1;
1713 for (i = 0; i < nb_input_streams; i++) {
1714 ist = input_streams[i];
1715 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1716 ist->st->codec->channels > channels) {
1717 channels = ist->st->codec->channels;
1722 new_audio_stream(o, oc, idx);
1725 /* subtitles: pick first */
1726 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1727 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1728 for (i = 0; i < nb_input_streams; i++)
1729 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1730 new_subtitle_stream(o, oc, i);
1734 /* do something with data? */
1736 for (i = 0; i < o->nb_stream_maps; i++) {
1737 StreamMap *map = &o->stream_maps[i];
1742 if (map->linklabel) {
1744 OutputFilter *ofilter = NULL;
1747 for (j = 0; j < nb_filtergraphs; j++) {
1748 fg = filtergraphs[j];
1749 for (k = 0; k < fg->nb_outputs; k++) {
1750 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1751 if (out && !strcmp(out->name, map->linklabel)) {
1752 ofilter = fg->outputs[k];
1759 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1760 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1763 init_output_filter(ofilter, o, oc);
1765 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1767 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1768 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1770 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1772 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1774 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1777 switch (ist->st->codec->codec_type) {
1778 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1779 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1780 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1781 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1782 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1784 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1785 map->file_index, map->stream_index);
1792 /* handle attached files */
1793 for (i = 0; i < o->nb_attachments; i++) {
1795 uint8_t *attachment;
1799 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1800 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1804 if ((len = avio_size(pb)) <= 0) {
1805 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1809 if (!(attachment = av_malloc(len))) {
1810 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1814 avio_read(pb, attachment, len);
1816 ost = new_attachment_stream(o, oc, -1);
1817 ost->stream_copy = 0;
1818 ost->attachment_filename = o->attachments[i];
1820 ost->st->codec->extradata = attachment;
1821 ost->st->codec->extradata_size = len;
1823 p = strrchr(o->attachments[i], '/');
1824 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1828 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1829 AVDictionaryEntry *e;
1830 ost = output_streams[i];
1832 if ((ost->stream_copy || ost->attachment_filename)
1833 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1834 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1835 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1839 /* check if all codec options have been used */
1840 unused_opts = strip_specifiers(o->g->codec_opts);
1841 for (i = of->ost_index; i < nb_output_streams; i++) {
1843 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1844 AV_DICT_IGNORE_SUFFIX)))
1845 av_dict_set(&unused_opts, e->key, NULL, 0);
1849 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1850 const AVClass *class = avcodec_get_class();
1851 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1852 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1855 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1856 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1857 "output file #%d (%s) is not an encoding option.\n", e->key,
1858 option->help ? option->help : "", nb_output_files - 1,
1863 // gop_timecode is injected by generic code but not always used
1864 if (!strcmp(e->key, "gop_timecode"))
1867 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1868 "output file #%d (%s) has not been used for any stream. The most "
1869 "likely reason is either wrong type (e.g. a video option with "
1870 "no video streams) or that it is a private option of some encoder "
1871 "which was not actually used for any stream.\n", e->key,
1872 option->help ? option->help : "", nb_output_files - 1, filename);
1874 av_dict_free(&unused_opts);
1876 /* check filename in case of an image number is expected */
1877 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1878 if (!av_filename_number_test(oc->filename)) {
1879 print_error(oc->filename, AVERROR(EINVAL));
1884 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1885 /* test if it already exists to avoid losing precious files */
1886 assert_file_overwrite(filename);
1889 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1890 &oc->interrupt_callback,
1892 print_error(filename, err);
1895 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1896 assert_file_overwrite(filename);
1898 if (o->mux_preload) {
1900 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1901 av_dict_set(&of->opts, "preload", buf, 0);
1903 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1906 for (i = 0; i < o->nb_metadata_map; i++) {
1908 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1910 if (in_file_index >= nb_input_files) {
1911 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1914 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1915 in_file_index >= 0 ?
1916 input_files[in_file_index]->ctx : NULL, o);
1920 if (o->chapters_input_file >= nb_input_files) {
1921 if (o->chapters_input_file == INT_MAX) {
1922 /* copy chapters from the first input file that has them*/
1923 o->chapters_input_file = -1;
1924 for (i = 0; i < nb_input_files; i++)
1925 if (input_files[i]->ctx->nb_chapters) {
1926 o->chapters_input_file = i;
1930 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1931 o->chapters_input_file);
1935 if (o->chapters_input_file >= 0)
1936 copy_chapters(input_files[o->chapters_input_file], of,
1937 !o->metadata_chapters_manual);
1939 /* copy global metadata by default */
1940 if (!o->metadata_global_manual && nb_input_files){
1941 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1942 AV_DICT_DONT_OVERWRITE);
1943 if(o->recording_time != INT64_MAX)
1944 av_dict_set(&oc->metadata, "duration", NULL, 0);
1945 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1947 if (!o->metadata_streams_manual)
1948 for (i = of->ost_index; i < nb_output_streams; i++) {
1950 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1952 ist = input_streams[output_streams[i]->source_index];
1953 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1956 /* process manually set metadata */
1957 for (i = 0; i < o->nb_metadata; i++) {
1960 const char *stream_spec;
1961 int index = 0, j, ret = 0;
1963 val = strchr(o->metadata[i].u.str, '=');
1965 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1966 o->metadata[i].u.str);
1971 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1973 for (j = 0; j < oc->nb_streams; j++) {
1974 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1975 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1986 if (index < 0 || index >= oc->nb_chapters) {
1987 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1990 m = &oc->chapters[index]->metadata;
1993 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1996 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2003 static int opt_target(void *optctx, const char *opt, const char *arg)
2005 OptionsContext *o = optctx;
2006 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2007 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2009 if (!strncmp(arg, "pal-", 4)) {
2012 } else if (!strncmp(arg, "ntsc-", 5)) {
2015 } else if (!strncmp(arg, "film-", 5)) {
2019 /* Try to determine PAL/NTSC by peeking in the input files */
2020 if (nb_input_files) {
2022 for (j = 0; j < nb_input_files; j++) {
2023 for (i = 0; i < input_files[j]->nb_streams; i++) {
2024 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2025 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2027 fr = c->time_base.den * 1000 / c->time_base.num;
2031 } else if ((fr == 29970) || (fr == 23976)) {
2036 if (norm != UNKNOWN)
2040 if (norm != UNKNOWN)
2041 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2044 if (norm == UNKNOWN) {
2045 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2046 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2047 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2051 if (!strcmp(arg, "vcd")) {
2052 opt_video_codec(o, "c:v", "mpeg1video");
2053 opt_audio_codec(o, "c:a", "mp2");
2054 parse_option(o, "f", "vcd", options);
2055 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2057 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2058 parse_option(o, "r", frame_rates[norm], options);
2059 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2061 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2062 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2063 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2064 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2066 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2067 parse_option(o, "ar", "44100", options);
2068 parse_option(o, "ac", "2", options);
2070 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2071 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2073 /* We have to offset the PTS, so that it is consistent with the SCR.
2074 SCR starts at 36000, but the first two packs contain only padding
2075 and the first pack from the other stream, respectively, may also have
2076 been written before.
2077 So the real data starts at SCR 36000+3*1200. */
2078 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2079 } else if (!strcmp(arg, "svcd")) {
2081 opt_video_codec(o, "c:v", "mpeg2video");
2082 opt_audio_codec(o, "c:a", "mp2");
2083 parse_option(o, "f", "svcd", options);
2085 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2086 parse_option(o, "r", frame_rates[norm], options);
2087 parse_option(o, "pix_fmt", "yuv420p", options);
2088 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2090 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2091 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2092 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2093 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2094 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2096 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2097 parse_option(o, "ar", "44100", options);
2099 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2101 } else if (!strcmp(arg, "dvd")) {
2103 opt_video_codec(o, "c:v", "mpeg2video");
2104 opt_audio_codec(o, "c:a", "ac3");
2105 parse_option(o, "f", "dvd", options);
2107 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2108 parse_option(o, "r", frame_rates[norm], options);
2109 parse_option(o, "pix_fmt", "yuv420p", options);
2110 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2112 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2113 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2114 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2115 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2117 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.
2118 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2120 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2121 parse_option(o, "ar", "48000", options);
2123 } else if (!strncmp(arg, "dv", 2)) {
2125 parse_option(o, "f", "dv", options);
2127 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2128 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2129 norm == PAL ? "yuv420p" : "yuv411p", options);
2130 parse_option(o, "r", frame_rates[norm], options);
2132 parse_option(o, "ar", "48000", options);
2133 parse_option(o, "ac", "2", options);
2136 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2137 return AVERROR(EINVAL);
2142 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2144 av_free (vstats_filename);
2145 vstats_filename = av_strdup (arg);
2149 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2152 time_t today2 = time(NULL);
2153 struct tm *today = localtime(&today2);
2155 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2157 return opt_vstats_file(NULL, opt, filename);
2160 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2162 OptionsContext *o = optctx;
2163 return parse_option(o, "frames:v", arg, options);
2166 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2168 OptionsContext *o = optctx;
2169 return parse_option(o, "frames:a", arg, options);
2172 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2174 OptionsContext *o = optctx;
2175 return parse_option(o, "frames:d", arg, options);
2178 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2181 AVDictionary *cbak = codec_opts;
2182 AVDictionary *fbak = format_opts;
2186 ret = opt_default(NULL, opt, arg);
2188 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2189 av_dict_copy(&o->g->format_opts, format_opts, 0);
2190 av_dict_free(&codec_opts);
2191 av_dict_free(&format_opts);
2198 static int opt_preset(void *optctx, const char *opt, const char *arg)
2200 OptionsContext *o = optctx;
2202 char filename[1000], line[1000], tmp_line[1000];
2203 const char *codec_name = NULL;
2207 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2209 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2210 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2211 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2213 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2217 while (fgets(line, sizeof(line), f)) {
2218 char *key = tmp_line, *value, *endptr;
2220 if (strcspn(line, "#\n\r") == 0)
2222 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2223 if (!av_strtok(key, "=", &value) ||
2224 !av_strtok(value, "\r\n", &endptr)) {
2225 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2228 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2230 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2231 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2232 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2233 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2234 else if (opt_default_new(o, key, value) < 0) {
2235 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2236 filename, line, key, value);
2246 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2248 OptionsContext *o = optctx;
2249 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2250 int ret = parse_option(o, s, arg, options);
2255 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2257 OptionsContext *o = optctx;
2258 if(!strcmp(opt, "b")){
2259 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2260 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2263 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2267 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2269 OptionsContext *o = optctx;
2272 if(!strcmp(opt, "qscale")){
2273 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2274 return parse_option(o, "q:v", arg, options);
2276 s = av_asprintf("q%s", opt + 6);
2277 ret = parse_option(o, s, arg, options);
2282 static int opt_profile(void *optctx, const char *opt, const char *arg)
2284 OptionsContext *o = optctx;
2285 if(!strcmp(opt, "profile")){
2286 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2287 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2290 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2294 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2296 OptionsContext *o = optctx;
2297 return parse_option(o, "filter:v", arg, options);
2300 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2302 OptionsContext *o = optctx;
2303 return parse_option(o, "filter:a", arg, options);
2306 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2308 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2309 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2310 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2311 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2313 if (video_sync_method == VSYNC_AUTO)
2314 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2318 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2320 OptionsContext *o = optctx;
2321 char *tcr = av_asprintf("timecode=%s", arg);
2322 int ret = parse_option(o, "metadata:g", tcr, options);
2324 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2329 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2331 OptionsContext *o = optctx;
2332 char layout_str[32];
2335 int ret, channels, ac_str_size;
2338 layout = av_get_channel_layout(arg);
2340 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2341 return AVERROR(EINVAL);
2343 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2344 ret = opt_default_new(o, opt, layout_str);
2348 /* set 'ac' option based on channel layout */
2349 channels = av_get_channel_layout_nb_channels(layout);
2350 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2351 stream_str = strchr(opt, ':');
2352 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2353 ac_str = av_mallocz(ac_str_size);
2355 return AVERROR(ENOMEM);
2356 av_strlcpy(ac_str, "ac", 3);
2358 av_strlcat(ac_str, stream_str, ac_str_size);
2359 ret = parse_option(o, ac_str, layout_str, options);
2365 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2367 OptionsContext *o = optctx;
2368 return parse_option(o, "q:a", arg, options);
2371 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2373 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2374 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2375 return AVERROR(ENOMEM);
2376 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2377 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2378 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2379 return AVERROR(ENOMEM);
2383 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2385 uint8_t *graph_desc = read_file(arg);
2387 return AVERROR(EINVAL);
2389 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2390 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2391 return AVERROR(ENOMEM);
2392 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2393 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2397 void show_help_default(const char *opt, const char *arg)
2399 /* per-file options have at least one of those set */
2400 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2401 int show_advanced = 0, show_avoptions = 0;
2404 if (!strcmp(opt, "long"))
2406 else if (!strcmp(opt, "full"))
2407 show_advanced = show_avoptions = 1;
2409 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2414 printf("Getting help:\n"
2415 " -h -- print basic options\n"
2416 " -h long -- print more options\n"
2417 " -h full -- print all options (including all format and codec specific options, very long)\n"
2418 " See man %s for detailed description of the options.\n"
2419 "\n", program_name);
2421 show_help_options(options, "Print help / information / capabilities:",
2424 show_help_options(options, "Global options (affect whole program "
2425 "instead of just one file:",
2426 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2428 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2429 per_file | OPT_EXIT, 0);
2431 show_help_options(options, "Per-file main options:", 0,
2432 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2433 OPT_EXIT, per_file);
2435 show_help_options(options, "Advanced per-file options:",
2436 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2438 show_help_options(options, "Video options:",
2439 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2441 show_help_options(options, "Advanced Video options:",
2442 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2444 show_help_options(options, "Audio options:",
2445 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2447 show_help_options(options, "Advanced Audio options:",
2448 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2449 show_help_options(options, "Subtitle options:",
2450 OPT_SUBTITLE, 0, 0);
2453 if (show_avoptions) {
2454 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2455 show_help_children(avcodec_get_class(), flags);
2456 show_help_children(avformat_get_class(), flags);
2457 show_help_children(sws_get_class(), flags);
2458 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2459 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2463 void show_usage(void)
2465 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2466 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2467 av_log(NULL, AV_LOG_INFO, "\n");
2475 static const OptionGroupDef groups[] = {
2476 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2477 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2480 static int open_files(OptionGroupList *l, const char *inout,
2481 int (*open_file)(OptionsContext*, const char*))
2485 for (i = 0; i < l->nb_groups; i++) {
2486 OptionGroup *g = &l->groups[i];
2489 init_options(&o, !strcmp(inout, "input"));
2492 ret = parse_optgroup(&o, g);
2494 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2495 "%s.\n", inout, g->arg);
2499 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2500 ret = open_file(&o, g->arg);
2501 uninit_options(&o, !strcmp(inout, "input"));
2503 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2507 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2513 int ffmpeg_parse_options(int argc, char **argv)
2515 OptionParseContext octx;
2519 memset(&octx, 0, sizeof(octx));
2521 /* split the commandline into an internal representation */
2522 ret = split_commandline(&octx, argc, argv, options, groups,
2523 FF_ARRAY_ELEMS(groups));
2525 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2529 /* apply global options */
2530 ret = parse_optgroup(NULL, &octx.global_opts);
2532 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2536 /* open input files */
2537 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2539 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2543 /* open output files */
2544 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2546 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2551 uninit_parse_context(&octx);
2553 av_strerror(ret, error, sizeof(error));
2554 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2559 static int opt_progress(void *optctx, const char *opt, const char *arg)
2561 AVIOContext *avio = NULL;
2564 if (!strcmp(arg, "-"))
2566 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2568 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2569 arg, av_err2str(ret));
2572 progress_avio = avio;
2576 #define OFFSET(x) offsetof(OptionsContext, x)
2577 const OptionDef options[] = {
2579 #include "cmdutils_common_opts.h"
2580 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2581 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2582 "force format", "fmt" },
2583 { "y", OPT_BOOL, { &file_overwrite },
2584 "overwrite output files" },
2585 { "n", OPT_BOOL, { &no_file_overwrite },
2586 "never overwrite output files" },
2587 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2588 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2589 "codec name", "codec" },
2590 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2591 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2592 "codec name", "codec" },
2593 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2594 OPT_OUTPUT, { .off = OFFSET(presets) },
2595 "preset name", "preset" },
2596 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2597 OPT_OUTPUT, { .func_arg = opt_map },
2598 "set input stream mapping",
2599 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2600 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2601 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2602 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2603 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2604 "set metadata information of outfile from infile",
2605 "outfile[,metadata]:infile[,metadata]" },
2606 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2607 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2608 "set chapters mapping", "input_file_index" },
2609 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2610 "record or transcode \"duration\" seconds of audio/video",
2612 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2613 "record or transcode stop time", "time_stop" },
2614 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2615 "set the limit file size in bytes", "limit_size" },
2616 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2617 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2618 "set the start time offset", "time_off" },
2619 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2620 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2621 "set the input ts offset", "time_off" },
2622 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2623 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2624 "set the input ts scale", "scale" },
2625 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2626 "set the recording timestamp ('now' to set the current time)", "time" },
2627 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2628 "add metadata", "string=string" },
2629 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2630 OPT_OUTPUT, { .func_arg = opt_data_frames },
2631 "set the number of data frames to record", "number" },
2632 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2633 "add timings for benchmarking" },
2634 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2635 "add timings for each task" },
2636 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2637 "write program-readable progress information", "url" },
2638 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2639 "enable or disable interaction on standard input" },
2640 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2641 "set max runtime in seconds", "limit" },
2642 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2643 "dump each input packet" },
2644 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2645 "when dumping packets, also dump the payload" },
2646 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2647 OPT_INPUT, { .off = OFFSET(rate_emu) },
2648 "read input at native frame rate", "" },
2649 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2650 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2651 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2652 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2653 "video sync method", "" },
2654 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2655 "audio sync method", "" },
2656 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2657 "audio drift threshold", "threshold" },
2658 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2659 "copy timestamps" },
2660 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2661 "copy input stream time base when stream copying", "mode" },
2662 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2663 OPT_OUTPUT, { .off = OFFSET(shortest) },
2664 "finish encoding within shortest input" },
2665 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2666 OPT_OUTPUT, { .off = OFFSET(apad) },
2668 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2669 "timestamp discontinuity delta threshold", "threshold" },
2670 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2671 "timestamp error delta threshold", "threshold" },
2672 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2673 "exit on error", "error" },
2674 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2675 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2676 "copy initial non-keyframes" },
2677 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2678 "copy or discard frames before start time" },
2679 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2680 "set the number of frames to record", "number" },
2681 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2682 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2683 "force codec tag/fourcc", "fourcc/tag" },
2684 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2685 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2686 "use fixed quality scale (VBR)", "q" },
2687 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2688 OPT_OUTPUT, { .func_arg = opt_qscale },
2689 "use fixed quality scale (VBR)", "q" },
2690 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2691 "set profile", "profile" },
2692 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2693 "set stream filtergraph", "filter_graph" },
2694 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2695 "read stream filtergraph description from a file", "filename" },
2696 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2697 "reinit filtergraph on input parameter changes", "" },
2698 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2699 "create a complex filtergraph", "graph_description" },
2700 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2701 "create a complex filtergraph", "graph_description" },
2702 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2703 "read complex filtergraph description from a file", "filename" },
2704 { "stats", OPT_BOOL, { &print_stats },
2705 "print progress report during encoding", },
2706 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2707 OPT_OUTPUT, { .func_arg = opt_attach },
2708 "add an attachment to the output file", "filename" },
2709 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2710 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2711 "extract an attachment into a file", "filename" },
2712 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2713 "print timestamp debugging info" },
2716 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2717 "set the number of video frames to record", "number" },
2718 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2719 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2720 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2721 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2722 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2723 "set frame size (WxH or abbreviation)", "size" },
2724 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2725 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2726 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2727 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2728 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2729 "set pixel format", "format" },
2730 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2731 "set the number of bits per raw sample", "number" },
2732 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2733 "deprecated use -g 1" },
2734 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2736 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2737 "discard threshold", "n" },
2738 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2739 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2740 "rate control override for specific intervals", "override" },
2741 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2742 OPT_OUTPUT, { .func_arg = opt_video_codec },
2743 "force video codec ('copy' to copy stream)", "codec" },
2744 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2746 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2748 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2749 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2750 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2751 "select the pass number (1 to 3)", "n" },
2752 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2753 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2754 "select two pass log file name prefix", "prefix" },
2755 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2756 "this option is deprecated, use the yadif filter instead" },
2757 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2758 "calculate PSNR of compressed frames" },
2759 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2760 "dump video coding statistics to file" },
2761 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2762 "dump video coding statistics to file", "file" },
2763 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2764 "set video filters", "filter_graph" },
2765 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2766 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2767 "specify intra matrix coeffs", "matrix" },
2768 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2769 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2770 "specify inter matrix coeffs", "matrix" },
2771 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2772 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2773 "top=1/bottom=0/auto=-1 field first", "" },
2774 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2775 "intra_dc_precision", "precision" },
2776 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2777 OPT_OUTPUT, { .func_arg = opt_old2new },
2778 "force video tag/fourcc", "fourcc/tag" },
2779 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2780 "show QP histogram" },
2781 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2782 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2783 "force the selected framerate, disable the best supported framerate selection" },
2784 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2785 OPT_OUTPUT, { .func_arg = opt_streamid },
2786 "set the value of an outfile streamid", "streamIndex:value" },
2787 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2788 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2789 "force key frames at specified timestamps", "timestamps" },
2790 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2791 "video bitrate (please use -b:v)", "bitrate" },
2794 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2795 "set the number of audio frames to record", "number" },
2796 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2797 "set audio quality (codec-specific)", "quality", },
2798 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2799 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2800 "set audio sampling rate (in Hz)", "rate" },
2801 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2802 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2803 "set number of audio channels", "channels" },
2804 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2806 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2807 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2808 "force audio codec ('copy' to copy stream)", "codec" },
2809 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2810 OPT_OUTPUT, { .func_arg = opt_old2new },
2811 "force audio tag/fourcc", "fourcc/tag" },
2812 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2813 "change audio volume (256=normal)" , "volume" },
2814 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2815 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2816 "set sample format", "format" },
2817 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2818 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2819 "set channel layout", "layout" },
2820 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2821 "set audio filters", "filter_graph" },
2822 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2823 "set the maximum number of channels to try to guess the channel layout" },
2825 /* subtitle options */
2826 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2827 "disable subtitle" },
2828 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2829 "force subtitle codec ('copy' to copy stream)", "codec" },
2830 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2831 , "force subtitle tag/fourcc", "fourcc/tag" },
2832 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2833 "fix subtitles duration" },
2834 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2835 "set canvas size (WxH or abbreviation)", "size" },
2838 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2839 "deprecated, use -channel", "channel" },
2840 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2841 "deprecated, use -standard", "standard" },
2842 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2845 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2846 "set the maximum demux-decode delay", "seconds" },
2847 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2848 "set the initial demux-decode delay", "seconds" },
2849 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2850 "override the options from ffserver", "" },
2852 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2853 "A comma-separated list of bitstream filters", "bitstream_filters" },
2854 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2855 "deprecated", "audio bitstream_filters" },
2856 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2857 "deprecated", "video bitstream_filters" },
2859 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2860 "set the audio options to the indicated preset", "preset" },
2861 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2862 "set the video options to the indicated preset", "preset" },
2863 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2864 "set the subtitle options to the indicated preset", "preset" },
2865 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2866 "set options from indicated preset file", "filename" },
2867 /* data codec support */
2868 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2869 "force data codec ('copy' to copy stream)", "codec" },
2870 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },