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;
1320 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1324 AVCodecContext *subtitle_enc;
1326 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1328 subtitle_enc = st->codec;
1330 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1332 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1334 if (!ost->stream_copy) {
1335 char *frame_size = NULL;
1337 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1338 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1339 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1347 /* arg format is "output-stream-index:streamid-value". */
1348 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1350 OptionsContext *o = optctx;
1355 av_strlcpy(idx_str, arg, sizeof(idx_str));
1356 p = strchr(idx_str, ':');
1358 av_log(NULL, AV_LOG_FATAL,
1359 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1364 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1365 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1366 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1370 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1372 AVFormatContext *is = ifile->ctx;
1373 AVFormatContext *os = ofile->ctx;
1377 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1379 return AVERROR(ENOMEM);
1382 for (i = 0; i < is->nb_chapters; i++) {
1383 AVChapter *in_ch = is->chapters[i], *out_ch;
1384 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1385 AV_TIME_BASE_Q, in_ch->time_base);
1386 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1387 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1390 if (in_ch->end < ts_off)
1392 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1395 out_ch = av_mallocz(sizeof(AVChapter));
1397 return AVERROR(ENOMEM);
1399 out_ch->id = in_ch->id;
1400 out_ch->time_base = in_ch->time_base;
1401 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1402 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1405 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1407 os->chapters[os->nb_chapters++] = out_ch;
1412 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1415 AVFormatContext *ic = avformat_alloc_context();
1417 ic->interrupt_callback = int_cb;
1418 err = avformat_open_input(&ic, filename, NULL, NULL);
1421 /* copy stream format */
1422 for(i=0;i<ic->nb_streams;i++) {
1426 AVCodecContext *avctx;
1428 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1429 ost = new_output_stream(o, s, codec->type, -1);
1434 // FIXME: a more elegant solution is needed
1435 memcpy(st, ic->streams[i], sizeof(AVStream));
1437 st->info = av_malloc(sizeof(*st->info));
1438 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1440 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1442 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1443 choose_sample_fmt(st, codec);
1444 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1445 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1448 /* ffserver seeking with date=... needs a date reference */
1449 err = parse_option(o, "metadata", "creation_time=now", options);
1451 avformat_close_input(&ic);
1455 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1456 AVFormatContext *oc)
1460 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1461 ofilter->out_tmp->pad_idx)) {
1462 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1463 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1465 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1470 ost->source_index = -1;
1471 ost->filter = ofilter;
1475 if (ost->stream_copy) {
1476 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1477 "which is fed from a complex filtergraph. Filtering and streamcopy "
1478 "cannot be used together.\n", ost->file_index, ost->index);
1482 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1483 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1486 avfilter_inout_free(&ofilter->out_tmp);
1489 static int configure_complex_filters(void)
1493 for (i = 0; i < nb_filtergraphs; i++)
1494 if (!filtergraphs[i]->graph &&
1495 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1500 static int open_output_file(OptionsContext *o, const char *filename)
1502 AVFormatContext *oc;
1504 AVOutputFormat *file_oformat;
1508 AVDictionary *unused_opts = NULL;
1509 AVDictionaryEntry *e = NULL;
1511 if (configure_complex_filters() < 0) {
1512 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1516 if (!strcmp(filename, "-"))
1519 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1521 print_error(filename, err);
1524 file_oformat= oc->oformat;
1525 oc->interrupt_callback = int_cb;
1527 /* create streams for all unlabeled output pads */
1528 for (i = 0; i < nb_filtergraphs; i++) {
1529 FilterGraph *fg = filtergraphs[i];
1530 for (j = 0; j < fg->nb_outputs; j++) {
1531 OutputFilter *ofilter = fg->outputs[j];
1533 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1536 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1537 ofilter->out_tmp->pad_idx)) {
1538 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1539 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1540 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1542 init_output_filter(ofilter, o, oc);
1546 if (!strcmp(file_oformat->name, "ffm") &&
1547 av_strstart(filename, "http:", NULL)) {
1549 /* special case for files sent to ffserver: we get the stream
1550 parameters from ffserver */
1551 int err = read_ffserver_streams(o, oc, filename);
1553 print_error(filename, err);
1556 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1557 ost = output_streams[j];
1558 for (i = 0; i < nb_input_streams; i++) {
1559 ist = input_streams[i];
1560 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1562 ost->source_index= i;
1563 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1564 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1566 ist->st->discard = AVDISCARD_NONE;
1571 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));
1575 } else if (!o->nb_stream_maps) {
1576 char *subtitle_codec_name = NULL;
1577 /* pick the "best" stream of each type */
1579 /* video: highest resolution */
1580 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1581 int area = 0, idx = -1;
1582 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1583 for (i = 0; i < nb_input_streams; i++) {
1585 ist = input_streams[i];
1586 new_area = ist->st->codec->width * ist->st->codec->height;
1587 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1589 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1591 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1598 new_video_stream(o, oc, idx);
1601 /* audio: most channels */
1602 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1603 int channels = 0, idx = -1;
1604 for (i = 0; i < nb_input_streams; i++) {
1605 ist = input_streams[i];
1606 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1607 ist->st->codec->channels > channels) {
1608 channels = ist->st->codec->channels;
1613 new_audio_stream(o, oc, idx);
1616 /* subtitles: pick first */
1617 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1618 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1619 for (i = 0; i < nb_input_streams; i++)
1620 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1621 new_subtitle_stream(o, oc, i);
1625 /* do something with data? */
1627 for (i = 0; i < o->nb_stream_maps; i++) {
1628 StreamMap *map = &o->stream_maps[i];
1629 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1634 if (map->linklabel) {
1636 OutputFilter *ofilter = NULL;
1639 for (j = 0; j < nb_filtergraphs; j++) {
1640 fg = filtergraphs[j];
1641 for (k = 0; k < fg->nb_outputs; k++) {
1642 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1643 if (out && !strcmp(out->name, map->linklabel)) {
1644 ofilter = fg->outputs[k];
1651 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1652 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1655 init_output_filter(ofilter, o, oc);
1657 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1658 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1660 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1662 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1664 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1667 switch (ist->st->codec->codec_type) {
1668 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1669 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1670 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1671 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1672 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1674 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1675 map->file_index, map->stream_index);
1682 /* handle attached files */
1683 for (i = 0; i < o->nb_attachments; i++) {
1685 uint8_t *attachment;
1689 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1690 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1694 if ((len = avio_size(pb)) <= 0) {
1695 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1699 if (!(attachment = av_malloc(len))) {
1700 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1704 avio_read(pb, attachment, len);
1706 ost = new_attachment_stream(o, oc, -1);
1707 ost->stream_copy = 0;
1708 ost->attachment_filename = o->attachments[i];
1710 ost->st->codec->extradata = attachment;
1711 ost->st->codec->extradata_size = len;
1713 p = strrchr(o->attachments[i], '/');
1714 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1718 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1719 AVDictionaryEntry *e;
1720 ost = output_streams[i];
1722 if ((ost->stream_copy || ost->attachment_filename)
1723 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1724 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1725 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1729 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1730 o->stop_time = INT64_MAX;
1731 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1734 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1735 if (o->stop_time <= o->start_time) {
1736 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1737 o->stop_time = INT64_MAX;
1739 o->recording_time = o->stop_time - o->start_time;
1743 GROW_ARRAY(output_files, nb_output_files);
1744 of = av_mallocz(sizeof(*of));
1747 output_files[nb_output_files - 1] = of;
1750 of->ost_index = nb_output_streams - oc->nb_streams;
1751 of->recording_time = o->recording_time;
1752 if (o->recording_time != INT64_MAX)
1753 oc->duration = o->recording_time;
1754 of->start_time = o->start_time;
1755 of->limit_filesize = o->limit_filesize;
1756 of->shortest = o->shortest;
1757 av_dict_copy(&of->opts, o->g->format_opts, 0);
1760 /* check if all codec options have been used */
1761 unused_opts = strip_specifiers(o->g->codec_opts);
1762 for (i = of->ost_index; i < nb_output_streams; i++) {
1764 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1765 AV_DICT_IGNORE_SUFFIX)))
1766 av_dict_set(&unused_opts, e->key, NULL, 0);
1770 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1771 const AVClass *class = avcodec_get_class();
1772 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1773 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1776 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1777 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1778 "output file #%d (%s) is not an encoding option.\n", e->key,
1779 option->help ? option->help : "", nb_output_files - 1,
1784 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1785 "output file #%d (%s) has not been used for any stream. The most "
1786 "likely reason is either wrong type (e.g. a video option with "
1787 "no video streams) or that it is a private option of some encoder "
1788 "which was not actually used for any stream.\n", e->key,
1789 option->help ? option->help : "", nb_output_files - 1, filename);
1791 av_dict_free(&unused_opts);
1793 /* check filename in case of an image number is expected */
1794 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1795 if (!av_filename_number_test(oc->filename)) {
1796 print_error(oc->filename, AVERROR(EINVAL));
1801 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1802 /* test if it already exists to avoid losing precious files */
1803 assert_file_overwrite(filename);
1806 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1807 &oc->interrupt_callback,
1809 print_error(filename, err);
1812 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1813 assert_file_overwrite(filename);
1815 if (o->mux_preload) {
1817 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1818 av_dict_set(&of->opts, "preload", buf, 0);
1820 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1823 for (i = 0; i < o->nb_metadata_map; i++) {
1825 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1827 if (in_file_index >= nb_input_files) {
1828 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1831 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1832 in_file_index >= 0 ?
1833 input_files[in_file_index]->ctx : NULL, o);
1837 if (o->chapters_input_file >= nb_input_files) {
1838 if (o->chapters_input_file == INT_MAX) {
1839 /* copy chapters from the first input file that has them*/
1840 o->chapters_input_file = -1;
1841 for (i = 0; i < nb_input_files; i++)
1842 if (input_files[i]->ctx->nb_chapters) {
1843 o->chapters_input_file = i;
1847 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1848 o->chapters_input_file);
1852 if (o->chapters_input_file >= 0)
1853 copy_chapters(input_files[o->chapters_input_file], of,
1854 !o->metadata_chapters_manual);
1856 /* copy global metadata by default */
1857 if (!o->metadata_global_manual && nb_input_files){
1858 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1859 AV_DICT_DONT_OVERWRITE);
1860 if(o->recording_time != INT64_MAX)
1861 av_dict_set(&oc->metadata, "duration", NULL, 0);
1862 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1864 if (!o->metadata_streams_manual)
1865 for (i = of->ost_index; i < nb_output_streams; i++) {
1867 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1869 ist = input_streams[output_streams[i]->source_index];
1870 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1873 /* process manually set metadata */
1874 for (i = 0; i < o->nb_metadata; i++) {
1877 const char *stream_spec;
1878 int index = 0, j, ret = 0;
1880 val = strchr(o->metadata[i].u.str, '=');
1882 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1883 o->metadata[i].u.str);
1888 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1890 for (j = 0; j < oc->nb_streams; j++) {
1891 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1892 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1903 if (index < 0 || index >= oc->nb_chapters) {
1904 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1907 m = &oc->chapters[index]->metadata;
1910 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1913 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1920 static int opt_target(void *optctx, const char *opt, const char *arg)
1922 OptionsContext *o = optctx;
1923 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1924 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1926 if (!strncmp(arg, "pal-", 4)) {
1929 } else if (!strncmp(arg, "ntsc-", 5)) {
1932 } else if (!strncmp(arg, "film-", 5)) {
1936 /* Try to determine PAL/NTSC by peeking in the input files */
1937 if (nb_input_files) {
1939 for (j = 0; j < nb_input_files; j++) {
1940 for (i = 0; i < input_files[j]->nb_streams; i++) {
1941 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1942 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1944 fr = c->time_base.den * 1000 / c->time_base.num;
1948 } else if ((fr == 29970) || (fr == 23976)) {
1953 if (norm != UNKNOWN)
1957 if (norm != UNKNOWN)
1958 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1961 if (norm == UNKNOWN) {
1962 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1963 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1964 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1968 if (!strcmp(arg, "vcd")) {
1969 opt_video_codec(o, "c:v", "mpeg1video");
1970 opt_audio_codec(o, "c:a", "mp2");
1971 parse_option(o, "f", "vcd", options);
1972 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
1974 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1975 parse_option(o, "r", frame_rates[norm], options);
1976 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
1978 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
1979 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
1980 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
1981 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
1983 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
1984 parse_option(o, "ar", "44100", options);
1985 parse_option(o, "ac", "2", options);
1987 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
1988 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
1990 /* We have to offset the PTS, so that it is consistent with the SCR.
1991 SCR starts at 36000, but the first two packs contain only padding
1992 and the first pack from the other stream, respectively, may also have
1993 been written before.
1994 So the real data starts at SCR 36000+3*1200. */
1995 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1996 } else if (!strcmp(arg, "svcd")) {
1998 opt_video_codec(o, "c:v", "mpeg2video");
1999 opt_audio_codec(o, "c:a", "mp2");
2000 parse_option(o, "f", "svcd", options);
2002 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2003 parse_option(o, "r", frame_rates[norm], options);
2004 parse_option(o, "pix_fmt", "yuv420p", options);
2005 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2007 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2008 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2009 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2010 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2011 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2013 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2014 parse_option(o, "ar", "44100", options);
2016 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2018 } else if (!strcmp(arg, "dvd")) {
2020 opt_video_codec(o, "c:v", "mpeg2video");
2021 opt_audio_codec(o, "c:a", "ac3");
2022 parse_option(o, "f", "dvd", options);
2024 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2025 parse_option(o, "r", frame_rates[norm], options);
2026 parse_option(o, "pix_fmt", "yuv420p", options);
2027 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2029 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2030 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2031 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2032 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2034 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.
2035 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2037 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2038 parse_option(o, "ar", "48000", options);
2040 } else if (!strncmp(arg, "dv", 2)) {
2042 parse_option(o, "f", "dv", options);
2044 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2045 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2046 norm == PAL ? "yuv420p" : "yuv411p", options);
2047 parse_option(o, "r", frame_rates[norm], options);
2049 parse_option(o, "ar", "48000", options);
2050 parse_option(o, "ac", "2", options);
2053 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2054 return AVERROR(EINVAL);
2059 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2061 av_free (vstats_filename);
2062 vstats_filename = av_strdup (arg);
2066 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2069 time_t today2 = time(NULL);
2070 struct tm *today = localtime(&today2);
2072 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2074 return opt_vstats_file(NULL, opt, filename);
2077 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2079 OptionsContext *o = optctx;
2080 return parse_option(o, "frames:v", arg, options);
2083 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2085 OptionsContext *o = optctx;
2086 return parse_option(o, "frames:a", arg, options);
2089 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2091 OptionsContext *o = optctx;
2092 return parse_option(o, "frames:d", arg, options);
2095 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2098 AVDictionary *cbak = codec_opts;
2099 AVDictionary *fbak = format_opts;
2103 ret = opt_default(NULL, opt, arg);
2105 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2106 av_dict_copy(&o->g->format_opts, format_opts, 0);
2107 av_dict_free(&codec_opts);
2108 av_dict_free(&format_opts);
2115 static int opt_preset(void *optctx, const char *opt, const char *arg)
2117 OptionsContext *o = optctx;
2119 char filename[1000], line[1000], tmp_line[1000];
2120 const char *codec_name = NULL;
2124 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2126 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2127 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2128 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2130 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2134 while (fgets(line, sizeof(line), f)) {
2135 char *key = tmp_line, *value, *endptr;
2137 if (strcspn(line, "#\n\r") == 0)
2139 strcpy(tmp_line, line);
2140 if (!av_strtok(key, "=", &value) ||
2141 !av_strtok(value, "\r\n", &endptr)) {
2142 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2145 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2147 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2148 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2149 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2150 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2151 else if (opt_default_new(o, key, value) < 0) {
2152 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2153 filename, line, key, value);
2163 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2165 OptionsContext *o = optctx;
2166 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2167 int ret = parse_option(o, s, arg, options);
2172 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2174 OptionsContext *o = optctx;
2175 if(!strcmp(opt, "b")){
2176 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2177 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2180 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2184 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2186 OptionsContext *o = optctx;
2189 if(!strcmp(opt, "qscale")){
2190 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2191 return parse_option(o, "q:v", arg, options);
2193 s = av_asprintf("q%s", opt + 6);
2194 ret = parse_option(o, s, arg, options);
2199 static int opt_profile(void *optctx, const char *opt, const char *arg)
2201 OptionsContext *o = optctx;
2202 if(!strcmp(opt, "profile")){
2203 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2204 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2207 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2211 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2213 OptionsContext *o = optctx;
2214 return parse_option(o, "filter:v", arg, options);
2217 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2219 OptionsContext *o = optctx;
2220 return parse_option(o, "filter:a", arg, options);
2223 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2225 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2226 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2227 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2228 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2230 if (video_sync_method == VSYNC_AUTO)
2231 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2235 #if FF_API_DEINTERLACE
2236 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2238 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2244 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2246 OptionsContext *o = optctx;
2247 char *tcr = av_asprintf("timecode=%s", arg);
2248 int ret = parse_option(o, "metadata:g", tcr, options);
2250 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2255 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2257 OptionsContext *o = optctx;
2258 char layout_str[32];
2261 int ret, channels, ac_str_size;
2264 layout = av_get_channel_layout(arg);
2266 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2267 return AVERROR(EINVAL);
2269 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2270 ret = opt_default_new(o, opt, layout_str);
2274 /* set 'ac' option based on channel layout */
2275 channels = av_get_channel_layout_nb_channels(layout);
2276 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2277 stream_str = strchr(opt, ':');
2278 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2279 ac_str = av_mallocz(ac_str_size);
2281 return AVERROR(ENOMEM);
2282 av_strlcpy(ac_str, "ac", 3);
2284 av_strlcat(ac_str, stream_str, ac_str_size);
2285 ret = parse_option(o, ac_str, layout_str, options);
2291 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2293 OptionsContext *o = optctx;
2294 return parse_option(o, "q:a", arg, options);
2297 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2299 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2300 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2301 return AVERROR(ENOMEM);
2302 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2303 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2307 void show_help_default(const char *opt, const char *arg)
2309 /* per-file options have at least one of those set */
2310 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2311 int show_advanced = 0, show_avoptions = 0;
2314 if (!strcmp(opt, "long"))
2316 else if (!strcmp(opt, "full"))
2317 show_advanced = show_avoptions = 1;
2319 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2324 printf("Getting help:\n"
2325 " -h -- print basic options\n"
2326 " -h long -- print more options\n"
2327 " -h full -- print all options (including all format and codec specific options, very long)\n"
2328 " See man %s for detailed description of the options.\n"
2329 "\n", program_name);
2331 show_help_options(options, "Print help / information / capabilities:",
2334 show_help_options(options, "Global options (affect whole program "
2335 "instead of just one file:",
2336 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2338 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2339 per_file | OPT_EXIT, 0);
2341 show_help_options(options, "Per-file main options:", 0,
2342 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2343 OPT_EXIT, per_file);
2345 show_help_options(options, "Advanced per-file options:",
2346 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2348 show_help_options(options, "Video options:",
2349 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2351 show_help_options(options, "Advanced Video options:",
2352 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2354 show_help_options(options, "Audio options:",
2355 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2357 show_help_options(options, "Advanced Audio options:",
2358 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2359 show_help_options(options, "Subtitle options:",
2360 OPT_SUBTITLE, 0, 0);
2363 if (show_avoptions) {
2364 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2365 show_help_children(avcodec_get_class(), flags);
2366 show_help_children(avformat_get_class(), flags);
2367 show_help_children(sws_get_class(), flags);
2368 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2369 show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2373 void show_usage(void)
2375 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2376 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2377 av_log(NULL, AV_LOG_INFO, "\n");
2385 static const OptionGroupDef groups[] = {
2386 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2387 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2390 static int open_files(OptionGroupList *l, const char *inout,
2391 int (*open_file)(OptionsContext*, const char*))
2395 for (i = 0; i < l->nb_groups; i++) {
2396 OptionGroup *g = &l->groups[i];
2399 init_options(&o, !strcmp(inout, "input"));
2402 ret = parse_optgroup(&o, g);
2404 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2405 "%s.\n", inout, g->arg);
2409 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2410 ret = open_file(&o, g->arg);
2411 uninit_options(&o, !strcmp(inout, "input"));
2413 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2417 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2423 int ffmpeg_parse_options(int argc, char **argv)
2425 OptionParseContext octx;
2429 memset(&octx, 0, sizeof(octx));
2431 /* split the commandline into an internal representation */
2432 ret = split_commandline(&octx, argc, argv, options, groups,
2433 FF_ARRAY_ELEMS(groups));
2435 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2439 /* apply global options */
2440 ret = parse_optgroup(NULL, &octx.global_opts);
2442 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2446 /* open input files */
2447 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2449 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2453 /* open output files */
2454 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2456 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2461 uninit_parse_context(&octx);
2463 av_strerror(ret, error, sizeof(error));
2464 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2469 static int opt_progress(void *optctx, const char *opt, const char *arg)
2471 AVIOContext *avio = NULL;
2474 if (!strcmp(arg, "-"))
2476 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2478 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2479 arg, av_err2str(ret));
2482 progress_avio = avio;
2486 #define OFFSET(x) offsetof(OptionsContext, x)
2487 const OptionDef options[] = {
2489 #include "cmdutils_common_opts.h"
2490 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2491 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2492 "force format", "fmt" },
2493 { "y", OPT_BOOL, { &file_overwrite },
2494 "overwrite output files" },
2495 { "n", OPT_BOOL, { &no_file_overwrite },
2496 "do not overwrite output files" },
2497 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2498 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2499 "codec name", "codec" },
2500 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2501 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2502 "codec name", "codec" },
2503 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2504 OPT_OUTPUT, { .off = OFFSET(presets) },
2505 "preset name", "preset" },
2506 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2507 OPT_OUTPUT, { .func_arg = opt_map },
2508 "set input stream mapping",
2509 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2510 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2511 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2512 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2513 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2514 "set metadata information of outfile from infile",
2515 "outfile[,metadata]:infile[,metadata]" },
2516 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2517 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2518 "set chapters mapping", "input_file_index" },
2519 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2520 "record or transcode \"duration\" seconds of audio/video",
2522 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(stop_time) },
2523 "record or transcode stop time", "time_stop" },
2524 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2525 "set the limit file size in bytes", "limit_size" },
2526 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2527 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2528 "set the start time offset", "time_off" },
2529 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2530 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2531 "set the input ts offset", "time_off" },
2532 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2533 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2534 "set the input ts scale", "scale" },
2535 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2536 "set the recording timestamp ('now' to set the current time)", "time" },
2537 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2538 "add metadata", "string=string" },
2539 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2540 OPT_OUTPUT, { .func_arg = opt_data_frames },
2541 "set the number of data frames to record", "number" },
2542 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2543 "add timings for benchmarking" },
2544 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2545 "add timings for each task" },
2546 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2547 "write program-readable progress information", "url" },
2548 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2549 "enable or disable interaction on standard input" },
2550 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2551 "set max runtime in seconds", "limit" },
2552 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2553 "dump each input packet" },
2554 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2555 "when dumping packets, also dump the payload" },
2556 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2557 OPT_INPUT, { .off = OFFSET(rate_emu) },
2558 "read input at native frame rate", "" },
2559 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2560 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2561 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2562 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2563 "video sync method", "" },
2564 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2565 "audio sync method", "" },
2566 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2567 "audio drift threshold", "threshold" },
2568 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2569 "copy timestamps" },
2570 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2571 "copy input stream time base when stream copying", "mode" },
2572 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2573 OPT_OUTPUT, { .off = OFFSET(shortest) },
2574 "finish encoding within shortest input" },
2575 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2576 "timestamp discontinuity delta threshold", "threshold" },
2577 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2578 "timestamp error delta threshold", "threshold" },
2579 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2580 "exit on error", "error" },
2581 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2582 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2583 "copy initial non-keyframes" },
2584 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2585 "copy or discard frames before start time" },
2586 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2587 "set the number of frames to record", "number" },
2588 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2589 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2590 "force codec tag/fourcc", "fourcc/tag" },
2591 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2592 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2593 "use fixed quality scale (VBR)", "q" },
2594 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2595 OPT_OUTPUT, { .func_arg = opt_qscale },
2596 "use fixed quality scale (VBR)", "q" },
2597 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2598 "set profile", "profile" },
2599 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2600 "set stream filtergraph", "filter_graph" },
2601 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2602 "reinit filtergraph on input parameter changes", "" },
2603 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2604 "create a complex filtergraph", "graph_description" },
2605 { "stats", OPT_BOOL, { &print_stats },
2606 "print progress report during encoding", },
2607 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2608 OPT_OUTPUT, { .func_arg = opt_attach },
2609 "add an attachment to the output file", "filename" },
2610 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2611 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2612 "extract an attachment into a file", "filename" },
2613 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2614 "print timestamp debugging info" },
2617 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2618 "set the number of video frames to record", "number" },
2619 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2620 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2621 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2622 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2623 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2624 "set frame size (WxH or abbreviation)", "size" },
2625 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2626 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2627 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2628 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2629 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2630 "set pixel format", "format" },
2631 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2632 "set the number of bits per raw sample", "number" },
2633 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2634 "deprecated use -g 1" },
2635 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2637 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2638 "discard threshold", "n" },
2639 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2640 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2641 "rate control override for specific intervals", "override" },
2642 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2643 OPT_OUTPUT, { .func_arg = opt_video_codec },
2644 "force video codec ('copy' to copy stream)", "codec" },
2645 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2647 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2649 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2650 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2651 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2652 "select the pass number (1 to 3)", "n" },
2653 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2654 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2655 "select two pass log file name prefix", "prefix" },
2656 #if FF_API_DEINTERLACE
2657 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2658 "this option is deprecated, use the yadif filter instead" },
2660 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2661 "calculate PSNR of compressed frames" },
2662 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2663 "dump video coding statistics to file" },
2664 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2665 "dump video coding statistics to file", "file" },
2666 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2667 "set video filters", "filter_graph" },
2668 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2669 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2670 "specify intra matrix coeffs", "matrix" },
2671 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2672 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2673 "specify inter matrix coeffs", "matrix" },
2674 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2675 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2676 "top=1/bottom=0/auto=-1 field first", "" },
2677 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2678 "intra_dc_precision", "precision" },
2679 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2680 OPT_OUTPUT, { .func_arg = opt_old2new },
2681 "force video tag/fourcc", "fourcc/tag" },
2682 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2683 "show QP histogram" },
2684 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2685 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2686 "force the selected framerate, disable the best supported framerate selection" },
2687 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2688 OPT_OUTPUT, { .func_arg = opt_streamid },
2689 "set the value of an outfile streamid", "streamIndex:value" },
2690 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2691 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2692 "force key frames at specified timestamps", "timestamps" },
2693 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2694 "video bitrate (please use -b:v)", "bitrate" },
2697 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2698 "set the number of audio frames to record", "number" },
2699 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2700 "set audio quality (codec-specific)", "quality", },
2701 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2702 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2703 "set audio sampling rate (in Hz)", "rate" },
2704 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2705 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2706 "set number of audio channels", "channels" },
2707 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2709 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2710 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2711 "force audio codec ('copy' to copy stream)", "codec" },
2712 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2713 OPT_OUTPUT, { .func_arg = opt_old2new },
2714 "force audio tag/fourcc", "fourcc/tag" },
2715 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2716 "change audio volume (256=normal)" , "volume" },
2717 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2718 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2719 "set sample format", "format" },
2720 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2721 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2722 "set channel layout", "layout" },
2723 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2724 "set audio filters", "filter_graph" },
2725 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(guess_layout_max) },
2726 "set the maximum number of channels to try to guess the channel layout" },
2728 /* subtitle options */
2729 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2730 "disable subtitle" },
2731 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2732 "force subtitle codec ('copy' to copy stream)", "codec" },
2733 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2734 , "force subtitle tag/fourcc", "fourcc/tag" },
2735 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2736 "fix subtitles duration" },
2737 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(canvas_sizes) },
2738 "set canvas size (WxH or abbreviation)", "size" },
2741 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2742 "deprecated, use -channel", "channel" },
2743 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2744 "deprecated, use -standard", "standard" },
2745 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2748 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2749 "set the maximum demux-decode delay", "seconds" },
2750 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2751 "set the initial demux-decode delay", "seconds" },
2753 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2754 "A comma-separated list of bitstream filters", "bitstream_filters" },
2755 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2756 "deprecated", "audio bitstream_filters" },
2757 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2758 "deprecated", "video bitstream_filters" },
2760 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2761 "set the audio options to the indicated preset", "preset" },
2762 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2763 "set the video options to the indicated preset", "preset" },
2764 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2765 "set the subtitle options to the indicated preset", "preset" },
2766 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2767 "set options from indicated preset file", "filename" },
2768 /* data codec support */
2769 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2770 "force data codec ('copy' to copy stream)", "codec" },
2771 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },