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->input_ts_offset = o->input_ts_offset;
856 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
857 f->nb_streams = ic->nb_streams;
858 f->rate_emu = o->rate_emu;
859 f->accurate_seek = o->accurate_seek;
861 /* check if all codec options have been used */
862 unused_opts = strip_specifiers(o->g->codec_opts);
863 for (i = f->ist_index; i < nb_input_streams; i++) {
865 while ((e = av_dict_get(input_streams[i]->opts, "", e,
866 AV_DICT_IGNORE_SUFFIX)))
867 av_dict_set(&unused_opts, e->key, NULL, 0);
871 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
872 const AVClass *class = avcodec_get_class();
873 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
874 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
877 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
878 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
879 "input file #%d (%s) is not a decoding option.\n", e->key,
880 option->help ? option->help : "", nb_input_files - 1,
885 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
886 "input file #%d (%s) has not been used for any stream. The most "
887 "likely reason is either wrong type (e.g. a video option with "
888 "no video streams) or that it is a private option of some decoder "
889 "which was not actually used for any stream.\n", e->key,
890 option->help ? option->help : "", nb_input_files - 1, filename);
892 av_dict_free(&unused_opts);
894 for (i = 0; i < o->nb_dump_attachment; i++) {
897 for (j = 0; j < ic->nb_streams; j++) {
898 AVStream *st = ic->streams[j];
900 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
901 dump_attachment(st, o->dump_attachment[i].u.str);
905 for (i = 0; i < orig_nb_streams; i++)
906 av_dict_free(&opts[i]);
912 static uint8_t *get_line(AVIOContext *s)
918 if (avio_open_dyn_buf(&line) < 0) {
919 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
923 while ((c = avio_r8(s)) && c != '\n')
926 avio_close_dyn_buf(line, &buf);
931 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
935 const char *base[3] = { getenv("AVCONV_DATADIR"),
940 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
944 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
945 i != 1 ? "" : "/.avconv", codec_name, preset_name);
946 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
949 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
950 i != 1 ? "" : "/.avconv", preset_name);
951 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
957 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
959 char *codec_name = NULL;
961 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
963 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
964 NULL, ost->st->codec->codec_type);
965 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
966 } else if (!strcmp(codec_name, "copy"))
967 ost->stream_copy = 1;
969 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
970 ost->st->codec->codec_id = ost->enc->id;
974 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
977 AVStream *st = avformat_new_stream(oc, NULL);
978 int idx = oc->nb_streams - 1, ret = 0;
979 char *bsf = NULL, *next, *codec_tag = NULL;
980 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
985 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
989 if (oc->nb_streams - 1 < o->nb_streamid_map)
990 st->id = o->streamid_map[oc->nb_streams - 1];
992 GROW_ARRAY(output_streams, nb_output_streams);
993 if (!(ost = av_mallocz(sizeof(*ost))))
995 output_streams[nb_output_streams - 1] = ost;
997 ost->file_index = nb_output_files - 1;
1000 st->codec->codec_type = type;
1001 choose_encoder(o, oc, ost);
1003 AVIOContext *s = NULL;
1004 char *buf = NULL, *arg = NULL, *preset = NULL;
1006 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1008 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1009 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1012 if (!buf[0] || buf[0] == '#') {
1016 if (!(arg = strchr(buf, '='))) {
1017 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1021 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1023 } while (!s->eof_reached);
1027 av_log(NULL, AV_LOG_FATAL,
1028 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1029 preset, ost->file_index, ost->index);
1033 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1036 avcodec_get_context_defaults3(st->codec, ost->enc);
1037 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
1039 ost->max_frames = INT64_MAX;
1040 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1041 for (i = 0; i<o->nb_max_frames; i++) {
1042 char *p = o->max_frames[i].specifier;
1043 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1044 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1049 ost->copy_prior_start = -1;
1050 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1052 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1054 if (next = strchr(bsf, ','))
1056 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1057 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1061 bsfc_prev->next = bsfc;
1063 ost->bitstream_filters = bsfc;
1069 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1071 uint32_t tag = strtol(codec_tag, &next, 0);
1073 tag = AV_RL32(codec_tag);
1074 st->codec->codec_tag = tag;
1077 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1079 st->codec->flags |= CODEC_FLAG_QSCALE;
1080 st->codec->global_quality = FF_QP2LAMBDA * qscale;
1083 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1084 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1086 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1088 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1089 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1090 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1092 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1094 ost->source_index = source_index;
1095 if (source_index >= 0) {
1096 ost->sync_ist = input_streams[source_index];
1097 input_streams[source_index]->discard = 0;
1098 input_streams[source_index]->st->discard = AVDISCARD_NONE;
1100 ost->last_mux_dts = AV_NOPTS_VALUE;
1105 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1108 const char *p = str;
1115 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1122 /* read file contents into a string */
1123 static uint8_t *read_file(const char *filename)
1125 AVIOContext *pb = NULL;
1126 AVIOContext *dyn_buf = NULL;
1127 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1128 uint8_t buf[1024], *str;
1131 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1135 ret = avio_open_dyn_buf(&dyn_buf);
1140 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1141 avio_write(dyn_buf, buf, ret);
1142 avio_w8(dyn_buf, 0);
1145 ret = avio_close_dyn_buf(dyn_buf, &str);
1151 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1154 AVStream *st = ost->st;
1156 if (ost->filters_script && ost->filters) {
1157 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1158 "output stream #%d:%d.\n", nb_output_files, st->index);
1162 if (ost->filters_script)
1163 return read_file(ost->filters_script);
1164 else if (ost->filters)
1165 return av_strdup(ost->filters);
1167 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1171 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1172 const OutputStream *ost, enum AVMediaType type)
1174 if (ost->filters_script || ost->filters) {
1175 av_log(NULL, AV_LOG_ERROR,
1176 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1177 "Filtering and streamcopy cannot be used together.\n",
1178 ost->filters ? "Filtergraph" : "Filtergraph script",
1179 ost->filters ? ost->filters : ost->filters_script,
1180 av_get_media_type_string(type), ost->file_index, ost->index);
1185 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1189 AVCodecContext *video_enc;
1190 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1192 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1194 video_enc = st->codec;
1196 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1197 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1198 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1202 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1203 if (frame_aspect_ratio) {
1205 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1206 q.num <= 0 || q.den <= 0) {
1207 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1210 ost->frame_aspect_ratio = q;
1213 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1214 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1216 if (!ost->stream_copy) {
1217 const char *p = NULL;
1218 char *frame_size = NULL;
1219 char *frame_pix_fmt = NULL;
1220 char *intra_matrix = NULL, *inter_matrix = NULL;
1224 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1225 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1226 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1230 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1231 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1232 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1233 ost->keep_pix_fmt = 1;
1234 if (!*++frame_pix_fmt)
1235 frame_pix_fmt = NULL;
1237 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1238 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1241 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1244 video_enc->gop_size = 0;
1245 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1247 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1248 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1251 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1253 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1255 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1256 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1259 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1262 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1263 for (i = 0; p; i++) {
1265 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1267 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1270 /* FIXME realloc failure */
1271 video_enc->rc_override =
1272 av_realloc(video_enc->rc_override,
1273 sizeof(RcOverride) * (i + 1));
1274 video_enc->rc_override[i].start_frame = start;
1275 video_enc->rc_override[i].end_frame = end;
1277 video_enc->rc_override[i].qscale = q;
1278 video_enc->rc_override[i].quality_factor = 1.0;
1281 video_enc->rc_override[i].qscale = 0;
1282 video_enc->rc_override[i].quality_factor = -q/100.0;
1287 video_enc->rc_override_count = i;
1288 video_enc->intra_dc_precision = intra_dc_precision - 8;
1291 video_enc->flags|= CODEC_FLAG_PSNR;
1294 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1297 video_enc->flags |= CODEC_FLAG_PASS1;
1298 av_dict_set(&ost->opts, "flags", "+pass1", AV_DICT_APPEND);
1301 video_enc->flags |= CODEC_FLAG_PASS2;
1302 av_dict_set(&ost->opts, "flags", "+pass2", AV_DICT_APPEND);
1306 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1307 if (ost->logfile_prefix &&
1308 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1311 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1312 if (ost->forced_keyframes)
1313 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1315 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1317 ost->top_field_first = -1;
1318 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1321 ost->avfilter = get_ost_filters(o, oc, ost);
1325 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1328 if (ost->stream_copy)
1329 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1334 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1339 AVCodecContext *audio_enc;
1341 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1344 audio_enc = st->codec;
1345 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1347 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1348 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1350 if (!ost->stream_copy) {
1351 char *sample_fmt = NULL;
1353 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1355 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1357 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1358 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1362 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1364 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1365 ost->apad = av_strdup(ost->apad);
1367 ost->avfilter = get_ost_filters(o, oc, ost);
1371 /* check for channel mapping for this audio stream */
1372 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1373 AudioChannelMap *map = &o->audio_channel_maps[n];
1374 InputStream *ist = input_streams[ost->source_index];
1375 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1376 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1377 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1378 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1379 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1381 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1382 ost->file_index, ost->st->index);
1387 if (ost->stream_copy)
1388 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1393 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1397 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1398 if (!ost->stream_copy) {
1399 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1406 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1408 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1409 ost->stream_copy = 1;
1414 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1418 AVCodecContext *subtitle_enc;
1420 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1422 subtitle_enc = st->codec;
1424 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1426 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1428 if (!ost->stream_copy) {
1429 char *frame_size = NULL;
1431 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1432 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1433 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1441 /* arg format is "output-stream-index:streamid-value". */
1442 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1444 OptionsContext *o = optctx;
1449 av_strlcpy(idx_str, arg, sizeof(idx_str));
1450 p = strchr(idx_str, ':');
1452 av_log(NULL, AV_LOG_FATAL,
1453 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1458 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1459 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1460 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1464 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1466 AVFormatContext *is = ifile->ctx;
1467 AVFormatContext *os = ofile->ctx;
1471 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1473 return AVERROR(ENOMEM);
1476 for (i = 0; i < is->nb_chapters; i++) {
1477 AVChapter *in_ch = is->chapters[i], *out_ch;
1478 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1479 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1480 AV_TIME_BASE_Q, in_ch->time_base);
1481 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1482 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1485 if (in_ch->end < ts_off)
1487 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1490 out_ch = av_mallocz(sizeof(AVChapter));
1492 return AVERROR(ENOMEM);
1494 out_ch->id = in_ch->id;
1495 out_ch->time_base = in_ch->time_base;
1496 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1497 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1500 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1502 os->chapters[os->nb_chapters++] = out_ch;
1507 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1510 AVFormatContext *ic = avformat_alloc_context();
1512 ic->interrupt_callback = int_cb;
1513 err = avformat_open_input(&ic, filename, NULL, NULL);
1516 /* copy stream format */
1517 for(i=0;i<ic->nb_streams;i++) {
1521 AVCodecContext *avctx;
1523 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1524 ost = new_output_stream(o, s, codec->type, -1);
1529 // FIXME: a more elegant solution is needed
1530 memcpy(st, ic->streams[i], sizeof(AVStream));
1532 st->info = av_malloc(sizeof(*st->info));
1533 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1535 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1537 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1538 choose_sample_fmt(st, codec);
1539 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1540 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1543 avformat_close_input(&ic);
1547 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1548 AVFormatContext *oc)
1552 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1553 ofilter->out_tmp->pad_idx)) {
1554 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1555 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1557 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1562 ost->source_index = -1;
1563 ost->filter = ofilter;
1567 if (ost->stream_copy) {
1568 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1569 "which is fed from a complex filtergraph. Filtering and streamcopy "
1570 "cannot be used together.\n", ost->file_index, ost->index);
1574 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1575 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1576 av_log(NULL, AV_LOG_ERROR,
1577 "%s '%s' was specified through the %s option "
1578 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1579 "%s and -filter_complex cannot be used together for the same stream.\n",
1580 ost->filters ? "Filtergraph" : "Filtergraph script",
1581 ost->filters ? ost->filters : ost->filters_script,
1582 opt, ost->file_index, ost->index, opt);
1586 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1587 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1590 avfilter_inout_free(&ofilter->out_tmp);
1593 static int configure_complex_filters(void)
1597 for (i = 0; i < nb_filtergraphs; i++)
1598 if (!filtergraphs[i]->graph &&
1599 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1604 static int open_output_file(OptionsContext *o, const char *filename)
1606 AVFormatContext *oc;
1608 AVOutputFormat *file_oformat;
1612 AVDictionary *unused_opts = NULL;
1613 AVDictionaryEntry *e = NULL;
1615 if (configure_complex_filters() < 0) {
1616 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1620 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1621 o->stop_time = INT64_MAX;
1622 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1625 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1626 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1627 if (o->stop_time <= start_time) {
1628 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1629 o->stop_time = INT64_MAX;
1631 o->recording_time = o->stop_time - start_time;
1635 GROW_ARRAY(output_files, nb_output_files);
1636 of = av_mallocz(sizeof(*of));
1639 output_files[nb_output_files - 1] = of;
1641 of->ost_index = nb_output_streams;
1642 of->recording_time = o->recording_time;
1643 of->start_time = o->start_time;
1644 of->limit_filesize = o->limit_filesize;
1645 of->shortest = o->shortest;
1646 av_dict_copy(&of->opts, o->g->format_opts, 0);
1648 if (!strcmp(filename, "-"))
1651 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1653 print_error(filename, err);
1658 if (o->recording_time != INT64_MAX)
1659 oc->duration = o->recording_time;
1661 file_oformat= oc->oformat;
1662 oc->interrupt_callback = int_cb;
1664 /* create streams for all unlabeled output pads */
1665 for (i = 0; i < nb_filtergraphs; i++) {
1666 FilterGraph *fg = filtergraphs[i];
1667 for (j = 0; j < fg->nb_outputs; j++) {
1668 OutputFilter *ofilter = fg->outputs[j];
1670 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1673 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1674 ofilter->out_tmp->pad_idx)) {
1675 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1676 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1677 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1679 init_output_filter(ofilter, o, oc);
1683 /* ffserver seeking with date=... needs a date reference */
1684 if (!strcmp(file_oformat->name, "ffm") &&
1685 av_strstart(filename, "http:", NULL)) {
1686 int err = parse_option(o, "metadata", "creation_time=now", options);
1688 print_error(filename, err);
1693 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1694 av_strstart(filename, "http:", NULL)) {
1696 /* special case for files sent to ffserver: we get the stream
1697 parameters from ffserver */
1698 int err = read_ffserver_streams(o, oc, filename);
1700 print_error(filename, err);
1703 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1704 ost = output_streams[j];
1705 for (i = 0; i < nb_input_streams; i++) {
1706 ist = input_streams[i];
1707 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1709 ost->source_index= i;
1710 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1711 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1713 ist->st->discard = AVDISCARD_NONE;
1718 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));
1722 } else if (!o->nb_stream_maps) {
1723 char *subtitle_codec_name = NULL;
1724 /* pick the "best" stream of each type */
1726 /* video: highest resolution */
1727 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1728 int area = 0, idx = -1;
1729 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1730 for (i = 0; i < nb_input_streams; i++) {
1732 ist = input_streams[i];
1733 new_area = ist->st->codec->width * ist->st->codec->height;
1734 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1736 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1738 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1745 new_video_stream(o, oc, idx);
1748 /* audio: most channels */
1749 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1750 int channels = 0, idx = -1;
1751 for (i = 0; i < nb_input_streams; i++) {
1752 ist = input_streams[i];
1753 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1754 ist->st->codec->channels > channels) {
1755 channels = ist->st->codec->channels;
1760 new_audio_stream(o, oc, idx);
1763 /* subtitles: pick first */
1764 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1765 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1766 for (i = 0; i < nb_input_streams; i++)
1767 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1768 new_subtitle_stream(o, oc, i);
1772 /* do something with data? */
1774 for (i = 0; i < o->nb_stream_maps; i++) {
1775 StreamMap *map = &o->stream_maps[i];
1780 if (map->linklabel) {
1782 OutputFilter *ofilter = NULL;
1785 for (j = 0; j < nb_filtergraphs; j++) {
1786 fg = filtergraphs[j];
1787 for (k = 0; k < fg->nb_outputs; k++) {
1788 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1789 if (out && !strcmp(out->name, map->linklabel)) {
1790 ofilter = fg->outputs[k];
1797 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1798 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1801 init_output_filter(ofilter, o, oc);
1803 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1805 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1806 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1808 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1810 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1812 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1815 switch (ist->st->codec->codec_type) {
1816 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1817 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1818 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1819 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1820 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1822 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1823 map->file_index, map->stream_index);
1830 /* handle attached files */
1831 for (i = 0; i < o->nb_attachments; i++) {
1833 uint8_t *attachment;
1837 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1838 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1842 if ((len = avio_size(pb)) <= 0) {
1843 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1847 if (!(attachment = av_malloc(len))) {
1848 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1852 avio_read(pb, attachment, len);
1854 ost = new_attachment_stream(o, oc, -1);
1855 ost->stream_copy = 0;
1856 ost->attachment_filename = o->attachments[i];
1858 ost->st->codec->extradata = attachment;
1859 ost->st->codec->extradata_size = len;
1861 p = strrchr(o->attachments[i], '/');
1862 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1866 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1867 AVDictionaryEntry *e;
1868 ost = output_streams[i];
1870 if ((ost->stream_copy || ost->attachment_filename)
1871 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1872 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1873 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1877 /* check if all codec options have been used */
1878 unused_opts = strip_specifiers(o->g->codec_opts);
1879 for (i = of->ost_index; i < nb_output_streams; i++) {
1881 while ((e = av_dict_get(output_streams[i]->opts, "", e,
1882 AV_DICT_IGNORE_SUFFIX)))
1883 av_dict_set(&unused_opts, e->key, NULL, 0);
1887 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1888 const AVClass *class = avcodec_get_class();
1889 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1890 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1893 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1894 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1895 "output file #%d (%s) is not an encoding option.\n", e->key,
1896 option->help ? option->help : "", nb_output_files - 1,
1901 // gop_timecode is injected by generic code but not always used
1902 if (!strcmp(e->key, "gop_timecode"))
1905 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1906 "output file #%d (%s) has not been used for any stream. The most "
1907 "likely reason is either wrong type (e.g. a video option with "
1908 "no video streams) or that it is a private option of some encoder "
1909 "which was not actually used for any stream.\n", e->key,
1910 option->help ? option->help : "", nb_output_files - 1, filename);
1912 av_dict_free(&unused_opts);
1914 /* check filename in case of an image number is expected */
1915 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1916 if (!av_filename_number_test(oc->filename)) {
1917 print_error(oc->filename, AVERROR(EINVAL));
1922 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1923 /* test if it already exists to avoid losing precious files */
1924 assert_file_overwrite(filename);
1927 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1928 &oc->interrupt_callback,
1930 print_error(filename, err);
1933 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
1934 assert_file_overwrite(filename);
1936 if (o->mux_preload) {
1938 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1939 av_dict_set(&of->opts, "preload", buf, 0);
1941 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1944 for (i = 0; i < o->nb_metadata_map; i++) {
1946 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1948 if (in_file_index >= nb_input_files) {
1949 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1952 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1953 in_file_index >= 0 ?
1954 input_files[in_file_index]->ctx : NULL, o);
1958 if (o->chapters_input_file >= nb_input_files) {
1959 if (o->chapters_input_file == INT_MAX) {
1960 /* copy chapters from the first input file that has them*/
1961 o->chapters_input_file = -1;
1962 for (i = 0; i < nb_input_files; i++)
1963 if (input_files[i]->ctx->nb_chapters) {
1964 o->chapters_input_file = i;
1968 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1969 o->chapters_input_file);
1973 if (o->chapters_input_file >= 0)
1974 copy_chapters(input_files[o->chapters_input_file], of,
1975 !o->metadata_chapters_manual);
1977 /* copy global metadata by default */
1978 if (!o->metadata_global_manual && nb_input_files){
1979 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1980 AV_DICT_DONT_OVERWRITE);
1981 if(o->recording_time != INT64_MAX)
1982 av_dict_set(&oc->metadata, "duration", NULL, 0);
1983 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1985 if (!o->metadata_streams_manual)
1986 for (i = of->ost_index; i < nb_output_streams; i++) {
1988 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1990 ist = input_streams[output_streams[i]->source_index];
1991 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1994 /* process manually set metadata */
1995 for (i = 0; i < o->nb_metadata; i++) {
1998 const char *stream_spec;
1999 int index = 0, j, ret = 0;
2001 val = strchr(o->metadata[i].u.str, '=');
2003 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2004 o->metadata[i].u.str);
2009 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2011 for (j = 0; j < oc->nb_streams; j++) {
2012 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2013 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2024 if (index < 0 || index >= oc->nb_chapters) {
2025 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2028 m = &oc->chapters[index]->metadata;
2031 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2034 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2041 static int opt_target(void *optctx, const char *opt, const char *arg)
2043 OptionsContext *o = optctx;
2044 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2045 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2047 if (!strncmp(arg, "pal-", 4)) {
2050 } else if (!strncmp(arg, "ntsc-", 5)) {
2053 } else if (!strncmp(arg, "film-", 5)) {
2057 /* Try to determine PAL/NTSC by peeking in the input files */
2058 if (nb_input_files) {
2060 for (j = 0; j < nb_input_files; j++) {
2061 for (i = 0; i < input_files[j]->nb_streams; i++) {
2062 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2063 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2065 fr = c->time_base.den * 1000 / c->time_base.num;
2069 } else if ((fr == 29970) || (fr == 23976)) {
2074 if (norm != UNKNOWN)
2078 if (norm != UNKNOWN)
2079 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2082 if (norm == UNKNOWN) {
2083 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2084 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2085 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2089 if (!strcmp(arg, "vcd")) {
2090 opt_video_codec(o, "c:v", "mpeg1video");
2091 opt_audio_codec(o, "c:a", "mp2");
2092 parse_option(o, "f", "vcd", options);
2093 av_dict_set(&o->g->codec_opts, "b:v", arg, AV_DICT_DONT_OVERWRITE);
2095 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2096 parse_option(o, "r", frame_rates[norm], options);
2097 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2099 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2100 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2101 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2102 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2104 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2105 parse_option(o, "ar", "44100", options);
2106 parse_option(o, "ac", "2", options);
2108 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2109 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2111 /* We have to offset the PTS, so that it is consistent with the SCR.
2112 SCR starts at 36000, but the first two packs contain only padding
2113 and the first pack from the other stream, respectively, may also have
2114 been written before.
2115 So the real data starts at SCR 36000+3*1200. */
2116 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2117 } else if (!strcmp(arg, "svcd")) {
2119 opt_video_codec(o, "c:v", "mpeg2video");
2120 opt_audio_codec(o, "c:a", "mp2");
2121 parse_option(o, "f", "svcd", options);
2123 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2124 parse_option(o, "r", frame_rates[norm], options);
2125 parse_option(o, "pix_fmt", "yuv420p", options);
2126 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2128 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2129 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2130 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2131 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2132 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2134 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2135 parse_option(o, "ar", "44100", options);
2137 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2139 } else if (!strcmp(arg, "dvd")) {
2141 opt_video_codec(o, "c:v", "mpeg2video");
2142 opt_audio_codec(o, "c:a", "ac3");
2143 parse_option(o, "f", "dvd", options);
2145 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2146 parse_option(o, "r", frame_rates[norm], options);
2147 parse_option(o, "pix_fmt", "yuv420p", options);
2148 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2150 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2151 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2152 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2153 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2155 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.
2156 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2158 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2159 parse_option(o, "ar", "48000", options);
2161 } else if (!strncmp(arg, "dv", 2)) {
2163 parse_option(o, "f", "dv", options);
2165 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2166 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2167 norm == PAL ? "yuv420p" : "yuv411p", options);
2168 parse_option(o, "r", frame_rates[norm], options);
2170 parse_option(o, "ar", "48000", options);
2171 parse_option(o, "ac", "2", options);
2174 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2175 return AVERROR(EINVAL);
2180 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2182 av_free (vstats_filename);
2183 vstats_filename = av_strdup (arg);
2187 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2190 time_t today2 = time(NULL);
2191 struct tm *today = localtime(&today2);
2193 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2195 return opt_vstats_file(NULL, opt, filename);
2198 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2200 OptionsContext *o = optctx;
2201 return parse_option(o, "frames:v", arg, options);
2204 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2206 OptionsContext *o = optctx;
2207 return parse_option(o, "frames:a", arg, options);
2210 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2212 OptionsContext *o = optctx;
2213 return parse_option(o, "frames:d", arg, options);
2216 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2219 AVDictionary *cbak = codec_opts;
2220 AVDictionary *fbak = format_opts;
2224 ret = opt_default(NULL, opt, arg);
2226 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2227 av_dict_copy(&o->g->format_opts, format_opts, 0);
2228 av_dict_free(&codec_opts);
2229 av_dict_free(&format_opts);
2236 static int opt_preset(void *optctx, const char *opt, const char *arg)
2238 OptionsContext *o = optctx;
2240 char filename[1000], line[1000], tmp_line[1000];
2241 const char *codec_name = NULL;
2245 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2247 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2248 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2249 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2251 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2255 while (fgets(line, sizeof(line), f)) {
2256 char *key = tmp_line, *value, *endptr;
2258 if (strcspn(line, "#\n\r") == 0)
2260 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2261 if (!av_strtok(key, "=", &value) ||
2262 !av_strtok(value, "\r\n", &endptr)) {
2263 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2266 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2268 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2269 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2270 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2271 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2272 else if (opt_default_new(o, key, value) < 0) {
2273 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2274 filename, line, key, value);
2284 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2286 OptionsContext *o = optctx;
2287 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2288 int ret = parse_option(o, s, arg, options);
2293 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2295 OptionsContext *o = optctx;
2296 if(!strcmp(opt, "b")){
2297 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2298 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2301 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2305 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2307 OptionsContext *o = optctx;
2310 if(!strcmp(opt, "qscale")){
2311 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2312 return parse_option(o, "q:v", arg, options);
2314 s = av_asprintf("q%s", opt + 6);
2315 ret = parse_option(o, s, arg, options);
2320 static int opt_profile(void *optctx, const char *opt, const char *arg)
2322 OptionsContext *o = optctx;
2323 if(!strcmp(opt, "profile")){
2324 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2325 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2328 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2332 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2334 OptionsContext *o = optctx;
2335 return parse_option(o, "filter:v", arg, options);
2338 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2340 OptionsContext *o = optctx;
2341 return parse_option(o, "filter:a", arg, options);
2344 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2346 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2347 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2348 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2349 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2351 if (video_sync_method == VSYNC_AUTO)
2352 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2356 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2358 OptionsContext *o = optctx;
2359 char *tcr = av_asprintf("timecode=%s", arg);
2360 int ret = parse_option(o, "metadata:g", tcr, options);
2362 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2367 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2369 OptionsContext *o = optctx;
2370 char layout_str[32];
2373 int ret, channels, ac_str_size;
2376 layout = av_get_channel_layout(arg);
2378 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2379 return AVERROR(EINVAL);
2381 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2382 ret = opt_default_new(o, opt, layout_str);
2386 /* set 'ac' option based on channel layout */
2387 channels = av_get_channel_layout_nb_channels(layout);
2388 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2389 stream_str = strchr(opt, ':');
2390 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2391 ac_str = av_mallocz(ac_str_size);
2393 return AVERROR(ENOMEM);
2394 av_strlcpy(ac_str, "ac", 3);
2396 av_strlcat(ac_str, stream_str, ac_str_size);
2397 ret = parse_option(o, ac_str, layout_str, options);
2403 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2405 OptionsContext *o = optctx;
2406 return parse_option(o, "q:a", arg, options);
2409 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2411 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2412 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2413 return AVERROR(ENOMEM);
2414 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2415 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2416 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2417 return AVERROR(ENOMEM);
2421 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2423 uint8_t *graph_desc = read_file(arg);
2425 return AVERROR(EINVAL);
2427 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2428 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2429 return AVERROR(ENOMEM);
2430 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2431 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2435 void show_help_default(const char *opt, const char *arg)
2437 /* per-file options have at least one of those set */
2438 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2439 int show_advanced = 0, show_avoptions = 0;
2442 if (!strcmp(opt, "long"))
2444 else if (!strcmp(opt, "full"))
2445 show_advanced = show_avoptions = 1;
2447 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2452 printf("Getting help:\n"
2453 " -h -- print basic options\n"
2454 " -h long -- print more options\n"
2455 " -h full -- print all options (including all format and codec specific options, very long)\n"
2456 " See man %s for detailed description of the options.\n"
2457 "\n", program_name);
2459 show_help_options(options, "Print help / information / capabilities:",
2462 show_help_options(options, "Global options (affect whole program "
2463 "instead of just one file:",
2464 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2466 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2467 per_file | OPT_EXIT, 0);
2469 show_help_options(options, "Per-file main options:", 0,
2470 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2471 OPT_EXIT, per_file);
2473 show_help_options(options, "Advanced per-file options:",
2474 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2476 show_help_options(options, "Video options:",
2477 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2479 show_help_options(options, "Advanced Video options:",
2480 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2482 show_help_options(options, "Audio options:",
2483 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2485 show_help_options(options, "Advanced Audio options:",
2486 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2487 show_help_options(options, "Subtitle options:",
2488 OPT_SUBTITLE, 0, 0);
2491 if (show_avoptions) {
2492 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2493 show_help_children(avcodec_get_class(), flags);
2494 show_help_children(avformat_get_class(), flags);
2496 show_help_children(sws_get_class(), flags);
2498 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2499 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2503 void show_usage(void)
2505 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2506 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2507 av_log(NULL, AV_LOG_INFO, "\n");
2515 static const OptionGroupDef groups[] = {
2516 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2517 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2520 static int open_files(OptionGroupList *l, const char *inout,
2521 int (*open_file)(OptionsContext*, const char*))
2525 for (i = 0; i < l->nb_groups; i++) {
2526 OptionGroup *g = &l->groups[i];
2532 ret = parse_optgroup(&o, g);
2534 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2535 "%s.\n", inout, g->arg);
2539 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2540 ret = open_file(&o, g->arg);
2543 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2547 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2553 int ffmpeg_parse_options(int argc, char **argv)
2555 OptionParseContext octx;
2559 memset(&octx, 0, sizeof(octx));
2561 /* split the commandline into an internal representation */
2562 ret = split_commandline(&octx, argc, argv, options, groups,
2563 FF_ARRAY_ELEMS(groups));
2565 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2569 /* apply global options */
2570 ret = parse_optgroup(NULL, &octx.global_opts);
2572 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2576 /* open input files */
2577 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2579 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2583 /* open output files */
2584 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2586 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2591 uninit_parse_context(&octx);
2593 av_strerror(ret, error, sizeof(error));
2594 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2599 static int opt_progress(void *optctx, const char *opt, const char *arg)
2601 AVIOContext *avio = NULL;
2604 if (!strcmp(arg, "-"))
2606 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2608 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2609 arg, av_err2str(ret));
2612 progress_avio = avio;
2616 #define OFFSET(x) offsetof(OptionsContext, x)
2617 const OptionDef options[] = {
2619 #include "cmdutils_common_opts.h"
2620 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2621 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2622 "force format", "fmt" },
2623 { "y", OPT_BOOL, { &file_overwrite },
2624 "overwrite output files" },
2625 { "n", OPT_BOOL, { &no_file_overwrite },
2626 "never overwrite output files" },
2627 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2628 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2629 "codec name", "codec" },
2630 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2631 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2632 "codec name", "codec" },
2633 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2634 OPT_OUTPUT, { .off = OFFSET(presets) },
2635 "preset name", "preset" },
2636 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2637 OPT_OUTPUT, { .func_arg = opt_map },
2638 "set input stream mapping",
2639 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2640 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2641 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2642 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2643 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2644 "set metadata information of outfile from infile",
2645 "outfile[,metadata]:infile[,metadata]" },
2646 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2647 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2648 "set chapters mapping", "input_file_index" },
2649 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2650 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2651 "record or transcode \"duration\" seconds of audio/video",
2653 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2654 "record or transcode stop time", "time_stop" },
2655 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2656 "set the limit file size in bytes", "limit_size" },
2657 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2658 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2659 "set the start time offset", "time_off" },
2660 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2661 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2662 "enable/disable accurate seeking with -ss" },
2663 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2664 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2665 "set the input ts offset", "time_off" },
2666 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2667 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2668 "set the input ts scale", "scale" },
2669 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2670 "set the recording timestamp ('now' to set the current time)", "time" },
2671 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2672 "add metadata", "string=string" },
2673 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2674 OPT_OUTPUT, { .func_arg = opt_data_frames },
2675 "set the number of data frames to record", "number" },
2676 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2677 "add timings for benchmarking" },
2678 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2679 "add timings for each task" },
2680 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2681 "write program-readable progress information", "url" },
2682 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2683 "enable or disable interaction on standard input" },
2684 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2685 "set max runtime in seconds", "limit" },
2686 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2687 "dump each input packet" },
2688 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2689 "when dumping packets, also dump the payload" },
2690 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2691 OPT_INPUT, { .off = OFFSET(rate_emu) },
2692 "read input at native frame rate", "" },
2693 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2694 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2695 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2696 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2697 "video sync method", "" },
2698 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2699 "audio sync method", "" },
2700 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2701 "audio drift threshold", "threshold" },
2702 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2703 "copy timestamps" },
2704 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2705 "copy input stream time base when stream copying", "mode" },
2706 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2707 OPT_OUTPUT, { .off = OFFSET(shortest) },
2708 "finish encoding within shortest input" },
2709 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2710 OPT_OUTPUT, { .off = OFFSET(apad) },
2712 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2713 "timestamp discontinuity delta threshold", "threshold" },
2714 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2715 "timestamp error delta threshold", "threshold" },
2716 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2717 "exit on error", "error" },
2718 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2719 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2720 "copy initial non-keyframes" },
2721 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2722 "copy or discard frames before start time" },
2723 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2724 "set the number of frames to record", "number" },
2725 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2726 OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(codec_tags) },
2727 "force codec tag/fourcc", "fourcc/tag" },
2728 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2729 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2730 "use fixed quality scale (VBR)", "q" },
2731 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2732 OPT_OUTPUT, { .func_arg = opt_qscale },
2733 "use fixed quality scale (VBR)", "q" },
2734 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2735 "set profile", "profile" },
2736 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2737 "set stream filtergraph", "filter_graph" },
2738 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2739 "read stream filtergraph description from a file", "filename" },
2740 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2741 "reinit filtergraph on input parameter changes", "" },
2742 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2743 "create a complex filtergraph", "graph_description" },
2744 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2745 "create a complex filtergraph", "graph_description" },
2746 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2747 "read complex filtergraph description from a file", "filename" },
2748 { "stats", OPT_BOOL, { &print_stats },
2749 "print progress report during encoding", },
2750 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2751 OPT_OUTPUT, { .func_arg = opt_attach },
2752 "add an attachment to the output file", "filename" },
2753 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2754 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2755 "extract an attachment into a file", "filename" },
2756 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2757 "print timestamp debugging info" },
2758 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2759 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2762 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2763 "set the number of video frames to record", "number" },
2764 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2765 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2766 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2767 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2768 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2769 "set frame size (WxH or abbreviation)", "size" },
2770 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2771 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2772 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2773 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2774 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2775 "set pixel format", "format" },
2776 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2777 "set the number of bits per raw sample", "number" },
2778 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2779 "deprecated use -g 1" },
2780 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2782 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2783 "discard threshold", "n" },
2784 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2785 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2786 "rate control override for specific intervals", "override" },
2787 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2788 OPT_OUTPUT, { .func_arg = opt_video_codec },
2789 "force video codec ('copy' to copy stream)", "codec" },
2790 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2792 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2794 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2795 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2796 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2797 "select the pass number (1 to 3)", "n" },
2798 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2799 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2800 "select two pass log file name prefix", "prefix" },
2801 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2802 "this option is deprecated, use the yadif filter instead" },
2803 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2804 "calculate PSNR of compressed frames" },
2805 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2806 "dump video coding statistics to file" },
2807 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2808 "dump video coding statistics to file", "file" },
2809 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2810 "set video filters", "filter_graph" },
2811 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2812 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2813 "specify intra matrix coeffs", "matrix" },
2814 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2815 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2816 "specify inter matrix coeffs", "matrix" },
2817 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2818 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2819 "top=1/bottom=0/auto=-1 field first", "" },
2820 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2821 "intra_dc_precision", "precision" },
2822 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2823 OPT_OUTPUT, { .func_arg = opt_old2new },
2824 "force video tag/fourcc", "fourcc/tag" },
2825 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2826 "show QP histogram" },
2827 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2828 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2829 "force the selected framerate, disable the best supported framerate selection" },
2830 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2831 OPT_OUTPUT, { .func_arg = opt_streamid },
2832 "set the value of an outfile streamid", "streamIndex:value" },
2833 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2834 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2835 "force key frames at specified timestamps", "timestamps" },
2836 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2837 "video bitrate (please use -b:v)", "bitrate" },
2840 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2841 "set the number of audio frames to record", "number" },
2842 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2843 "set audio quality (codec-specific)", "quality", },
2844 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2845 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2846 "set audio sampling rate (in Hz)", "rate" },
2847 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2848 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2849 "set number of audio channels", "channels" },
2850 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2852 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2853 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2854 "force audio codec ('copy' to copy stream)", "codec" },
2855 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2856 OPT_OUTPUT, { .func_arg = opt_old2new },
2857 "force audio tag/fourcc", "fourcc/tag" },
2858 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2859 "change audio volume (256=normal)" , "volume" },
2860 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2861 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2862 "set sample format", "format" },
2863 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2864 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2865 "set channel layout", "layout" },
2866 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2867 "set audio filters", "filter_graph" },
2868 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2869 "set the maximum number of channels to try to guess the channel layout" },
2871 /* subtitle options */
2872 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2873 "disable subtitle" },
2874 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2875 "force subtitle codec ('copy' to copy stream)", "codec" },
2876 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2877 , "force subtitle tag/fourcc", "fourcc/tag" },
2878 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2879 "fix subtitles duration" },
2880 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2881 "set canvas size (WxH or abbreviation)", "size" },
2884 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2885 "deprecated, use -channel", "channel" },
2886 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2887 "deprecated, use -standard", "standard" },
2888 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2891 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2892 "set the maximum demux-decode delay", "seconds" },
2893 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2894 "set the initial demux-decode delay", "seconds" },
2895 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
2896 "override the options from ffserver", "" },
2898 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2899 "A comma-separated list of bitstream filters", "bitstream_filters" },
2900 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2901 "deprecated", "audio bitstream_filters" },
2902 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
2903 "deprecated", "video bitstream_filters" },
2905 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2906 "set the audio options to the indicated preset", "preset" },
2907 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2908 "set the video options to the indicated preset", "preset" },
2909 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2910 "set the subtitle options to the indicated preset", "preset" },
2911 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
2912 "set options from indicated preset file", "filename" },
2913 /* data codec support */
2914 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2915 "force data codec ('copy' to copy stream)", "codec" },
2916 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },