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;
87 float max_error_rate = 2.0/3;
90 static int intra_only = 0;
91 static int file_overwrite = 0;
92 static int no_file_overwrite = 0;
93 static int video_discard = 0;
94 static int intra_dc_precision = 8;
95 static int do_psnr = 0;
96 static int input_sync;
97 static int override_ffserver = 0;
99 static void uninit_options(OptionsContext *o)
101 const OptionDef *po = options;
104 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
106 void *dst = (uint8_t*)o + po->u.off;
108 if (po->flags & OPT_SPEC) {
109 SpecifierOpt **so = dst;
110 int i, *count = (int*)(so + 1);
111 for (i = 0; i < *count; i++) {
112 av_freep(&(*so)[i].specifier);
113 if (po->flags & OPT_STRING)
114 av_freep(&(*so)[i].u.str);
118 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
123 for (i = 0; i < o->nb_stream_maps; i++)
124 av_freep(&o->stream_maps[i].linklabel);
125 av_freep(&o->stream_maps);
126 av_freep(&o->audio_channel_maps);
127 av_freep(&o->streamid_map);
128 av_freep(&o->attachments);
131 static void init_options(OptionsContext *o)
133 memset(o, 0, sizeof(*o));
135 o->stop_time = INT64_MAX;
136 o->mux_max_delay = 0.7;
137 o->start_time = AV_NOPTS_VALUE;
138 o->recording_time = INT64_MAX;
139 o->limit_filesize = UINT64_MAX;
140 o->chapters_input_file = INT_MAX;
141 o->accurate_seek = 1;
144 /* return a copy of the input with the stream specifiers removed from the keys */
145 static AVDictionary *strip_specifiers(AVDictionary *dict)
147 AVDictionaryEntry *e = NULL;
148 AVDictionary *ret = NULL;
150 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
151 char *p = strchr(e->key, ':');
155 av_dict_set(&ret, e->key, e->value, 0);
162 static int opt_sameq(void *optctx, const char *opt, const char *arg)
164 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
165 "If you are looking for an option to preserve the quality (which is not "
166 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
168 return AVERROR(EINVAL);
171 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
173 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
174 return opt_default(optctx, "channel", arg);
177 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
179 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
180 return opt_default(optctx, "standard", arg);
183 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
185 OptionsContext *o = optctx;
186 return parse_option(o, "codec:a", arg, options);
189 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
191 OptionsContext *o = optctx;
192 return parse_option(o, "codec:v", arg, options);
195 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
197 OptionsContext *o = optctx;
198 return parse_option(o, "codec:s", arg, options);
201 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
203 OptionsContext *o = optctx;
204 return parse_option(o, "codec:d", arg, options);
207 static int opt_map(void *optctx, const char *opt, const char *arg)
209 OptionsContext *o = optctx;
211 int i, negative = 0, file_idx;
212 int sync_file_idx = -1, sync_stream_idx = 0;
220 map = av_strdup(arg);
222 /* parse sync stream first, just pick first matching stream */
223 if (sync = strchr(map, ',')) {
225 sync_file_idx = strtol(sync + 1, &sync, 0);
226 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
227 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
232 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
233 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
234 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
238 if (i == input_files[sync_file_idx]->nb_streams) {
239 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
240 "match any streams.\n", arg);
247 /* this mapping refers to lavfi output */
248 const char *c = map + 1;
249 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
250 m = &o->stream_maps[o->nb_stream_maps - 1];
251 m->linklabel = av_get_token(&c, "]");
253 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
257 file_idx = strtol(map, &p, 0);
258 if (file_idx >= nb_input_files || file_idx < 0) {
259 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
263 /* disable some already defined maps */
264 for (i = 0; i < o->nb_stream_maps; i++) {
265 m = &o->stream_maps[i];
266 if (file_idx == m->file_index &&
267 check_stream_specifier(input_files[m->file_index]->ctx,
268 input_files[m->file_index]->ctx->streams[m->stream_index],
269 *p == ':' ? p + 1 : p) > 0)
273 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
274 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
275 *p == ':' ? p + 1 : p) <= 0)
277 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
278 m = &o->stream_maps[o->nb_stream_maps - 1];
280 m->file_index = file_idx;
283 if (sync_file_idx >= 0) {
284 m->sync_file_index = sync_file_idx;
285 m->sync_stream_index = sync_stream_idx;
287 m->sync_file_index = file_idx;
288 m->sync_stream_index = i;
294 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
302 static int opt_attach(void *optctx, const char *opt, const char *arg)
304 OptionsContext *o = optctx;
305 GROW_ARRAY(o->attachments, o->nb_attachments);
306 o->attachments[o->nb_attachments - 1] = arg;
310 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
312 OptionsContext *o = optctx;
317 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
318 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
320 /* muted channel syntax */
321 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
322 if ((n == 1 || n == 3) && m->channel_idx == -1) {
323 m->file_idx = m->stream_idx = -1;
325 m->ofile_idx = m->ostream_idx = -1;
330 n = sscanf(arg, "%d.%d.%d:%d.%d",
331 &m->file_idx, &m->stream_idx, &m->channel_idx,
332 &m->ofile_idx, &m->ostream_idx);
334 if (n != 3 && n != 5) {
335 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
336 "[file.stream.channel|-1][:syncfile:syncstream]\n");
340 if (n != 5) // only file.stream.channel specified
341 m->ofile_idx = m->ostream_idx = -1;
344 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
345 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
349 if (m->stream_idx < 0 ||
350 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
351 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
352 m->file_idx, m->stream_idx);
355 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
356 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
357 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
358 m->file_idx, m->stream_idx);
361 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
362 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
363 m->file_idx, m->stream_idx, m->channel_idx);
370 * Parse a metadata specifier passed as 'arg' parameter.
371 * @param arg metadata string to parse
372 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
373 * @param index for type c/p, chapter/program index is written here
374 * @param stream_spec for type s, the stream specifier is written here
376 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
384 if (*(++arg) && *arg != ':') {
385 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
388 *stream_spec = *arg == ':' ? arg + 1 : "";
393 *index = strtol(++arg, NULL, 0);
396 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
403 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
405 AVDictionary **meta_in = NULL;
406 AVDictionary **meta_out = NULL;
408 char type_in, type_out;
409 const char *istream_spec = NULL, *ostream_spec = NULL;
410 int idx_in = 0, idx_out = 0;
412 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
413 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
416 if (type_out == 'g' || !*outspec)
417 o->metadata_global_manual = 1;
418 if (type_out == 's' || !*outspec)
419 o->metadata_streams_manual = 1;
420 if (type_out == 'c' || !*outspec)
421 o->metadata_chapters_manual = 1;
425 if (type_in == 'g' || type_out == 'g')
426 o->metadata_global_manual = 1;
427 if (type_in == 's' || type_out == 's')
428 o->metadata_streams_manual = 1;
429 if (type_in == 'c' || type_out == 'c')
430 o->metadata_chapters_manual = 1;
432 /* ic is NULL when just disabling automatic mappings */
436 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
437 if ((index) < 0 || (index) >= (nb_elems)) {\
438 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
443 #define SET_DICT(type, meta, context, index)\
446 meta = &context->metadata;\
449 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
450 meta = &context->chapters[index]->metadata;\
453 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
454 meta = &context->programs[index]->metadata;\
457 break; /* handled separately below */ \
458 default: av_assert0(0);\
461 SET_DICT(type_in, meta_in, ic, idx_in);
462 SET_DICT(type_out, meta_out, oc, idx_out);
464 /* for input streams choose first matching stream */
465 if (type_in == 's') {
466 for (i = 0; i < ic->nb_streams; i++) {
467 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
468 meta_in = &ic->streams[i]->metadata;
474 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
479 if (type_out == 's') {
480 for (i = 0; i < oc->nb_streams; i++) {
481 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
482 meta_out = &oc->streams[i]->metadata;
483 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
488 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
493 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
495 OptionsContext *o = optctx;
497 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
498 struct tm time = *gmtime((time_t*)&recording_timestamp);
499 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
500 parse_option(o, "metadata", buf, options);
502 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
503 "tag instead.\n", opt);
507 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
509 const AVCodecDescriptor *desc;
510 const char *codec_string = encoder ? "encoder" : "decoder";
514 avcodec_find_encoder_by_name(name) :
515 avcodec_find_decoder_by_name(name);
517 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
518 codec = encoder ? avcodec_find_encoder(desc->id) :
519 avcodec_find_decoder(desc->id);
521 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
522 codec_string, codec->name, desc->name);
526 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
529 if (codec->type != type) {
530 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
536 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
538 char *codec_name = NULL;
540 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
542 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
543 st->codec->codec_id = codec->id;
546 return avcodec_find_decoder(st->codec->codec_id);
549 /* Add all the streams from the given input file to the global
550 * list of input streams. */
551 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
554 char *next, *codec_tag = NULL;
556 for (i = 0; i < ic->nb_streams; i++) {
557 AVStream *st = ic->streams[i];
558 AVCodecContext *dec = st->codec;
559 InputStream *ist = av_mallocz(sizeof(*ist));
560 char *framerate = NULL;
565 GROW_ARRAY(input_streams, nb_input_streams);
566 input_streams[nb_input_streams - 1] = ist;
569 ist->file_index = nb_input_files;
571 st->discard = AVDISCARD_ALL;
574 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
576 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
578 uint32_t tag = strtol(codec_tag, &next, 0);
580 tag = AV_RL32(codec_tag);
581 st->codec->codec_tag = tag;
584 ist->dec = choose_decoder(o, ic, st);
585 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
587 ist->reinit_filters = -1;
588 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
590 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
592 switch (dec->codec_type) {
593 case AVMEDIA_TYPE_VIDEO:
595 ist->dec = avcodec_find_decoder(dec->codec_id);
596 if (av_codec_get_lowres(dec)) {
597 dec->flags |= CODEC_FLAG_EMU_EDGE;
600 ist->resample_height = dec->height;
601 ist->resample_width = dec->width;
602 ist->resample_pix_fmt = dec->pix_fmt;
604 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
605 if (framerate && av_parse_video_rate(&ist->framerate,
607 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
612 ist->top_field_first = -1;
613 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
616 case AVMEDIA_TYPE_AUDIO:
617 ist->guess_layout_max = INT_MAX;
618 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
619 guess_input_channel_layout(ist);
621 ist->resample_sample_fmt = dec->sample_fmt;
622 ist->resample_sample_rate = dec->sample_rate;
623 ist->resample_channels = dec->channels;
624 ist->resample_channel_layout = dec->channel_layout;
627 case AVMEDIA_TYPE_DATA:
628 case AVMEDIA_TYPE_SUBTITLE: {
629 char *canvas_size = NULL;
631 ist->dec = avcodec_find_decoder(dec->codec_id);
632 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
633 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
635 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
636 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
641 case AVMEDIA_TYPE_ATTACHMENT:
642 case AVMEDIA_TYPE_UNKNOWN:
650 static void assert_file_overwrite(const char *filename)
652 if (file_overwrite && no_file_overwrite) {
653 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
657 if (!file_overwrite &&
658 (strchr(filename, ':') == NULL || filename[1] == ':' ||
659 av_strstart(filename, "file:", NULL))) {
660 if (avio_check(filename, 0) == 0) {
661 if (stdin_interaction && !no_file_overwrite) {
662 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
665 signal(SIGINT, SIG_DFL);
667 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
673 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
680 static void dump_attachment(AVStream *st, const char *filename)
683 AVIOContext *out = NULL;
684 AVDictionaryEntry *e;
686 if (!st->codec->extradata_size) {
687 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
688 nb_input_files - 1, st->index);
691 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
694 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
695 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
699 assert_file_overwrite(filename);
701 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
702 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
707 avio_write(out, st->codec->extradata, st->codec->extradata_size);
712 static int open_input_file(OptionsContext *o, const char *filename)
716 AVInputFormat *file_iformat = NULL;
721 AVDictionary *unused_opts = NULL;
722 AVDictionaryEntry *e = NULL;
723 int orig_nb_streams; // number of streams before avformat_find_stream_info
724 char * video_codec_name = NULL;
725 char * audio_codec_name = NULL;
726 char *subtitle_codec_name = NULL;
729 if (!(file_iformat = av_find_input_format(o->format))) {
730 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
735 if (!strcmp(filename, "-"))
738 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
739 strcmp(filename, "/dev/stdin");
741 /* get default parameters from command line */
742 ic = avformat_alloc_context();
744 print_error(filename, AVERROR(ENOMEM));
747 if (o->nb_audio_sample_rate) {
748 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
749 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
751 if (o->nb_audio_channels) {
752 /* because we set audio_channels based on both the "ac" and
753 * "channel_layout" options, we need to check that the specified
754 * demuxer actually has the "channels" option before setting it */
755 if (file_iformat && file_iformat->priv_class &&
756 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
757 AV_OPT_SEARCH_FAKE_OBJ)) {
758 snprintf(buf, sizeof(buf), "%d",
759 o->audio_channels[o->nb_audio_channels - 1].u.i);
760 av_dict_set(&o->g->format_opts, "channels", buf, 0);
763 if (o->nb_frame_rates) {
764 /* set the format-level framerate option;
765 * this is important for video grabbers, e.g. x11 */
766 if (file_iformat && file_iformat->priv_class &&
767 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
768 AV_OPT_SEARCH_FAKE_OBJ)) {
769 av_dict_set(&o->g->format_opts, "framerate",
770 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
773 if (o->nb_frame_sizes) {
774 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
776 if (o->nb_frame_pix_fmts)
777 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
779 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
780 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
781 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
783 ic->video_codec_id = video_codec_name ?
784 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
785 ic->audio_codec_id = audio_codec_name ?
786 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
787 ic->subtitle_codec_id= subtitle_codec_name ?
788 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
790 if (video_codec_name)
791 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
792 if (audio_codec_name)
793 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
794 if (subtitle_codec_name)
795 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
797 ic->flags |= AVFMT_FLAG_NONBLOCK;
798 ic->interrupt_callback = int_cb;
800 /* open the input file with generic avformat function */
801 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
803 print_error(filename, err);
806 assert_avoptions(o->g->format_opts);
808 /* apply forced codec ids */
809 for (i = 0; i < ic->nb_streams; i++)
810 choose_decoder(o, ic, ic->streams[i]);
812 /* Set AVCodecContext options for avformat_find_stream_info */
813 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
814 orig_nb_streams = ic->nb_streams;
816 /* If not enough info to get the stream parameters, we decode the
817 first frames to get it. (used in mpeg case for example) */
818 ret = avformat_find_stream_info(ic, opts);
820 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
821 avformat_close_input(&ic);
825 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
826 /* add the stream start time */
827 if (ic->start_time != AV_NOPTS_VALUE)
828 timestamp += ic->start_time;
830 /* if seeking requested, we execute it */
831 if (o->start_time != AV_NOPTS_VALUE) {
832 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
834 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
835 filename, (double)timestamp / AV_TIME_BASE);
839 /* update the current parameters so that they match the one of the input stream */
840 add_input_streams(o, ic);
842 /* dump the file content */
843 av_dump_format(ic, nb_input_files, filename, 0);
845 GROW_ARRAY(input_files, nb_input_files);
846 f = av_mallocz(sizeof(*f));
849 input_files[nb_input_files - 1] = f;
852 f->ist_index = nb_input_streams - ic->nb_streams;
853 f->start_time = o->start_time;
854 f->recording_time = o->recording_time;
855 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
856 f->nb_streams = ic->nb_streams;
857 f->rate_emu = o->rate_emu;
858 f->accurate_seek = o->accurate_seek;
860 /* check if all codec options have been used */
861 unused_opts = strip_specifiers(o->g->codec_opts);
862 for (i = f->ist_index; i < nb_input_streams; i++) {
864 while ((e = av_dict_get(input_streams[i]->opts, "", e,
865 AV_DICT_IGNORE_SUFFIX)))
866 av_dict_set(&unused_opts, e->key, NULL, 0);
870 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
871 const AVClass *class = avcodec_get_class();
872 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
873 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
876 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
877 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
878 "input file #%d (%s) is not a decoding option.\n", e->key,
879 option->help ? option->help : "", nb_input_files - 1,
884 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
885 "input file #%d (%s) has not been used for any stream. The most "
886 "likely reason is either wrong type (e.g. a video option with "
887 "no video streams) or that it is a private option of some decoder "
888 "which was not actually used for any stream.\n", e->key,
889 option->help ? option->help : "", nb_input_files - 1, filename);
891 av_dict_free(&unused_opts);
893 for (i = 0; i < o->nb_dump_attachment; i++) {
896 for (j = 0; j < ic->nb_streams; j++) {
897 AVStream *st = ic->streams[j];
899 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
900 dump_attachment(st, o->dump_attachment[i].u.str);
904 for (i = 0; i < orig_nb_streams; i++)
905 av_dict_free(&opts[i]);
911 static uint8_t *get_line(AVIOContext *s)
917 if (avio_open_dyn_buf(&line) < 0) {
918 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
922 while ((c = avio_r8(s)) && c != '\n')
925 avio_close_dyn_buf(line, &buf);
930 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
934 const char *base[3] = { getenv("AVCONV_DATADIR"),
939 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
943 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
944 i != 1 ? "" : "/.avconv", codec_name, preset_name);
945 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
948 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
949 i != 1 ? "" : "/.avconv", preset_name);
950 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
956 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
958 char *codec_name = NULL;
960 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
962 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
963 NULL, ost->st->codec->codec_type);
964 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
965 } else if (!strcmp(codec_name, "copy"))
966 ost->stream_copy = 1;
968 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
969 ost->st->codec->codec_id = ost->enc->id;
973 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
976 AVStream *st = avformat_new_stream(oc, NULL);
977 int idx = oc->nb_streams - 1, ret = 0;
978 char *bsf = NULL, *next, *codec_tag = NULL;
979 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
984 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
988 if (oc->nb_streams - 1 < o->nb_streamid_map)
989 st->id = o->streamid_map[oc->nb_streams - 1];
991 GROW_ARRAY(output_streams, nb_output_streams);
992 if (!(ost = av_mallocz(sizeof(*ost))))
994 output_streams[nb_output_streams - 1] = ost;
996 ost->file_index = nb_output_files - 1;
999 st->codec->codec_type = type;
1000 choose_encoder(o, oc, ost);
1002 AVIOContext *s = NULL;
1003 char *buf = NULL, *arg = NULL, *preset = NULL;
1005 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1007 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1008 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1011 if (!buf[0] || buf[0] == '#') {
1015 if (!(arg = strchr(buf, '='))) {
1016 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1020 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1022 } while (!s->eof_reached);
1026 av_log(NULL, AV_LOG_FATAL,
1027 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1028 preset, ost->file_index, ost->index);
1032 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1035 avcodec_get_context_defaults3(st->codec, ost->enc);
1036 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1038 ost->max_frames = INT64_MAX;
1039 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1040 for (i = 0; i<o->nb_max_frames; i++) {
1041 char *p = o->max_frames[i].specifier;
1042 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1043 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1048 ost->copy_prior_start = -1;
1049 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1051 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1053 if (next = strchr(bsf, ','))
1055 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1056 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1060 bsfc_prev->next = bsfc;
1062 ost->bitstream_filters = bsfc;
1068 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1070 uint32_t tag = strtol(codec_tag, &next, 0);
1072 tag = AV_RL32(codec_tag);
1073 st->codec->codec_tag = tag;
1076 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1078 st->codec->flags |= CODEC_FLAG_QSCALE;
1079 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1082 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1083 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1085 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1087 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1088 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1089 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1091 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1093 ost->source_index = source_index;
1094 if (source_index >= 0) {
1095 ost->sync_ist = input_streams[source_index];
1096 input_streams[source_index]->discard = 0;
1097 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1099 ost->last_mux_dts = AV_NOPTS_VALUE;
1104 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1107 const char *p = str;
1114 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1121 /* read file contents into a string */
1122 static uint8_t *read_file(const char *filename)
1124 AVIOContext *pb = NULL;
1125 AVIOContext *dyn_buf = NULL;
1126 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1127 uint8_t buf[1024], *str;
1130 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1134 ret = avio_open_dyn_buf(&dyn_buf);
1139 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1140 avio_write(dyn_buf, buf, ret);
1141 avio_w8(dyn_buf, 0);
1144 ret = avio_close_dyn_buf(dyn_buf, &str);
1150 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1153 AVStream *st = ost->st;
1155 if (ost->filters_script && ost->filters) {
1156 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1157 "output stream #%d:%d.\n", nb_output_files, st->index);
1161 if (ost->filters_script)
1162 return read_file(ost->filters_script);
1163 else if (ost->filters)
1164 return av_strdup(ost->filters);
1166 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1170 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1171 const OutputStream *ost, enum AVMediaType type)
1173 if (ost->filters_script || ost->filters) {
1174 av_log(NULL, AV_LOG_ERROR,
1175 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1176 "Filtering and streamcopy cannot be used together.\n",
1177 ost->filters ? "Filtergraph" : "Filtergraph script",
1178 ost->filters ? ost->filters : ost->filters_script,
1179 av_get_media_type_string(type), ost->file_index, ost->index);
1184 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1188 AVCodecContext *video_enc;
1189 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1191 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1193 video_enc = st->codec;
1195 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1196 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1197 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1201 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1202 if (frame_aspect_ratio) {
1204 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1205 q.num <= 0 || q.den <= 0) {
1206 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1209 ost->frame_aspect_ratio = q;
1212 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1213 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1215 if (!ost->stream_copy) {
1216 const char *p = NULL;
1217 char *frame_size = NULL;
1218 char *frame_pix_fmt = NULL;
1219 char *intra_matrix = NULL, *inter_matrix = NULL;
1223 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1224 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1225 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1229 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1230 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1231 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1232 ost->keep_pix_fmt = 1;
1233 if (!*++frame_pix_fmt)
1234 frame_pix_fmt = NULL;
1236 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1237 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1240 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1243 video_enc->gop_size = 0;
1244 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1246 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1247 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1250 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1252 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1254 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1255 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1258 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1261 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1262 for (i = 0; p; i++) {
1264 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1266 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1269 /* FIXME realloc failure */
1270 video_enc->rc_override =
1271 av_realloc(video_enc->rc_override,
1272 sizeof(RcOverride) * (i + 1));
1273 video_enc->rc_override[i].start_frame = start;
1274 video_enc->rc_override[i].end_frame = end;
1276 video_enc->rc_override[i].qscale = q;
1277 video_enc->rc_override[i].quality_factor = 1.0;
1280 video_enc->rc_override[i].qscale = 0;
1281 video_enc->rc_override[i].quality_factor = -q/100.0;
1286 video_enc->rc_override_count = i;
1287 video_enc->intra_dc_precision = intra_dc_precision - 8;
1290 video_enc->flags|= CODEC_FLAG_PSNR;
1293 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1296 video_enc->flags |= CODEC_FLAG_PASS1;
1297 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1300 video_enc->flags |= CODEC_FLAG_PASS2;
1301 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1305 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1306 if (ost->logfile_prefix &&
1307 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1310 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1311 if (ost->forced_keyframes)
1312 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1314 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1316 ost->top_field_first = -1;
1317 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1320 ost->avfilter = get_ost_filters(o, oc, ost);
1324 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1327 if (ost->stream_copy)
1328 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1333 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1338 AVCodecContext *audio_enc;
1340 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1343 audio_enc = st->codec;
1344 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1346 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1347 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1349 if (!ost->stream_copy) {
1350 char *sample_fmt = NULL;
1352 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1354 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1356 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1357 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1361 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1363 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1364 ost->apad = av_strdup(ost->apad);
1366 ost->avfilter = get_ost_filters(o, oc, ost);
1370 /* check for channel mapping for this audio stream */
1371 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1372 AudioChannelMap *map = &o->audio_channel_maps[n];
1373 InputStream *ist = input_streams[ost->source_index];
1374 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1375 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1376 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1377 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1378 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1380 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1381 ost->file_index, ost->st->index);
1386 if (ost->stream_copy)
1387 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1392 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1396 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1397 if (!ost->stream_copy) {
1398 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1405 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1407 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1408 ost->stream_copy = 1;
1413 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1417 AVCodecContext *subtitle_enc;
1419 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1421 subtitle_enc = st->codec;
1423 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1425 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1427 if (!ost->stream_copy) {
1428 char *frame_size = NULL;
1430 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1431 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1432 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1440 /* arg format is "output-stream-index:streamid-value". */
1441 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1443 OptionsContext *o = optctx;
1448 av_strlcpy(idx_str, arg, sizeof(idx_str));
1449 p = strchr(idx_str, ':');
1451 av_log(NULL, AV_LOG_FATAL,
1452 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1457 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1458 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1459 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1463 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1465 AVFormatContext *is = ifile->ctx;
1466 AVFormatContext *os = ofile->ctx;
1470 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1472 return AVERROR(ENOMEM);
1475 for (i = 0; i < is->nb_chapters; i++) {
1476 AVChapter *in_ch = is->chapters[i], *out_ch;
1477 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1478 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1479 AV_TIME_BASE_Q, in_ch->time_base);
1480 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1481 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1484 if (in_ch->end < ts_off)
1486 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1489 out_ch = av_mallocz(sizeof(AVChapter));
1491 return AVERROR(ENOMEM);
1493 out_ch->id = in_ch->id;
1494 out_ch->time_base = in_ch->time_base;
1495 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1496 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1499 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1501 os->chapters[os->nb_chapters++] = out_ch;
1506 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1509 AVFormatContext *ic = avformat_alloc_context();
1511 ic->interrupt_callback = int_cb;
1512 err = avformat_open_input(&ic, filename, NULL, NULL);
1515 /* copy stream format */
1516 for(i=0;i<ic->nb_streams;i++) {
1520 AVCodecContext *avctx;
1522 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1523 ost = new_output_stream(o, s, codec->type, -1);
1528 // FIXME: a more elegant solution is needed
1529 memcpy(st, ic->streams[i], sizeof(AVStream));
1531 st->info = av_malloc(sizeof(*st->info));
1532 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1534 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1536 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1537 choose_sample_fmt(st, codec);
1538 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1539 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1542 avformat_close_input(&ic);
1546 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1547 AVFormatContext *oc)
1551 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1552 ofilter->out_tmp->pad_idx)) {
1553 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1554 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1556 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1561 ost->source_index = -1;
1562 ost->filter = ofilter;
1566 if (ost->stream_copy) {
1567 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1568 "which is fed from a complex filtergraph. Filtering and streamcopy "
1569 "cannot be used together.\n", ost->file_index, ost->index);
1573 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1574 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1575 av_log(NULL, AV_LOG_ERROR,
1576 "%s '%s' was specified through the %s option "
1577 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1578 "%s and -filter_complex cannot be used together for the same stream.\n",
1579 ost->filters ? "Filtergraph" : "Filtergraph script",
1580 ost->filters ? ost->filters : ost->filters_script,
1581 opt, ost->file_index, ost->index, opt);
1585 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1586 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1589 avfilter_inout_free(&ofilter->out_tmp);
1592 static int configure_complex_filters(void)
1596 for (i = 0; i < nb_filtergraphs; i++)
1597 if (!filtergraphs[i]->graph &&
1598 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1603 static int open_output_file(OptionsContext *o, const char *filename)
1605 AVFormatContext *oc;
1607 AVOutputFormat *file_oformat;
1611 AVDictionary *unused_opts = NULL;
1612 AVDictionaryEntry *e = NULL;
1614 if (configure_complex_filters() < 0) {
1615 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1619 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1620 o->stop_time = INT64_MAX;
1621 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1624 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1625 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1626 if (o->stop_time <= start_time) {
1627 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1628 o->stop_time = INT64_MAX;
1630 o->recording_time = o->stop_time - start_time;
1634 GROW_ARRAY(output_files, nb_output_files);
1635 of = av_mallocz(sizeof(*of));
1638 output_files[nb_output_files - 1] = of;
1640 of->ost_index = nb_output_streams;
1641 of->recording_time = o->recording_time;
1642 of->start_time = o->start_time;
1643 of->limit_filesize = o->limit_filesize;
1644 of->shortest = o->shortest;
1645 av_dict_copy(&of->opts, o->g->format_opts, 0);
1647 if (!strcmp(filename, "-"))
1650 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1652 print_error(filename, err);
1657 if (o->recording_time != INT64_MAX)
1658 oc->duration = o->recording_time;
1660 file_oformat= oc->oformat;
1661 oc->interrupt_callback = int_cb;
1663 /* create streams for all unlabeled output pads */
1664 for (i = 0; i < nb_filtergraphs; i++) {
1665 FilterGraph *fg = filtergraphs[i];
1666 for (j = 0; j < fg->nb_outputs; j++) {
1667 OutputFilter *ofilter = fg->outputs[j];
1669 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1672 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1673 ofilter->out_tmp->pad_idx)) {
1674 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1675 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1676 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1678 init_output_filter(ofilter, o, oc);
1682 /* ffserver seeking with date=... needs a date reference */
1683 if (!strcmp(file_oformat->name, "ffm") &&
1684 av_strstart(filename, "http:", NULL)) {
1685 int err = parse_option(o, "metadata", "creation_time=now", options);
1687 print_error(filename, err);
1692 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1693 av_strstart(filename, "http:", NULL)) {
1695 /* special case for files sent to ffserver: we get the stream
1696 parameters from ffserver */
1697 int err = read_ffserver_streams(o, oc, filename);
1699 print_error(filename, err);
1702 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1703 ost = output_streams[j];
1704 for (i = 0; i < nb_input_streams; i++) {
1705 ist = input_streams[i];
1706 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1708 ost->source_index= i;
1709 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1710 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1712 ist->st->discard = AVDISCARD_NONE;
1717 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));
1721 } else if (!o->nb_stream_maps) {
1722 char *subtitle_codec_name = NULL;
1723 /* pick the "best" stream of each type */
1725 /* video: highest resolution */
1726 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1727 int area = 0, idx = -1;
1728 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1729 for (i = 0; i < nb_input_streams; i++) {
1731 ist = input_streams[i];
1732 new_area = ist->st->codec->width * ist->st->codec->height;
1733 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1735 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1737 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1744 new_video_stream(o, oc, idx);
1747 /* audio: most channels */
1748 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1749 int channels = 0, idx = -1;
1750 for (i = 0; i < nb_input_streams; i++) {
1751 ist = input_streams[i];
1752 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1753 ist->st->codec->channels > channels) {
1754 channels = ist->st->codec->channels;
1759 new_audio_stream(o, oc, idx);
1762 /* subtitles: pick first */
1763 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1764 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1765 for (i = 0; i < nb_input_streams; i++)
1766 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1767 new_subtitle_stream(o, oc, i);
1771 /* do something with data? */
1773 for (i = 0; i < o->nb_stream_maps; i++) {
1774 StreamMap *map = &o->stream_maps[i];
1779 if (map->linklabel) {
1781 OutputFilter *ofilter = NULL;
1784 for (j = 0; j < nb_filtergraphs; j++) {
1785 fg = filtergraphs[j];
1786 for (k = 0; k < fg->nb_outputs; k++) {
1787 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1788 if (out && !strcmp(out->name, map->linklabel)) {
1789 ofilter = fg->outputs[k];
1796 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1797 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1800 init_output_filter(ofilter, o, oc);
1802 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1804 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1805 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1807 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1809 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1811 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1814 switch (ist->st->codec->codec_type) {
1815 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1816 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1817 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1818 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1819 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1821 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1822 map->file_index, map->stream_index);
1829 /* handle attached files */
1830 for (i = 0; i < o->nb_attachments; i++) {
1832 uint8_t *attachment;
1836 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1837 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1841 if ((len = avio_size(pb)) <= 0) {
1842 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1846 if (!(attachment = av_malloc(len))) {
1847 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1851 avio_read(pb, attachment, len);
1853 ost = new_attachment_stream(o, oc, -1);
1854 ost->stream_copy = 0;
1855 ost->attachment_filename = o->attachments[i];
1857 ost->st->codec->extradata = attachment;
1858 ost->st->codec->extradata_size = len;
1860 p = strrchr(o->attachments[i], '/');
1861 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1865 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1866 AVDictionaryEntry *e;
1867 ost = output_streams[i];
1869 if ((ost->stream_copy || ost->attachment_filename)
1870 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1871 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1872 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1876 /* check if all codec options have been used */
1877 unused_opts = strip_specifiers(o->g->codec_opts);
1878 for (i = of->ost_index; i < nb_output_streams; i++) {
1880 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1881 AV_DICT_IGNORE_SUFFIX)))
1882 av_dict_set(&unused_opts, e->key, NULL, 0);
1886 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1887 const AVClass *class = avcodec_get_class();
1888 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1889 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1892 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1893 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1894 "output file #%d (%s) is not an encoding option.\n", e->key,
1895 option->help ? option->help : "", nb_output_files - 1,
1900 // gop_timecode is injected by generic code but not always used
1901 if (!strcmp(e->key, "gop_timecode"))
1904 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1905 "output file #%d (%s) has not been used for any stream. The most "
1906 "likely reason is either wrong type (e.g. a video option with "
1907 "no video streams) or that it is a private option of some encoder "
1908 "which was not actually used for any stream.\n", e->key,
1909 option->help ? option->help : "", nb_output_files - 1, filename);
1911 av_dict_free(&unused_opts);
1913 /* check filename in case of an image number is expected */
1914 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1915 if (!av_filename_number_test(oc->filename)) {
1916 print_error(oc->filename, AVERROR(EINVAL));
1921 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1922 /* test if it already exists to avoid losing precious files */
1923 assert_file_overwrite(filename);
1926 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1927 &oc->interrupt_callback,
1929 print_error(filename, err);
1932 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1933 assert_file_overwrite(filename);
1935 if (o->mux_preload) {
1937 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1938 av_dict_set(&of->opts, "preload", buf, 0);
1940 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1943 for (i = 0; i < o->nb_metadata_map; i++) {
1945 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1947 if (in_file_index >= nb_input_files) {
1948 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1951 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1952 in_file_index >= 0 ?
1953 input_files[in_file_index]->ctx : NULL, o);
1957 if (o->chapters_input_file >= nb_input_files) {
1958 if (o->chapters_input_file == INT_MAX) {
1959 /* copy chapters from the first input file that has them*/
1960 o->chapters_input_file = -1;
1961 for (i = 0; i < nb_input_files; i++)
1962 if (input_files[i]->ctx->nb_chapters) {
1963 o->chapters_input_file = i;
1967 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1968 o->chapters_input_file);
1972 if (o->chapters_input_file >= 0)
1973 copy_chapters(input_files[o->chapters_input_file], of,
1974 !o->metadata_chapters_manual);
1976 /* copy global metadata by default */
1977 if (!o->metadata_global_manual && nb_input_files){
1978 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1979 AV_DICT_DONT_OVERWRITE);
1980 if(o->recording_time != INT64_MAX)
1981 av_dict_set(&oc->metadata, "duration", NULL, 0);
1982 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1984 if (!o->metadata_streams_manual)
1985 for (i = of->ost_index; i < nb_output_streams; i++) {
1987 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1989 ist = input_streams[output_streams[i]->source_index];
1990 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1993 /* process manually set metadata */
1994 for (i = 0; i < o->nb_metadata; i++) {
1997 const char *stream_spec;
1998 int index = 0, j, ret = 0;
2000 val = strchr(o->metadata[i].u.str, '=');
2002 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2003 o->metadata[i].u.str);
2008 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2010 for (j = 0; j < oc->nb_streams; j++) {
2011 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2012 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2023 if (index < 0 || index >= oc->nb_chapters) {
2024 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2027 m = &oc->chapters[index]->metadata;
2030 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2033 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2040 static int opt_target(void *optctx, const char *opt, const char *arg)
2042 OptionsContext *o = optctx;
2043 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2044 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2046 if (!strncmp(arg, "pal-", 4)) {
2049 } else if (!strncmp(arg, "ntsc-", 5)) {
2052 } else if (!strncmp(arg, "film-", 5)) {
2056 /* Try to determine PAL/NTSC by peeking in the input files */
2057 if (nb_input_files) {
2059 for (j = 0; j < nb_input_files; j++) {
2060 for (i = 0; i < input_files[j]->nb_streams; i++) {
2061 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2062 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2064 fr = c->time_base.den * 1000 / c->time_base.num;
2068 } else if ((fr == 29970) || (fr == 23976)) {
2073 if (norm != UNKNOWN)
2077 if (norm != UNKNOWN)
2078 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2081 if (norm == UNKNOWN) {
2082 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2083 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2084 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2088 if (!strcmp(arg, "vcd")) {
2089 opt_video_codec(o, "c:v", "mpeg1video");
2090 opt_audio_codec(o, "c:a", "mp2");
2091 parse_option(o, "f", "vcd", options);
2092 av_dict_set(&o->g->codec_opts, "b:v", arg, AV_DICT_DONT_OVERWRITE);
2094 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2095 parse_option(o, "r", frame_rates[norm], options);
2096 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2098 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2099 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2100 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2101 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2103 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2104 parse_option(o, "ar", "44100", options);
2105 parse_option(o, "ac", "2", options);
2107 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2108 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2110 /* We have to offset the PTS, so that it is consistent with the SCR.
2111 SCR starts at 36000, but the first two packs contain only padding
2112 and the first pack from the other stream, respectively, may also have
2113 been written before.
2114 So the real data starts at SCR 36000+3*1200. */
2115 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2116 } else if (!strcmp(arg, "svcd")) {
2118 opt_video_codec(o, "c:v", "mpeg2video");
2119 opt_audio_codec(o, "c:a", "mp2");
2120 parse_option(o, "f", "svcd", options);
2122 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2123 parse_option(o, "r", frame_rates[norm], options);
2124 parse_option(o, "pix_fmt", "yuv420p", options);
2125 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2127 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2128 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2129 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2130 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2131 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2133 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2134 parse_option(o, "ar", "44100", options);
2136 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2138 } else if (!strcmp(arg, "dvd")) {
2140 opt_video_codec(o, "c:v", "mpeg2video");
2141 opt_audio_codec(o, "c:a", "ac3");
2142 parse_option(o, "f", "dvd", options);
2144 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2145 parse_option(o, "r", frame_rates[norm], options);
2146 parse_option(o, "pix_fmt", "yuv420p", options);
2147 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2149 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2150 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2151 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2152 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2154 av_dict_set(&o->g->format_opts, "packetsize", "2048", AV_DICT_DONT_OVERWRITE); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2155 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2157 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2158 parse_option(o, "ar", "48000", options);
2160 } else if (!strncmp(arg, "dv", 2)) {
2162 parse_option(o, "f", "dv", options);
2164 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2165 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2166 norm == PAL ? "yuv420p" : "yuv411p", options);
2167 parse_option(o, "r", frame_rates[norm], options);
2169 parse_option(o, "ar", "48000", options);
2170 parse_option(o, "ac", "2", options);
2173 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2174 return AVERROR(EINVAL);
2179 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2181 av_free (vstats_filename);
2182 vstats_filename = av_strdup (arg);
2186 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2189 time_t today2 = time(NULL);
2190 struct tm *today = localtime(&today2);
2192 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2194 return opt_vstats_file(NULL, opt, filename);
2197 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2199 OptionsContext *o = optctx;
2200 return parse_option(o, "frames:v", arg, options);
2203 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2205 OptionsContext *o = optctx;
2206 return parse_option(o, "frames:a", arg, options);
2209 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2211 OptionsContext *o = optctx;
2212 return parse_option(o, "frames:d", arg, options);
2215 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2218 AVDictionary *cbak = codec_opts;
2219 AVDictionary *fbak = format_opts;
2223 ret = opt_default(NULL, opt, arg);
2225 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2226 av_dict_copy(&o->g->format_opts, format_opts, 0);
2227 av_dict_free(&codec_opts);
2228 av_dict_free(&format_opts);
2235 static int opt_preset(void *optctx, const char *opt, const char *arg)
2237 OptionsContext *o = optctx;
2239 char filename[1000], line[1000], tmp_line[1000];
2240 const char *codec_name = NULL;
2244 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2246 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2247 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2248 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2250 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2254 while (fgets(line, sizeof(line), f)) {
2255 char *key = tmp_line, *value, *endptr;
2257 if (strcspn(line, "#\n\r") == 0)
2259 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2260 if (!av_strtok(key, "=", &value) ||
2261 !av_strtok(value, "\r\n", &endptr)) {
2262 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2265 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2267 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2268 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2269 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2270 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2271 else if (opt_default_new(o, key, value) < 0) {
2272 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2273 filename, line, key, value);
2283 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2285 OptionsContext *o = optctx;
2286 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2287 int ret = parse_option(o, s, arg, options);
2292 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2294 OptionsContext *o = optctx;
2295 if(!strcmp(opt, "b")){
2296 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2297 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2300 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2304 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2306 OptionsContext *o = optctx;
2309 if(!strcmp(opt, "qscale")){
2310 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2311 return parse_option(o, "q:v", arg, options);
2313 s = av_asprintf("q%s", opt + 6);
2314 ret = parse_option(o, s, arg, options);
2319 static int opt_profile(void *optctx, const char *opt, const char *arg)
2321 OptionsContext *o = optctx;
2322 if(!strcmp(opt, "profile")){
2323 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2324 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2327 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2331 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2333 OptionsContext *o = optctx;
2334 return parse_option(o, "filter:v", arg, options);
2337 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2339 OptionsContext *o = optctx;
2340 return parse_option(o, "filter:a", arg, options);
2343 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2345 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2346 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2347 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2348 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2350 if (video_sync_method == VSYNC_AUTO)
2351 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2355 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2357 OptionsContext *o = optctx;
2358 char *tcr = av_asprintf("timecode=%s", arg);
2359 int ret = parse_option(o, "metadata:g", tcr, options);
2361 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2366 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2368 OptionsContext *o = optctx;
2369 char layout_str[32];
2372 int ret, channels, ac_str_size;
2375 layout = av_get_channel_layout(arg);
2377 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2378 return AVERROR(EINVAL);
2380 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2381 ret = opt_default_new(o, opt, layout_str);
2385 /* set 'ac' option based on channel layout */
2386 channels = av_get_channel_layout_nb_channels(layout);
2387 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2388 stream_str = strchr(opt, ':');
2389 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2390 ac_str = av_mallocz(ac_str_size);
2392 return AVERROR(ENOMEM);
2393 av_strlcpy(ac_str, "ac", 3);
2395 av_strlcat(ac_str, stream_str, ac_str_size);
2396 ret = parse_option(o, ac_str, layout_str, options);
2402 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2404 OptionsContext *o = optctx;
2405 return parse_option(o, "q:a", arg, options);
2408 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2410 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2411 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2412 return AVERROR(ENOMEM);
2413 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2414 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2415 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2416 return AVERROR(ENOMEM);
2420 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2422 uint8_t *graph_desc = read_file(arg);
2424 return AVERROR(EINVAL);
2426 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2427 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2428 return AVERROR(ENOMEM);
2429 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2430 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2434 void show_help_default(const char *opt, const char *arg)
2436 /* per-file options have at least one of those set */
2437 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2438 int show_advanced = 0, show_avoptions = 0;
2441 if (!strcmp(opt, "long"))
2443 else if (!strcmp(opt, "full"))
2444 show_advanced = show_avoptions = 1;
2446 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2451 printf("Getting help:\n"
2452 " -h -- print basic options\n"
2453 " -h long -- print more options\n"
2454 " -h full -- print all options (including all format and codec specific options, very long)\n"
2455 " See man %s for detailed description of the options.\n"
2456 "\n", program_name);
2458 show_help_options(options, "Print help / information / capabilities:",
2461 show_help_options(options, "Global options (affect whole program "
2462 "instead of just one file:",
2463 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2465 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2466 per_file | OPT_EXIT, 0);
2468 show_help_options(options, "Per-file main options:", 0,
2469 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2470 OPT_EXIT, per_file);
2472 show_help_options(options, "Advanced per-file options:",
2473 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2475 show_help_options(options, "Video options:",
2476 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2478 show_help_options(options, "Advanced Video options:",
2479 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2481 show_help_options(options, "Audio options:",
2482 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2484 show_help_options(options, "Advanced Audio options:",
2485 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2486 show_help_options(options, "Subtitle options:",
2487 OPT_SUBTITLE, 0, 0);
2490 if (show_avoptions) {
2491 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2492 show_help_children(avcodec_get_class(), flags);
2493 show_help_children(avformat_get_class(), flags);
2495 show_help_children(sws_get_class(), flags);
2497 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2498 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2502 void show_usage(void)
2504 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2505 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2506 av_log(NULL, AV_LOG_INFO, "\n");
2514 static const OptionGroupDef groups[] = {
2515 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2516 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2519 static int open_files(OptionGroupList *l, const char *inout,
2520 int (*open_file)(OptionsContext*, const char*))
2524 for (i = 0; i < l->nb_groups; i++) {
2525 OptionGroup *g = &l->groups[i];
2531 ret = parse_optgroup(&o, g);
2533 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2534 "%s.\n", inout, g->arg);
2538 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2539 ret = open_file(&o, g->arg);
2542 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2546 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2552 int ffmpeg_parse_options(int argc, char **argv)
2554 OptionParseContext octx;
2558 memset(&octx, 0, sizeof(octx));
2560 /* split the commandline into an internal representation */
2561 ret = split_commandline(&octx, argc, argv, options, groups,
2562 FF_ARRAY_ELEMS(groups));
2564 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2568 /* apply global options */
2569 ret = parse_optgroup(NULL, &octx.global_opts);
2571 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2575 /* open input files */
2576 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2578 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2582 /* open output files */
2583 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2585 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2590 uninit_parse_context(&octx);
2592 av_strerror(ret, error, sizeof(error));
2593 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2598 static int opt_progress(void *optctx, const char *opt, const char *arg)
2600 AVIOContext *avio = NULL;
2603 if (!strcmp(arg, "-"))
2605 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2607 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2608 arg, av_err2str(ret));
2611 progress_avio = avio;
2615 #define OFFSET(x) offsetof(OptionsContext, x)
2616 const OptionDef options[] = {
2618 #include "cmdutils_common_opts.h"
2619 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2620 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2621 "force format", "fmt" },
2622 { "y", OPT_BOOL, { &file_overwrite },
2623 "overwrite output files" },
2624 { "n", OPT_BOOL, { &no_file_overwrite },
2625 "never overwrite output files" },
2626 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2627 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2628 "codec name", "codec" },
2629 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2630 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2631 "codec name", "codec" },
2632 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2633 OPT_OUTPUT, { .off = OFFSET(presets) },
2634 "preset name", "preset" },
2635 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2636 OPT_OUTPUT, { .func_arg = opt_map },
2637 "set input stream mapping",
2638 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2639 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2640 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2641 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2642 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2643 "set metadata information of outfile from infile",
2644 "outfile[,metadata]:infile[,metadata]" },
2645 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2646 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2647 "set chapters mapping", "input_file_index" },
2648 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2649 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2650 "record or transcode \"duration\" seconds of audio/video",
2652 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2653 "record or transcode stop time", "time_stop" },
2654 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2655 "set the limit file size in bytes", "limit_size" },
2656 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2657 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2658 "set the start time offset", "time_off" },
2659 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2660 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2661 "enable/disable accurate seeking with -ss" },
2662 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2663 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2664 "set the input ts offset", "time_off" },
2665 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2666 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2667 "set the input ts scale", "scale" },
2668 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2669 "set the recording timestamp ('now' to set the current time)", "time" },
2670 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2671 "add metadata", "string=string" },
2672 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2673 OPT_OUTPUT, { .func_arg = opt_data_frames },
2674 "set the number of data frames to record", "number" },
2675 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2676 "add timings for benchmarking" },
2677 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2678 "add timings for each task" },
2679 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2680 "write program-readable progress information", "url" },
2681 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2682 "enable or disable interaction on standard input" },
2683 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2684 "set max runtime in seconds", "limit" },
2685 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2686 "dump each input packet" },
2687 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2688 "when dumping packets, also dump the payload" },
2689 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2690 OPT_INPUT, { .off = OFFSET(rate_emu) },
2691 "read input at native frame rate", "" },
2692 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2693 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2694 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2695 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2696 "video sync method", "" },
2697 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2698 "audio sync method", "" },
2699 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2700 "audio drift threshold", "threshold" },
2701 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2702 "copy timestamps" },
2703 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2704 "copy input stream time base when stream copying", "mode" },
2705 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2706 OPT_OUTPUT, { .off = OFFSET(shortest) },
2707 "finish encoding within shortest input" },
2708 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2709 OPT_OUTPUT, { .off = OFFSET(apad) },
2711 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2712 "timestamp discontinuity delta threshold", "threshold" },
2713 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2714 "timestamp error delta threshold", "threshold" },
2715 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2716 "exit on error", "error" },
2717 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2718 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2719 "copy initial non-keyframes" },
2720 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2721 "copy or discard frames before start time" },
2722 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2723 "set the number of frames to record", "number" },
2724 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2725 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2726 "force codec tag/fourcc", "fourcc/tag" },
2727 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2728 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2729 "use fixed quality scale (VBR)", "q" },
2730 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2731 OPT_OUTPUT, { .func_arg = opt_qscale },
2732 "use fixed quality scale (VBR)", "q" },
2733 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2734 "set profile", "profile" },
2735 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2736 "set stream filtergraph", "filter_graph" },
2737 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2738 "read stream filtergraph description from a file", "filename" },
2739 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2740 "reinit filtergraph on input parameter changes", "" },
2741 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2742 "create a complex filtergraph", "graph_description" },
2743 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2744 "create a complex filtergraph", "graph_description" },
2745 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2746 "read complex filtergraph description from a file", "filename" },
2747 { "stats", OPT_BOOL, { &print_stats },
2748 "print progress report during encoding", },
2749 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2750 OPT_OUTPUT, { .func_arg = opt_attach },
2751 "add an attachment to the output file", "filename" },
2752 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2753 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2754 "extract an attachment into a file", "filename" },
2755 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2756 "print timestamp debugging info" },
2757 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2758 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2761 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2762 "set the number of video frames to record", "number" },
2763 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2764 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2765 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2766 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2767 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2768 "set frame size (WxH or abbreviation)", "size" },
2769 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2770 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2771 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2772 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2773 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2774 "set pixel format", "format" },
2775 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2776 "set the number of bits per raw sample", "number" },
2777 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2778 "deprecated use -g 1" },
2779 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2781 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2782 "discard threshold", "n" },
2783 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2784 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2785 "rate control override for specific intervals", "override" },
2786 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2787 OPT_OUTPUT, { .func_arg = opt_video_codec },
2788 "force video codec ('copy' to copy stream)", "codec" },
2789 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2791 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2793 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2794 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2795 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2796 "select the pass number (1 to 3)", "n" },
2797 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2798 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2799 "select two pass log file name prefix", "prefix" },
2800 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2801 "this option is deprecated, use the yadif filter instead" },
2802 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2803 "calculate PSNR of compressed frames" },
2804 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2805 "dump video coding statistics to file" },
2806 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2807 "dump video coding statistics to file", "file" },
2808 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2809 "set video filters", "filter_graph" },
2810 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2811 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2812 "specify intra matrix coeffs", "matrix" },
2813 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2814 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2815 "specify inter matrix coeffs", "matrix" },
2816 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2817 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2818 "top=1/bottom=0/auto=-1 field first", "" },
2819 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2820 "intra_dc_precision", "precision" },
2821 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2822 OPT_OUTPUT, { .func_arg = opt_old2new },
2823 "force video tag/fourcc", "fourcc/tag" },
2824 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2825 "show QP histogram" },
2826 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2827 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2828 "force the selected framerate, disable the best supported framerate selection" },
2829 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2830 OPT_OUTPUT, { .func_arg = opt_streamid },
2831 "set the value of an outfile streamid", "streamIndex:value" },
2832 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2833 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2834 "force key frames at specified timestamps", "timestamps" },
2835 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2836 "video bitrate (please use -b:v)", "bitrate" },
2839 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2840 "set the number of audio frames to record", "number" },
2841 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2842 "set audio quality (codec-specific)", "quality", },
2843 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2844 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2845 "set audio sampling rate (in Hz)", "rate" },
2846 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2847 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2848 "set number of audio channels", "channels" },
2849 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2851 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2852 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2853 "force audio codec ('copy' to copy stream)", "codec" },
2854 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2855 OPT_OUTPUT, { .func_arg = opt_old2new },
2856 "force audio tag/fourcc", "fourcc/tag" },
2857 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2858 "change audio volume (256=normal)" , "volume" },
2859 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2860 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2861 "set sample format", "format" },
2862 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2863 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2864 "set channel layout", "layout" },
2865 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2866 "set audio filters", "filter_graph" },
2867 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2868 "set the maximum number of channels to try to guess the channel layout" },
2870 /* subtitle options */
2871 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2872 "disable subtitle" },
2873 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2874 "force subtitle codec ('copy' to copy stream)", "codec" },
2875 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2876 , "force subtitle tag/fourcc", "fourcc/tag" },
2877 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2878 "fix subtitles duration" },
2879 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2880 "set canvas size (WxH or abbreviation)", "size" },
2883 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2884 "deprecated, use -channel", "channel" },
2885 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2886 "deprecated, use -standard", "standard" },
2887 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2890 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2891 "set the maximum demux-decode delay", "seconds" },
2892 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2893 "set the initial demux-decode delay", "seconds" },
2894 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2895 "override the options from ffserver", "" },
2897 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2898 "A comma-separated list of bitstream filters", "bitstream_filters" },
2899 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2900 "deprecated", "audio bitstream_filters" },
2901 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2902 "deprecated", "video bitstream_filters" },
2904 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2905 "set the audio options to the indicated preset", "preset" },
2906 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2907 "set the video options to the indicated preset", "preset" },
2908 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2909 "set the subtitle options to the indicated preset", "preset" },
2910 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2911 "set options from indicated preset file", "filename" },
2912 /* data codec support */
2913 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2914 "force data codec ('copy' to copy stream)", "codec" },
2915 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },