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"
31 #include "libavfilter/avfiltergraph.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
57 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
60 for (i = 0; i < o->nb_ ## name; i++) {\
61 char *spec = o->name[i].specifier;\
62 if (!strcmp(spec, mediatype))\
63 outvar = o->name[i].u.type;\
66 char *vstats_filename;
68 float audio_drift_threshold = 0.1;
69 float dts_delta_threshold = 10;
70 float dts_error_threshold = 3600*30;
72 int audio_volume = 256;
73 int audio_sync_method = 0;
74 int video_sync_method = VSYNC_AUTO;
75 int do_deinterlace = 0;
77 int do_benchmark_all = 0;
83 int exit_on_error = 0;
86 int stdin_interaction = 1;
87 int frame_bits_per_raw_sample = 0;
90 static int intra_only = 0;
91 static int file_overwrite = 0;
92 static int no_file_overwrite = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int do_psnr = 0;
96 static int input_sync;
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;
977 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
981 if (oc->nb_streams - 1 < o->nb_streamid_map)
982 st->id = o->streamid_map[oc->nb_streams - 1];
984 GROW_ARRAY(output_streams, nb_output_streams);
985 if (!(ost = av_mallocz(sizeof(*ost))))
987 output_streams[nb_output_streams - 1] = ost;
989 ost->file_index = nb_output_files;
992 st->codec->codec_type = type;
993 choose_encoder(o, oc, ost);
995 AVIOContext *s = NULL;
996 char *buf = NULL, *arg = NULL, *preset = NULL;
998 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1000 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1001 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1004 if (!buf[0] || buf[0] == '#') {
1008 if (!(arg = strchr(buf, '='))) {
1009 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1013 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1015 } while (!s->eof_reached);
1019 av_log(NULL, AV_LOG_FATAL,
1020 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1021 preset, ost->file_index, ost->index);
1025 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1028 avcodec_get_context_defaults3(st->codec, ost->enc);
1029 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1031 ost->max_frames = INT64_MAX;
1032 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1034 ost->copy_prior_start = -1;
1035 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1037 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1039 if (next = strchr(bsf, ','))
1041 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1042 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1046 bsfc_prev->next = bsfc;
1048 ost->bitstream_filters = bsfc;
1054 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1056 uint32_t tag = strtol(codec_tag, &next, 0);
1058 tag = AV_RL32(codec_tag);
1059 st->codec->codec_tag = tag;
1062 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1064 st->codec->flags |= CODEC_FLAG_QSCALE;
1065 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1068 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1069 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1071 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1073 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1074 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1075 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1077 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1079 ost->source_index = source_index;
1080 if (source_index >= 0) {
1081 ost->sync_ist = input_streams[source_index];
1082 input_streams[source_index]->discard = 0;
1083 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1089 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1092 const char *p = str;
1099 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1106 /* read file contents into a string */
1107 static uint8_t *read_file(const char *filename)
1109 AVIOContext *pb = NULL;
1110 AVIOContext *dyn_buf = NULL;
1111 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1112 uint8_t buf[1024], *str;
1115 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1119 ret = avio_open_dyn_buf(&dyn_buf);
1124 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1125 avio_write(dyn_buf, buf, ret);
1126 avio_w8(dyn_buf, 0);
1129 ret = avio_close_dyn_buf(dyn_buf, &str);
1135 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1138 AVStream *st = ost->st;
1139 char *filter = NULL, *filter_script = NULL;
1141 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1142 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1144 if (filter_script && filter) {
1145 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1146 "output stream #%d:%d.\n", nb_output_files, st->index);
1151 return read_file(filter_script);
1153 return av_strdup(filter);
1155 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1159 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1163 AVCodecContext *video_enc;
1164 char *frame_rate = NULL;
1166 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1168 video_enc = st->codec;
1170 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1171 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1172 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1176 if (!ost->stream_copy) {
1177 const char *p = NULL;
1178 char *frame_size = NULL;
1179 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1180 char *intra_matrix = NULL, *inter_matrix = NULL;
1184 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1185 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1186 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
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 = av_q2d(q);
1201 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1202 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1203 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1204 ost->keep_pix_fmt = 1;
1205 if (!*++frame_pix_fmt)
1206 frame_pix_fmt = NULL;
1208 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1209 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1212 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1215 video_enc->gop_size = 0;
1216 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1218 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1219 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1222 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1224 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1226 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1227 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1230 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1233 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1234 for (i = 0; p; i++) {
1236 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1238 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1241 /* FIXME realloc failure */
1242 video_enc->rc_override =
1243 av_realloc(video_enc->rc_override,
1244 sizeof(RcOverride) * (i + 1));
1245 video_enc->rc_override[i].start_frame = start;
1246 video_enc->rc_override[i].end_frame = end;
1248 video_enc->rc_override[i].qscale = q;
1249 video_enc->rc_override[i].quality_factor = 1.0;
1252 video_enc->rc_override[i].qscale = 0;
1253 video_enc->rc_override[i].quality_factor = -q/100.0;
1258 video_enc->rc_override_count = i;
1259 video_enc->intra_dc_precision = intra_dc_precision - 8;
1262 video_enc->flags|= CODEC_FLAG_PSNR;
1265 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1268 video_enc->flags |= CODEC_FLAG_PASS1;
1269 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1272 video_enc->flags |= CODEC_FLAG_PASS2;
1273 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1277 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1278 if (ost->logfile_prefix &&
1279 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1282 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1283 if (ost->forced_keyframes)
1284 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1286 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1288 ost->top_field_first = -1;
1289 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1292 ost->avfilter = get_ost_filters(o, oc, ost);
1296 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1302 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1307 AVCodecContext *audio_enc;
1309 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1312 audio_enc = st->codec;
1313 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1315 if (!ost->stream_copy) {
1316 char *sample_fmt = NULL;
1318 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1320 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1322 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1323 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1327 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1329 ost->avfilter = get_ost_filters(o, oc, ost);
1333 /* check for channel mapping for this audio stream */
1334 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1335 AudioChannelMap *map = &o->audio_channel_maps[n];
1336 InputStream *ist = input_streams[ost->source_index];
1337 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1338 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1339 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1340 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1341 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1343 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1344 ost->file_index, ost->st->index);
1352 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1356 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1357 if (!ost->stream_copy) {
1358 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1365 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1367 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1368 ost->stream_copy = 1;
1373 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1377 AVCodecContext *subtitle_enc;
1379 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1381 subtitle_enc = st->codec;
1383 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1385 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1387 if (!ost->stream_copy) {
1388 char *frame_size = NULL;
1390 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1391 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1392 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1400 /* arg format is "output-stream-index:streamid-value". */
1401 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1403 OptionsContext *o = optctx;
1408 av_strlcpy(idx_str, arg, sizeof(idx_str));
1409 p = strchr(idx_str, ':');
1411 av_log(NULL, AV_LOG_FATAL,
1412 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1417 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1418 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1419 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1423 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1425 AVFormatContext *is = ifile->ctx;
1426 AVFormatContext *os = ofile->ctx;
1430 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1432 return AVERROR(ENOMEM);
1435 for (i = 0; i < is->nb_chapters; i++) {
1436 AVChapter *in_ch = is->chapters[i], *out_ch;
1437 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1438 AV_TIME_BASE_Q, in_ch->time_base);
1439 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1440 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1443 if (in_ch->end < ts_off)
1445 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1448 out_ch = av_mallocz(sizeof(AVChapter));
1450 return AVERROR(ENOMEM);
1452 out_ch->id = in_ch->id;
1453 out_ch->time_base = in_ch->time_base;
1454 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1455 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1458 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1460 os->chapters[os->nb_chapters++] = out_ch;
1465 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1468 AVFormatContext *ic = avformat_alloc_context();
1470 ic->interrupt_callback = int_cb;
1471 err = avformat_open_input(&ic, filename, NULL, NULL);
1474 /* copy stream format */
1475 for(i=0;i<ic->nb_streams;i++) {
1479 AVCodecContext *avctx;
1481 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1482 ost = new_output_stream(o, s, codec->type, -1);
1487 // FIXME: a more elegant solution is needed
1488 memcpy(st, ic->streams[i], sizeof(AVStream));
1490 st->info = av_malloc(sizeof(*st->info));
1491 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1493 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1495 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1496 choose_sample_fmt(st, codec);
1497 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1498 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1501 /* ffserver seeking with date=... needs a date reference */
1502 err = parse_option(o, "metadata", "creation_time=now", options);
1504 avformat_close_input(&ic);
1508 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1509 AVFormatContext *oc)
1513 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1514 ofilter->out_tmp->pad_idx)) {
1515 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1516 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1518 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1523 ost->source_index = -1;
1524 ost->filter = ofilter;
1528 if (ost->stream_copy) {
1529 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1530 "which is fed from a complex filtergraph. Filtering and streamcopy "
1531 "cannot be used together.\n", ost->file_index, ost->index);
1535 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1536 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1539 avfilter_inout_free(&ofilter->out_tmp);
1542 static int configure_complex_filters(void)
1546 for (i = 0; i < nb_filtergraphs; i++)
1547 if (!filtergraphs[i]->graph &&
1548 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1553 static int open_output_file(OptionsContext *o, const char *filename)
1555 AVFormatContext *oc;
1557 AVOutputFormat *file_oformat;
1561 AVDictionary *unused_opts = NULL;
1562 AVDictionaryEntry *e = NULL;
1564 if (configure_complex_filters() < 0) {
1565 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1569 if (!strcmp(filename, "-"))
1572 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1574 print_error(filename, err);
1577 file_oformat= oc->oformat;
1578 oc->interrupt_callback = int_cb;
1580 /* create streams for all unlabeled output pads */
1581 for (i = 0; i < nb_filtergraphs; i++) {
1582 FilterGraph *fg = filtergraphs[i];
1583 for (j = 0; j < fg->nb_outputs; j++) {
1584 OutputFilter *ofilter = fg->outputs[j];
1586 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1589 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1590 ofilter->out_tmp->pad_idx)) {
1591 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1592 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1593 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1595 init_output_filter(ofilter, o, oc);
1599 if (!strcmp(file_oformat->name, "ffm") &&
1600 av_strstart(filename, "http:", NULL)) {
1602 /* special case for files sent to ffserver: we get the stream
1603 parameters from ffserver */
1604 int err = read_ffserver_streams(o, oc, filename);
1606 print_error(filename, err);
1609 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1610 ost = output_streams[j];
1611 for (i = 0; i < nb_input_streams; i++) {
1612 ist = input_streams[i];
1613 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1615 ost->source_index= i;
1616 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1617 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1619 ist->st->discard = AVDISCARD_NONE;
1624 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));
1628 } else if (!o->nb_stream_maps) {
1629 char *subtitle_codec_name = NULL;
1630 /* pick the "best" stream of each type */
1632 /* video: highest resolution */
1633 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1634 int area = 0, idx = -1;
1635 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1636 for (i = 0; i < nb_input_streams; i++) {
1638 ist = input_streams[i];
1639 new_area = ist->st->codec->width * ist->st->codec->height;
1640 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1642 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1644 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1651 new_video_stream(o, oc, idx);
1654 /* audio: most channels */
1655 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1656 int channels = 0, idx = -1;
1657 for (i = 0; i < nb_input_streams; i++) {
1658 ist = input_streams[i];
1659 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1660 ist->st->codec->channels > channels) {
1661 channels = ist->st->codec->channels;
1666 new_audio_stream(o, oc, idx);
1669 /* subtitles: pick first */
1670 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1671 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1672 for (i = 0; i < nb_input_streams; i++)
1673 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1674 new_subtitle_stream(o, oc, i);
1678 /* do something with data? */
1680 for (i = 0; i < o->nb_stream_maps; i++) {
1681 StreamMap *map = &o->stream_maps[i];
1682 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1687 if (map->linklabel) {
1689 OutputFilter *ofilter = NULL;
1692 for (j = 0; j < nb_filtergraphs; j++) {
1693 fg = filtergraphs[j];
1694 for (k = 0; k < fg->nb_outputs; k++) {
1695 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1696 if (out && !strcmp(out->name, map->linklabel)) {
1697 ofilter = fg->outputs[k];
1704 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1705 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1708 init_output_filter(ofilter, o, oc);
1710 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1711 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1713 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1715 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1717 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1720 switch (ist->st->codec->codec_type) {
1721 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1722 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1723 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1724 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1725 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1727 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1728 map->file_index, map->stream_index);
1735 /* handle attached files */
1736 for (i = 0; i < o->nb_attachments; i++) {
1738 uint8_t *attachment;
1742 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1743 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1747 if ((len = avio_size(pb)) <= 0) {
1748 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1752 if (!(attachment = av_malloc(len))) {
1753 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1757 avio_read(pb, attachment, len);
1759 ost = new_attachment_stream(o, oc, -1);
1760 ost->stream_copy = 0;
1761 ost->attachment_filename = o->attachments[i];
1763 ost->st->codec->extradata = attachment;
1764 ost->st->codec->extradata_size = len;
1766 p = strrchr(o->attachments[i], '/');
1767 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1771 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1772 AVDictionaryEntry *e;
1773 ost = output_streams[i];
1775 if ((ost->stream_copy || ost->attachment_filename)
1776 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1777 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1778 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1782 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1783 o->stop_time = INT64_MAX;
1784 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1787 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1788 if (o->stop_time <= o->start_time) {
1789 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1790 o->stop_time = INT64_MAX;
1792 o->recording_time = o->stop_time - o->start_time;
1796 GROW_ARRAY(output_files, nb_output_files);
1797 of = av_mallocz(sizeof(*of));
1800 output_files[nb_output_files - 1] = of;
1803 of->ost_index = nb_output_streams - oc->nb_streams;
1804 of->recording_time = o->recording_time;
1805 if (o->recording_time != INT64_MAX)
1806 oc->duration = o->recording_time;
1807 of->start_time = o->start_time;
1808 of->limit_filesize = o->limit_filesize;
1809 of->shortest = o->shortest;
1810 av_dict_copy(&of->opts, o->g->format_opts, 0);
1813 /* check if all codec options have been used */
1814 unused_opts = strip_specifiers(o->g->codec_opts);
1815 for (i = of->ost_index; i < nb_output_streams; i++) {
1817 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1818 AV_DICT_IGNORE_SUFFIX)))
1819 av_dict_set(&unused_opts, e->key, NULL, 0);
1823 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1824 const AVClass *class = avcodec_get_class();
1825 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1826 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1829 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1830 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1831 "output file #%d (%s) is not an encoding option.\n", e->key,
1832 option->help ? option->help : "", nb_output_files - 1,
1837 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1838 "output file #%d (%s) has not been used for any stream. The most "
1839 "likely reason is either wrong type (e.g. a video option with "
1840 "no video streams) or that it is a private option of some encoder "
1841 "which was not actually used for any stream.\n", e->key,
1842 option->help ? option->help : "", nb_output_files - 1, filename);
1844 av_dict_free(&unused_opts);
1846 /* check filename in case of an image number is expected */
1847 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1848 if (!av_filename_number_test(oc->filename)) {
1849 print_error(oc->filename, AVERROR(EINVAL));
1854 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1855 /* test if it already exists to avoid losing precious files */
1856 assert_file_overwrite(filename);
1859 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1860 &oc->interrupt_callback,
1862 print_error(filename, err);
1865 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1866 assert_file_overwrite(filename);
1868 if (o->mux_preload) {
1870 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1871 av_dict_set(&of->opts, "preload", buf, 0);
1873 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1876 for (i = 0; i < o->nb_metadata_map; i++) {
1878 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1880 if (in_file_index >= nb_input_files) {
1881 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1884 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1885 in_file_index >= 0 ?
1886 input_files[in_file_index]->ctx : NULL, o);
1890 if (o->chapters_input_file >= nb_input_files) {
1891 if (o->chapters_input_file == INT_MAX) {
1892 /* copy chapters from the first input file that has them*/
1893 o->chapters_input_file = -1;
1894 for (i = 0; i < nb_input_files; i++)
1895 if (input_files[i]->ctx->nb_chapters) {
1896 o->chapters_input_file = i;
1900 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1901 o->chapters_input_file);
1905 if (o->chapters_input_file >= 0)
1906 copy_chapters(input_files[o->chapters_input_file], of,
1907 !o->metadata_chapters_manual);
1909 /* copy global metadata by default */
1910 if (!o->metadata_global_manual && nb_input_files){
1911 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1912 AV_DICT_DONT_OVERWRITE);
1913 if(o->recording_time != INT64_MAX)
1914 av_dict_set(&oc->metadata, "duration", NULL, 0);
1915 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1917 if (!o->metadata_streams_manual)
1918 for (i = of->ost_index; i < nb_output_streams; i++) {
1920 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1922 ist = input_streams[output_streams[i]->source_index];
1923 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1926 /* process manually set metadata */
1927 for (i = 0; i < o->nb_metadata; i++) {
1930 const char *stream_spec;
1931 int index = 0, j, ret = 0;
1933 val = strchr(o->metadata[i].u.str, '=');
1935 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1936 o->metadata[i].u.str);
1941 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1943 for (j = 0; j < oc->nb_streams; j++) {
1944 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1945 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1956 if (index < 0 || index >= oc->nb_chapters) {
1957 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1960 m = &oc->chapters[index]->metadata;
1963 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1966 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1973 static int opt_target(void *optctx, const char *opt, const char *arg)
1975 OptionsContext *o = optctx;
1976 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1977 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1979 if (!strncmp(arg, "pal-", 4)) {
1982 } else if (!strncmp(arg, "ntsc-", 5)) {
1985 } else if (!strncmp(arg, "film-", 5)) {
1989 /* Try to determine PAL/NTSC by peeking in the input files */
1990 if (nb_input_files) {
1992 for (j = 0; j < nb_input_files; j++) {
1993 for (i = 0; i < input_files[j]->nb_streams; i++) {
1994 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1995 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1997 fr = c->time_base.den * 1000 / c->time_base.num;
2001 } else if ((fr == 29970) || (fr == 23976)) {
2006 if (norm != UNKNOWN)
2010 if (norm != UNKNOWN)
2011 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2014 if (norm == UNKNOWN) {
2015 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2016 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2017 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2021 if (!strcmp(arg, "vcd")) {
2022 opt_video_codec(o, "c:v", "mpeg1video");
2023 opt_audio_codec(o, "c:a", "mp2");
2024 parse_option(o, "f", "vcd", options);
2025 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2027 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2028 parse_option(o, "r", frame_rates[norm], options);
2029 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2031 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2032 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2033 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2034 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2036 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2037 parse_option(o, "ar", "44100", options);
2038 parse_option(o, "ac", "2", options);
2040 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2041 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2043 /* We have to offset the PTS, so that it is consistent with the SCR.
2044 SCR starts at 36000, but the first two packs contain only padding
2045 and the first pack from the other stream, respectively, may also have
2046 been written before.
2047 So the real data starts at SCR 36000+3*1200. */
2048 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2049 } else if (!strcmp(arg, "svcd")) {
2051 opt_video_codec(o, "c:v", "mpeg2video");
2052 opt_audio_codec(o, "c:a", "mp2");
2053 parse_option(o, "f", "svcd", options);
2055 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2056 parse_option(o, "r", frame_rates[norm], options);
2057 parse_option(o, "pix_fmt", "yuv420p", options);
2058 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2060 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2061 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2062 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2063 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2064 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2066 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2067 parse_option(o, "ar", "44100", options);
2069 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2071 } else if (!strcmp(arg, "dvd")) {
2073 opt_video_codec(o, "c:v", "mpeg2video");
2074 opt_audio_codec(o, "c:a", "ac3");
2075 parse_option(o, "f", "dvd", options);
2077 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2078 parse_option(o, "r", frame_rates[norm], options);
2079 parse_option(o, "pix_fmt", "yuv420p", options);
2080 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2082 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2083 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2084 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2085 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2087 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.
2088 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2090 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2091 parse_option(o, "ar", "48000", options);
2093 } else if (!strncmp(arg, "dv", 2)) {
2095 parse_option(o, "f", "dv", options);
2097 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2098 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2099 norm == PAL ? "yuv420p" : "yuv411p", options);
2100 parse_option(o, "r", frame_rates[norm], options);
2102 parse_option(o, "ar", "48000", options);
2103 parse_option(o, "ac", "2", options);
2106 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2107 return AVERROR(EINVAL);
2112 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2114 av_free (vstats_filename);
2115 vstats_filename = av_strdup (arg);
2119 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2122 time_t today2 = time(NULL);
2123 struct tm *today = localtime(&today2);
2125 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2127 return opt_vstats_file(NULL, opt, filename);
2130 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2132 OptionsContext *o = optctx;
2133 return parse_option(o, "frames:v", arg, options);
2136 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2138 OptionsContext *o = optctx;
2139 return parse_option(o, "frames:a", arg, options);
2142 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2144 OptionsContext *o = optctx;
2145 return parse_option(o, "frames:d", arg, options);
2148 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2151 AVDictionary *cbak = codec_opts;
2152 AVDictionary *fbak = format_opts;
2156 ret = opt_default(NULL, opt, arg);
2158 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2159 av_dict_copy(&o->g->format_opts, format_opts, 0);
2160 av_dict_free(&codec_opts);
2161 av_dict_free(&format_opts);
2168 static int opt_preset(void *optctx, const char *opt, const char *arg)
2170 OptionsContext *o = optctx;
2172 char filename[1000], line[1000], tmp_line[1000];
2173 const char *codec_name = NULL;
2177 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2179 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2180 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2181 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2183 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2187 while (fgets(line, sizeof(line), f)) {
2188 char *key = tmp_line, *value, *endptr;
2190 if (strcspn(line, "#\n\r") == 0)
2192 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2193 if (!av_strtok(key, "=", &value) ||
2194 !av_strtok(value, "\r\n", &endptr)) {
2195 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2198 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2200 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2201 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2202 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2203 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2204 else if (opt_default_new(o, key, value) < 0) {
2205 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2206 filename, line, key, value);
2216 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2218 OptionsContext *o = optctx;
2219 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2220 int ret = parse_option(o, s, arg, options);
2225 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2227 OptionsContext *o = optctx;
2228 if(!strcmp(opt, "b")){
2229 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2230 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2233 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2237 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2239 OptionsContext *o = optctx;
2242 if(!strcmp(opt, "qscale")){
2243 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2244 return parse_option(o, "q:v", arg, options);
2246 s = av_asprintf("q%s", opt + 6);
2247 ret = parse_option(o, s, arg, options);
2252 static int opt_profile(void *optctx, const char *opt, const char *arg)
2254 OptionsContext *o = optctx;
2255 if(!strcmp(opt, "profile")){
2256 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2257 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2260 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2264 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2266 OptionsContext *o = optctx;
2267 return parse_option(o, "filter:v", arg, options);
2270 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2272 OptionsContext *o = optctx;
2273 return parse_option(o, "filter:a", arg, options);
2276 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2278 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2279 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2280 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2281 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2283 if (video_sync_method == VSYNC_AUTO)
2284 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2288 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2290 OptionsContext *o = optctx;
2291 char *tcr = av_asprintf("timecode=%s", arg);
2292 int ret = parse_option(o, "metadata:g", tcr, options);
2294 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2299 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2301 OptionsContext *o = optctx;
2302 char layout_str[32];
2305 int ret, channels, ac_str_size;
2308 layout = av_get_channel_layout(arg);
2310 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2311 return AVERROR(EINVAL);
2313 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2314 ret = opt_default_new(o, opt, layout_str);
2318 /* set 'ac' option based on channel layout */
2319 channels = av_get_channel_layout_nb_channels(layout);
2320 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2321 stream_str = strchr(opt, ':');
2322 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2323 ac_str = av_mallocz(ac_str_size);
2325 return AVERROR(ENOMEM);
2326 av_strlcpy(ac_str, "ac", 3);
2328 av_strlcat(ac_str, stream_str, ac_str_size);
2329 ret = parse_option(o, ac_str, layout_str, options);
2335 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2337 OptionsContext *o = optctx;
2338 return parse_option(o, "q:a", arg, options);
2341 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2343 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2344 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2345 return AVERROR(ENOMEM);
2346 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2347 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2348 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2349 return AVERROR(ENOMEM);
2353 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2355 uint8_t *graph_desc = read_file(arg);
2357 return AVERROR(EINVAL);
2359 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2360 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2361 return AVERROR(ENOMEM);
2362 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2363 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2367 void show_help_default(const char *opt, const char *arg)
2369 /* per-file options have at least one of those set */
2370 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2371 int show_advanced = 0, show_avoptions = 0;
2374 if (!strcmp(opt, "long"))
2376 else if (!strcmp(opt, "full"))
2377 show_advanced = show_avoptions = 1;
2379 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2384 printf("Getting help:\n"
2385 " -h -- print basic options\n"
2386 " -h long -- print more options\n"
2387 " -h full -- print all options (including all format and codec specific options, very long)\n"
2388 " See man %s for detailed description of the options.\n"
2389 "\n", program_name);
2391 show_help_options(options, "Print help / information / capabilities:",
2394 show_help_options(options, "Global options (affect whole program "
2395 "instead of just one file:",
2396 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2398 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2399 per_file | OPT_EXIT, 0);
2401 show_help_options(options, "Per-file main options:", 0,
2402 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2403 OPT_EXIT, per_file);
2405 show_help_options(options, "Advanced per-file options:",
2406 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2408 show_help_options(options, "Video options:",
2409 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2411 show_help_options(options, "Advanced Video options:",
2412 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2414 show_help_options(options, "Audio options:",
2415 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2417 show_help_options(options, "Advanced Audio options:",
2418 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2419 show_help_options(options, "Subtitle options:",
2420 OPT_SUBTITLE, 0, 0);
2423 if (show_avoptions) {
2424 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2425 show_help_children(avcodec_get_class(), flags);
2426 show_help_children(avformat_get_class(), flags);
2427 show_help_children(sws_get_class(), flags);
2428 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2429 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2433 void show_usage(void)
2435 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2436 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2437 av_log(NULL, AV_LOG_INFO, "\n");
2445 static const OptionGroupDef groups[] = {
2446 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2447 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2450 static int open_files(OptionGroupList *l, const char *inout,
2451 int (*open_file)(OptionsContext*, const char*))
2455 for (i = 0; i < l->nb_groups; i++) {
2456 OptionGroup *g = &l->groups[i];
2459 init_options(&o, !strcmp(inout, "input"));
2462 ret = parse_optgroup(&o, g);
2464 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2465 "%s.\n", inout, g->arg);
2469 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2470 ret = open_file(&o, g->arg);
2471 uninit_options(&o, !strcmp(inout, "input"));
2473 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2477 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2483 int ffmpeg_parse_options(int argc, char **argv)
2485 OptionParseContext octx;
2489 memset(&octx, 0, sizeof(octx));
2491 /* split the commandline into an internal representation */
2492 ret = split_commandline(&octx, argc, argv, options, groups,
2493 FF_ARRAY_ELEMS(groups));
2495 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2499 /* apply global options */
2500 ret = parse_optgroup(NULL, &octx.global_opts);
2502 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2506 /* open input files */
2507 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2509 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2513 /* open output files */
2514 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2516 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2521 uninit_parse_context(&octx);
2523 av_strerror(ret, error, sizeof(error));
2524 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2529 static int opt_progress(void *optctx, const char *opt, const char *arg)
2531 AVIOContext *avio = NULL;
2534 if (!strcmp(arg, "-"))
2536 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2538 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2539 arg, av_err2str(ret));
2542 progress_avio = avio;
2546 #define OFFSET(x) offsetof(OptionsContext, x)
2547 const OptionDef options[] = {
2549 #include "cmdutils_common_opts.h"
2550 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2551 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2552 "force format", "fmt" },
2553 { "y", OPT_BOOL, { &file_overwrite },
2554 "overwrite output files" },
2555 { "n", OPT_BOOL, { &no_file_overwrite },
2556 "do not overwrite output files" },
2557 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2558 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2559 "codec name", "codec" },
2560 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2561 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2562 "codec name", "codec" },
2563 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2564 OPT_OUTPUT, { .off = OFFSET(presets) },
2565 "preset name", "preset" },
2566 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2567 OPT_OUTPUT, { .func_arg = opt_map },
2568 "set input stream mapping",
2569 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2570 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2571 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2572 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2573 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2574 "set metadata information of outfile from infile",
2575 "outfile[,metadata]:infile[,metadata]" },
2576 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2577 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2578 "set chapters mapping", "input_file_index" },
2579 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2580 "record or transcode \"duration\" seconds of audio/video",
2582 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2583 "record or transcode stop time", "time_stop" },
2584 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2585 "set the limit file size in bytes", "limit_size" },
2586 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2587 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2588 "set the start time offset", "time_off" },
2589 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2590 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2591 "set the input ts offset", "time_off" },
2592 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2593 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2594 "set the input ts scale", "scale" },
2595 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2596 "set the recording timestamp ('now' to set the current time)", "time" },
2597 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2598 "add metadata", "string=string" },
2599 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2600 OPT_OUTPUT, { .func_arg = opt_data_frames },
2601 "set the number of data frames to record", "number" },
2602 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2603 "add timings for benchmarking" },
2604 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2605 "add timings for each task" },
2606 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2607 "write program-readable progress information", "url" },
2608 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2609 "enable or disable interaction on standard input" },
2610 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2611 "set max runtime in seconds", "limit" },
2612 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2613 "dump each input packet" },
2614 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2615 "when dumping packets, also dump the payload" },
2616 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2617 OPT_INPUT, { .off = OFFSET(rate_emu) },
2618 "read input at native frame rate", "" },
2619 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2620 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2621 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2622 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2623 "video sync method", "" },
2624 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2625 "audio sync method", "" },
2626 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2627 "audio drift threshold", "threshold" },
2628 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2629 "copy timestamps" },
2630 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2631 "copy input stream time base when stream copying", "mode" },
2632 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2633 OPT_OUTPUT, { .off = OFFSET(shortest) },
2634 "finish encoding within shortest input" },
2635 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2636 "timestamp discontinuity delta threshold", "threshold" },
2637 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2638 "timestamp error delta threshold", "threshold" },
2639 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2640 "exit on error", "error" },
2641 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2642 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2643 "copy initial non-keyframes" },
2644 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2645 "copy or discard frames before start time" },
2646 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2647 "set the number of frames to record", "number" },
2648 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2649 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2650 "force codec tag/fourcc", "fourcc/tag" },
2651 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2652 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2653 "use fixed quality scale (VBR)", "q" },
2654 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2655 OPT_OUTPUT, { .func_arg = opt_qscale },
2656 "use fixed quality scale (VBR)", "q" },
2657 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2658 "set profile", "profile" },
2659 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2660 "set stream filtergraph", "filter_graph" },
2661 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2662 "read stream filtergraph description from a file", "filename" },
2663 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2664 "reinit filtergraph on input parameter changes", "" },
2665 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2666 "create a complex filtergraph", "graph_description" },
2667 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2668 "create a complex filtergraph", "graph_description" },
2669 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2670 "read complex filtergraph description from a file", "filename" },
2671 { "stats", OPT_BOOL, { &print_stats },
2672 "print progress report during encoding", },
2673 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2674 OPT_OUTPUT, { .func_arg = opt_attach },
2675 "add an attachment to the output file", "filename" },
2676 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2677 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2678 "extract an attachment into a file", "filename" },
2679 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2680 "print timestamp debugging info" },
2683 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2684 "set the number of video frames to record", "number" },
2685 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2686 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2687 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2688 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2689 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2690 "set frame size (WxH or abbreviation)", "size" },
2691 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2692 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2693 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2694 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2695 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2696 "set pixel format", "format" },
2697 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2698 "set the number of bits per raw sample", "number" },
2699 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2700 "deprecated use -g 1" },
2701 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2703 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2704 "discard threshold", "n" },
2705 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2706 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2707 "rate control override for specific intervals", "override" },
2708 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2709 OPT_OUTPUT, { .func_arg = opt_video_codec },
2710 "force video codec ('copy' to copy stream)", "codec" },
2711 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2713 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2715 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2716 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2717 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2718 "select the pass number (1 to 3)", "n" },
2719 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2720 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2721 "select two pass log file name prefix", "prefix" },
2722 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2723 "this option is deprecated, use the yadif filter instead" },
2724 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2725 "calculate PSNR of compressed frames" },
2726 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2727 "dump video coding statistics to file" },
2728 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2729 "dump video coding statistics to file", "file" },
2730 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2731 "set video filters", "filter_graph" },
2732 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2733 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2734 "specify intra matrix coeffs", "matrix" },
2735 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2736 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2737 "specify inter matrix coeffs", "matrix" },
2738 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2739 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2740 "top=1/bottom=0/auto=-1 field first", "" },
2741 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2742 "intra_dc_precision", "precision" },
2743 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2744 OPT_OUTPUT, { .func_arg = opt_old2new },
2745 "force video tag/fourcc", "fourcc/tag" },
2746 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2747 "show QP histogram" },
2748 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2749 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2750 "force the selected framerate, disable the best supported framerate selection" },
2751 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2752 OPT_OUTPUT, { .func_arg = opt_streamid },
2753 "set the value of an outfile streamid", "streamIndex:value" },
2754 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2755 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2756 "force key frames at specified timestamps", "timestamps" },
2757 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2758 "video bitrate (please use -b:v)", "bitrate" },
2761 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2762 "set the number of audio frames to record", "number" },
2763 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2764 "set audio quality (codec-specific)", "quality", },
2765 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2766 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2767 "set audio sampling rate (in Hz)", "rate" },
2768 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2769 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2770 "set number of audio channels", "channels" },
2771 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2773 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2774 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2775 "force audio codec ('copy' to copy stream)", "codec" },
2776 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2777 OPT_OUTPUT, { .func_arg = opt_old2new },
2778 "force audio tag/fourcc", "fourcc/tag" },
2779 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2780 "change audio volume (256=normal)" , "volume" },
2781 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2782 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2783 "set sample format", "format" },
2784 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2785 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2786 "set channel layout", "layout" },
2787 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2788 "set audio filters", "filter_graph" },
2789 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2790 "set the maximum number of channels to try to guess the channel layout" },
2792 /* subtitle options */
2793 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2794 "disable subtitle" },
2795 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2796 "force subtitle codec ('copy' to copy stream)", "codec" },
2797 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2798 , "force subtitle tag/fourcc", "fourcc/tag" },
2799 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2800 "fix subtitles duration" },
2801 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2802 "set canvas size (WxH or abbreviation)", "size" },
2805 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2806 "deprecated, use -channel", "channel" },
2807 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2808 "deprecated, use -standard", "standard" },
2809 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2812 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2813 "set the maximum demux-decode delay", "seconds" },
2814 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2815 "set the initial demux-decode delay", "seconds" },
2817 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2818 "A comma-separated list of bitstream filters", "bitstream_filters" },
2819 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2820 "deprecated", "audio bitstream_filters" },
2821 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2822 "deprecated", "video bitstream_filters" },
2824 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2825 "set the audio options to the indicated preset", "preset" },
2826 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2827 "set the video options to the indicated preset", "preset" },
2828 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2829 "set the subtitle options to the indicated preset", "preset" },
2830 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2831 "set options from indicated preset file", "filename" },
2832 /* data codec support */
2833 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2834 "force data codec ('copy' to copy stream)", "codec" },
2835 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },