2 * ffmpeg option parsing
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 #include "libavformat/avformat.h"
28 #include "libavcodec/avcodec.h"
30 #include "libavfilter/avfilter.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/avstring.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/channel_layout.h"
36 #include "libavutil/intreadwrite.h"
37 #include "libavutil/fifo.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/pixfmt.h"
44 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47 for (i = 0; i < o->nb_ ## name; i++) {\
48 char *spec = o->name[i].specifier;\
49 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
50 outvar = o->name[i].u.type;\
56 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59 for (i = 0; i < o->nb_ ## name; i++) {\
60 char *spec = o->name[i].specifier;\
61 if (!strcmp(spec, mediatype))\
62 outvar = o->name[i].u.type;\
65 char *vstats_filename;
67 float audio_drift_threshold = 0.1;
68 float dts_delta_threshold = 10;
69 float dts_error_threshold = 3600*30;
71 int audio_volume = 256;
72 int audio_sync_method = 0;
73 int video_sync_method = VSYNC_AUTO;
74 int do_deinterlace = 0;
76 int do_benchmark_all = 0;
82 int exit_on_error = 0;
85 int stdin_interaction = 1;
86 int frame_bits_per_raw_sample = 0;
89 static int intra_only = 0;
90 static int file_overwrite = 0;
91 static int no_file_overwrite = 0;
92 static int video_discard = 0;
93 static int intra_dc_precision = 8;
94 static int do_psnr = 0;
95 static int input_sync;
96 static int override_ffserver = 0;
98 static void uninit_options(OptionsContext *o)
100 const OptionDef *po = options;
103 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
105 void *dst = (uint8_t*)o + po->u.off;
107 if (po->flags & OPT_SPEC) {
108 SpecifierOpt **so = dst;
109 int i, *count = (int*)(so + 1);
110 for (i = 0; i < *count; i++) {
111 av_freep(&(*so)[i].specifier);
112 if (po->flags & OPT_STRING)
113 av_freep(&(*so)[i].u.str);
117 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
122 for (i = 0; i < o->nb_stream_maps; i++)
123 av_freep(&o->stream_maps[i].linklabel);
124 av_freep(&o->stream_maps);
125 av_freep(&o->audio_channel_maps);
126 av_freep(&o->streamid_map);
127 av_freep(&o->attachments);
130 static void init_options(OptionsContext *o)
132 memset(o, 0, sizeof(*o));
134 o->stop_time = INT64_MAX;
135 o->mux_max_delay = 0.7;
136 o->start_time = AV_NOPTS_VALUE;
137 o->recording_time = INT64_MAX;
138 o->limit_filesize = UINT64_MAX;
139 o->chapters_input_file = INT_MAX;
140 o->accurate_seek = 1;
143 /* return a copy of the input with the stream specifiers removed from the keys */
144 static AVDictionary *strip_specifiers(AVDictionary *dict)
146 AVDictionaryEntry *e = NULL;
147 AVDictionary *ret = NULL;
149 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
150 char *p = strchr(e->key, ':');
154 av_dict_set(&ret, e->key, e->value, 0);
161 static int opt_sameq(void *optctx, const char *opt, const char *arg)
163 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
164 "If you are looking for an option to preserve the quality (which is not "
165 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
167 return AVERROR(EINVAL);
170 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
172 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
173 return opt_default(optctx, "channel", arg);
176 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
178 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
179 return opt_default(optctx, "standard", arg);
182 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
184 OptionsContext *o = optctx;
185 return parse_option(o, "codec:a", arg, options);
188 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
190 OptionsContext *o = optctx;
191 return parse_option(o, "codec:v", arg, options);
194 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
196 OptionsContext *o = optctx;
197 return parse_option(o, "codec:s", arg, options);
200 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
202 OptionsContext *o = optctx;
203 return parse_option(o, "codec:d", arg, options);
206 static int opt_map(void *optctx, const char *opt, const char *arg)
208 OptionsContext *o = optctx;
210 int i, negative = 0, file_idx;
211 int sync_file_idx = -1, sync_stream_idx = 0;
219 map = av_strdup(arg);
221 /* parse sync stream first, just pick first matching stream */
222 if (sync = strchr(map, ',')) {
224 sync_file_idx = strtol(sync + 1, &sync, 0);
225 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
226 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
231 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
232 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
233 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
237 if (i == input_files[sync_file_idx]->nb_streams) {
238 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
239 "match any streams.\n", arg);
246 /* this mapping refers to lavfi output */
247 const char *c = map + 1;
248 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
249 m = &o->stream_maps[o->nb_stream_maps - 1];
250 m->linklabel = av_get_token(&c, "]");
252 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
256 file_idx = strtol(map, &p, 0);
257 if (file_idx >= nb_input_files || file_idx < 0) {
258 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
262 /* disable some already defined maps */
263 for (i = 0; i < o->nb_stream_maps; i++) {
264 m = &o->stream_maps[i];
265 if (file_idx == m->file_index &&
266 check_stream_specifier(input_files[m->file_index]->ctx,
267 input_files[m->file_index]->ctx->streams[m->stream_index],
268 *p == ':' ? p + 1 : p) > 0)
272 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
273 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
274 *p == ':' ? p + 1 : p) <= 0)
276 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
277 m = &o->stream_maps[o->nb_stream_maps - 1];
279 m->file_index = file_idx;
282 if (sync_file_idx >= 0) {
283 m->sync_file_index = sync_file_idx;
284 m->sync_stream_index = sync_stream_idx;
286 m->sync_file_index = file_idx;
287 m->sync_stream_index = i;
293 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
301 static int opt_attach(void *optctx, const char *opt, const char *arg)
303 OptionsContext *o = optctx;
304 GROW_ARRAY(o->attachments, o->nb_attachments);
305 o->attachments[o->nb_attachments - 1] = arg;
309 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
311 OptionsContext *o = optctx;
316 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
317 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
319 /* muted channel syntax */
320 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
321 if ((n == 1 || n == 3) && m->channel_idx == -1) {
322 m->file_idx = m->stream_idx = -1;
324 m->ofile_idx = m->ostream_idx = -1;
329 n = sscanf(arg, "%d.%d.%d:%d.%d",
330 &m->file_idx, &m->stream_idx, &m->channel_idx,
331 &m->ofile_idx, &m->ostream_idx);
333 if (n != 3 && n != 5) {
334 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
335 "[file.stream.channel|-1][:syncfile:syncstream]\n");
339 if (n != 5) // only file.stream.channel specified
340 m->ofile_idx = m->ostream_idx = -1;
343 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
344 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
348 if (m->stream_idx < 0 ||
349 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
350 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
351 m->file_idx, m->stream_idx);
354 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
355 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
356 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
357 m->file_idx, m->stream_idx);
360 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
361 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
362 m->file_idx, m->stream_idx, m->channel_idx);
369 * Parse a metadata specifier passed as 'arg' parameter.
370 * @param arg metadata string to parse
371 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
372 * @param index for type c/p, chapter/program index is written here
373 * @param stream_spec for type s, the stream specifier is written here
375 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
383 if (*(++arg) && *arg != ':') {
384 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
387 *stream_spec = *arg == ':' ? arg + 1 : "";
392 *index = strtol(++arg, NULL, 0);
395 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
402 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
404 AVDictionary **meta_in = NULL;
405 AVDictionary **meta_out = NULL;
407 char type_in, type_out;
408 const char *istream_spec = NULL, *ostream_spec = NULL;
409 int idx_in = 0, idx_out = 0;
411 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
412 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
415 if (type_out == 'g' || !*outspec)
416 o->metadata_global_manual = 1;
417 if (type_out == 's' || !*outspec)
418 o->metadata_streams_manual = 1;
419 if (type_out == 'c' || !*outspec)
420 o->metadata_chapters_manual = 1;
424 if (type_in == 'g' || type_out == 'g')
425 o->metadata_global_manual = 1;
426 if (type_in == 's' || type_out == 's')
427 o->metadata_streams_manual = 1;
428 if (type_in == 'c' || type_out == 'c')
429 o->metadata_chapters_manual = 1;
431 /* ic is NULL when just disabling automatic mappings */
435 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
436 if ((index) < 0 || (index) >= (nb_elems)) {\
437 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
442 #define SET_DICT(type, meta, context, index)\
445 meta = &context->metadata;\
448 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
449 meta = &context->chapters[index]->metadata;\
452 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
453 meta = &context->programs[index]->metadata;\
456 break; /* handled separately below */ \
457 default: av_assert0(0);\
460 SET_DICT(type_in, meta_in, ic, idx_in);
461 SET_DICT(type_out, meta_out, oc, idx_out);
463 /* for input streams choose first matching stream */
464 if (type_in == 's') {
465 for (i = 0; i < ic->nb_streams; i++) {
466 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
467 meta_in = &ic->streams[i]->metadata;
473 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
478 if (type_out == 's') {
479 for (i = 0; i < oc->nb_streams; i++) {
480 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
481 meta_out = &oc->streams[i]->metadata;
482 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
487 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
492 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
494 OptionsContext *o = optctx;
496 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
497 struct tm time = *gmtime((time_t*)&recording_timestamp);
498 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
499 parse_option(o, "metadata", buf, options);
501 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
502 "tag instead.\n", opt);
506 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
508 const AVCodecDescriptor *desc;
509 const char *codec_string = encoder ? "encoder" : "decoder";
513 avcodec_find_encoder_by_name(name) :
514 avcodec_find_decoder_by_name(name);
516 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
517 codec = encoder ? avcodec_find_encoder(desc->id) :
518 avcodec_find_decoder(desc->id);
520 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
521 codec_string, codec->name, desc->name);
525 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
528 if (codec->type != type) {
529 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
535 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
537 char *codec_name = NULL;
539 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
541 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
542 st->codec->codec_id = codec->id;
545 return avcodec_find_decoder(st->codec->codec_id);
548 /* Add all the streams from the given input file to the global
549 * list of input streams. */
550 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
553 char *next, *codec_tag = NULL;
555 for (i = 0; i < ic->nb_streams; i++) {
556 AVStream *st = ic->streams[i];
557 AVCodecContext *dec = st->codec;
558 InputStream *ist = av_mallocz(sizeof(*ist));
559 char *framerate = NULL;
564 GROW_ARRAY(input_streams, nb_input_streams);
565 input_streams[nb_input_streams - 1] = ist;
568 ist->file_index = nb_input_files;
570 st->discard = AVDISCARD_ALL;
573 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
575 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
577 uint32_t tag = strtol(codec_tag, &next, 0);
579 tag = AV_RL32(codec_tag);
580 st->codec->codec_tag = tag;
583 ist->dec = choose_decoder(o, ic, st);
584 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
586 ist->reinit_filters = -1;
587 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
589 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
591 switch (dec->codec_type) {
592 case AVMEDIA_TYPE_VIDEO:
594 ist->dec = avcodec_find_decoder(dec->codec_id);
596 dec->flags |= CODEC_FLAG_EMU_EDGE;
599 ist->resample_height = dec->height;
600 ist->resample_width = dec->width;
601 ist->resample_pix_fmt = dec->pix_fmt;
603 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
604 if (framerate && av_parse_video_rate(&ist->framerate,
606 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
611 ist->top_field_first = -1;
612 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
615 case AVMEDIA_TYPE_AUDIO:
616 ist->guess_layout_max = INT_MAX;
617 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
618 guess_input_channel_layout(ist);
620 ist->resample_sample_fmt = dec->sample_fmt;
621 ist->resample_sample_rate = dec->sample_rate;
622 ist->resample_channels = dec->channels;
623 ist->resample_channel_layout = dec->channel_layout;
626 case AVMEDIA_TYPE_DATA:
627 case AVMEDIA_TYPE_SUBTITLE: {
628 char *canvas_size = NULL;
630 ist->dec = avcodec_find_decoder(dec->codec_id);
631 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
632 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
634 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
635 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
640 case AVMEDIA_TYPE_ATTACHMENT:
641 case AVMEDIA_TYPE_UNKNOWN:
649 static void assert_file_overwrite(const char *filename)
651 if (file_overwrite && no_file_overwrite) {
652 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
656 if (!file_overwrite &&
657 (strchr(filename, ':') == NULL || filename[1] == ':' ||
658 av_strstart(filename, "file:", NULL))) {
659 if (avio_check(filename, 0) == 0) {
660 if (stdin_interaction && !no_file_overwrite) {
661 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
664 signal(SIGINT, SIG_DFL);
666 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
672 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
679 static void dump_attachment(AVStream *st, const char *filename)
682 AVIOContext *out = NULL;
683 AVDictionaryEntry *e;
685 if (!st->codec->extradata_size) {
686 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
687 nb_input_files - 1, st->index);
690 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
693 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
694 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
698 assert_file_overwrite(filename);
700 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
701 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
706 avio_write(out, st->codec->extradata, st->codec->extradata_size);
711 static int open_input_file(OptionsContext *o, const char *filename)
715 AVInputFormat *file_iformat = NULL;
720 AVDictionary *unused_opts = NULL;
721 AVDictionaryEntry *e = NULL;
722 int orig_nb_streams; // number of streams before avformat_find_stream_info
723 char * video_codec_name = NULL;
724 char * audio_codec_name = NULL;
725 char *subtitle_codec_name = NULL;
728 if (!(file_iformat = av_find_input_format(o->format))) {
729 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
734 if (!strcmp(filename, "-"))
737 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
738 strcmp(filename, "/dev/stdin");
740 /* get default parameters from command line */
741 ic = avformat_alloc_context();
743 print_error(filename, AVERROR(ENOMEM));
746 if (o->nb_audio_sample_rate) {
747 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
748 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
750 if (o->nb_audio_channels) {
751 /* because we set audio_channels based on both the "ac" and
752 * "channel_layout" options, we need to check that the specified
753 * demuxer actually has the "channels" option before setting it */
754 if (file_iformat && file_iformat->priv_class &&
755 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
756 AV_OPT_SEARCH_FAKE_OBJ)) {
757 snprintf(buf, sizeof(buf), "%d",
758 o->audio_channels[o->nb_audio_channels - 1].u.i);
759 av_dict_set(&o->g->format_opts, "channels", buf, 0);
762 if (o->nb_frame_rates) {
763 /* set the format-level framerate option;
764 * this is important for video grabbers, e.g. x11 */
765 if (file_iformat && file_iformat->priv_class &&
766 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
767 AV_OPT_SEARCH_FAKE_OBJ)) {
768 av_dict_set(&o->g->format_opts, "framerate",
769 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
772 if (o->nb_frame_sizes) {
773 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
775 if (o->nb_frame_pix_fmts)
776 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
778 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
779 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
780 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
782 ic->video_codec_id = video_codec_name ?
783 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
784 ic->audio_codec_id = audio_codec_name ?
785 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
786 ic->subtitle_codec_id= subtitle_codec_name ?
787 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
788 ic->flags |= AVFMT_FLAG_NONBLOCK;
789 ic->interrupt_callback = int_cb;
791 /* open the input file with generic avformat function */
792 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
794 print_error(filename, err);
797 assert_avoptions(o->g->format_opts);
799 /* apply forced codec ids */
800 for (i = 0; i < ic->nb_streams; i++)
801 choose_decoder(o, ic, ic->streams[i]);
803 /* Set AVCodecContext options for avformat_find_stream_info */
804 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
805 orig_nb_streams = ic->nb_streams;
807 /* If not enough info to get the stream parameters, we decode the
808 first frames to get it. (used in mpeg case for example) */
809 ret = avformat_find_stream_info(ic, opts);
811 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
812 avformat_close_input(&ic);
816 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
817 /* add the stream start time */
818 if (ic->start_time != AV_NOPTS_VALUE)
819 timestamp += ic->start_time;
821 /* if seeking requested, we execute it */
822 if (o->start_time != AV_NOPTS_VALUE) {
823 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
825 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
826 filename, (double)timestamp / AV_TIME_BASE);
830 /* update the current parameters so that they match the one of the input stream */
831 add_input_streams(o, ic);
833 /* dump the file content */
834 av_dump_format(ic, nb_input_files, filename, 0);
836 GROW_ARRAY(input_files, nb_input_files);
837 f = av_mallocz(sizeof(*f));
840 input_files[nb_input_files - 1] = f;
843 f->ist_index = nb_input_streams - ic->nb_streams;
844 f->start_time = o->start_time;
845 f->recording_time = o->recording_time;
846 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
847 f->nb_streams = ic->nb_streams;
848 f->rate_emu = o->rate_emu;
849 f->accurate_seek = o->accurate_seek;
851 /* check if all codec options have been used */
852 unused_opts = strip_specifiers(o->g->codec_opts);
853 for (i = f->ist_index; i < nb_input_streams; i++) {
855 while ((e = av_dict_get(input_streams[i]->opts, "", e,
856 AV_DICT_IGNORE_SUFFIX)))
857 av_dict_set(&unused_opts, e->key, NULL, 0);
861 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
862 const AVClass *class = avcodec_get_class();
863 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
864 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
867 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
868 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
869 "input file #%d (%s) is not a decoding option.\n", e->key,
870 option->help ? option->help : "", nb_input_files - 1,
875 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
876 "input file #%d (%s) has not been used for any stream. The most "
877 "likely reason is either wrong type (e.g. a video option with "
878 "no video streams) or that it is a private option of some decoder "
879 "which was not actually used for any stream.\n", e->key,
880 option->help ? option->help : "", nb_input_files - 1, filename);
882 av_dict_free(&unused_opts);
884 for (i = 0; i < o->nb_dump_attachment; i++) {
887 for (j = 0; j < ic->nb_streams; j++) {
888 AVStream *st = ic->streams[j];
890 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
891 dump_attachment(st, o->dump_attachment[i].u.str);
895 for (i = 0; i < orig_nb_streams; i++)
896 av_dict_free(&opts[i]);
902 static uint8_t *get_line(AVIOContext *s)
908 if (avio_open_dyn_buf(&line) < 0) {
909 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
913 while ((c = avio_r8(s)) && c != '\n')
916 avio_close_dyn_buf(line, &buf);
921 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
925 const char *base[3] = { getenv("AVCONV_DATADIR"),
930 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
934 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
935 i != 1 ? "" : "/.avconv", codec_name, preset_name);
936 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
939 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
940 i != 1 ? "" : "/.avconv", preset_name);
941 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
947 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
949 char *codec_name = NULL;
951 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
953 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
954 NULL, ost->st->codec->codec_type);
955 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
956 } else if (!strcmp(codec_name, "copy"))
957 ost->stream_copy = 1;
959 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
960 ost->st->codec->codec_id = ost->enc->id;
964 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
967 AVStream *st = avformat_new_stream(oc, NULL);
968 int idx = oc->nb_streams - 1, ret = 0;
969 char *bsf = NULL, *next, *codec_tag = NULL;
970 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
975 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
979 if (oc->nb_streams - 1 < o->nb_streamid_map)
980 st->id = o->streamid_map[oc->nb_streams - 1];
982 GROW_ARRAY(output_streams, nb_output_streams);
983 if (!(ost = av_mallocz(sizeof(*ost))))
985 output_streams[nb_output_streams - 1] = ost;
987 ost->file_index = nb_output_files - 1;
990 st->codec->codec_type = type;
991 choose_encoder(o, oc, ost);
993 AVIOContext *s = NULL;
994 char *buf = NULL, *arg = NULL, *preset = NULL;
996 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
998 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
999 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1002 if (!buf[0] || buf[0] == '#') {
1006 if (!(arg = strchr(buf, '='))) {
1007 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1011 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1013 } while (!s->eof_reached);
1017 av_log(NULL, AV_LOG_FATAL,
1018 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1019 preset, ost->file_index, ost->index);
1023 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1026 avcodec_get_context_defaults3(st->codec, ost->enc);
1027 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1029 ost->max_frames = INT64_MAX;
1030 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1031 for (i = 0; i<o->nb_max_frames; i++) {
1032 char *p = o->max_frames[i].specifier;
1033 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1034 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1039 ost->copy_prior_start = -1;
1040 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1042 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1044 if (next = strchr(bsf, ','))
1046 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1047 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1051 bsfc_prev->next = bsfc;
1053 ost->bitstream_filters = bsfc;
1059 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1061 uint32_t tag = strtol(codec_tag, &next, 0);
1063 tag = AV_RL32(codec_tag);
1064 st->codec->codec_tag = tag;
1067 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1069 st->codec->flags |= CODEC_FLAG_QSCALE;
1070 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1073 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1074 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1076 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1078 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1079 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1080 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1082 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1084 ost->source_index = source_index;
1085 if (source_index >= 0) {
1086 ost->sync_ist = input_streams[source_index];
1087 input_streams[source_index]->discard = 0;
1088 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1090 ost->last_mux_dts = AV_NOPTS_VALUE;
1095 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1098 const char *p = str;
1105 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1112 /* read file contents into a string */
1113 static uint8_t *read_file(const char *filename)
1115 AVIOContext *pb = NULL;
1116 AVIOContext *dyn_buf = NULL;
1117 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1118 uint8_t buf[1024], *str;
1121 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1125 ret = avio_open_dyn_buf(&dyn_buf);
1130 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1131 avio_write(dyn_buf, buf, ret);
1132 avio_w8(dyn_buf, 0);
1135 ret = avio_close_dyn_buf(dyn_buf, &str);
1141 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1144 AVStream *st = ost->st;
1145 char *filter = NULL, *filter_script = NULL;
1147 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1148 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1150 if (filter_script && filter) {
1151 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1152 "output stream #%d:%d.\n", nb_output_files, st->index);
1157 return read_file(filter_script);
1159 return av_strdup(filter);
1161 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1165 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1169 AVCodecContext *video_enc;
1170 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1172 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1174 video_enc = st->codec;
1176 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1177 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1178 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1182 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1183 if (frame_aspect_ratio) {
1185 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1186 q.num <= 0 || q.den <= 0) {
1187 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1190 ost->frame_aspect_ratio = q;
1193 if (!ost->stream_copy) {
1194 const char *p = NULL;
1195 char *frame_size = NULL;
1196 char *frame_pix_fmt = NULL;
1197 char *intra_matrix = NULL, *inter_matrix = NULL;
1201 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1202 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1203 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1207 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1208 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1209 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1210 ost->keep_pix_fmt = 1;
1211 if (!*++frame_pix_fmt)
1212 frame_pix_fmt = NULL;
1214 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1215 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1218 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1221 video_enc->gop_size = 0;
1222 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1224 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1225 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1228 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1230 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1232 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1233 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1236 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1239 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1240 for (i = 0; p; i++) {
1242 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1244 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1247 /* FIXME realloc failure */
1248 video_enc->rc_override =
1249 av_realloc(video_enc->rc_override,
1250 sizeof(RcOverride) * (i + 1));
1251 video_enc->rc_override[i].start_frame = start;
1252 video_enc->rc_override[i].end_frame = end;
1254 video_enc->rc_override[i].qscale = q;
1255 video_enc->rc_override[i].quality_factor = 1.0;
1258 video_enc->rc_override[i].qscale = 0;
1259 video_enc->rc_override[i].quality_factor = -q/100.0;
1264 video_enc->rc_override_count = i;
1265 video_enc->intra_dc_precision = intra_dc_precision - 8;
1268 video_enc->flags|= CODEC_FLAG_PSNR;
1271 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1274 video_enc->flags |= CODEC_FLAG_PASS1;
1275 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1278 video_enc->flags |= CODEC_FLAG_PASS2;
1279 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1283 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1284 if (ost->logfile_prefix &&
1285 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1288 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1289 if (ost->forced_keyframes)
1290 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1292 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1294 ost->top_field_first = -1;
1295 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1298 ost->avfilter = get_ost_filters(o, oc, ost);
1302 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1308 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1313 AVCodecContext *audio_enc;
1315 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1318 audio_enc = st->codec;
1319 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1321 if (!ost->stream_copy) {
1322 char *sample_fmt = NULL;
1324 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1326 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1328 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1329 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1333 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1335 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1336 ost->apad = av_strdup(ost->apad);
1338 ost->avfilter = get_ost_filters(o, oc, ost);
1342 /* check for channel mapping for this audio stream */
1343 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1344 AudioChannelMap *map = &o->audio_channel_maps[n];
1345 InputStream *ist = input_streams[ost->source_index];
1346 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1347 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1348 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1349 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1350 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1352 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1353 ost->file_index, ost->st->index);
1361 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1365 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1366 if (!ost->stream_copy) {
1367 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1374 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1376 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1377 ost->stream_copy = 1;
1382 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1386 AVCodecContext *subtitle_enc;
1388 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1390 subtitle_enc = st->codec;
1392 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1394 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1396 if (!ost->stream_copy) {
1397 char *frame_size = NULL;
1399 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1400 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1401 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1409 /* arg format is "output-stream-index:streamid-value". */
1410 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1412 OptionsContext *o = optctx;
1417 av_strlcpy(idx_str, arg, sizeof(idx_str));
1418 p = strchr(idx_str, ':');
1420 av_log(NULL, AV_LOG_FATAL,
1421 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1426 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1427 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1428 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1432 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1434 AVFormatContext *is = ifile->ctx;
1435 AVFormatContext *os = ofile->ctx;
1439 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1441 return AVERROR(ENOMEM);
1444 for (i = 0; i < is->nb_chapters; i++) {
1445 AVChapter *in_ch = is->chapters[i], *out_ch;
1446 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1447 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1448 AV_TIME_BASE_Q, in_ch->time_base);
1449 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1450 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1453 if (in_ch->end < ts_off)
1455 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1458 out_ch = av_mallocz(sizeof(AVChapter));
1460 return AVERROR(ENOMEM);
1462 out_ch->id = in_ch->id;
1463 out_ch->time_base = in_ch->time_base;
1464 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1465 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1468 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1470 os->chapters[os->nb_chapters++] = out_ch;
1475 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1478 AVFormatContext *ic = avformat_alloc_context();
1480 ic->interrupt_callback = int_cb;
1481 err = avformat_open_input(&ic, filename, NULL, NULL);
1484 /* copy stream format */
1485 for(i=0;i<ic->nb_streams;i++) {
1489 AVCodecContext *avctx;
1491 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1492 ost = new_output_stream(o, s, codec->type, -1);
1497 // FIXME: a more elegant solution is needed
1498 memcpy(st, ic->streams[i], sizeof(AVStream));
1500 st->info = av_malloc(sizeof(*st->info));
1501 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1503 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1505 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1506 choose_sample_fmt(st, codec);
1507 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1508 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1511 avformat_close_input(&ic);
1515 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1516 AVFormatContext *oc)
1520 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1521 ofilter->out_tmp->pad_idx)) {
1522 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1523 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1525 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1530 ost->source_index = -1;
1531 ost->filter = ofilter;
1535 if (ost->stream_copy) {
1536 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1537 "which is fed from a complex filtergraph. Filtering and streamcopy "
1538 "cannot be used together.\n", ost->file_index, ost->index);
1542 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1543 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1546 avfilter_inout_free(&ofilter->out_tmp);
1549 static int configure_complex_filters(void)
1553 for (i = 0; i < nb_filtergraphs; i++)
1554 if (!filtergraphs[i]->graph &&
1555 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1560 static int open_output_file(OptionsContext *o, const char *filename)
1562 AVFormatContext *oc;
1564 AVOutputFormat *file_oformat;
1568 AVDictionary *unused_opts = NULL;
1569 AVDictionaryEntry *e = NULL;
1571 if (configure_complex_filters() < 0) {
1572 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1576 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1577 o->stop_time = INT64_MAX;
1578 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1581 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1582 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1583 if (o->stop_time <= start_time) {
1584 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1585 o->stop_time = INT64_MAX;
1587 o->recording_time = o->stop_time - start_time;
1591 GROW_ARRAY(output_files, nb_output_files);
1592 of = av_mallocz(sizeof(*of));
1595 output_files[nb_output_files - 1] = of;
1597 of->ost_index = nb_output_streams;
1598 of->recording_time = o->recording_time;
1599 of->start_time = o->start_time;
1600 of->limit_filesize = o->limit_filesize;
1601 of->shortest = o->shortest;
1602 av_dict_copy(&of->opts, o->g->format_opts, 0);
1604 if (!strcmp(filename, "-"))
1607 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1609 print_error(filename, err);
1614 if (o->recording_time != INT64_MAX)
1615 oc->duration = o->recording_time;
1617 file_oformat= oc->oformat;
1618 oc->interrupt_callback = int_cb;
1620 /* create streams for all unlabeled output pads */
1621 for (i = 0; i < nb_filtergraphs; i++) {
1622 FilterGraph *fg = filtergraphs[i];
1623 for (j = 0; j < fg->nb_outputs; j++) {
1624 OutputFilter *ofilter = fg->outputs[j];
1626 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1629 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1630 ofilter->out_tmp->pad_idx)) {
1631 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1632 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1633 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1635 init_output_filter(ofilter, o, oc);
1639 /* ffserver seeking with date=... needs a date reference */
1640 if (!strcmp(file_oformat->name, "ffm") &&
1641 av_strstart(filename, "http:", NULL)) {
1642 int err = parse_option(o, "metadata", "creation_time=now", options);
1644 print_error(filename, err);
1649 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1650 av_strstart(filename, "http:", NULL)) {
1652 /* special case for files sent to ffserver: we get the stream
1653 parameters from ffserver */
1654 int err = read_ffserver_streams(o, oc, filename);
1656 print_error(filename, err);
1659 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1660 ost = output_streams[j];
1661 for (i = 0; i < nb_input_streams; i++) {
1662 ist = input_streams[i];
1663 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1665 ost->source_index= i;
1666 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1667 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1669 ist->st->discard = AVDISCARD_NONE;
1674 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));
1678 } else if (!o->nb_stream_maps) {
1679 char *subtitle_codec_name = NULL;
1680 /* pick the "best" stream of each type */
1682 /* video: highest resolution */
1683 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1684 int area = 0, idx = -1;
1685 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1686 for (i = 0; i < nb_input_streams; i++) {
1688 ist = input_streams[i];
1689 new_area = ist->st->codec->width * ist->st->codec->height;
1690 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1692 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1694 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1701 new_video_stream(o, oc, idx);
1704 /* audio: most channels */
1705 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1706 int channels = 0, idx = -1;
1707 for (i = 0; i < nb_input_streams; i++) {
1708 ist = input_streams[i];
1709 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1710 ist->st->codec->channels > channels) {
1711 channels = ist->st->codec->channels;
1716 new_audio_stream(o, oc, idx);
1719 /* subtitles: pick first */
1720 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1721 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1722 for (i = 0; i < nb_input_streams; i++)
1723 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1724 new_subtitle_stream(o, oc, i);
1728 /* do something with data? */
1730 for (i = 0; i < o->nb_stream_maps; i++) {
1731 StreamMap *map = &o->stream_maps[i];
1736 if (map->linklabel) {
1738 OutputFilter *ofilter = NULL;
1741 for (j = 0; j < nb_filtergraphs; j++) {
1742 fg = filtergraphs[j];
1743 for (k = 0; k < fg->nb_outputs; k++) {
1744 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1745 if (out && !strcmp(out->name, map->linklabel)) {
1746 ofilter = fg->outputs[k];
1753 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1754 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1757 init_output_filter(ofilter, o, oc);
1759 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1761 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1762 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1764 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1766 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1768 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1771 switch (ist->st->codec->codec_type) {
1772 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1773 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1774 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1775 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1776 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1778 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1779 map->file_index, map->stream_index);
1786 /* handle attached files */
1787 for (i = 0; i < o->nb_attachments; i++) {
1789 uint8_t *attachment;
1793 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1794 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1798 if ((len = avio_size(pb)) <= 0) {
1799 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1803 if (!(attachment = av_malloc(len))) {
1804 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1808 avio_read(pb, attachment, len);
1810 ost = new_attachment_stream(o, oc, -1);
1811 ost->stream_copy = 0;
1812 ost->attachment_filename = o->attachments[i];
1814 ost->st->codec->extradata = attachment;
1815 ost->st->codec->extradata_size = len;
1817 p = strrchr(o->attachments[i], '/');
1818 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1822 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1823 AVDictionaryEntry *e;
1824 ost = output_streams[i];
1826 if ((ost->stream_copy || ost->attachment_filename)
1827 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1828 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1829 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1833 /* check if all codec options have been used */
1834 unused_opts = strip_specifiers(o->g->codec_opts);
1835 for (i = of->ost_index; i < nb_output_streams; i++) {
1837 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1838 AV_DICT_IGNORE_SUFFIX)))
1839 av_dict_set(&unused_opts, e->key, NULL, 0);
1843 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1844 const AVClass *class = avcodec_get_class();
1845 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1846 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1849 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1850 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1851 "output file #%d (%s) is not an encoding option.\n", e->key,
1852 option->help ? option->help : "", nb_output_files - 1,
1857 // gop_timecode is injected by generic code but not always used
1858 if (!strcmp(e->key, "gop_timecode"))
1861 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1862 "output file #%d (%s) has not been used for any stream. The most "
1863 "likely reason is either wrong type (e.g. a video option with "
1864 "no video streams) or that it is a private option of some encoder "
1865 "which was not actually used for any stream.\n", e->key,
1866 option->help ? option->help : "", nb_output_files - 1, filename);
1868 av_dict_free(&unused_opts);
1870 /* check filename in case of an image number is expected */
1871 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1872 if (!av_filename_number_test(oc->filename)) {
1873 print_error(oc->filename, AVERROR(EINVAL));
1878 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1879 /* test if it already exists to avoid losing precious files */
1880 assert_file_overwrite(filename);
1883 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1884 &oc->interrupt_callback,
1886 print_error(filename, err);
1889 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1890 assert_file_overwrite(filename);
1892 if (o->mux_preload) {
1894 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1895 av_dict_set(&of->opts, "preload", buf, 0);
1897 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1900 for (i = 0; i < o->nb_metadata_map; i++) {
1902 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1904 if (in_file_index >= nb_input_files) {
1905 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1908 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1909 in_file_index >= 0 ?
1910 input_files[in_file_index]->ctx : NULL, o);
1914 if (o->chapters_input_file >= nb_input_files) {
1915 if (o->chapters_input_file == INT_MAX) {
1916 /* copy chapters from the first input file that has them*/
1917 o->chapters_input_file = -1;
1918 for (i = 0; i < nb_input_files; i++)
1919 if (input_files[i]->ctx->nb_chapters) {
1920 o->chapters_input_file = i;
1924 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1925 o->chapters_input_file);
1929 if (o->chapters_input_file >= 0)
1930 copy_chapters(input_files[o->chapters_input_file], of,
1931 !o->metadata_chapters_manual);
1933 /* copy global metadata by default */
1934 if (!o->metadata_global_manual && nb_input_files){
1935 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1936 AV_DICT_DONT_OVERWRITE);
1937 if(o->recording_time != INT64_MAX)
1938 av_dict_set(&oc->metadata, "duration", NULL, 0);
1939 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1941 if (!o->metadata_streams_manual)
1942 for (i = of->ost_index; i < nb_output_streams; i++) {
1944 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1946 ist = input_streams[output_streams[i]->source_index];
1947 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1950 /* process manually set metadata */
1951 for (i = 0; i < o->nb_metadata; i++) {
1954 const char *stream_spec;
1955 int index = 0, j, ret = 0;
1957 val = strchr(o->metadata[i].u.str, '=');
1959 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1960 o->metadata[i].u.str);
1965 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1967 for (j = 0; j < oc->nb_streams; j++) {
1968 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1969 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1980 if (index < 0 || index >= oc->nb_chapters) {
1981 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1984 m = &oc->chapters[index]->metadata;
1987 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1990 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1997 static int opt_target(void *optctx, const char *opt, const char *arg)
1999 OptionsContext *o = optctx;
2000 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2001 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2003 if (!strncmp(arg, "pal-", 4)) {
2006 } else if (!strncmp(arg, "ntsc-", 5)) {
2009 } else if (!strncmp(arg, "film-", 5)) {
2013 /* Try to determine PAL/NTSC by peeking in the input files */
2014 if (nb_input_files) {
2016 for (j = 0; j < nb_input_files; j++) {
2017 for (i = 0; i < input_files[j]->nb_streams; i++) {
2018 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2019 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2021 fr = c->time_base.den * 1000 / c->time_base.num;
2025 } else if ((fr == 29970) || (fr == 23976)) {
2030 if (norm != UNKNOWN)
2034 if (norm != UNKNOWN)
2035 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2038 if (norm == UNKNOWN) {
2039 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2040 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2041 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2045 if (!strcmp(arg, "vcd")) {
2046 opt_video_codec(o, "c:v", "mpeg1video");
2047 opt_audio_codec(o, "c:a", "mp2");
2048 parse_option(o, "f", "vcd", options);
2049 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2051 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2052 parse_option(o, "r", frame_rates[norm], options);
2053 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2055 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2056 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2057 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2058 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2060 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2061 parse_option(o, "ar", "44100", options);
2062 parse_option(o, "ac", "2", options);
2064 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2065 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2067 /* We have to offset the PTS, so that it is consistent with the SCR.
2068 SCR starts at 36000, but the first two packs contain only padding
2069 and the first pack from the other stream, respectively, may also have
2070 been written before.
2071 So the real data starts at SCR 36000+3*1200. */
2072 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2073 } else if (!strcmp(arg, "svcd")) {
2075 opt_video_codec(o, "c:v", "mpeg2video");
2076 opt_audio_codec(o, "c:a", "mp2");
2077 parse_option(o, "f", "svcd", options);
2079 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2080 parse_option(o, "r", frame_rates[norm], options);
2081 parse_option(o, "pix_fmt", "yuv420p", options);
2082 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2084 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2085 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2086 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2087 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2088 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2090 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2091 parse_option(o, "ar", "44100", options);
2093 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2095 } else if (!strcmp(arg, "dvd")) {
2097 opt_video_codec(o, "c:v", "mpeg2video");
2098 opt_audio_codec(o, "c:a", "ac3");
2099 parse_option(o, "f", "dvd", options);
2101 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2102 parse_option(o, "r", frame_rates[norm], options);
2103 parse_option(o, "pix_fmt", "yuv420p", options);
2104 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2106 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2107 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2108 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2109 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2111 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.
2112 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2114 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2115 parse_option(o, "ar", "48000", options);
2117 } else if (!strncmp(arg, "dv", 2)) {
2119 parse_option(o, "f", "dv", options);
2121 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2122 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2123 norm == PAL ? "yuv420p" : "yuv411p", options);
2124 parse_option(o, "r", frame_rates[norm], options);
2126 parse_option(o, "ar", "48000", options);
2127 parse_option(o, "ac", "2", options);
2130 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2131 return AVERROR(EINVAL);
2136 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2138 av_free (vstats_filename);
2139 vstats_filename = av_strdup (arg);
2143 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2146 time_t today2 = time(NULL);
2147 struct tm *today = localtime(&today2);
2149 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2151 return opt_vstats_file(NULL, opt, filename);
2154 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2156 OptionsContext *o = optctx;
2157 return parse_option(o, "frames:v", arg, options);
2160 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2162 OptionsContext *o = optctx;
2163 return parse_option(o, "frames:a", arg, options);
2166 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2168 OptionsContext *o = optctx;
2169 return parse_option(o, "frames:d", arg, options);
2172 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2175 AVDictionary *cbak = codec_opts;
2176 AVDictionary *fbak = format_opts;
2180 ret = opt_default(NULL, opt, arg);
2182 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2183 av_dict_copy(&o->g->format_opts, format_opts, 0);
2184 av_dict_free(&codec_opts);
2185 av_dict_free(&format_opts);
2192 static int opt_preset(void *optctx, const char *opt, const char *arg)
2194 OptionsContext *o = optctx;
2196 char filename[1000], line[1000], tmp_line[1000];
2197 const char *codec_name = NULL;
2201 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2203 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2204 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2205 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2207 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2211 while (fgets(line, sizeof(line), f)) {
2212 char *key = tmp_line, *value, *endptr;
2214 if (strcspn(line, "#\n\r") == 0)
2216 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2217 if (!av_strtok(key, "=", &value) ||
2218 !av_strtok(value, "\r\n", &endptr)) {
2219 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2222 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2224 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2225 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2226 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2227 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2228 else if (opt_default_new(o, key, value) < 0) {
2229 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2230 filename, line, key, value);
2240 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2242 OptionsContext *o = optctx;
2243 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2244 int ret = parse_option(o, s, arg, options);
2249 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2251 OptionsContext *o = optctx;
2252 if(!strcmp(opt, "b")){
2253 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2254 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2257 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2261 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2263 OptionsContext *o = optctx;
2266 if(!strcmp(opt, "qscale")){
2267 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2268 return parse_option(o, "q:v", arg, options);
2270 s = av_asprintf("q%s", opt + 6);
2271 ret = parse_option(o, s, arg, options);
2276 static int opt_profile(void *optctx, const char *opt, const char *arg)
2278 OptionsContext *o = optctx;
2279 if(!strcmp(opt, "profile")){
2280 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2281 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2284 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2288 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2290 OptionsContext *o = optctx;
2291 return parse_option(o, "filter:v", arg, options);
2294 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2296 OptionsContext *o = optctx;
2297 return parse_option(o, "filter:a", arg, options);
2300 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2302 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2303 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2304 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2305 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2307 if (video_sync_method == VSYNC_AUTO)
2308 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2312 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2314 OptionsContext *o = optctx;
2315 char *tcr = av_asprintf("timecode=%s", arg);
2316 int ret = parse_option(o, "metadata:g", tcr, options);
2318 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2323 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2325 OptionsContext *o = optctx;
2326 char layout_str[32];
2329 int ret, channels, ac_str_size;
2332 layout = av_get_channel_layout(arg);
2334 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2335 return AVERROR(EINVAL);
2337 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2338 ret = opt_default_new(o, opt, layout_str);
2342 /* set 'ac' option based on channel layout */
2343 channels = av_get_channel_layout_nb_channels(layout);
2344 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2345 stream_str = strchr(opt, ':');
2346 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2347 ac_str = av_mallocz(ac_str_size);
2349 return AVERROR(ENOMEM);
2350 av_strlcpy(ac_str, "ac", 3);
2352 av_strlcat(ac_str, stream_str, ac_str_size);
2353 ret = parse_option(o, ac_str, layout_str, options);
2359 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2361 OptionsContext *o = optctx;
2362 return parse_option(o, "q:a", arg, options);
2365 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2367 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2368 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2369 return AVERROR(ENOMEM);
2370 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2371 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2372 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2373 return AVERROR(ENOMEM);
2377 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2379 uint8_t *graph_desc = read_file(arg);
2381 return AVERROR(EINVAL);
2383 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2384 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2385 return AVERROR(ENOMEM);
2386 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2387 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2391 void show_help_default(const char *opt, const char *arg)
2393 /* per-file options have at least one of those set */
2394 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2395 int show_advanced = 0, show_avoptions = 0;
2398 if (!strcmp(opt, "long"))
2400 else if (!strcmp(opt, "full"))
2401 show_advanced = show_avoptions = 1;
2403 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2408 printf("Getting help:\n"
2409 " -h -- print basic options\n"
2410 " -h long -- print more options\n"
2411 " -h full -- print all options (including all format and codec specific options, very long)\n"
2412 " See man %s for detailed description of the options.\n"
2413 "\n", program_name);
2415 show_help_options(options, "Print help / information / capabilities:",
2418 show_help_options(options, "Global options (affect whole program "
2419 "instead of just one file:",
2420 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2422 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2423 per_file | OPT_EXIT, 0);
2425 show_help_options(options, "Per-file main options:", 0,
2426 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2427 OPT_EXIT, per_file);
2429 show_help_options(options, "Advanced per-file options:",
2430 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2432 show_help_options(options, "Video options:",
2433 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2435 show_help_options(options, "Advanced Video options:",
2436 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2438 show_help_options(options, "Audio options:",
2439 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2441 show_help_options(options, "Advanced Audio options:",
2442 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2443 show_help_options(options, "Subtitle options:",
2444 OPT_SUBTITLE, 0, 0);
2447 if (show_avoptions) {
2448 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2449 show_help_children(avcodec_get_class(), flags);
2450 show_help_children(avformat_get_class(), flags);
2451 show_help_children(sws_get_class(), flags);
2452 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2453 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2457 void show_usage(void)
2459 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2460 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2461 av_log(NULL, AV_LOG_INFO, "\n");
2469 static const OptionGroupDef groups[] = {
2470 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2471 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2474 static int open_files(OptionGroupList *l, const char *inout,
2475 int (*open_file)(OptionsContext*, const char*))
2479 for (i = 0; i < l->nb_groups; i++) {
2480 OptionGroup *g = &l->groups[i];
2486 ret = parse_optgroup(&o, g);
2488 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2489 "%s.\n", inout, g->arg);
2493 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2494 ret = open_file(&o, g->arg);
2497 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2501 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2507 int ffmpeg_parse_options(int argc, char **argv)
2509 OptionParseContext octx;
2513 memset(&octx, 0, sizeof(octx));
2515 /* split the commandline into an internal representation */
2516 ret = split_commandline(&octx, argc, argv, options, groups,
2517 FF_ARRAY_ELEMS(groups));
2519 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2523 /* apply global options */
2524 ret = parse_optgroup(NULL, &octx.global_opts);
2526 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2530 /* open input files */
2531 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2533 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2537 /* open output files */
2538 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2540 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2545 uninit_parse_context(&octx);
2547 av_strerror(ret, error, sizeof(error));
2548 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2553 static int opt_progress(void *optctx, const char *opt, const char *arg)
2555 AVIOContext *avio = NULL;
2558 if (!strcmp(arg, "-"))
2560 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2562 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2563 arg, av_err2str(ret));
2566 progress_avio = avio;
2570 #define OFFSET(x) offsetof(OptionsContext, x)
2571 const OptionDef options[] = {
2573 #include "cmdutils_common_opts.h"
2574 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2575 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2576 "force format", "fmt" },
2577 { "y", OPT_BOOL, { &file_overwrite },
2578 "overwrite output files" },
2579 { "n", OPT_BOOL, { &no_file_overwrite },
2580 "never overwrite output files" },
2581 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2582 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2583 "codec name", "codec" },
2584 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2585 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2586 "codec name", "codec" },
2587 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2588 OPT_OUTPUT, { .off = OFFSET(presets) },
2589 "preset name", "preset" },
2590 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2591 OPT_OUTPUT, { .func_arg = opt_map },
2592 "set input stream mapping",
2593 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2594 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2595 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2596 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2597 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2598 "set metadata information of outfile from infile",
2599 "outfile[,metadata]:infile[,metadata]" },
2600 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2601 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2602 "set chapters mapping", "input_file_index" },
2603 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2604 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2605 "record or transcode \"duration\" seconds of audio/video",
2607 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2608 "record or transcode stop time", "time_stop" },
2609 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2610 "set the limit file size in bytes", "limit_size" },
2611 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2612 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2613 "set the start time offset", "time_off" },
2614 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2615 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2616 "enable/disable accurate seeking with -ss" },
2617 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2618 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2619 "set the input ts offset", "time_off" },
2620 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2621 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2622 "set the input ts scale", "scale" },
2623 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2624 "set the recording timestamp ('now' to set the current time)", "time" },
2625 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2626 "add metadata", "string=string" },
2627 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2628 OPT_OUTPUT, { .func_arg = opt_data_frames },
2629 "set the number of data frames to record", "number" },
2630 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2631 "add timings for benchmarking" },
2632 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2633 "add timings for each task" },
2634 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2635 "write program-readable progress information", "url" },
2636 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2637 "enable or disable interaction on standard input" },
2638 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2639 "set max runtime in seconds", "limit" },
2640 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2641 "dump each input packet" },
2642 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2643 "when dumping packets, also dump the payload" },
2644 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2645 OPT_INPUT, { .off = OFFSET(rate_emu) },
2646 "read input at native frame rate", "" },
2647 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2648 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2649 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2650 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2651 "video sync method", "" },
2652 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2653 "audio sync method", "" },
2654 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2655 "audio drift threshold", "threshold" },
2656 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2657 "copy timestamps" },
2658 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2659 "copy input stream time base when stream copying", "mode" },
2660 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2661 OPT_OUTPUT, { .off = OFFSET(shortest) },
2662 "finish encoding within shortest input" },
2663 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2664 OPT_OUTPUT, { .off = OFFSET(apad) },
2666 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2667 "timestamp discontinuity delta threshold", "threshold" },
2668 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2669 "timestamp error delta threshold", "threshold" },
2670 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2671 "exit on error", "error" },
2672 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2673 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2674 "copy initial non-keyframes" },
2675 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2676 "copy or discard frames before start time" },
2677 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2678 "set the number of frames to record", "number" },
2679 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2680 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2681 "force codec tag/fourcc", "fourcc/tag" },
2682 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2683 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2684 "use fixed quality scale (VBR)", "q" },
2685 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2686 OPT_OUTPUT, { .func_arg = opt_qscale },
2687 "use fixed quality scale (VBR)", "q" },
2688 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2689 "set profile", "profile" },
2690 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2691 "set stream filtergraph", "filter_graph" },
2692 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2693 "read stream filtergraph description from a file", "filename" },
2694 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2695 "reinit filtergraph on input parameter changes", "" },
2696 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2697 "create a complex filtergraph", "graph_description" },
2698 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2699 "create a complex filtergraph", "graph_description" },
2700 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2701 "read complex filtergraph description from a file", "filename" },
2702 { "stats", OPT_BOOL, { &print_stats },
2703 "print progress report during encoding", },
2704 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2705 OPT_OUTPUT, { .func_arg = opt_attach },
2706 "add an attachment to the output file", "filename" },
2707 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2708 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2709 "extract an attachment into a file", "filename" },
2710 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2711 "print timestamp debugging info" },
2714 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2715 "set the number of video frames to record", "number" },
2716 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2717 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2718 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2719 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2720 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2721 "set frame size (WxH or abbreviation)", "size" },
2722 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2723 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2724 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2725 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2726 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2727 "set pixel format", "format" },
2728 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2729 "set the number of bits per raw sample", "number" },
2730 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2731 "deprecated use -g 1" },
2732 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2734 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2735 "discard threshold", "n" },
2736 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2737 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2738 "rate control override for specific intervals", "override" },
2739 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2740 OPT_OUTPUT, { .func_arg = opt_video_codec },
2741 "force video codec ('copy' to copy stream)", "codec" },
2742 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2744 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2746 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2747 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2748 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2749 "select the pass number (1 to 3)", "n" },
2750 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2751 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2752 "select two pass log file name prefix", "prefix" },
2753 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2754 "this option is deprecated, use the yadif filter instead" },
2755 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2756 "calculate PSNR of compressed frames" },
2757 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2758 "dump video coding statistics to file" },
2759 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2760 "dump video coding statistics to file", "file" },
2761 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2762 "set video filters", "filter_graph" },
2763 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2764 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2765 "specify intra matrix coeffs", "matrix" },
2766 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2767 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2768 "specify inter matrix coeffs", "matrix" },
2769 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2770 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2771 "top=1/bottom=0/auto=-1 field first", "" },
2772 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2773 "intra_dc_precision", "precision" },
2774 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2775 OPT_OUTPUT, { .func_arg = opt_old2new },
2776 "force video tag/fourcc", "fourcc/tag" },
2777 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2778 "show QP histogram" },
2779 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2780 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2781 "force the selected framerate, disable the best supported framerate selection" },
2782 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2783 OPT_OUTPUT, { .func_arg = opt_streamid },
2784 "set the value of an outfile streamid", "streamIndex:value" },
2785 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2786 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2787 "force key frames at specified timestamps", "timestamps" },
2788 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2789 "video bitrate (please use -b:v)", "bitrate" },
2792 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2793 "set the number of audio frames to record", "number" },
2794 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2795 "set audio quality (codec-specific)", "quality", },
2796 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2797 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2798 "set audio sampling rate (in Hz)", "rate" },
2799 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2800 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2801 "set number of audio channels", "channels" },
2802 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2804 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2805 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2806 "force audio codec ('copy' to copy stream)", "codec" },
2807 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2808 OPT_OUTPUT, { .func_arg = opt_old2new },
2809 "force audio tag/fourcc", "fourcc/tag" },
2810 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2811 "change audio volume (256=normal)" , "volume" },
2812 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2813 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2814 "set sample format", "format" },
2815 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2816 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2817 "set channel layout", "layout" },
2818 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2819 "set audio filters", "filter_graph" },
2820 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2821 "set the maximum number of channels to try to guess the channel layout" },
2823 /* subtitle options */
2824 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2825 "disable subtitle" },
2826 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2827 "force subtitle codec ('copy' to copy stream)", "codec" },
2828 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2829 , "force subtitle tag/fourcc", "fourcc/tag" },
2830 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2831 "fix subtitles duration" },
2832 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2833 "set canvas size (WxH or abbreviation)", "size" },
2836 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2837 "deprecated, use -channel", "channel" },
2838 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2839 "deprecated, use -standard", "standard" },
2840 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2843 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2844 "set the maximum demux-decode delay", "seconds" },
2845 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2846 "set the initial demux-decode delay", "seconds" },
2847 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2848 "override the options from ffserver", "" },
2850 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2851 "A comma-separated list of bitstream filters", "bitstream_filters" },
2852 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2853 "deprecated", "audio bitstream_filters" },
2854 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2855 "deprecated", "video bitstream_filters" },
2857 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2858 "set the audio options to the indicated preset", "preset" },
2859 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2860 "set the video options to the indicated preset", "preset" },
2861 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2862 "set the subtitle options to the indicated preset", "preset" },
2863 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2864 "set options from indicated preset file", "filename" },
2865 /* data codec support */
2866 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2867 "force data codec ('copy' to copy stream)", "codec" },
2868 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },