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 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1110 AVCodecContext *video_enc;
1111 char *frame_rate = NULL;
1113 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1115 video_enc = st->codec;
1117 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1118 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1119 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1123 if (!ost->stream_copy) {
1124 const char *p = NULL;
1125 char *frame_size = NULL;
1126 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1127 char *intra_matrix = NULL, *inter_matrix = NULL;
1128 const char *filters = "null";
1132 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1133 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1134 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1138 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1139 if (frame_aspect_ratio) {
1141 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1142 q.num <= 0 || q.den <= 0) {
1143 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1146 ost->frame_aspect_ratio = av_q2d(q);
1149 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1150 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1151 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1152 ost->keep_pix_fmt = 1;
1153 if (!*++frame_pix_fmt)
1154 frame_pix_fmt = NULL;
1156 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1157 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1160 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1163 video_enc->gop_size = 0;
1164 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1166 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1167 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1170 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1172 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1174 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1175 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1178 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1181 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1182 for (i = 0; p; i++) {
1184 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1186 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1189 /* FIXME realloc failure */
1190 video_enc->rc_override =
1191 av_realloc(video_enc->rc_override,
1192 sizeof(RcOverride) * (i + 1));
1193 video_enc->rc_override[i].start_frame = start;
1194 video_enc->rc_override[i].end_frame = end;
1196 video_enc->rc_override[i].qscale = q;
1197 video_enc->rc_override[i].quality_factor = 1.0;
1200 video_enc->rc_override[i].qscale = 0;
1201 video_enc->rc_override[i].quality_factor = -q/100.0;
1206 video_enc->rc_override_count = i;
1207 video_enc->intra_dc_precision = intra_dc_precision - 8;
1210 video_enc->flags|= CODEC_FLAG_PSNR;
1213 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1216 video_enc->flags |= CODEC_FLAG_PASS1;
1217 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1220 video_enc->flags |= CODEC_FLAG_PASS2;
1221 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1225 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1226 if (ost->logfile_prefix &&
1227 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1230 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1231 if (ost->forced_keyframes)
1232 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1234 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1236 ost->top_field_first = -1;
1237 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1239 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1240 ost->avfilter = av_strdup(filters);
1242 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1248 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1253 AVCodecContext *audio_enc;
1255 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1258 audio_enc = st->codec;
1259 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1261 if (!ost->stream_copy) {
1262 char *sample_fmt = NULL;
1263 const char *filters = "anull";
1265 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1267 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1269 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1270 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1274 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1276 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1278 av_assert1(filters);
1279 ost->avfilter = av_strdup(filters);
1281 /* check for channel mapping for this audio stream */
1282 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1283 AudioChannelMap *map = &o->audio_channel_maps[n];
1284 InputStream *ist = input_streams[ost->source_index];
1285 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1286 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1287 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1288 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1289 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1291 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1292 ost->file_index, ost->st->index);
1300 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1304 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1305 if (!ost->stream_copy) {
1306 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1313 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1315 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1316 ost->stream_copy = 1;
1321 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1325 AVCodecContext *subtitle_enc;
1327 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1329 subtitle_enc = st->codec;
1331 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1333 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1335 if (!ost->stream_copy) {
1336 char *frame_size = NULL;
1338 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1339 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1340 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1348 /* arg format is "output-stream-index:streamid-value". */
1349 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1351 OptionsContext *o = optctx;
1356 av_strlcpy(idx_str, arg, sizeof(idx_str));
1357 p = strchr(idx_str, ':');
1359 av_log(NULL, AV_LOG_FATAL,
1360 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1365 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1366 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1367 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1371 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1373 AVFormatContext *is = ifile->ctx;
1374 AVFormatContext *os = ofile->ctx;
1378 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1380 return AVERROR(ENOMEM);
1383 for (i = 0; i < is->nb_chapters; i++) {
1384 AVChapter *in_ch = is->chapters[i], *out_ch;
1385 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1386 AV_TIME_BASE_Q, in_ch->time_base);
1387 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1388 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1391 if (in_ch->end < ts_off)
1393 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1396 out_ch = av_mallocz(sizeof(AVChapter));
1398 return AVERROR(ENOMEM);
1400 out_ch->id = in_ch->id;
1401 out_ch->time_base = in_ch->time_base;
1402 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1403 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1406 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1408 os->chapters[os->nb_chapters++] = out_ch;
1413 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1416 AVFormatContext *ic = avformat_alloc_context();
1418 ic->interrupt_callback = int_cb;
1419 err = avformat_open_input(&ic, filename, NULL, NULL);
1422 /* copy stream format */
1423 for(i=0;i<ic->nb_streams;i++) {
1427 AVCodecContext *avctx;
1429 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1430 ost = new_output_stream(o, s, codec->type, -1);
1435 // FIXME: a more elegant solution is needed
1436 memcpy(st, ic->streams[i], sizeof(AVStream));
1438 st->info = av_malloc(sizeof(*st->info));
1439 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1441 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1443 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1444 choose_sample_fmt(st, codec);
1445 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1446 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1449 /* ffserver seeking with date=... needs a date reference */
1450 err = parse_option(o, "metadata", "creation_time=now", options);
1452 avformat_close_input(&ic);
1456 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1457 AVFormatContext *oc)
1461 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1462 ofilter->out_tmp->pad_idx)) {
1463 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1464 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1466 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1471 ost->source_index = -1;
1472 ost->filter = ofilter;
1476 if (ost->stream_copy) {
1477 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1478 "which is fed from a complex filtergraph. Filtering and streamcopy "
1479 "cannot be used together.\n", ost->file_index, ost->index);
1483 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1484 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1487 avfilter_inout_free(&ofilter->out_tmp);
1490 static int configure_complex_filters(void)
1494 for (i = 0; i < nb_filtergraphs; i++)
1495 if (!filtergraphs[i]->graph &&
1496 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1501 static int open_output_file(OptionsContext *o, const char *filename)
1503 AVFormatContext *oc;
1505 AVOutputFormat *file_oformat;
1509 AVDictionary *unused_opts = NULL;
1510 AVDictionaryEntry *e = NULL;
1512 if (configure_complex_filters() < 0) {
1513 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1517 if (!strcmp(filename, "-"))
1520 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1522 print_error(filename, err);
1525 file_oformat= oc->oformat;
1526 oc->interrupt_callback = int_cb;
1528 /* create streams for all unlabeled output pads */
1529 for (i = 0; i < nb_filtergraphs; i++) {
1530 FilterGraph *fg = filtergraphs[i];
1531 for (j = 0; j < fg->nb_outputs; j++) {
1532 OutputFilter *ofilter = fg->outputs[j];
1534 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1537 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1538 ofilter->out_tmp->pad_idx)) {
1539 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1540 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1541 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1543 init_output_filter(ofilter, o, oc);
1547 if (!strcmp(file_oformat->name, "ffm") &&
1548 av_strstart(filename, "http:", NULL)) {
1550 /* special case for files sent to ffserver: we get the stream
1551 parameters from ffserver */
1552 int err = read_ffserver_streams(o, oc, filename);
1554 print_error(filename, err);
1557 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1558 ost = output_streams[j];
1559 for (i = 0; i < nb_input_streams; i++) {
1560 ist = input_streams[i];
1561 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1563 ost->source_index= i;
1564 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1565 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1567 ist->st->discard = AVDISCARD_NONE;
1572 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));
1576 } else if (!o->nb_stream_maps) {
1577 char *subtitle_codec_name = NULL;
1578 /* pick the "best" stream of each type */
1580 /* video: highest resolution */
1581 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1582 int area = 0, idx = -1;
1583 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1584 for (i = 0; i < nb_input_streams; i++) {
1586 ist = input_streams[i];
1587 new_area = ist->st->codec->width * ist->st->codec->height;
1588 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1590 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1592 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1599 new_video_stream(o, oc, idx);
1602 /* audio: most channels */
1603 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1604 int channels = 0, idx = -1;
1605 for (i = 0; i < nb_input_streams; i++) {
1606 ist = input_streams[i];
1607 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1608 ist->st->codec->channels > channels) {
1609 channels = ist->st->codec->channels;
1614 new_audio_stream(o, oc, idx);
1617 /* subtitles: pick first */
1618 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1619 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1620 for (i = 0; i < nb_input_streams; i++)
1621 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1622 new_subtitle_stream(o, oc, i);
1626 /* do something with data? */
1628 for (i = 0; i < o->nb_stream_maps; i++) {
1629 StreamMap *map = &o->stream_maps[i];
1630 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1635 if (map->linklabel) {
1637 OutputFilter *ofilter = NULL;
1640 for (j = 0; j < nb_filtergraphs; j++) {
1641 fg = filtergraphs[j];
1642 for (k = 0; k < fg->nb_outputs; k++) {
1643 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1644 if (out && !strcmp(out->name, map->linklabel)) {
1645 ofilter = fg->outputs[k];
1652 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1653 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1656 init_output_filter(ofilter, o, oc);
1658 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1659 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1661 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1663 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1665 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1668 switch (ist->st->codec->codec_type) {
1669 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1670 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1671 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1672 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1673 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1675 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1676 map->file_index, map->stream_index);
1683 /* handle attached files */
1684 for (i = 0; i < o->nb_attachments; i++) {
1686 uint8_t *attachment;
1690 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1691 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1695 if ((len = avio_size(pb)) <= 0) {
1696 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1700 if (!(attachment = av_malloc(len))) {
1701 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1705 avio_read(pb, attachment, len);
1707 ost = new_attachment_stream(o, oc, -1);
1708 ost->stream_copy = 0;
1709 ost->attachment_filename = o->attachments[i];
1711 ost->st->codec->extradata = attachment;
1712 ost->st->codec->extradata_size = len;
1714 p = strrchr(o->attachments[i], '/');
1715 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1719 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1720 AVDictionaryEntry *e;
1721 ost = output_streams[i];
1723 if ((ost->stream_copy || ost->attachment_filename)
1724 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1725 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1726 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1730 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1731 o->stop_time = INT64_MAX;
1732 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1735 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1736 if (o->stop_time <= o->start_time) {
1737 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1738 o->stop_time = INT64_MAX;
1740 o->recording_time = o->stop_time - o->start_time;
1744 GROW_ARRAY(output_files, nb_output_files);
1745 of = av_mallocz(sizeof(*of));
1748 output_files[nb_output_files - 1] = of;
1751 of->ost_index = nb_output_streams - oc->nb_streams;
1752 of->recording_time = o->recording_time;
1753 if (o->recording_time != INT64_MAX)
1754 oc->duration = o->recording_time;
1755 of->start_time = o->start_time;
1756 of->limit_filesize = o->limit_filesize;
1757 of->shortest = o->shortest;
1758 av_dict_copy(&of->opts, o->g->format_opts, 0);
1761 /* check if all codec options have been used */
1762 unused_opts = strip_specifiers(o->g->codec_opts);
1763 for (i = of->ost_index; i < nb_output_streams; i++) {
1765 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1766 AV_DICT_IGNORE_SUFFIX)))
1767 av_dict_set(&unused_opts, e->key, NULL, 0);
1771 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1772 const AVClass *class = avcodec_get_class();
1773 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1774 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1777 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1778 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1779 "output file #%d (%s) is not an encoding option.\n", e->key,
1780 option->help ? option->help : "", nb_output_files - 1,
1785 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1786 "output file #%d (%s) has not been used for any stream. The most "
1787 "likely reason is either wrong type (e.g. a video option with "
1788 "no video streams) or that it is a private option of some encoder "
1789 "which was not actually used for any stream.\n", e->key,
1790 option->help ? option->help : "", nb_output_files - 1, filename);
1792 av_dict_free(&unused_opts);
1794 /* check filename in case of an image number is expected */
1795 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1796 if (!av_filename_number_test(oc->filename)) {
1797 print_error(oc->filename, AVERROR(EINVAL));
1802 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1803 /* test if it already exists to avoid losing precious files */
1804 assert_file_overwrite(filename);
1807 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1808 &oc->interrupt_callback,
1810 print_error(filename, err);
1813 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1814 assert_file_overwrite(filename);
1816 if (o->mux_preload) {
1818 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1819 av_dict_set(&of->opts, "preload", buf, 0);
1821 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1824 for (i = 0; i < o->nb_metadata_map; i++) {
1826 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1828 if (in_file_index >= nb_input_files) {
1829 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1832 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1833 in_file_index >= 0 ?
1834 input_files[in_file_index]->ctx : NULL, o);
1838 if (o->chapters_input_file >= nb_input_files) {
1839 if (o->chapters_input_file == INT_MAX) {
1840 /* copy chapters from the first input file that has them*/
1841 o->chapters_input_file = -1;
1842 for (i = 0; i < nb_input_files; i++)
1843 if (input_files[i]->ctx->nb_chapters) {
1844 o->chapters_input_file = i;
1848 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1849 o->chapters_input_file);
1853 if (o->chapters_input_file >= 0)
1854 copy_chapters(input_files[o->chapters_input_file], of,
1855 !o->metadata_chapters_manual);
1857 /* copy global metadata by default */
1858 if (!o->metadata_global_manual && nb_input_files){
1859 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1860 AV_DICT_DONT_OVERWRITE);
1861 if(o->recording_time != INT64_MAX)
1862 av_dict_set(&oc->metadata, "duration", NULL, 0);
1863 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1865 if (!o->metadata_streams_manual)
1866 for (i = of->ost_index; i < nb_output_streams; i++) {
1868 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1870 ist = input_streams[output_streams[i]->source_index];
1871 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1874 /* process manually set metadata */
1875 for (i = 0; i < o->nb_metadata; i++) {
1878 const char *stream_spec;
1879 int index = 0, j, ret = 0;
1881 val = strchr(o->metadata[i].u.str, '=');
1883 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1884 o->metadata[i].u.str);
1889 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1891 for (j = 0; j < oc->nb_streams; j++) {
1892 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1893 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1904 if (index < 0 || index >= oc->nb_chapters) {
1905 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1908 m = &oc->chapters[index]->metadata;
1911 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1914 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1921 static int opt_target(void *optctx, const char *opt, const char *arg)
1923 OptionsContext *o = optctx;
1924 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1925 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1927 if (!strncmp(arg, "pal-", 4)) {
1930 } else if (!strncmp(arg, "ntsc-", 5)) {
1933 } else if (!strncmp(arg, "film-", 5)) {
1937 /* Try to determine PAL/NTSC by peeking in the input files */
1938 if (nb_input_files) {
1940 for (j = 0; j < nb_input_files; j++) {
1941 for (i = 0; i < input_files[j]->nb_streams; i++) {
1942 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1943 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1945 fr = c->time_base.den * 1000 / c->time_base.num;
1949 } else if ((fr == 29970) || (fr == 23976)) {
1954 if (norm != UNKNOWN)
1958 if (norm != UNKNOWN)
1959 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1962 if (norm == UNKNOWN) {
1963 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1964 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1965 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1969 if (!strcmp(arg, "vcd")) {
1970 opt_video_codec(o, "c:v", "mpeg1video");
1971 opt_audio_codec(o, "c:a", "mp2");
1972 parse_option(o, "f", "vcd", options);
1973 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1975 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1976 parse_option(o, "r", frame_rates[norm], options);
1977 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1979 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1980 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1981 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1982 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1984 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1985 parse_option(o, "ar", "44100", options);
1986 parse_option(o, "ac", "2", options);
1988 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1989 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1991 /* We have to offset the PTS, so that it is consistent with the SCR.
1992 SCR starts at 36000, but the first two packs contain only padding
1993 and the first pack from the other stream, respectively, may also have
1994 been written before.
1995 So the real data starts at SCR 36000+3*1200. */
1996 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1997 } else if (!strcmp(arg, "svcd")) {
1999 opt_video_codec(o, "c:v", "mpeg2video");
2000 opt_audio_codec(o, "c:a", "mp2");
2001 parse_option(o, "f", "svcd", options);
2003 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2004 parse_option(o, "r", frame_rates[norm], options);
2005 parse_option(o, "pix_fmt", "yuv420p", options);
2006 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2008 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2009 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2010 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2011 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2012 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2014 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2015 parse_option(o, "ar", "44100", options);
2017 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2019 } else if (!strcmp(arg, "dvd")) {
2021 opt_video_codec(o, "c:v", "mpeg2video");
2022 opt_audio_codec(o, "c:a", "ac3");
2023 parse_option(o, "f", "dvd", options);
2025 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2026 parse_option(o, "r", frame_rates[norm], options);
2027 parse_option(o, "pix_fmt", "yuv420p", options);
2028 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2030 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2031 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2032 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2033 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2035 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.
2036 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2038 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2039 parse_option(o, "ar", "48000", options);
2041 } else if (!strncmp(arg, "dv", 2)) {
2043 parse_option(o, "f", "dv", options);
2045 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2046 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2047 norm == PAL ? "yuv420p" : "yuv411p", options);
2048 parse_option(o, "r", frame_rates[norm], options);
2050 parse_option(o, "ar", "48000", options);
2051 parse_option(o, "ac", "2", options);
2054 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2055 return AVERROR(EINVAL);
2060 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2062 av_free (vstats_filename);
2063 vstats_filename = av_strdup (arg);
2067 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2070 time_t today2 = time(NULL);
2071 struct tm *today = localtime(&today2);
2073 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2075 return opt_vstats_file(NULL, opt, filename);
2078 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2080 OptionsContext *o = optctx;
2081 return parse_option(o, "frames:v", arg, options);
2084 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2086 OptionsContext *o = optctx;
2087 return parse_option(o, "frames:a", arg, options);
2090 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2092 OptionsContext *o = optctx;
2093 return parse_option(o, "frames:d", arg, options);
2096 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2099 AVDictionary *cbak = codec_opts;
2100 AVDictionary *fbak = format_opts;
2104 ret = opt_default(NULL, opt, arg);
2106 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2107 av_dict_copy(&o->g->format_opts, format_opts, 0);
2108 av_dict_free(&codec_opts);
2109 av_dict_free(&format_opts);
2116 static int opt_preset(void *optctx, const char *opt, const char *arg)
2118 OptionsContext *o = optctx;
2120 char filename[1000], line[1000], tmp_line[1000];
2121 const char *codec_name = NULL;
2125 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2127 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2128 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2129 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2131 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2135 while (fgets(line, sizeof(line), f)) {
2136 char *key = tmp_line, *value, *endptr;
2138 if (strcspn(line, "#\n\r") == 0)
2140 strcpy(tmp_line, line);
2141 if (!av_strtok(key, "=", &value) ||
2142 !av_strtok(value, "\r\n", &endptr)) {
2143 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2146 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2148 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2149 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2150 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2151 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2152 else if (opt_default_new(o, key, value) < 0) {
2153 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2154 filename, line, key, value);
2164 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2166 OptionsContext *o = optctx;
2167 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2168 int ret = parse_option(o, s, arg, options);
2173 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2175 OptionsContext *o = optctx;
2176 if(!strcmp(opt, "b")){
2177 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2178 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2181 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2185 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2187 OptionsContext *o = optctx;
2190 if(!strcmp(opt, "qscale")){
2191 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2192 return parse_option(o, "q:v", arg, options);
2194 s = av_asprintf("q%s", opt + 6);
2195 ret = parse_option(o, s, arg, options);
2200 static int opt_profile(void *optctx, const char *opt, const char *arg)
2202 OptionsContext *o = optctx;
2203 if(!strcmp(opt, "profile")){
2204 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2205 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2208 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2212 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2214 OptionsContext *o = optctx;
2215 return parse_option(o, "filter:v", arg, options);
2218 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2220 OptionsContext *o = optctx;
2221 return parse_option(o, "filter:a", arg, options);
2224 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2226 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2227 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2228 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2229 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2231 if (video_sync_method == VSYNC_AUTO)
2232 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2236 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2238 OptionsContext *o = optctx;
2239 char *tcr = av_asprintf("timecode=%s", arg);
2240 int ret = parse_option(o, "metadata:g", tcr, options);
2242 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2247 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2249 OptionsContext *o = optctx;
2250 char layout_str[32];
2253 int ret, channels, ac_str_size;
2256 layout = av_get_channel_layout(arg);
2258 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2259 return AVERROR(EINVAL);
2261 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2262 ret = opt_default_new(o, opt, layout_str);
2266 /* set 'ac' option based on channel layout */
2267 channels = av_get_channel_layout_nb_channels(layout);
2268 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2269 stream_str = strchr(opt, ':');
2270 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2271 ac_str = av_mallocz(ac_str_size);
2273 return AVERROR(ENOMEM);
2274 av_strlcpy(ac_str, "ac", 3);
2276 av_strlcat(ac_str, stream_str, ac_str_size);
2277 ret = parse_option(o, ac_str, layout_str, options);
2283 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2285 OptionsContext *o = optctx;
2286 return parse_option(o, "q:a", arg, options);
2289 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2291 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2292 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2293 return AVERROR(ENOMEM);
2294 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2295 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2299 void show_help_default(const char *opt, const char *arg)
2301 /* per-file options have at least one of those set */
2302 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2303 int show_advanced = 0, show_avoptions = 0;
2306 if (!strcmp(opt, "long"))
2308 else if (!strcmp(opt, "full"))
2309 show_advanced = show_avoptions = 1;
2311 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2316 printf("Getting help:\n"
2317 " -h -- print basic options\n"
2318 " -h long -- print more options\n"
2319 " -h full -- print all options (including all format and codec specific options, very long)\n"
2320 " See man %s for detailed description of the options.\n"
2321 "\n", program_name);
2323 show_help_options(options, "Print help / information / capabilities:",
2326 show_help_options(options, "Global options (affect whole program "
2327 "instead of just one file:",
2328 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2330 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2331 per_file | OPT_EXIT, 0);
2333 show_help_options(options, "Per-file main options:", 0,
2334 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2335 OPT_EXIT, per_file);
2337 show_help_options(options, "Advanced per-file options:",
2338 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2340 show_help_options(options, "Video options:",
2341 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2343 show_help_options(options, "Advanced Video options:",
2344 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2346 show_help_options(options, "Audio options:",
2347 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2349 show_help_options(options, "Advanced Audio options:",
2350 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2351 show_help_options(options, "Subtitle options:",
2352 OPT_SUBTITLE, 0, 0);
2355 if (show_avoptions) {
2356 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2357 show_help_children(avcodec_get_class(), flags);
2358 show_help_children(avformat_get_class(), flags);
2359 show_help_children(sws_get_class(), flags);
2360 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2361 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2365 void show_usage(void)
2367 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2368 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2369 av_log(NULL, AV_LOG_INFO, "\n");
2377 static const OptionGroupDef groups[] = {
2378 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2379 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2382 static int open_files(OptionGroupList *l, const char *inout,
2383 int (*open_file)(OptionsContext*, const char*))
2387 for (i = 0; i < l->nb_groups; i++) {
2388 OptionGroup *g = &l->groups[i];
2391 init_options(&o, !strcmp(inout, "input"));
2394 ret = parse_optgroup(&o, g);
2396 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2397 "%s.\n", inout, g->arg);
2401 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2402 ret = open_file(&o, g->arg);
2403 uninit_options(&o, !strcmp(inout, "input"));
2405 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2409 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2415 int ffmpeg_parse_options(int argc, char **argv)
2417 OptionParseContext octx;
2421 memset(&octx, 0, sizeof(octx));
2423 /* split the commandline into an internal representation */
2424 ret = split_commandline(&octx, argc, argv, options, groups,
2425 FF_ARRAY_ELEMS(groups));
2427 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2431 /* apply global options */
2432 ret = parse_optgroup(NULL, &octx.global_opts);
2434 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2438 /* open input files */
2439 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2441 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2445 /* open output files */
2446 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2448 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2453 uninit_parse_context(&octx);
2455 av_strerror(ret, error, sizeof(error));
2456 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2461 static int opt_progress(void *optctx, const char *opt, const char *arg)
2463 AVIOContext *avio = NULL;
2466 if (!strcmp(arg, "-"))
2468 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2470 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2471 arg, av_err2str(ret));
2474 progress_avio = avio;
2478 #define OFFSET(x) offsetof(OptionsContext, x)
2479 const OptionDef options[] = {
2481 #include "cmdutils_common_opts.h"
2482 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2483 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2484 "force format", "fmt" },
2485 { "y", OPT_BOOL, { &file_overwrite },
2486 "overwrite output files" },
2487 { "n", OPT_BOOL, { &no_file_overwrite },
2488 "do not overwrite output files" },
2489 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2490 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2491 "codec name", "codec" },
2492 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2493 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2494 "codec name", "codec" },
2495 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2496 OPT_OUTPUT, { .off = OFFSET(presets) },
2497 "preset name", "preset" },
2498 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2499 OPT_OUTPUT, { .func_arg = opt_map },
2500 "set input stream mapping",
2501 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2502 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2503 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2504 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2505 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2506 "set metadata information of outfile from infile",
2507 "outfile[,metadata]:infile[,metadata]" },
2508 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2509 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2510 "set chapters mapping", "input_file_index" },
2511 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2512 "record or transcode \"duration\" seconds of audio/video",
2514 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2515 "record or transcode stop time", "time_stop" },
2516 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2517 "set the limit file size in bytes", "limit_size" },
2518 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2519 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2520 "set the start time offset", "time_off" },
2521 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2522 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2523 "set the input ts offset", "time_off" },
2524 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2525 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2526 "set the input ts scale", "scale" },
2527 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2528 "set the recording timestamp ('now' to set the current time)", "time" },
2529 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2530 "add metadata", "string=string" },
2531 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2532 OPT_OUTPUT, { .func_arg = opt_data_frames },
2533 "set the number of data frames to record", "number" },
2534 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2535 "add timings for benchmarking" },
2536 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2537 "add timings for each task" },
2538 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2539 "write program-readable progress information", "url" },
2540 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2541 "enable or disable interaction on standard input" },
2542 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2543 "set max runtime in seconds", "limit" },
2544 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2545 "dump each input packet" },
2546 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2547 "when dumping packets, also dump the payload" },
2548 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2549 OPT_INPUT, { .off = OFFSET(rate_emu) },
2550 "read input at native frame rate", "" },
2551 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2552 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2553 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2554 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2555 "video sync method", "" },
2556 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2557 "audio sync method", "" },
2558 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2559 "audio drift threshold", "threshold" },
2560 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2561 "copy timestamps" },
2562 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2563 "copy input stream time base when stream copying", "mode" },
2564 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2565 OPT_OUTPUT, { .off = OFFSET(shortest) },
2566 "finish encoding within shortest input" },
2567 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2568 "timestamp discontinuity delta threshold", "threshold" },
2569 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2570 "timestamp error delta threshold", "threshold" },
2571 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2572 "exit on error", "error" },
2573 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2574 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2575 "copy initial non-keyframes" },
2576 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2577 "copy or discard frames before start time" },
2578 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2579 "set the number of frames to record", "number" },
2580 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2581 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2582 "force codec tag/fourcc", "fourcc/tag" },
2583 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2584 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2585 "use fixed quality scale (VBR)", "q" },
2586 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2587 OPT_OUTPUT, { .func_arg = opt_qscale },
2588 "use fixed quality scale (VBR)", "q" },
2589 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2590 "set profile", "profile" },
2591 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2592 "set stream filtergraph", "filter_graph" },
2593 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2594 "reinit filtergraph on input parameter changes", "" },
2595 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2596 "create a complex filtergraph", "graph_description" },
2597 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2598 "create a complex filtergraph", "graph_description" },
2599 { "stats", OPT_BOOL, { &print_stats },
2600 "print progress report during encoding", },
2601 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2602 OPT_OUTPUT, { .func_arg = opt_attach },
2603 "add an attachment to the output file", "filename" },
2604 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2605 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2606 "extract an attachment into a file", "filename" },
2607 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2608 "print timestamp debugging info" },
2611 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2612 "set the number of video frames to record", "number" },
2613 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2614 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2615 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2616 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2617 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2618 "set frame size (WxH or abbreviation)", "size" },
2619 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2620 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2621 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2622 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2623 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2624 "set pixel format", "format" },
2625 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2626 "set the number of bits per raw sample", "number" },
2627 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2628 "deprecated use -g 1" },
2629 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2631 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2632 "discard threshold", "n" },
2633 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2634 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2635 "rate control override for specific intervals", "override" },
2636 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2637 OPT_OUTPUT, { .func_arg = opt_video_codec },
2638 "force video codec ('copy' to copy stream)", "codec" },
2639 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2641 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2643 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2644 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2645 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2646 "select the pass number (1 to 3)", "n" },
2647 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2648 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2649 "select two pass log file name prefix", "prefix" },
2650 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2651 "this option is deprecated, use the yadif filter instead" },
2652 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2653 "calculate PSNR of compressed frames" },
2654 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2655 "dump video coding statistics to file" },
2656 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2657 "dump video coding statistics to file", "file" },
2658 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2659 "set video filters", "filter_graph" },
2660 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2661 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2662 "specify intra matrix coeffs", "matrix" },
2663 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2664 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2665 "specify inter matrix coeffs", "matrix" },
2666 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2667 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2668 "top=1/bottom=0/auto=-1 field first", "" },
2669 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2670 "intra_dc_precision", "precision" },
2671 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2672 OPT_OUTPUT, { .func_arg = opt_old2new },
2673 "force video tag/fourcc", "fourcc/tag" },
2674 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2675 "show QP histogram" },
2676 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2677 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2678 "force the selected framerate, disable the best supported framerate selection" },
2679 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2680 OPT_OUTPUT, { .func_arg = opt_streamid },
2681 "set the value of an outfile streamid", "streamIndex:value" },
2682 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2683 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2684 "force key frames at specified timestamps", "timestamps" },
2685 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2686 "video bitrate (please use -b:v)", "bitrate" },
2689 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2690 "set the number of audio frames to record", "number" },
2691 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2692 "set audio quality (codec-specific)", "quality", },
2693 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2694 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2695 "set audio sampling rate (in Hz)", "rate" },
2696 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2697 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2698 "set number of audio channels", "channels" },
2699 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2701 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2702 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2703 "force audio codec ('copy' to copy stream)", "codec" },
2704 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2705 OPT_OUTPUT, { .func_arg = opt_old2new },
2706 "force audio tag/fourcc", "fourcc/tag" },
2707 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2708 "change audio volume (256=normal)" , "volume" },
2709 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2710 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2711 "set sample format", "format" },
2712 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2713 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2714 "set channel layout", "layout" },
2715 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2716 "set audio filters", "filter_graph" },
2717 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2718 "set the maximum number of channels to try to guess the channel layout" },
2720 /* subtitle options */
2721 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2722 "disable subtitle" },
2723 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2724 "force subtitle codec ('copy' to copy stream)", "codec" },
2725 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2726 , "force subtitle tag/fourcc", "fourcc/tag" },
2727 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2728 "fix subtitles duration" },
2729 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2730 "set canvas size (WxH or abbreviation)", "size" },
2733 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2734 "deprecated, use -channel", "channel" },
2735 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2736 "deprecated, use -standard", "standard" },
2737 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2740 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2741 "set the maximum demux-decode delay", "seconds" },
2742 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2743 "set the initial demux-decode delay", "seconds" },
2745 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2746 "A comma-separated list of bitstream filters", "bitstream_filters" },
2747 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2748 "deprecated", "audio bitstream_filters" },
2749 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2750 "deprecated", "video bitstream_filters" },
2752 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2753 "set the audio options to the indicated preset", "preset" },
2754 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2755 "set the video options to the indicated preset", "preset" },
2756 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2757 "set the subtitle options to the indicated preset", "preset" },
2758 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2759 "set options from indicated preset file", "filename" },
2760 /* data codec support */
2761 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2762 "force data codec ('copy' to copy stream)", "codec" },
2763 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },