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);
595 if (av_codec_get_lowres(dec)) {
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;
789 if (video_codec_name)
790 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
791 if (audio_codec_name)
792 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
793 if (subtitle_codec_name)
794 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
796 ic->flags |= AVFMT_FLAG_NONBLOCK;
797 ic->interrupt_callback = int_cb;
799 /* open the input file with generic avformat function */
800 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
802 print_error(filename, err);
805 assert_avoptions(o->g->format_opts);
807 /* apply forced codec ids */
808 for (i = 0; i < ic->nb_streams; i++)
809 choose_decoder(o, ic, ic->streams[i]);
811 /* Set AVCodecContext options for avformat_find_stream_info */
812 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
813 orig_nb_streams = ic->nb_streams;
815 /* If not enough info to get the stream parameters, we decode the
816 first frames to get it. (used in mpeg case for example) */
817 ret = avformat_find_stream_info(ic, opts);
819 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
820 avformat_close_input(&ic);
824 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
825 /* add the stream start time */
826 if (ic->start_time != AV_NOPTS_VALUE)
827 timestamp += ic->start_time;
829 /* if seeking requested, we execute it */
830 if (o->start_time != AV_NOPTS_VALUE) {
831 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
833 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
834 filename, (double)timestamp / AV_TIME_BASE);
838 /* update the current parameters so that they match the one of the input stream */
839 add_input_streams(o, ic);
841 /* dump the file content */
842 av_dump_format(ic, nb_input_files, filename, 0);
844 GROW_ARRAY(input_files, nb_input_files);
845 f = av_mallocz(sizeof(*f));
848 input_files[nb_input_files - 1] = f;
851 f->ist_index = nb_input_streams - ic->nb_streams;
852 f->start_time = o->start_time;
853 f->recording_time = o->recording_time;
854 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
855 f->nb_streams = ic->nb_streams;
856 f->rate_emu = o->rate_emu;
857 f->accurate_seek = o->accurate_seek;
859 /* check if all codec options have been used */
860 unused_opts = strip_specifiers(o->g->codec_opts);
861 for (i = f->ist_index; i < nb_input_streams; i++) {
863 while ((e = av_dict_get(input_streams[i]->opts, "", e,
864 AV_DICT_IGNORE_SUFFIX)))
865 av_dict_set(&unused_opts, e->key, NULL, 0);
869 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
870 const AVClass *class = avcodec_get_class();
871 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
872 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
875 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
876 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
877 "input file #%d (%s) is not a decoding option.\n", e->key,
878 option->help ? option->help : "", nb_input_files - 1,
883 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
884 "input file #%d (%s) has not been used for any stream. The most "
885 "likely reason is either wrong type (e.g. a video option with "
886 "no video streams) or that it is a private option of some decoder "
887 "which was not actually used for any stream.\n", e->key,
888 option->help ? option->help : "", nb_input_files - 1, filename);
890 av_dict_free(&unused_opts);
892 for (i = 0; i < o->nb_dump_attachment; i++) {
895 for (j = 0; j < ic->nb_streams; j++) {
896 AVStream *st = ic->streams[j];
898 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
899 dump_attachment(st, o->dump_attachment[i].u.str);
903 for (i = 0; i < orig_nb_streams; i++)
904 av_dict_free(&opts[i]);
910 static uint8_t *get_line(AVIOContext *s)
916 if (avio_open_dyn_buf(&line) < 0) {
917 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
921 while ((c = avio_r8(s)) && c != '\n')
924 avio_close_dyn_buf(line, &buf);
929 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
933 const char *base[3] = { getenv("AVCONV_DATADIR"),
938 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
942 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
943 i != 1 ? "" : "/.avconv", codec_name, preset_name);
944 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
947 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
948 i != 1 ? "" : "/.avconv", preset_name);
949 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
955 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
957 char *codec_name = NULL;
959 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
961 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
962 NULL, ost->st->codec->codec_type);
963 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
964 } else if (!strcmp(codec_name, "copy"))
965 ost->stream_copy = 1;
967 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
968 ost->st->codec->codec_id = ost->enc->id;
972 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
975 AVStream *st = avformat_new_stream(oc, NULL);
976 int idx = oc->nb_streams - 1, ret = 0;
977 char *bsf = NULL, *next, *codec_tag = NULL;
978 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
983 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
987 if (oc->nb_streams - 1 < o->nb_streamid_map)
988 st->id = o->streamid_map[oc->nb_streams - 1];
990 GROW_ARRAY(output_streams, nb_output_streams);
991 if (!(ost = av_mallocz(sizeof(*ost))))
993 output_streams[nb_output_streams - 1] = ost;
995 ost->file_index = nb_output_files - 1;
998 st->codec->codec_type = type;
999 choose_encoder(o, oc, ost);
1001 AVIOContext *s = NULL;
1002 char *buf = NULL, *arg = NULL, *preset = NULL;
1004 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1006 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1007 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1010 if (!buf[0] || buf[0] == '#') {
1014 if (!(arg = strchr(buf, '='))) {
1015 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1019 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1021 } while (!s->eof_reached);
1025 av_log(NULL, AV_LOG_FATAL,
1026 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1027 preset, ost->file_index, ost->index);
1031 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1034 avcodec_get_context_defaults3(st->codec, ost->enc);
1035 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1037 ost->max_frames = INT64_MAX;
1038 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1039 for (i = 0; i<o->nb_max_frames; i++) {
1040 char *p = o->max_frames[i].specifier;
1041 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1042 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1047 ost->copy_prior_start = -1;
1048 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1050 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1052 if (next = strchr(bsf, ','))
1054 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1055 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1059 bsfc_prev->next = bsfc;
1061 ost->bitstream_filters = bsfc;
1067 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1069 uint32_t tag = strtol(codec_tag, &next, 0);
1071 tag = AV_RL32(codec_tag);
1072 st->codec->codec_tag = tag;
1075 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1077 st->codec->flags |= CODEC_FLAG_QSCALE;
1078 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1081 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1082 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1084 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1086 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1087 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1088 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1090 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1092 ost->source_index = source_index;
1093 if (source_index >= 0) {
1094 ost->sync_ist = input_streams[source_index];
1095 input_streams[source_index]->discard = 0;
1096 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1098 ost->last_mux_dts = AV_NOPTS_VALUE;
1103 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1106 const char *p = str;
1113 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1120 /* read file contents into a string */
1121 static uint8_t *read_file(const char *filename)
1123 AVIOContext *pb = NULL;
1124 AVIOContext *dyn_buf = NULL;
1125 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1126 uint8_t buf[1024], *str;
1129 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1133 ret = avio_open_dyn_buf(&dyn_buf);
1138 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1139 avio_write(dyn_buf, buf, ret);
1140 avio_w8(dyn_buf, 0);
1143 ret = avio_close_dyn_buf(dyn_buf, &str);
1149 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1152 AVStream *st = ost->st;
1153 char *filter = NULL, *filter_script = NULL;
1155 MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1156 MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1158 if (filter_script && filter) {
1159 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1160 "output stream #%d:%d.\n", nb_output_files, st->index);
1165 return read_file(filter_script);
1167 return av_strdup(filter);
1169 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1173 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1177 AVCodecContext *video_enc;
1178 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1180 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1182 video_enc = st->codec;
1184 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1185 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1186 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1190 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1191 if (frame_aspect_ratio) {
1193 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1194 q.num <= 0 || q.den <= 0) {
1195 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1198 ost->frame_aspect_ratio = q;
1201 if (!ost->stream_copy) {
1202 const char *p = NULL;
1203 char *frame_size = NULL;
1204 char *frame_pix_fmt = NULL;
1205 char *intra_matrix = NULL, *inter_matrix = NULL;
1209 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1210 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1211 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1215 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1216 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1217 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1218 ost->keep_pix_fmt = 1;
1219 if (!*++frame_pix_fmt)
1220 frame_pix_fmt = NULL;
1222 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1223 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1226 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1229 video_enc->gop_size = 0;
1230 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1232 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1233 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1236 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1238 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1240 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1241 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1244 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1247 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1248 for (i = 0; p; i++) {
1250 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1252 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1255 /* FIXME realloc failure */
1256 video_enc->rc_override =
1257 av_realloc(video_enc->rc_override,
1258 sizeof(RcOverride) * (i + 1));
1259 video_enc->rc_override[i].start_frame = start;
1260 video_enc->rc_override[i].end_frame = end;
1262 video_enc->rc_override[i].qscale = q;
1263 video_enc->rc_override[i].quality_factor = 1.0;
1266 video_enc->rc_override[i].qscale = 0;
1267 video_enc->rc_override[i].quality_factor = -q/100.0;
1272 video_enc->rc_override_count = i;
1273 video_enc->intra_dc_precision = intra_dc_precision - 8;
1276 video_enc->flags|= CODEC_FLAG_PSNR;
1279 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1282 video_enc->flags |= CODEC_FLAG_PASS1;
1283 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1286 video_enc->flags |= CODEC_FLAG_PASS2;
1287 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1291 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1292 if (ost->logfile_prefix &&
1293 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1296 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1297 if (ost->forced_keyframes)
1298 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1300 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1302 ost->top_field_first = -1;
1303 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1306 ost->avfilter = get_ost_filters(o, oc, ost);
1310 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1316 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1321 AVCodecContext *audio_enc;
1323 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1326 audio_enc = st->codec;
1327 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1329 if (!ost->stream_copy) {
1330 char *sample_fmt = NULL;
1332 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1334 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1336 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1337 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1341 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1343 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1344 ost->apad = av_strdup(ost->apad);
1346 ost->avfilter = get_ost_filters(o, oc, ost);
1350 /* check for channel mapping for this audio stream */
1351 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1352 AudioChannelMap *map = &o->audio_channel_maps[n];
1353 InputStream *ist = input_streams[ost->source_index];
1354 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1355 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1356 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1357 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1358 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1360 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1361 ost->file_index, ost->st->index);
1369 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1373 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1374 if (!ost->stream_copy) {
1375 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1382 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1384 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1385 ost->stream_copy = 1;
1390 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1394 AVCodecContext *subtitle_enc;
1396 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1398 subtitle_enc = st->codec;
1400 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1402 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1404 if (!ost->stream_copy) {
1405 char *frame_size = NULL;
1407 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1408 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1409 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1417 /* arg format is "output-stream-index:streamid-value". */
1418 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1420 OptionsContext *o = optctx;
1425 av_strlcpy(idx_str, arg, sizeof(idx_str));
1426 p = strchr(idx_str, ':');
1428 av_log(NULL, AV_LOG_FATAL,
1429 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1434 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1435 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1436 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1440 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1442 AVFormatContext *is = ifile->ctx;
1443 AVFormatContext *os = ofile->ctx;
1447 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1449 return AVERROR(ENOMEM);
1452 for (i = 0; i < is->nb_chapters; i++) {
1453 AVChapter *in_ch = is->chapters[i], *out_ch;
1454 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1455 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1456 AV_TIME_BASE_Q, in_ch->time_base);
1457 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1458 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1461 if (in_ch->end < ts_off)
1463 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1466 out_ch = av_mallocz(sizeof(AVChapter));
1468 return AVERROR(ENOMEM);
1470 out_ch->id = in_ch->id;
1471 out_ch->time_base = in_ch->time_base;
1472 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1473 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1476 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1478 os->chapters[os->nb_chapters++] = out_ch;
1483 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1486 AVFormatContext *ic = avformat_alloc_context();
1488 ic->interrupt_callback = int_cb;
1489 err = avformat_open_input(&ic, filename, NULL, NULL);
1492 /* copy stream format */
1493 for(i=0;i<ic->nb_streams;i++) {
1497 AVCodecContext *avctx;
1499 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1500 ost = new_output_stream(o, s, codec->type, -1);
1505 // FIXME: a more elegant solution is needed
1506 memcpy(st, ic->streams[i], sizeof(AVStream));
1508 st->info = av_malloc(sizeof(*st->info));
1509 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1511 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1513 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1514 choose_sample_fmt(st, codec);
1515 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1516 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1519 avformat_close_input(&ic);
1523 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1524 AVFormatContext *oc)
1528 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1529 ofilter->out_tmp->pad_idx)) {
1530 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1531 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1533 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1538 ost->source_index = -1;
1539 ost->filter = ofilter;
1543 if (ost->stream_copy) {
1544 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1545 "which is fed from a complex filtergraph. Filtering and streamcopy "
1546 "cannot be used together.\n", ost->file_index, ost->index);
1550 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1551 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1554 avfilter_inout_free(&ofilter->out_tmp);
1557 static int configure_complex_filters(void)
1561 for (i = 0; i < nb_filtergraphs; i++)
1562 if (!filtergraphs[i]->graph &&
1563 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1568 static int open_output_file(OptionsContext *o, const char *filename)
1570 AVFormatContext *oc;
1572 AVOutputFormat *file_oformat;
1576 AVDictionary *unused_opts = NULL;
1577 AVDictionaryEntry *e = NULL;
1579 if (configure_complex_filters() < 0) {
1580 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1584 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1585 o->stop_time = INT64_MAX;
1586 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1589 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1590 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1591 if (o->stop_time <= start_time) {
1592 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1593 o->stop_time = INT64_MAX;
1595 o->recording_time = o->stop_time - start_time;
1599 GROW_ARRAY(output_files, nb_output_files);
1600 of = av_mallocz(sizeof(*of));
1603 output_files[nb_output_files - 1] = of;
1605 of->ost_index = nb_output_streams;
1606 of->recording_time = o->recording_time;
1607 of->start_time = o->start_time;
1608 of->limit_filesize = o->limit_filesize;
1609 of->shortest = o->shortest;
1610 av_dict_copy(&of->opts, o->g->format_opts, 0);
1612 if (!strcmp(filename, "-"))
1615 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1617 print_error(filename, err);
1622 if (o->recording_time != INT64_MAX)
1623 oc->duration = o->recording_time;
1625 file_oformat= oc->oformat;
1626 oc->interrupt_callback = int_cb;
1628 /* create streams for all unlabeled output pads */
1629 for (i = 0; i < nb_filtergraphs; i++) {
1630 FilterGraph *fg = filtergraphs[i];
1631 for (j = 0; j < fg->nb_outputs; j++) {
1632 OutputFilter *ofilter = fg->outputs[j];
1634 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1637 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1638 ofilter->out_tmp->pad_idx)) {
1639 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1640 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1641 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1643 init_output_filter(ofilter, o, oc);
1647 /* ffserver seeking with date=... needs a date reference */
1648 if (!strcmp(file_oformat->name, "ffm") &&
1649 av_strstart(filename, "http:", NULL)) {
1650 int err = parse_option(o, "metadata", "creation_time=now", options);
1652 print_error(filename, err);
1657 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1658 av_strstart(filename, "http:", NULL)) {
1660 /* special case for files sent to ffserver: we get the stream
1661 parameters from ffserver */
1662 int err = read_ffserver_streams(o, oc, filename);
1664 print_error(filename, err);
1667 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1668 ost = output_streams[j];
1669 for (i = 0; i < nb_input_streams; i++) {
1670 ist = input_streams[i];
1671 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1673 ost->source_index= i;
1674 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1675 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1677 ist->st->discard = AVDISCARD_NONE;
1682 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));
1686 } else if (!o->nb_stream_maps) {
1687 char *subtitle_codec_name = NULL;
1688 /* pick the "best" stream of each type */
1690 /* video: highest resolution */
1691 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1692 int area = 0, idx = -1;
1693 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1694 for (i = 0; i < nb_input_streams; i++) {
1696 ist = input_streams[i];
1697 new_area = ist->st->codec->width * ist->st->codec->height;
1698 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1700 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1702 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1709 new_video_stream(o, oc, idx);
1712 /* audio: most channels */
1713 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1714 int channels = 0, idx = -1;
1715 for (i = 0; i < nb_input_streams; i++) {
1716 ist = input_streams[i];
1717 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1718 ist->st->codec->channels > channels) {
1719 channels = ist->st->codec->channels;
1724 new_audio_stream(o, oc, idx);
1727 /* subtitles: pick first */
1728 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1729 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1730 for (i = 0; i < nb_input_streams; i++)
1731 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1732 new_subtitle_stream(o, oc, i);
1736 /* do something with data? */
1738 for (i = 0; i < o->nb_stream_maps; i++) {
1739 StreamMap *map = &o->stream_maps[i];
1744 if (map->linklabel) {
1746 OutputFilter *ofilter = NULL;
1749 for (j = 0; j < nb_filtergraphs; j++) {
1750 fg = filtergraphs[j];
1751 for (k = 0; k < fg->nb_outputs; k++) {
1752 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1753 if (out && !strcmp(out->name, map->linklabel)) {
1754 ofilter = fg->outputs[k];
1761 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1762 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1765 init_output_filter(ofilter, o, oc);
1767 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1769 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1770 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1772 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1774 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1776 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1779 switch (ist->st->codec->codec_type) {
1780 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1781 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1782 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1783 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1784 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1786 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1787 map->file_index, map->stream_index);
1794 /* handle attached files */
1795 for (i = 0; i < o->nb_attachments; i++) {
1797 uint8_t *attachment;
1801 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1802 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1806 if ((len = avio_size(pb)) <= 0) {
1807 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1811 if (!(attachment = av_malloc(len))) {
1812 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1816 avio_read(pb, attachment, len);
1818 ost = new_attachment_stream(o, oc, -1);
1819 ost->stream_copy = 0;
1820 ost->attachment_filename = o->attachments[i];
1822 ost->st->codec->extradata = attachment;
1823 ost->st->codec->extradata_size = len;
1825 p = strrchr(o->attachments[i], '/');
1826 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1830 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1831 AVDictionaryEntry *e;
1832 ost = output_streams[i];
1834 if ((ost->stream_copy || ost->attachment_filename)
1835 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1836 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1837 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1841 /* check if all codec options have been used */
1842 unused_opts = strip_specifiers(o->g->codec_opts);
1843 for (i = of->ost_index; i < nb_output_streams; i++) {
1845 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1846 AV_DICT_IGNORE_SUFFIX)))
1847 av_dict_set(&unused_opts, e->key, NULL, 0);
1851 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1852 const AVClass *class = avcodec_get_class();
1853 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1854 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1857 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1858 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1859 "output file #%d (%s) is not an encoding option.\n", e->key,
1860 option->help ? option->help : "", nb_output_files - 1,
1865 // gop_timecode is injected by generic code but not always used
1866 if (!strcmp(e->key, "gop_timecode"))
1869 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1870 "output file #%d (%s) has not been used for any stream. The most "
1871 "likely reason is either wrong type (e.g. a video option with "
1872 "no video streams) or that it is a private option of some encoder "
1873 "which was not actually used for any stream.\n", e->key,
1874 option->help ? option->help : "", nb_output_files - 1, filename);
1876 av_dict_free(&unused_opts);
1878 /* check filename in case of an image number is expected */
1879 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1880 if (!av_filename_number_test(oc->filename)) {
1881 print_error(oc->filename, AVERROR(EINVAL));
1886 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1887 /* test if it already exists to avoid losing precious files */
1888 assert_file_overwrite(filename);
1891 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1892 &oc->interrupt_callback,
1894 print_error(filename, err);
1897 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1898 assert_file_overwrite(filename);
1900 if (o->mux_preload) {
1902 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1903 av_dict_set(&of->opts, "preload", buf, 0);
1905 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1908 for (i = 0; i < o->nb_metadata_map; i++) {
1910 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1912 if (in_file_index >= nb_input_files) {
1913 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1916 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1917 in_file_index >= 0 ?
1918 input_files[in_file_index]->ctx : NULL, o);
1922 if (o->chapters_input_file >= nb_input_files) {
1923 if (o->chapters_input_file == INT_MAX) {
1924 /* copy chapters from the first input file that has them*/
1925 o->chapters_input_file = -1;
1926 for (i = 0; i < nb_input_files; i++)
1927 if (input_files[i]->ctx->nb_chapters) {
1928 o->chapters_input_file = i;
1932 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1933 o->chapters_input_file);
1937 if (o->chapters_input_file >= 0)
1938 copy_chapters(input_files[o->chapters_input_file], of,
1939 !o->metadata_chapters_manual);
1941 /* copy global metadata by default */
1942 if (!o->metadata_global_manual && nb_input_files){
1943 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1944 AV_DICT_DONT_OVERWRITE);
1945 if(o->recording_time != INT64_MAX)
1946 av_dict_set(&oc->metadata, "duration", NULL, 0);
1947 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1949 if (!o->metadata_streams_manual)
1950 for (i = of->ost_index; i < nb_output_streams; i++) {
1952 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1954 ist = input_streams[output_streams[i]->source_index];
1955 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1958 /* process manually set metadata */
1959 for (i = 0; i < o->nb_metadata; i++) {
1962 const char *stream_spec;
1963 int index = 0, j, ret = 0;
1965 val = strchr(o->metadata[i].u.str, '=');
1967 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1968 o->metadata[i].u.str);
1973 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1975 for (j = 0; j < oc->nb_streams; j++) {
1976 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1977 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1988 if (index < 0 || index >= oc->nb_chapters) {
1989 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1992 m = &oc->chapters[index]->metadata;
1995 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1998 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2005 static int opt_target(void *optctx, const char *opt, const char *arg)
2007 OptionsContext *o = optctx;
2008 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2009 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2011 if (!strncmp(arg, "pal-", 4)) {
2014 } else if (!strncmp(arg, "ntsc-", 5)) {
2017 } else if (!strncmp(arg, "film-", 5)) {
2021 /* Try to determine PAL/NTSC by peeking in the input files */
2022 if (nb_input_files) {
2024 for (j = 0; j < nb_input_files; j++) {
2025 for (i = 0; i < input_files[j]->nb_streams; i++) {
2026 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2027 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2029 fr = c->time_base.den * 1000 / c->time_base.num;
2033 } else if ((fr == 29970) || (fr == 23976)) {
2038 if (norm != UNKNOWN)
2042 if (norm != UNKNOWN)
2043 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2046 if (norm == UNKNOWN) {
2047 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2048 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2049 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2053 if (!strcmp(arg, "vcd")) {
2054 opt_video_codec(o, "c:v", "mpeg1video");
2055 opt_audio_codec(o, "c:a", "mp2");
2056 parse_option(o, "f", "vcd", options);
2057 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2059 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2060 parse_option(o, "r", frame_rates[norm], options);
2061 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2063 av_dict_set(&o->g->codec_opts, "b:v", "1150000", 0);
2064 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", 0);
2065 av_dict_set(&o->g->codec_opts, "minrate", "1150000", 0);
2066 av_dict_set(&o->g->codec_opts, "bufsize", "327680", 0); // 40*1024*8;
2068 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2069 parse_option(o, "ar", "44100", options);
2070 parse_option(o, "ac", "2", options);
2072 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2073 av_dict_set(&o->g->format_opts, "muxrate", "1411200", 0); // 2352 * 75 * 8;
2075 /* We have to offset the PTS, so that it is consistent with the SCR.
2076 SCR starts at 36000, but the first two packs contain only padding
2077 and the first pack from the other stream, respectively, may also have
2078 been written before.
2079 So the real data starts at SCR 36000+3*1200. */
2080 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2081 } else if (!strcmp(arg, "svcd")) {
2083 opt_video_codec(o, "c:v", "mpeg2video");
2084 opt_audio_codec(o, "c:a", "mp2");
2085 parse_option(o, "f", "svcd", options);
2087 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2088 parse_option(o, "r", frame_rates[norm], options);
2089 parse_option(o, "pix_fmt", "yuv420p", options);
2090 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2092 av_dict_set(&o->g->codec_opts, "b:v", "2040000", 0);
2093 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", 0);
2094 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1145000;
2095 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2096 av_dict_set(&o->g->codec_opts, "scan_offset", "1", 0);
2098 av_dict_set(&o->g->codec_opts, "b:a", "224000", 0);
2099 parse_option(o, "ar", "44100", options);
2101 av_dict_set(&o->g->format_opts, "packetsize", "2324", 0);
2103 } else if (!strcmp(arg, "dvd")) {
2105 opt_video_codec(o, "c:v", "mpeg2video");
2106 opt_audio_codec(o, "c:a", "ac3");
2107 parse_option(o, "f", "dvd", options);
2109 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2110 parse_option(o, "r", frame_rates[norm], options);
2111 parse_option(o, "pix_fmt", "yuv420p", options);
2112 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", 0);
2114 av_dict_set(&o->g->codec_opts, "b:v", "6000000", 0);
2115 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", 0);
2116 av_dict_set(&o->g->codec_opts, "minrate", "0", 0); // 1500000;
2117 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", 0); // 224*1024*8;
2119 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.
2120 av_dict_set(&o->g->format_opts, "muxrate", "10080000", 0); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2122 av_dict_set(&o->g->codec_opts, "b:a", "448000", 0);
2123 parse_option(o, "ar", "48000", options);
2125 } else if (!strncmp(arg, "dv", 2)) {
2127 parse_option(o, "f", "dv", options);
2129 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2130 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2131 norm == PAL ? "yuv420p" : "yuv411p", options);
2132 parse_option(o, "r", frame_rates[norm], options);
2134 parse_option(o, "ar", "48000", options);
2135 parse_option(o, "ac", "2", options);
2138 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2139 return AVERROR(EINVAL);
2144 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2146 av_free (vstats_filename);
2147 vstats_filename = av_strdup (arg);
2151 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2154 time_t today2 = time(NULL);
2155 struct tm *today = localtime(&today2);
2157 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2159 return opt_vstats_file(NULL, opt, filename);
2162 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2164 OptionsContext *o = optctx;
2165 return parse_option(o, "frames:v", arg, options);
2168 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2170 OptionsContext *o = optctx;
2171 return parse_option(o, "frames:a", arg, options);
2174 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2176 OptionsContext *o = optctx;
2177 return parse_option(o, "frames:d", arg, options);
2180 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2183 AVDictionary *cbak = codec_opts;
2184 AVDictionary *fbak = format_opts;
2188 ret = opt_default(NULL, opt, arg);
2190 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2191 av_dict_copy(&o->g->format_opts, format_opts, 0);
2192 av_dict_free(&codec_opts);
2193 av_dict_free(&format_opts);
2200 static int opt_preset(void *optctx, const char *opt, const char *arg)
2202 OptionsContext *o = optctx;
2204 char filename[1000], line[1000], tmp_line[1000];
2205 const char *codec_name = NULL;
2209 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2211 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2212 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2213 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2215 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2219 while (fgets(line, sizeof(line), f)) {
2220 char *key = tmp_line, *value, *endptr;
2222 if (strcspn(line, "#\n\r") == 0)
2224 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2225 if (!av_strtok(key, "=", &value) ||
2226 !av_strtok(value, "\r\n", &endptr)) {
2227 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2230 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2232 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2233 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2234 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2235 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2236 else if (opt_default_new(o, key, value) < 0) {
2237 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2238 filename, line, key, value);
2248 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2250 OptionsContext *o = optctx;
2251 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2252 int ret = parse_option(o, s, arg, options);
2257 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2259 OptionsContext *o = optctx;
2260 if(!strcmp(opt, "b")){
2261 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2262 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2265 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2269 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2271 OptionsContext *o = optctx;
2274 if(!strcmp(opt, "qscale")){
2275 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2276 return parse_option(o, "q:v", arg, options);
2278 s = av_asprintf("q%s", opt + 6);
2279 ret = parse_option(o, s, arg, options);
2284 static int opt_profile(void *optctx, const char *opt, const char *arg)
2286 OptionsContext *o = optctx;
2287 if(!strcmp(opt, "profile")){
2288 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2289 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2292 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2296 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2298 OptionsContext *o = optctx;
2299 return parse_option(o, "filter:v", arg, options);
2302 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2304 OptionsContext *o = optctx;
2305 return parse_option(o, "filter:a", arg, options);
2308 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2310 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2311 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2312 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2313 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2315 if (video_sync_method == VSYNC_AUTO)
2316 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2320 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2322 OptionsContext *o = optctx;
2323 char *tcr = av_asprintf("timecode=%s", arg);
2324 int ret = parse_option(o, "metadata:g", tcr, options);
2326 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2331 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2333 OptionsContext *o = optctx;
2334 char layout_str[32];
2337 int ret, channels, ac_str_size;
2340 layout = av_get_channel_layout(arg);
2342 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2343 return AVERROR(EINVAL);
2345 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2346 ret = opt_default_new(o, opt, layout_str);
2350 /* set 'ac' option based on channel layout */
2351 channels = av_get_channel_layout_nb_channels(layout);
2352 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2353 stream_str = strchr(opt, ':');
2354 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2355 ac_str = av_mallocz(ac_str_size);
2357 return AVERROR(ENOMEM);
2358 av_strlcpy(ac_str, "ac", 3);
2360 av_strlcat(ac_str, stream_str, ac_str_size);
2361 ret = parse_option(o, ac_str, layout_str, options);
2367 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2369 OptionsContext *o = optctx;
2370 return parse_option(o, "q:a", arg, options);
2373 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2375 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2376 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2377 return AVERROR(ENOMEM);
2378 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2379 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2380 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2381 return AVERROR(ENOMEM);
2385 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2387 uint8_t *graph_desc = read_file(arg);
2389 return AVERROR(EINVAL);
2391 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2392 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2393 return AVERROR(ENOMEM);
2394 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2395 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2399 void show_help_default(const char *opt, const char *arg)
2401 /* per-file options have at least one of those set */
2402 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2403 int show_advanced = 0, show_avoptions = 0;
2406 if (!strcmp(opt, "long"))
2408 else if (!strcmp(opt, "full"))
2409 show_advanced = show_avoptions = 1;
2411 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2416 printf("Getting help:\n"
2417 " -h -- print basic options\n"
2418 " -h long -- print more options\n"
2419 " -h full -- print all options (including all format and codec specific options, very long)\n"
2420 " See man %s for detailed description of the options.\n"
2421 "\n", program_name);
2423 show_help_options(options, "Print help / information / capabilities:",
2426 show_help_options(options, "Global options (affect whole program "
2427 "instead of just one file:",
2428 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2430 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2431 per_file | OPT_EXIT, 0);
2433 show_help_options(options, "Per-file main options:", 0,
2434 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2435 OPT_EXIT, per_file);
2437 show_help_options(options, "Advanced per-file options:",
2438 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2440 show_help_options(options, "Video options:",
2441 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2443 show_help_options(options, "Advanced Video options:",
2444 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2446 show_help_options(options, "Audio options:",
2447 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2449 show_help_options(options, "Advanced Audio options:",
2450 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2451 show_help_options(options, "Subtitle options:",
2452 OPT_SUBTITLE, 0, 0);
2455 if (show_avoptions) {
2456 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2457 show_help_children(avcodec_get_class(), flags);
2458 show_help_children(avformat_get_class(), flags);
2459 show_help_children(sws_get_class(), flags);
2460 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2461 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2465 void show_usage(void)
2467 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2468 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2469 av_log(NULL, AV_LOG_INFO, "\n");
2477 static const OptionGroupDef groups[] = {
2478 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2479 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2482 static int open_files(OptionGroupList *l, const char *inout,
2483 int (*open_file)(OptionsContext*, const char*))
2487 for (i = 0; i < l->nb_groups; i++) {
2488 OptionGroup *g = &l->groups[i];
2494 ret = parse_optgroup(&o, g);
2496 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2497 "%s.\n", inout, g->arg);
2501 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2502 ret = open_file(&o, g->arg);
2505 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2509 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2515 int ffmpeg_parse_options(int argc, char **argv)
2517 OptionParseContext octx;
2521 memset(&octx, 0, sizeof(octx));
2523 /* split the commandline into an internal representation */
2524 ret = split_commandline(&octx, argc, argv, options, groups,
2525 FF_ARRAY_ELEMS(groups));
2527 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2531 /* apply global options */
2532 ret = parse_optgroup(NULL, &octx.global_opts);
2534 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2538 /* open input files */
2539 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2541 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2545 /* open output files */
2546 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2548 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2553 uninit_parse_context(&octx);
2555 av_strerror(ret, error, sizeof(error));
2556 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2561 static int opt_progress(void *optctx, const char *opt, const char *arg)
2563 AVIOContext *avio = NULL;
2566 if (!strcmp(arg, "-"))
2568 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2570 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2571 arg, av_err2str(ret));
2574 progress_avio = avio;
2578 #define OFFSET(x) offsetof(OptionsContext, x)
2579 const OptionDef options[] = {
2581 #include "cmdutils_common_opts.h"
2582 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2583 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2584 "force format", "fmt" },
2585 { "y", OPT_BOOL, { &file_overwrite },
2586 "overwrite output files" },
2587 { "n", OPT_BOOL, { &no_file_overwrite },
2588 "never overwrite output files" },
2589 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2590 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2591 "codec name", "codec" },
2592 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2593 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2594 "codec name", "codec" },
2595 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2596 OPT_OUTPUT, { .off = OFFSET(presets) },
2597 "preset name", "preset" },
2598 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2599 OPT_OUTPUT, { .func_arg = opt_map },
2600 "set input stream mapping",
2601 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2602 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2603 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2604 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2605 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2606 "set metadata information of outfile from infile",
2607 "outfile[,metadata]:infile[,metadata]" },
2608 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2609 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2610 "set chapters mapping", "input_file_index" },
2611 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2612 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2613 "record or transcode \"duration\" seconds of audio/video",
2615 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2616 "record or transcode stop time", "time_stop" },
2617 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2618 "set the limit file size in bytes", "limit_size" },
2619 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2620 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2621 "set the start time offset", "time_off" },
2622 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2623 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2624 "enable/disable accurate seeking with -ss" },
2625 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2626 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2627 "set the input ts offset", "time_off" },
2628 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2629 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2630 "set the input ts scale", "scale" },
2631 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2632 "set the recording timestamp ('now' to set the current time)", "time" },
2633 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2634 "add metadata", "string=string" },
2635 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2636 OPT_OUTPUT, { .func_arg = opt_data_frames },
2637 "set the number of data frames to record", "number" },
2638 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2639 "add timings for benchmarking" },
2640 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2641 "add timings for each task" },
2642 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2643 "write program-readable progress information", "url" },
2644 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2645 "enable or disable interaction on standard input" },
2646 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2647 "set max runtime in seconds", "limit" },
2648 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2649 "dump each input packet" },
2650 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2651 "when dumping packets, also dump the payload" },
2652 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2653 OPT_INPUT, { .off = OFFSET(rate_emu) },
2654 "read input at native frame rate", "" },
2655 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2656 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2657 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2658 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2659 "video sync method", "" },
2660 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2661 "audio sync method", "" },
2662 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2663 "audio drift threshold", "threshold" },
2664 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2665 "copy timestamps" },
2666 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2667 "copy input stream time base when stream copying", "mode" },
2668 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2669 OPT_OUTPUT, { .off = OFFSET(shortest) },
2670 "finish encoding within shortest input" },
2671 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2672 OPT_OUTPUT, { .off = OFFSET(apad) },
2674 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2675 "timestamp discontinuity delta threshold", "threshold" },
2676 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2677 "timestamp error delta threshold", "threshold" },
2678 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2679 "exit on error", "error" },
2680 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2681 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2682 "copy initial non-keyframes" },
2683 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2684 "copy or discard frames before start time" },
2685 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2686 "set the number of frames to record", "number" },
2687 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2688 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2689 "force codec tag/fourcc", "fourcc/tag" },
2690 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2691 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2692 "use fixed quality scale (VBR)", "q" },
2693 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2694 OPT_OUTPUT, { .func_arg = opt_qscale },
2695 "use fixed quality scale (VBR)", "q" },
2696 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2697 "set profile", "profile" },
2698 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2699 "set stream filtergraph", "filter_graph" },
2700 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2701 "read stream filtergraph description from a file", "filename" },
2702 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2703 "reinit filtergraph on input parameter changes", "" },
2704 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2705 "create a complex filtergraph", "graph_description" },
2706 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2707 "create a complex filtergraph", "graph_description" },
2708 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2709 "read complex filtergraph description from a file", "filename" },
2710 { "stats", OPT_BOOL, { &print_stats },
2711 "print progress report during encoding", },
2712 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2713 OPT_OUTPUT, { .func_arg = opt_attach },
2714 "add an attachment to the output file", "filename" },
2715 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2716 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2717 "extract an attachment into a file", "filename" },
2718 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2719 "print timestamp debugging info" },
2722 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2723 "set the number of video frames to record", "number" },
2724 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2725 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2726 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2727 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2728 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2729 "set frame size (WxH or abbreviation)", "size" },
2730 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2731 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2732 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2733 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2734 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2735 "set pixel format", "format" },
2736 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2737 "set the number of bits per raw sample", "number" },
2738 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2739 "deprecated use -g 1" },
2740 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2742 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2743 "discard threshold", "n" },
2744 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2745 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2746 "rate control override for specific intervals", "override" },
2747 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2748 OPT_OUTPUT, { .func_arg = opt_video_codec },
2749 "force video codec ('copy' to copy stream)", "codec" },
2750 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2752 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2754 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2755 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2756 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2757 "select the pass number (1 to 3)", "n" },
2758 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2759 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2760 "select two pass log file name prefix", "prefix" },
2761 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2762 "this option is deprecated, use the yadif filter instead" },
2763 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2764 "calculate PSNR of compressed frames" },
2765 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2766 "dump video coding statistics to file" },
2767 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2768 "dump video coding statistics to file", "file" },
2769 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2770 "set video filters", "filter_graph" },
2771 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2772 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2773 "specify intra matrix coeffs", "matrix" },
2774 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2775 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2776 "specify inter matrix coeffs", "matrix" },
2777 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2778 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2779 "top=1/bottom=0/auto=-1 field first", "" },
2780 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2781 "intra_dc_precision", "precision" },
2782 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2783 OPT_OUTPUT, { .func_arg = opt_old2new },
2784 "force video tag/fourcc", "fourcc/tag" },
2785 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2786 "show QP histogram" },
2787 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2788 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2789 "force the selected framerate, disable the best supported framerate selection" },
2790 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2791 OPT_OUTPUT, { .func_arg = opt_streamid },
2792 "set the value of an outfile streamid", "streamIndex:value" },
2793 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2794 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2795 "force key frames at specified timestamps", "timestamps" },
2796 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2797 "video bitrate (please use -b:v)", "bitrate" },
2800 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2801 "set the number of audio frames to record", "number" },
2802 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2803 "set audio quality (codec-specific)", "quality", },
2804 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2805 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2806 "set audio sampling rate (in Hz)", "rate" },
2807 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2808 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2809 "set number of audio channels", "channels" },
2810 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2812 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2813 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2814 "force audio codec ('copy' to copy stream)", "codec" },
2815 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2816 OPT_OUTPUT, { .func_arg = opt_old2new },
2817 "force audio tag/fourcc", "fourcc/tag" },
2818 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2819 "change audio volume (256=normal)" , "volume" },
2820 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2821 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2822 "set sample format", "format" },
2823 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2824 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2825 "set channel layout", "layout" },
2826 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2827 "set audio filters", "filter_graph" },
2828 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2829 "set the maximum number of channels to try to guess the channel layout" },
2831 /* subtitle options */
2832 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2833 "disable subtitle" },
2834 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2835 "force subtitle codec ('copy' to copy stream)", "codec" },
2836 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2837 , "force subtitle tag/fourcc", "fourcc/tag" },
2838 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2839 "fix subtitles duration" },
2840 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2841 "set canvas size (WxH or abbreviation)", "size" },
2844 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2845 "deprecated, use -channel", "channel" },
2846 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2847 "deprecated, use -standard", "standard" },
2848 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2851 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2852 "set the maximum demux-decode delay", "seconds" },
2853 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2854 "set the initial demux-decode delay", "seconds" },
2855 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2856 "override the options from ffserver", "" },
2858 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2859 "A comma-separated list of bitstream filters", "bitstream_filters" },
2860 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2861 "deprecated", "audio bitstream_filters" },
2862 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2863 "deprecated", "video bitstream_filters" },
2865 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2866 "set the audio options to the indicated preset", "preset" },
2867 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2868 "set the video options to the indicated preset", "preset" },
2869 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2870 "set the subtitle options to the indicated preset", "preset" },
2871 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2872 "set options from indicated preset file", "filename" },
2873 /* data codec support */
2874 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2875 "force data codec ('copy' to copy stream)", "codec" },
2876 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },