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;\
66 const HWAccel hwaccels[] = {
68 { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71 { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74 { "vda", vda_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
79 char *vstats_filename;
81 float audio_drift_threshold = 0.1;
82 float dts_delta_threshold = 10;
83 float dts_error_threshold = 3600*30;
85 int audio_volume = 256;
86 int audio_sync_method = 0;
87 int video_sync_method = VSYNC_AUTO;
88 int do_deinterlace = 0;
90 int do_benchmark_all = 0;
96 int exit_on_error = 0;
99 int stdin_interaction = 1;
100 int frame_bits_per_raw_sample = 0;
101 float max_error_rate = 2.0/3;
104 static int intra_only = 0;
105 static int file_overwrite = 0;
106 static int no_file_overwrite = 0;
107 static int intra_dc_precision = 8;
108 static int do_psnr = 0;
109 static int input_sync;
110 static int override_ffserver = 0;
112 static void uninit_options(OptionsContext *o)
114 const OptionDef *po = options;
117 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
119 void *dst = (uint8_t*)o + po->u.off;
121 if (po->flags & OPT_SPEC) {
122 SpecifierOpt **so = dst;
123 int i, *count = (int*)(so + 1);
124 for (i = 0; i < *count; i++) {
125 av_freep(&(*so)[i].specifier);
126 if (po->flags & OPT_STRING)
127 av_freep(&(*so)[i].u.str);
131 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
136 for (i = 0; i < o->nb_stream_maps; i++)
137 av_freep(&o->stream_maps[i].linklabel);
138 av_freep(&o->stream_maps);
139 av_freep(&o->audio_channel_maps);
140 av_freep(&o->streamid_map);
141 av_freep(&o->attachments);
144 static void init_options(OptionsContext *o)
146 memset(o, 0, sizeof(*o));
148 o->stop_time = INT64_MAX;
149 o->mux_max_delay = 0.7;
150 o->start_time = AV_NOPTS_VALUE;
151 o->recording_time = INT64_MAX;
152 o->limit_filesize = UINT64_MAX;
153 o->chapters_input_file = INT_MAX;
154 o->accurate_seek = 1;
157 /* return a copy of the input with the stream specifiers removed from the keys */
158 static AVDictionary *strip_specifiers(AVDictionary *dict)
160 AVDictionaryEntry *e = NULL;
161 AVDictionary *ret = NULL;
163 while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
164 char *p = strchr(e->key, ':');
168 av_dict_set(&ret, e->key, e->value, 0);
175 static int opt_sameq(void *optctx, const char *opt, const char *arg)
177 av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
178 "If you are looking for an option to preserve the quality (which is not "
179 "what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
181 return AVERROR(EINVAL);
184 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
186 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
187 return opt_default(optctx, "channel", arg);
190 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
192 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
193 return opt_default(optctx, "standard", arg);
196 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
198 OptionsContext *o = optctx;
199 return parse_option(o, "codec:a", arg, options);
202 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
204 OptionsContext *o = optctx;
205 return parse_option(o, "codec:v", arg, options);
208 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
210 OptionsContext *o = optctx;
211 return parse_option(o, "codec:s", arg, options);
214 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
216 OptionsContext *o = optctx;
217 return parse_option(o, "codec:d", arg, options);
220 static int opt_map(void *optctx, const char *opt, const char *arg)
222 OptionsContext *o = optctx;
224 int i, negative = 0, file_idx;
225 int sync_file_idx = -1, sync_stream_idx = 0;
233 map = av_strdup(arg);
235 /* parse sync stream first, just pick first matching stream */
236 if (sync = strchr(map, ',')) {
238 sync_file_idx = strtol(sync + 1, &sync, 0);
239 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
240 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
245 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
246 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
247 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
251 if (i == input_files[sync_file_idx]->nb_streams) {
252 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
253 "match any streams.\n", arg);
260 /* this mapping refers to lavfi output */
261 const char *c = map + 1;
262 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
263 m = &o->stream_maps[o->nb_stream_maps - 1];
264 m->linklabel = av_get_token(&c, "]");
266 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
270 file_idx = strtol(map, &p, 0);
271 if (file_idx >= nb_input_files || file_idx < 0) {
272 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
276 /* disable some already defined maps */
277 for (i = 0; i < o->nb_stream_maps; i++) {
278 m = &o->stream_maps[i];
279 if (file_idx == m->file_index &&
280 check_stream_specifier(input_files[m->file_index]->ctx,
281 input_files[m->file_index]->ctx->streams[m->stream_index],
282 *p == ':' ? p + 1 : p) > 0)
286 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
287 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
288 *p == ':' ? p + 1 : p) <= 0)
290 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
291 m = &o->stream_maps[o->nb_stream_maps - 1];
293 m->file_index = file_idx;
296 if (sync_file_idx >= 0) {
297 m->sync_file_index = sync_file_idx;
298 m->sync_stream_index = sync_stream_idx;
300 m->sync_file_index = file_idx;
301 m->sync_stream_index = i;
307 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
315 static int opt_attach(void *optctx, const char *opt, const char *arg)
317 OptionsContext *o = optctx;
318 GROW_ARRAY(o->attachments, o->nb_attachments);
319 o->attachments[o->nb_attachments - 1] = arg;
323 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
325 OptionsContext *o = optctx;
330 GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
331 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
333 /* muted channel syntax */
334 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
335 if ((n == 1 || n == 3) && m->channel_idx == -1) {
336 m->file_idx = m->stream_idx = -1;
338 m->ofile_idx = m->ostream_idx = -1;
343 n = sscanf(arg, "%d.%d.%d:%d.%d",
344 &m->file_idx, &m->stream_idx, &m->channel_idx,
345 &m->ofile_idx, &m->ostream_idx);
347 if (n != 3 && n != 5) {
348 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
349 "[file.stream.channel|-1][:syncfile:syncstream]\n");
353 if (n != 5) // only file.stream.channel specified
354 m->ofile_idx = m->ostream_idx = -1;
357 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
358 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
362 if (m->stream_idx < 0 ||
363 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
364 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
365 m->file_idx, m->stream_idx);
368 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
369 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
370 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
371 m->file_idx, m->stream_idx);
374 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
375 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
376 m->file_idx, m->stream_idx, m->channel_idx);
383 * Parse a metadata specifier passed as 'arg' parameter.
384 * @param arg metadata string to parse
385 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
386 * @param index for type c/p, chapter/program index is written here
387 * @param stream_spec for type s, the stream specifier is written here
389 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
397 if (*(++arg) && *arg != ':') {
398 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
401 *stream_spec = *arg == ':' ? arg + 1 : "";
406 *index = strtol(++arg, NULL, 0);
409 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
416 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
418 AVDictionary **meta_in = NULL;
419 AVDictionary **meta_out = NULL;
421 char type_in, type_out;
422 const char *istream_spec = NULL, *ostream_spec = NULL;
423 int idx_in = 0, idx_out = 0;
425 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
426 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
429 if (type_out == 'g' || !*outspec)
430 o->metadata_global_manual = 1;
431 if (type_out == 's' || !*outspec)
432 o->metadata_streams_manual = 1;
433 if (type_out == 'c' || !*outspec)
434 o->metadata_chapters_manual = 1;
438 if (type_in == 'g' || type_out == 'g')
439 o->metadata_global_manual = 1;
440 if (type_in == 's' || type_out == 's')
441 o->metadata_streams_manual = 1;
442 if (type_in == 'c' || type_out == 'c')
443 o->metadata_chapters_manual = 1;
445 /* ic is NULL when just disabling automatic mappings */
449 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
450 if ((index) < 0 || (index) >= (nb_elems)) {\
451 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
456 #define SET_DICT(type, meta, context, index)\
459 meta = &context->metadata;\
462 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
463 meta = &context->chapters[index]->metadata;\
466 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
467 meta = &context->programs[index]->metadata;\
470 break; /* handled separately below */ \
471 default: av_assert0(0);\
474 SET_DICT(type_in, meta_in, ic, idx_in);
475 SET_DICT(type_out, meta_out, oc, idx_out);
477 /* for input streams choose first matching stream */
478 if (type_in == 's') {
479 for (i = 0; i < ic->nb_streams; i++) {
480 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
481 meta_in = &ic->streams[i]->metadata;
487 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
492 if (type_out == 's') {
493 for (i = 0; i < oc->nb_streams; i++) {
494 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
495 meta_out = &oc->streams[i]->metadata;
496 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
501 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
506 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
508 OptionsContext *o = optctx;
510 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
511 struct tm time = *gmtime((time_t*)&recording_timestamp);
512 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
513 parse_option(o, "metadata", buf, options);
515 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
516 "tag instead.\n", opt);
520 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
522 const AVCodecDescriptor *desc;
523 const char *codec_string = encoder ? "encoder" : "decoder";
527 avcodec_find_encoder_by_name(name) :
528 avcodec_find_decoder_by_name(name);
530 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
531 codec = encoder ? avcodec_find_encoder(desc->id) :
532 avcodec_find_decoder(desc->id);
534 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
535 codec_string, codec->name, desc->name);
539 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
542 if (codec->type != type) {
543 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
549 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
551 char *codec_name = NULL;
553 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
555 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
556 st->codec->codec_id = codec->id;
559 return avcodec_find_decoder(st->codec->codec_id);
562 /* Add all the streams from the given input file to the global
563 * list of input streams. */
564 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
568 for (i = 0; i < ic->nb_streams; i++) {
569 AVStream *st = ic->streams[i];
570 AVCodecContext *dec = st->codec;
571 InputStream *ist = av_mallocz(sizeof(*ist));
572 char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
573 char *codec_tag = NULL;
575 char *discard_str = NULL;
576 const AVOption *discard_opt = av_opt_find(dec, "skip_frame", NULL, 0, 0);
581 GROW_ARRAY(input_streams, nb_input_streams);
582 input_streams[nb_input_streams - 1] = ist;
585 ist->file_index = nb_input_files;
587 st->discard = AVDISCARD_ALL;
590 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
592 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
594 uint32_t tag = strtol(codec_tag, &next, 0);
596 tag = AV_RL32(codec_tag);
597 st->codec->codec_tag = tag;
600 ist->dec = choose_decoder(o, ic, st);
601 ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
603 ist->reinit_filters = -1;
604 MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
606 MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
607 ist->user_set_discard = AVDISCARD_NONE;
608 if (discard_str && av_opt_eval_int(dec, discard_opt, discard_str, &ist->user_set_discard) < 0) {
609 av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
614 ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
616 ist->dec_ctx = avcodec_alloc_context3(ist->dec);
618 av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
622 ret = avcodec_copy_context(ist->dec_ctx, dec);
624 av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
628 switch (dec->codec_type) {
629 case AVMEDIA_TYPE_VIDEO:
631 ist->dec = avcodec_find_decoder(dec->codec_id);
632 if (av_codec_get_lowres(dec)) {
633 dec->flags |= CODEC_FLAG_EMU_EDGE;
636 ist->resample_height = ist->dec_ctx->height;
637 ist->resample_width = ist->dec_ctx->width;
638 ist->resample_pix_fmt = ist->dec_ctx->pix_fmt;
640 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
641 if (framerate && av_parse_video_rate(&ist->framerate,
643 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
648 ist->top_field_first = -1;
649 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
651 MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
653 if (!strcmp(hwaccel, "none"))
654 ist->hwaccel_id = HWACCEL_NONE;
655 else if (!strcmp(hwaccel, "auto"))
656 ist->hwaccel_id = HWACCEL_AUTO;
659 for (i = 0; hwaccels[i].name; i++) {
660 if (!strcmp(hwaccels[i].name, hwaccel)) {
661 ist->hwaccel_id = hwaccels[i].id;
666 if (!ist->hwaccel_id) {
667 av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
669 av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
670 for (i = 0; hwaccels[i].name; i++)
671 av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
672 av_log(NULL, AV_LOG_FATAL, "\n");
678 MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
679 if (hwaccel_device) {
680 ist->hwaccel_device = av_strdup(hwaccel_device);
681 if (!ist->hwaccel_device)
684 ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
687 case AVMEDIA_TYPE_AUDIO:
688 ist->guess_layout_max = INT_MAX;
689 MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
690 guess_input_channel_layout(ist);
692 ist->resample_sample_fmt = ist->dec_ctx->sample_fmt;
693 ist->resample_sample_rate = ist->dec_ctx->sample_rate;
694 ist->resample_channels = ist->dec_ctx->channels;
695 ist->resample_channel_layout = ist->dec_ctx->channel_layout;
698 case AVMEDIA_TYPE_DATA:
699 case AVMEDIA_TYPE_SUBTITLE: {
700 char *canvas_size = NULL;
702 ist->dec = avcodec_find_decoder(dec->codec_id);
703 MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
704 MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
706 av_parse_video_size(&dec->width, &dec->height, canvas_size) < 0) {
707 av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
712 case AVMEDIA_TYPE_ATTACHMENT:
713 case AVMEDIA_TYPE_UNKNOWN:
721 static void assert_file_overwrite(const char *filename)
723 if (file_overwrite && no_file_overwrite) {
724 fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
728 if (!file_overwrite) {
729 const char *proto_name = avio_find_protocol_name(filename);
730 if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
731 if (stdin_interaction && !no_file_overwrite) {
732 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
735 signal(SIGINT, SIG_DFL);
737 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
743 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
750 static void dump_attachment(AVStream *st, const char *filename)
753 AVIOContext *out = NULL;
754 AVDictionaryEntry *e;
756 if (!st->codec->extradata_size) {
757 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
758 nb_input_files - 1, st->index);
761 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
764 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
765 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
769 assert_file_overwrite(filename);
771 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
772 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
777 avio_write(out, st->codec->extradata, st->codec->extradata_size);
782 static int open_input_file(OptionsContext *o, const char *filename)
786 AVInputFormat *file_iformat = NULL;
791 AVDictionary *unused_opts = NULL;
792 AVDictionaryEntry *e = NULL;
793 int orig_nb_streams; // number of streams before avformat_find_stream_info
794 char * video_codec_name = NULL;
795 char * audio_codec_name = NULL;
796 char *subtitle_codec_name = NULL;
799 if (!(file_iformat = av_find_input_format(o->format))) {
800 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
805 if (!strcmp(filename, "-"))
808 stdin_interaction &= strncmp(filename, "pipe:", 5) &&
809 strcmp(filename, "/dev/stdin");
811 /* get default parameters from command line */
812 ic = avformat_alloc_context();
814 print_error(filename, AVERROR(ENOMEM));
817 if (o->nb_audio_sample_rate) {
818 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
819 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
821 if (o->nb_audio_channels) {
822 /* because we set audio_channels based on both the "ac" and
823 * "channel_layout" options, we need to check that the specified
824 * demuxer actually has the "channels" option before setting it */
825 if (file_iformat && file_iformat->priv_class &&
826 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
827 AV_OPT_SEARCH_FAKE_OBJ)) {
828 snprintf(buf, sizeof(buf), "%d",
829 o->audio_channels[o->nb_audio_channels - 1].u.i);
830 av_dict_set(&o->g->format_opts, "channels", buf, 0);
833 if (o->nb_frame_rates) {
834 /* set the format-level framerate option;
835 * this is important for video grabbers, e.g. x11 */
836 if (file_iformat && file_iformat->priv_class &&
837 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
838 AV_OPT_SEARCH_FAKE_OBJ)) {
839 av_dict_set(&o->g->format_opts, "framerate",
840 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
843 if (o->nb_frame_sizes) {
844 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
846 if (o->nb_frame_pix_fmts)
847 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
849 MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
850 MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
851 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
853 ic->video_codec_id = video_codec_name ?
854 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
855 ic->audio_codec_id = audio_codec_name ?
856 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
857 ic->subtitle_codec_id= subtitle_codec_name ?
858 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
860 if (video_codec_name)
861 av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
862 if (audio_codec_name)
863 av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
864 if (subtitle_codec_name)
865 av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
867 ic->flags |= AVFMT_FLAG_NONBLOCK;
868 ic->interrupt_callback = int_cb;
870 /* open the input file with generic avformat function */
871 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
873 print_error(filename, err);
876 assert_avoptions(o->g->format_opts);
878 /* apply forced codec ids */
879 for (i = 0; i < ic->nb_streams; i++)
880 choose_decoder(o, ic, ic->streams[i]);
882 /* Set AVCodecContext options for avformat_find_stream_info */
883 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
884 orig_nb_streams = ic->nb_streams;
886 /* If not enough info to get the stream parameters, we decode the
887 first frames to get it. (used in mpeg case for example) */
888 ret = avformat_find_stream_info(ic, opts);
890 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
891 avformat_close_input(&ic);
895 timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
896 /* add the stream start time */
897 if (ic->start_time != AV_NOPTS_VALUE)
898 timestamp += ic->start_time;
900 /* if seeking requested, we execute it */
901 if (o->start_time != AV_NOPTS_VALUE) {
902 ret = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
904 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
905 filename, (double)timestamp / AV_TIME_BASE);
909 /* update the current parameters so that they match the one of the input stream */
910 add_input_streams(o, ic);
912 /* dump the file content */
913 av_dump_format(ic, nb_input_files, filename, 0);
915 GROW_ARRAY(input_files, nb_input_files);
916 f = av_mallocz(sizeof(*f));
919 input_files[nb_input_files - 1] = f;
922 f->ist_index = nb_input_streams - ic->nb_streams;
923 f->start_time = o->start_time;
924 f->recording_time = o->recording_time;
925 f->input_ts_offset = o->input_ts_offset;
926 f->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
927 f->nb_streams = ic->nb_streams;
928 f->rate_emu = o->rate_emu;
929 f->accurate_seek = o->accurate_seek;
931 /* check if all codec options have been used */
932 unused_opts = strip_specifiers(o->g->codec_opts);
933 for (i = f->ist_index; i < nb_input_streams; i++) {
935 while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
936 AV_DICT_IGNORE_SUFFIX)))
937 av_dict_set(&unused_opts, e->key, NULL, 0);
941 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
942 const AVClass *class = avcodec_get_class();
943 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
944 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
945 const AVClass *fclass = avformat_get_class();
946 const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
947 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
948 if (!option || foption)
952 if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
953 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
954 "input file #%d (%s) is not a decoding option.\n", e->key,
955 option->help ? option->help : "", nb_input_files - 1,
960 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
961 "input file #%d (%s) has not been used for any stream. The most "
962 "likely reason is either wrong type (e.g. a video option with "
963 "no video streams) or that it is a private option of some decoder "
964 "which was not actually used for any stream.\n", e->key,
965 option->help ? option->help : "", nb_input_files - 1, filename);
967 av_dict_free(&unused_opts);
969 for (i = 0; i < o->nb_dump_attachment; i++) {
972 for (j = 0; j < ic->nb_streams; j++) {
973 AVStream *st = ic->streams[j];
975 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
976 dump_attachment(st, o->dump_attachment[i].u.str);
980 for (i = 0; i < orig_nb_streams; i++)
981 av_dict_free(&opts[i]);
987 static uint8_t *get_line(AVIOContext *s)
993 if (avio_open_dyn_buf(&line) < 0) {
994 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
998 while ((c = avio_r8(s)) && c != '\n')
1001 avio_close_dyn_buf(line, &buf);
1006 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1009 char filename[1000];
1010 const char *base[3] = { getenv("AVCONV_DATADIR"),
1015 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1019 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1020 i != 1 ? "" : "/.avconv", codec_name, preset_name);
1021 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1024 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1025 i != 1 ? "" : "/.avconv", preset_name);
1026 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1032 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1034 char *codec_name = NULL;
1036 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1038 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1039 NULL, ost->st->codec->codec_type);
1040 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1041 } else if (!strcmp(codec_name, "copy"))
1042 ost->stream_copy = 1;
1044 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
1045 ost->st->codec->codec_id = ost->enc->id;
1049 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1052 AVStream *st = avformat_new_stream(oc, NULL);
1053 int idx = oc->nb_streams - 1, ret = 0;
1054 char *bsf = NULL, *next, *codec_tag = NULL;
1055 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
1060 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1064 if (oc->nb_streams - 1 < o->nb_streamid_map)
1065 st->id = o->streamid_map[oc->nb_streams - 1];
1067 GROW_ARRAY(output_streams, nb_output_streams);
1068 if (!(ost = av_mallocz(sizeof(*ost))))
1070 output_streams[nb_output_streams - 1] = ost;
1072 ost->file_index = nb_output_files - 1;
1075 st->codec->codec_type = type;
1076 choose_encoder(o, oc, ost);
1078 ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1079 if (!ost->enc_ctx) {
1080 av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1083 ost->enc_ctx->codec_type = type;
1086 AVIOContext *s = NULL;
1087 char *buf = NULL, *arg = NULL, *preset = NULL;
1089 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1091 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1092 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1095 if (!buf[0] || buf[0] == '#') {
1099 if (!(arg = strchr(buf, '='))) {
1100 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1104 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1106 } while (!s->eof_reached);
1110 av_log(NULL, AV_LOG_FATAL,
1111 "Preset %s specified for stream %d:%d, but could not be opened.\n",
1112 preset, ost->file_index, ost->index);
1116 ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1119 ost->max_frames = INT64_MAX;
1120 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1121 for (i = 0; i<o->nb_max_frames; i++) {
1122 char *p = o->max_frames[i].specifier;
1123 if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1124 av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1129 ost->copy_prior_start = -1;
1130 MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1132 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
1134 if (next = strchr(bsf, ','))
1136 if (!(bsfc = av_bitstream_filter_init(bsf))) {
1137 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
1141 bsfc_prev->next = bsfc;
1143 ost->bitstream_filters = bsfc;
1149 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1151 uint32_t tag = strtol(codec_tag, &next, 0);
1153 tag = AV_RL32(codec_tag);
1154 ost->enc_ctx->codec_tag = tag;
1157 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1159 ost->enc_ctx->flags |= CODEC_FLAG_QSCALE;
1160 ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1163 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1164 ost->enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
1166 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1168 av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1169 if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1170 av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1172 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1174 ost->source_index = source_index;
1175 if (source_index >= 0) {
1176 ost->sync_ist = input_streams[source_index];
1177 input_streams[source_index]->discard = 0;
1178 input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1180 ost->last_mux_dts = AV_NOPTS_VALUE;
1185 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1188 const char *p = str;
1195 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1202 /* read file contents into a string */
1203 static uint8_t *read_file(const char *filename)
1205 AVIOContext *pb = NULL;
1206 AVIOContext *dyn_buf = NULL;
1207 int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1208 uint8_t buf[1024], *str;
1211 av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1215 ret = avio_open_dyn_buf(&dyn_buf);
1220 while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1221 avio_write(dyn_buf, buf, ret);
1222 avio_w8(dyn_buf, 0);
1225 ret = avio_close_dyn_buf(dyn_buf, &str);
1231 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1234 AVStream *st = ost->st;
1236 if (ost->filters_script && ost->filters) {
1237 av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1238 "output stream #%d:%d.\n", nb_output_files, st->index);
1242 if (ost->filters_script)
1243 return read_file(ost->filters_script);
1244 else if (ost->filters)
1245 return av_strdup(ost->filters);
1247 return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1251 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1252 const OutputStream *ost, enum AVMediaType type)
1254 if (ost->filters_script || ost->filters) {
1255 av_log(NULL, AV_LOG_ERROR,
1256 "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1257 "Filtering and streamcopy cannot be used together.\n",
1258 ost->filters ? "Filtergraph" : "Filtergraph script",
1259 ost->filters ? ost->filters : ost->filters_script,
1260 av_get_media_type_string(type), ost->file_index, ost->index);
1265 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1269 AVCodecContext *video_enc;
1270 char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1272 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1274 video_enc = ost->enc_ctx;
1276 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1277 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1278 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1282 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1283 if (frame_aspect_ratio) {
1285 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1286 q.num <= 0 || q.den <= 0) {
1287 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1290 ost->frame_aspect_ratio = q;
1293 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1294 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1296 if (!ost->stream_copy) {
1297 const char *p = NULL;
1298 char *frame_size = NULL;
1299 char *frame_pix_fmt = NULL;
1300 char *intra_matrix = NULL, *inter_matrix = NULL;
1301 char *chroma_intra_matrix = NULL;
1305 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1306 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1307 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1311 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1312 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1313 if (frame_pix_fmt && *frame_pix_fmt == '+') {
1314 ost->keep_pix_fmt = 1;
1315 if (!*++frame_pix_fmt)
1316 frame_pix_fmt = NULL;
1318 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1319 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1322 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1325 video_enc->gop_size = 0;
1326 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1328 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1329 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1332 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1334 MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1335 if (chroma_intra_matrix) {
1336 uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1338 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1341 av_codec_set_chroma_intra_matrix(video_enc, p);
1342 parse_matrix_coeffs(p, chroma_intra_matrix);
1344 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1346 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1347 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1350 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1353 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1354 for (i = 0; p; i++) {
1356 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1358 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1361 /* FIXME realloc failure */
1362 video_enc->rc_override =
1363 av_realloc(video_enc->rc_override,
1364 sizeof(RcOverride) * (i + 1));
1365 video_enc->rc_override[i].start_frame = start;
1366 video_enc->rc_override[i].end_frame = end;
1368 video_enc->rc_override[i].qscale = q;
1369 video_enc->rc_override[i].quality_factor = 1.0;
1372 video_enc->rc_override[i].qscale = 0;
1373 video_enc->rc_override[i].quality_factor = -q/100.0;
1378 video_enc->rc_override_count = i;
1379 video_enc->intra_dc_precision = intra_dc_precision - 8;
1382 video_enc->flags|= CODEC_FLAG_PSNR;
1385 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1388 video_enc->flags |= CODEC_FLAG_PASS1;
1389 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1392 video_enc->flags |= CODEC_FLAG_PASS2;
1393 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1397 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1398 if (ost->logfile_prefix &&
1399 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1402 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1403 if (ost->forced_keyframes)
1404 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1406 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1408 ost->top_field_first = -1;
1409 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1412 ost->avfilter = get_ost_filters(o, oc, ost);
1416 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1419 if (ost->stream_copy)
1420 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1425 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1430 AVCodecContext *audio_enc;
1432 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1435 audio_enc = ost->enc_ctx;
1436 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1438 MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1439 MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1441 if (!ost->stream_copy) {
1442 char *sample_fmt = NULL;
1444 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1446 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1448 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1449 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1453 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1455 MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1456 ost->apad = av_strdup(ost->apad);
1458 ost->avfilter = get_ost_filters(o, oc, ost);
1462 /* check for channel mapping for this audio stream */
1463 for (n = 0; n < o->nb_audio_channel_maps; n++) {
1464 AudioChannelMap *map = &o->audio_channel_maps[n];
1465 if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1466 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1469 if (map->channel_idx == -1) {
1471 } else if (ost->source_index < 0) {
1472 av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1473 ost->file_index, ost->st->index);
1476 ist = input_streams[ost->source_index];
1479 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1480 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1481 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1483 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1484 ost->file_index, ost->st->index);
1490 if (ost->stream_copy)
1491 check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1496 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1500 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1501 if (!ost->stream_copy) {
1502 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1509 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1511 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1512 ost->stream_copy = 1;
1517 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1521 AVCodecContext *subtitle_enc;
1523 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1525 subtitle_enc = ost->enc_ctx;
1527 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1529 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1531 if (!ost->stream_copy) {
1532 char *frame_size = NULL;
1534 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1535 if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1536 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1544 /* arg format is "output-stream-index:streamid-value". */
1545 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1547 OptionsContext *o = optctx;
1552 av_strlcpy(idx_str, arg, sizeof(idx_str));
1553 p = strchr(idx_str, ':');
1555 av_log(NULL, AV_LOG_FATAL,
1556 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1561 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1562 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1563 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1567 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1569 AVFormatContext *is = ifile->ctx;
1570 AVFormatContext *os = ofile->ctx;
1574 tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1576 return AVERROR(ENOMEM);
1579 for (i = 0; i < is->nb_chapters; i++) {
1580 AVChapter *in_ch = is->chapters[i], *out_ch;
1581 int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1582 int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1583 AV_TIME_BASE_Q, in_ch->time_base);
1584 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1585 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1588 if (in_ch->end < ts_off)
1590 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1593 out_ch = av_mallocz(sizeof(AVChapter));
1595 return AVERROR(ENOMEM);
1597 out_ch->id = in_ch->id;
1598 out_ch->time_base = in_ch->time_base;
1599 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1600 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1603 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1605 os->chapters[os->nb_chapters++] = out_ch;
1610 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1613 AVFormatContext *ic = avformat_alloc_context();
1615 ic->interrupt_callback = int_cb;
1616 err = avformat_open_input(&ic, filename, NULL, NULL);
1619 /* copy stream format */
1620 for(i=0;i<ic->nb_streams;i++) {
1624 AVCodecContext *avctx;
1626 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1627 ost = new_output_stream(o, s, codec->type, -1);
1632 // FIXME: a more elegant solution is needed
1633 memcpy(st, ic->streams[i], sizeof(AVStream));
1635 st->info = av_malloc(sizeof(*st->info));
1636 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1638 avcodec_copy_context(st->codec, ic->streams[i]->codec);
1640 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1641 choose_sample_fmt(st, codec);
1642 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1643 choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1644 avcodec_copy_context(ost->enc_ctx, st->codec);
1647 avformat_close_input(&ic);
1651 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1652 AVFormatContext *oc)
1656 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1657 ofilter->out_tmp->pad_idx)) {
1658 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1659 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1661 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1666 ost->source_index = -1;
1667 ost->filter = ofilter;
1671 if (ost->stream_copy) {
1672 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1673 "which is fed from a complex filtergraph. Filtering and streamcopy "
1674 "cannot be used together.\n", ost->file_index, ost->index);
1678 if (ost->avfilter && (ost->filters || ost->filters_script)) {
1679 const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1680 av_log(NULL, AV_LOG_ERROR,
1681 "%s '%s' was specified through the %s option "
1682 "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1683 "%s and -filter_complex cannot be used together for the same stream.\n",
1684 ost->filters ? "Filtergraph" : "Filtergraph script",
1685 ost->filters ? ost->filters : ost->filters_script,
1686 opt, ost->file_index, ost->index, opt);
1690 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1691 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1694 avfilter_inout_free(&ofilter->out_tmp);
1697 static int configure_complex_filters(void)
1701 for (i = 0; i < nb_filtergraphs; i++)
1702 if (!filtergraphs[i]->graph &&
1703 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1708 static int open_output_file(OptionsContext *o, const char *filename)
1710 AVFormatContext *oc;
1712 AVOutputFormat *file_oformat;
1716 AVDictionary *unused_opts = NULL;
1717 AVDictionaryEntry *e = NULL;
1719 if (configure_complex_filters() < 0) {
1720 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1724 if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1725 o->stop_time = INT64_MAX;
1726 av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1729 if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1730 int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1731 if (o->stop_time <= start_time) {
1732 av_log(NULL, AV_LOG_WARNING, "-to value smaller than -ss; ignoring -to.\n");
1733 o->stop_time = INT64_MAX;
1735 o->recording_time = o->stop_time - start_time;
1739 GROW_ARRAY(output_files, nb_output_files);
1740 of = av_mallocz(sizeof(*of));
1743 output_files[nb_output_files - 1] = of;
1745 of->ost_index = nb_output_streams;
1746 of->recording_time = o->recording_time;
1747 of->start_time = o->start_time;
1748 of->limit_filesize = o->limit_filesize;
1749 of->shortest = o->shortest;
1750 av_dict_copy(&of->opts, o->g->format_opts, 0);
1752 if (!strcmp(filename, "-"))
1755 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1757 print_error(filename, err);
1762 if (o->recording_time != INT64_MAX)
1763 oc->duration = o->recording_time;
1765 file_oformat= oc->oformat;
1766 oc->interrupt_callback = int_cb;
1768 /* create streams for all unlabeled output pads */
1769 for (i = 0; i < nb_filtergraphs; i++) {
1770 FilterGraph *fg = filtergraphs[i];
1771 for (j = 0; j < fg->nb_outputs; j++) {
1772 OutputFilter *ofilter = fg->outputs[j];
1774 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1777 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1778 ofilter->out_tmp->pad_idx)) {
1779 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1780 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1781 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1783 init_output_filter(ofilter, o, oc);
1787 /* ffserver seeking with date=... needs a date reference */
1788 if (!strcmp(file_oformat->name, "ffm") &&
1789 av_strstart(filename, "http:", NULL)) {
1790 int err = parse_option(o, "metadata", "creation_time=now", options);
1792 print_error(filename, err);
1797 if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1798 av_strstart(filename, "http:", NULL)) {
1800 /* special case for files sent to ffserver: we get the stream
1801 parameters from ffserver */
1802 int err = read_ffserver_streams(o, oc, filename);
1804 print_error(filename, err);
1807 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1808 ost = output_streams[j];
1809 for (i = 0; i < nb_input_streams; i++) {
1810 ist = input_streams[i];
1811 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1813 ost->source_index= i;
1814 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1815 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1817 ist->st->discard = ist->user_set_discard;
1822 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));
1826 } else if (!o->nb_stream_maps) {
1827 char *subtitle_codec_name = NULL;
1828 /* pick the "best" stream of each type */
1830 /* video: highest resolution */
1831 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1832 int area = 0, idx = -1;
1833 int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1834 for (i = 0; i < nb_input_streams; i++) {
1836 ist = input_streams[i];
1837 new_area = ist->st->codec->width * ist->st->codec->height;
1838 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1840 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1842 if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1849 new_video_stream(o, oc, idx);
1852 /* audio: most channels */
1853 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1854 int channels = 0, idx = -1;
1855 for (i = 0; i < nb_input_streams; i++) {
1856 ist = input_streams[i];
1857 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1858 ist->st->codec->channels > channels) {
1859 channels = ist->st->codec->channels;
1864 new_audio_stream(o, oc, idx);
1867 /* subtitles: pick first */
1868 MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1869 if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
1870 for (i = 0; i < nb_input_streams; i++)
1871 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1872 new_subtitle_stream(o, oc, i);
1876 /* do something with data? */
1878 for (i = 0; i < o->nb_stream_maps; i++) {
1879 StreamMap *map = &o->stream_maps[i];
1884 if (map->linklabel) {
1886 OutputFilter *ofilter = NULL;
1889 for (j = 0; j < nb_filtergraphs; j++) {
1890 fg = filtergraphs[j];
1891 for (k = 0; k < fg->nb_outputs; k++) {
1892 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1893 if (out && !strcmp(out->name, map->linklabel)) {
1894 ofilter = fg->outputs[k];
1901 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1902 "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
1905 init_output_filter(ofilter, o, oc);
1907 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1909 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1910 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1912 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1914 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1916 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1919 switch (ist->st->codec->codec_type) {
1920 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
1921 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
1922 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
1923 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
1924 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1926 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1927 map->file_index, map->stream_index);
1934 /* handle attached files */
1935 for (i = 0; i < o->nb_attachments; i++) {
1937 uint8_t *attachment;
1941 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1942 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1946 if ((len = avio_size(pb)) <= 0) {
1947 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1951 if (!(attachment = av_malloc(len))) {
1952 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1956 avio_read(pb, attachment, len);
1958 ost = new_attachment_stream(o, oc, -1);
1959 ost->stream_copy = 0;
1960 ost->attachment_filename = o->attachments[i];
1962 ost->enc_ctx->extradata = attachment;
1963 ost->enc_ctx->extradata_size = len;
1965 p = strrchr(o->attachments[i], '/');
1966 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1970 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1971 AVDictionaryEntry *e;
1972 ost = output_streams[i];
1974 if ((ost->stream_copy || ost->attachment_filename)
1975 && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1976 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1977 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1981 /* check if all codec options have been used */
1982 unused_opts = strip_specifiers(o->g->codec_opts);
1983 for (i = of->ost_index; i < nb_output_streams; i++) {
1985 while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1986 AV_DICT_IGNORE_SUFFIX)))
1987 av_dict_set(&unused_opts, e->key, NULL, 0);
1991 while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1992 const AVClass *class = avcodec_get_class();
1993 const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1994 AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1997 if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1998 av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1999 "output file #%d (%s) is not an encoding option.\n", e->key,
2000 option->help ? option->help : "", nb_output_files - 1,
2005 // gop_timecode is injected by generic code but not always used
2006 if (!strcmp(e->key, "gop_timecode"))
2009 av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2010 "output file #%d (%s) has not been used for any stream. The most "
2011 "likely reason is either wrong type (e.g. a video option with "
2012 "no video streams) or that it is a private option of some encoder "
2013 "which was not actually used for any stream.\n", e->key,
2014 option->help ? option->help : "", nb_output_files - 1, filename);
2016 av_dict_free(&unused_opts);
2018 /* check filename in case of an image number is expected */
2019 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2020 if (!av_filename_number_test(oc->filename)) {
2021 print_error(oc->filename, AVERROR(EINVAL));
2026 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2027 /* test if it already exists to avoid losing precious files */
2028 assert_file_overwrite(filename);
2031 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2032 &oc->interrupt_callback,
2034 print_error(filename, err);
2037 } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2038 assert_file_overwrite(filename);
2040 if (o->mux_preload) {
2042 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
2043 av_dict_set(&of->opts, "preload", buf, 0);
2045 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2048 for (i = 0; i < o->nb_metadata_map; i++) {
2050 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2052 if (in_file_index >= nb_input_files) {
2053 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2056 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2057 in_file_index >= 0 ?
2058 input_files[in_file_index]->ctx : NULL, o);
2062 if (o->chapters_input_file >= nb_input_files) {
2063 if (o->chapters_input_file == INT_MAX) {
2064 /* copy chapters from the first input file that has them*/
2065 o->chapters_input_file = -1;
2066 for (i = 0; i < nb_input_files; i++)
2067 if (input_files[i]->ctx->nb_chapters) {
2068 o->chapters_input_file = i;
2072 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2073 o->chapters_input_file);
2077 if (o->chapters_input_file >= 0)
2078 copy_chapters(input_files[o->chapters_input_file], of,
2079 !o->metadata_chapters_manual);
2081 /* copy global metadata by default */
2082 if (!o->metadata_global_manual && nb_input_files){
2083 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2084 AV_DICT_DONT_OVERWRITE);
2085 if(o->recording_time != INT64_MAX)
2086 av_dict_set(&oc->metadata, "duration", NULL, 0);
2087 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2089 if (!o->metadata_streams_manual)
2090 for (i = of->ost_index; i < nb_output_streams; i++) {
2092 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2094 ist = input_streams[output_streams[i]->source_index];
2095 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2096 if (!output_streams[i]->stream_copy)
2097 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2100 /* process manually set metadata */
2101 for (i = 0; i < o->nb_metadata; i++) {
2104 const char *stream_spec;
2105 int index = 0, j, ret = 0;
2107 val = strchr(o->metadata[i].u.str, '=');
2109 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2110 o->metadata[i].u.str);
2115 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2117 for (j = 0; j < oc->nb_streams; j++) {
2118 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2119 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2130 if (index < 0 || index >= oc->nb_chapters) {
2131 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2134 m = &oc->chapters[index]->metadata;
2137 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2140 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2147 static int opt_target(void *optctx, const char *opt, const char *arg)
2149 OptionsContext *o = optctx;
2150 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2151 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2153 if (!strncmp(arg, "pal-", 4)) {
2156 } else if (!strncmp(arg, "ntsc-", 5)) {
2159 } else if (!strncmp(arg, "film-", 5)) {
2163 /* Try to determine PAL/NTSC by peeking in the input files */
2164 if (nb_input_files) {
2166 for (j = 0; j < nb_input_files; j++) {
2167 for (i = 0; i < input_files[j]->nb_streams; i++) {
2168 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2169 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
2171 fr = c->time_base.den * 1000 / c->time_base.num;
2175 } else if ((fr == 29970) || (fr == 23976)) {
2180 if (norm != UNKNOWN)
2184 if (norm != UNKNOWN)
2185 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2188 if (norm == UNKNOWN) {
2189 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2190 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2191 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2195 if (!strcmp(arg, "vcd")) {
2196 opt_video_codec(o, "c:v", "mpeg1video");
2197 opt_audio_codec(o, "c:a", "mp2");
2198 parse_option(o, "f", "vcd", options);
2200 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2201 parse_option(o, "r", frame_rates[norm], options);
2202 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2204 av_dict_set(&o->g->codec_opts, "b:v", "1150000", AV_DICT_DONT_OVERWRITE);
2205 av_dict_set(&o->g->codec_opts, "maxrate", "1150000", AV_DICT_DONT_OVERWRITE);
2206 av_dict_set(&o->g->codec_opts, "minrate", "1150000", AV_DICT_DONT_OVERWRITE);
2207 av_dict_set(&o->g->codec_opts, "bufsize", "327680", AV_DICT_DONT_OVERWRITE); // 40*1024*8;
2209 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2210 parse_option(o, "ar", "44100", options);
2211 parse_option(o, "ac", "2", options);
2213 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2214 av_dict_set(&o->g->format_opts, "muxrate", "1411200", AV_DICT_DONT_OVERWRITE); // 2352 * 75 * 8;
2216 /* We have to offset the PTS, so that it is consistent with the SCR.
2217 SCR starts at 36000, but the first two packs contain only padding
2218 and the first pack from the other stream, respectively, may also have
2219 been written before.
2220 So the real data starts at SCR 36000+3*1200. */
2221 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2222 } else if (!strcmp(arg, "svcd")) {
2224 opt_video_codec(o, "c:v", "mpeg2video");
2225 opt_audio_codec(o, "c:a", "mp2");
2226 parse_option(o, "f", "svcd", options);
2228 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2229 parse_option(o, "r", frame_rates[norm], options);
2230 parse_option(o, "pix_fmt", "yuv420p", options);
2231 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2233 av_dict_set(&o->g->codec_opts, "b:v", "2040000", AV_DICT_DONT_OVERWRITE);
2234 av_dict_set(&o->g->codec_opts, "maxrate", "2516000", AV_DICT_DONT_OVERWRITE);
2235 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1145000;
2236 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2237 av_dict_set(&o->g->codec_opts, "scan_offset", "1", AV_DICT_DONT_OVERWRITE);
2239 av_dict_set(&o->g->codec_opts, "b:a", "224000", AV_DICT_DONT_OVERWRITE);
2240 parse_option(o, "ar", "44100", options);
2242 av_dict_set(&o->g->format_opts, "packetsize", "2324", AV_DICT_DONT_OVERWRITE);
2244 } else if (!strcmp(arg, "dvd")) {
2246 opt_video_codec(o, "c:v", "mpeg2video");
2247 opt_audio_codec(o, "c:a", "ac3");
2248 parse_option(o, "f", "dvd", options);
2250 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2251 parse_option(o, "r", frame_rates[norm], options);
2252 parse_option(o, "pix_fmt", "yuv420p", options);
2253 av_dict_set(&o->g->codec_opts, "g", norm == PAL ? "15" : "18", AV_DICT_DONT_OVERWRITE);
2255 av_dict_set(&o->g->codec_opts, "b:v", "6000000", AV_DICT_DONT_OVERWRITE);
2256 av_dict_set(&o->g->codec_opts, "maxrate", "9000000", AV_DICT_DONT_OVERWRITE);
2257 av_dict_set(&o->g->codec_opts, "minrate", "0", AV_DICT_DONT_OVERWRITE); // 1500000;
2258 av_dict_set(&o->g->codec_opts, "bufsize", "1835008", AV_DICT_DONT_OVERWRITE); // 224*1024*8;
2260 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.
2261 av_dict_set(&o->g->format_opts, "muxrate", "10080000", AV_DICT_DONT_OVERWRITE); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2263 av_dict_set(&o->g->codec_opts, "b:a", "448000", AV_DICT_DONT_OVERWRITE);
2264 parse_option(o, "ar", "48000", options);
2266 } else if (!strncmp(arg, "dv", 2)) {
2268 parse_option(o, "f", "dv", options);
2270 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2271 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2272 norm == PAL ? "yuv420p" : "yuv411p", options);
2273 parse_option(o, "r", frame_rates[norm], options);
2275 parse_option(o, "ar", "48000", options);
2276 parse_option(o, "ac", "2", options);
2279 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2280 return AVERROR(EINVAL);
2285 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2287 av_free (vstats_filename);
2288 vstats_filename = av_strdup (arg);
2292 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2295 time_t today2 = time(NULL);
2296 struct tm *today = localtime(&today2);
2298 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2300 return opt_vstats_file(NULL, opt, filename);
2303 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2305 OptionsContext *o = optctx;
2306 return parse_option(o, "frames:v", arg, options);
2309 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2311 OptionsContext *o = optctx;
2312 return parse_option(o, "frames:a", arg, options);
2315 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2317 OptionsContext *o = optctx;
2318 return parse_option(o, "frames:d", arg, options);
2321 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2324 AVDictionary *cbak = codec_opts;
2325 AVDictionary *fbak = format_opts;
2329 ret = opt_default(NULL, opt, arg);
2331 av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2332 av_dict_copy(&o->g->format_opts, format_opts, 0);
2333 av_dict_free(&codec_opts);
2334 av_dict_free(&format_opts);
2341 static int opt_preset(void *optctx, const char *opt, const char *arg)
2343 OptionsContext *o = optctx;
2345 char filename[1000], line[1000], tmp_line[1000];
2346 const char *codec_name = NULL;
2350 MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2352 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2353 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2354 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2356 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2360 while (fgets(line, sizeof(line), f)) {
2361 char *key = tmp_line, *value, *endptr;
2363 if (strcspn(line, "#\n\r") == 0)
2365 av_strlcpy(tmp_line, line, sizeof(tmp_line));
2366 if (!av_strtok(key, "=", &value) ||
2367 !av_strtok(value, "\r\n", &endptr)) {
2368 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2371 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2373 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2374 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2375 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2376 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2377 else if (opt_default_new(o, key, value) < 0) {
2378 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2379 filename, line, key, value);
2389 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2391 OptionsContext *o = optctx;
2392 char *s = av_asprintf("%s:%c", opt + 1, *opt);
2393 int ret = parse_option(o, s, arg, options);
2398 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2400 OptionsContext *o = optctx;
2401 if(!strcmp(opt, "b")){
2402 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2403 av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2406 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2410 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2412 OptionsContext *o = optctx;
2415 if(!strcmp(opt, "qscale")){
2416 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2417 return parse_option(o, "q:v", arg, options);
2419 s = av_asprintf("q%s", opt + 6);
2420 ret = parse_option(o, s, arg, options);
2425 static int opt_profile(void *optctx, const char *opt, const char *arg)
2427 OptionsContext *o = optctx;
2428 if(!strcmp(opt, "profile")){
2429 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2430 av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2433 av_dict_set(&o->g->codec_opts, opt, arg, 0);
2437 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2439 OptionsContext *o = optctx;
2440 return parse_option(o, "filter:v", arg, options);
2443 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2445 OptionsContext *o = optctx;
2446 return parse_option(o, "filter:a", arg, options);
2449 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2451 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
2452 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
2453 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2454 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
2456 if (video_sync_method == VSYNC_AUTO)
2457 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2461 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2463 OptionsContext *o = optctx;
2464 char *tcr = av_asprintf("timecode=%s", arg);
2465 int ret = parse_option(o, "metadata:g", tcr, options);
2467 ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2472 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2474 OptionsContext *o = optctx;
2475 char layout_str[32];
2478 int ret, channels, ac_str_size;
2481 layout = av_get_channel_layout(arg);
2483 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2484 return AVERROR(EINVAL);
2486 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2487 ret = opt_default_new(o, opt, layout_str);
2491 /* set 'ac' option based on channel layout */
2492 channels = av_get_channel_layout_nb_channels(layout);
2493 snprintf(layout_str, sizeof(layout_str), "%d", channels);
2494 stream_str = strchr(opt, ':');
2495 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2496 ac_str = av_mallocz(ac_str_size);
2498 return AVERROR(ENOMEM);
2499 av_strlcpy(ac_str, "ac", 3);
2501 av_strlcat(ac_str, stream_str, ac_str_size);
2502 ret = parse_option(o, ac_str, layout_str, options);
2508 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2510 OptionsContext *o = optctx;
2511 return parse_option(o, "q:a", arg, options);
2514 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2516 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2517 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2518 return AVERROR(ENOMEM);
2519 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2520 filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2521 if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2522 return AVERROR(ENOMEM);
2526 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2528 uint8_t *graph_desc = read_file(arg);
2530 return AVERROR(EINVAL);
2532 GROW_ARRAY(filtergraphs, nb_filtergraphs);
2533 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2534 return AVERROR(ENOMEM);
2535 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
2536 filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2540 void show_help_default(const char *opt, const char *arg)
2542 /* per-file options have at least one of those set */
2543 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2544 int show_advanced = 0, show_avoptions = 0;
2547 if (!strcmp(opt, "long"))
2549 else if (!strcmp(opt, "full"))
2550 show_advanced = show_avoptions = 1;
2552 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2557 printf("Getting help:\n"
2558 " -h -- print basic options\n"
2559 " -h long -- print more options\n"
2560 " -h full -- print all options (including all format and codec specific options, very long)\n"
2561 " See man %s for detailed description of the options.\n"
2562 "\n", program_name);
2564 show_help_options(options, "Print help / information / capabilities:",
2567 show_help_options(options, "Global options (affect whole program "
2568 "instead of just one file:",
2569 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2571 show_help_options(options, "Advanced global options:", OPT_EXPERT,
2572 per_file | OPT_EXIT, 0);
2574 show_help_options(options, "Per-file main options:", 0,
2575 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2576 OPT_EXIT, per_file);
2578 show_help_options(options, "Advanced per-file options:",
2579 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2581 show_help_options(options, "Video options:",
2582 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2584 show_help_options(options, "Advanced Video options:",
2585 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2587 show_help_options(options, "Audio options:",
2588 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2590 show_help_options(options, "Advanced Audio options:",
2591 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2592 show_help_options(options, "Subtitle options:",
2593 OPT_SUBTITLE, 0, 0);
2596 if (show_avoptions) {
2597 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2598 show_help_children(avcodec_get_class(), flags);
2599 show_help_children(avformat_get_class(), flags);
2601 show_help_children(sws_get_class(), flags);
2603 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2604 show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2608 void show_usage(void)
2610 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2611 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2612 av_log(NULL, AV_LOG_INFO, "\n");
2620 static const OptionGroupDef groups[] = {
2621 [GROUP_OUTFILE] = { "output file", NULL, OPT_OUTPUT },
2622 [GROUP_INFILE] = { "input file", "i", OPT_INPUT },
2625 static int open_files(OptionGroupList *l, const char *inout,
2626 int (*open_file)(OptionsContext*, const char*))
2630 for (i = 0; i < l->nb_groups; i++) {
2631 OptionGroup *g = &l->groups[i];
2637 ret = parse_optgroup(&o, g);
2639 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2640 "%s.\n", inout, g->arg);
2644 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2645 ret = open_file(&o, g->arg);
2648 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2652 av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2658 int ffmpeg_parse_options(int argc, char **argv)
2660 OptionParseContext octx;
2664 memset(&octx, 0, sizeof(octx));
2666 /* split the commandline into an internal representation */
2667 ret = split_commandline(&octx, argc, argv, options, groups,
2668 FF_ARRAY_ELEMS(groups));
2670 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2674 /* apply global options */
2675 ret = parse_optgroup(NULL, &octx.global_opts);
2677 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2681 /* open input files */
2682 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2684 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2688 /* open output files */
2689 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2691 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2696 uninit_parse_context(&octx);
2698 av_strerror(ret, error, sizeof(error));
2699 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2704 static int opt_progress(void *optctx, const char *opt, const char *arg)
2706 AVIOContext *avio = NULL;
2709 if (!strcmp(arg, "-"))
2711 ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2713 av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2714 arg, av_err2str(ret));
2717 progress_avio = avio;
2721 #define OFFSET(x) offsetof(OptionsContext, x)
2722 const OptionDef options[] = {
2724 #include "cmdutils_common_opts.h"
2725 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
2726 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
2727 "force format", "fmt" },
2728 { "y", OPT_BOOL, { &file_overwrite },
2729 "overwrite output files" },
2730 { "n", OPT_BOOL, { &no_file_overwrite },
2731 "never overwrite output files" },
2732 { "c", HAS_ARG | OPT_STRING | OPT_SPEC |
2733 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2734 "codec name", "codec" },
2735 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
2736 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
2737 "codec name", "codec" },
2738 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
2739 OPT_OUTPUT, { .off = OFFSET(presets) },
2740 "preset name", "preset" },
2741 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2742 OPT_OUTPUT, { .func_arg = opt_map },
2743 "set input stream mapping",
2744 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2745 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2746 "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2747 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
2748 OPT_OUTPUT, { .off = OFFSET(metadata_map) },
2749 "set metadata information of outfile from infile",
2750 "outfile[,metadata]:infile[,metadata]" },
2751 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2752 OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
2753 "set chapters mapping", "input_file_index" },
2754 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
2755 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
2756 "record or transcode \"duration\" seconds of audio/video",
2758 { "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
2759 "record or transcode stop time", "time_stop" },
2760 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2761 "set the limit file size in bytes", "limit_size" },
2762 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
2763 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
2764 "set the start time offset", "time_off" },
2765 { "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2766 OPT_INPUT, { .off = OFFSET(accurate_seek) },
2767 "enable/disable accurate seeking with -ss" },
2768 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
2769 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
2770 "set the input ts offset", "time_off" },
2771 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2772 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
2773 "set the input ts scale", "scale" },
2774 { "timestamp", HAS_ARG | OPT_PERFILE, { .func_arg = opt_recording_timestamp },
2775 "set the recording timestamp ('now' to set the current time)", "time" },
2776 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2777 "add metadata", "string=string" },
2778 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2779 OPT_OUTPUT, { .func_arg = opt_data_frames },
2780 "set the number of data frames to record", "number" },
2781 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
2782 "add timings for benchmarking" },
2783 { "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
2784 "add timings for each task" },
2785 { "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
2786 "write program-readable progress information", "url" },
2787 { "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
2788 "enable or disable interaction on standard input" },
2789 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
2790 "set max runtime in seconds", "limit" },
2791 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
2792 "dump each input packet" },
2793 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
2794 "when dumping packets, also dump the payload" },
2795 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2796 OPT_INPUT, { .off = OFFSET(rate_emu) },
2797 "read input at native frame rate", "" },
2798 { "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
2799 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2800 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2801 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2802 "video sync method", "" },
2803 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2804 "audio sync method", "" },
2805 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2806 "audio drift threshold", "threshold" },
2807 { "copyts", OPT_BOOL | OPT_EXPERT, { ©_ts },
2808 "copy timestamps" },
2809 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { ©_tb },
2810 "copy input stream time base when stream copying", "mode" },
2811 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2812 OPT_OUTPUT, { .off = OFFSET(shortest) },
2813 "finish encoding within shortest input" },
2814 { "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
2815 OPT_OUTPUT, { .off = OFFSET(apad) },
2817 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2818 "timestamp discontinuity delta threshold", "threshold" },
2819 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
2820 "timestamp error delta threshold", "threshold" },
2821 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2822 "exit on error", "error" },
2823 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2824 OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
2825 "copy initial non-keyframes" },
2826 { "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
2827 "copy or discard frames before start time" },
2828 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2829 "set the number of frames to record", "number" },
2830 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
2831 OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
2832 "force codec tag/fourcc", "fourcc/tag" },
2833 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2834 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
2835 "use fixed quality scale (VBR)", "q" },
2836 { "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2837 OPT_OUTPUT, { .func_arg = opt_qscale },
2838 "use fixed quality scale (VBR)", "q" },
2839 { "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2840 "set profile", "profile" },
2841 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2842 "set stream filtergraph", "filter_graph" },
2843 { "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2844 "read stream filtergraph description from a file", "filename" },
2845 { "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
2846 "reinit filtergraph on input parameter changes", "" },
2847 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2848 "create a complex filtergraph", "graph_description" },
2849 { "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2850 "create a complex filtergraph", "graph_description" },
2851 { "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
2852 "read complex filtergraph description from a file", "filename" },
2853 { "stats", OPT_BOOL, { &print_stats },
2854 "print progress report during encoding", },
2855 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2856 OPT_OUTPUT, { .func_arg = opt_attach },
2857 "add an attachment to the output file", "filename" },
2858 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2859 OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
2860 "extract an attachment into a file", "filename" },
2861 { "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
2862 "print timestamp debugging info" },
2863 { "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
2864 "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2865 { "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
2866 OPT_INPUT, { .off = OFFSET(discard) },
2870 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
2871 "set the number of video frames to record", "number" },
2872 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2873 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
2874 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2875 { "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2876 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
2877 "set frame size (WxH or abbreviation)", "size" },
2878 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
2879 OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
2880 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2881 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2882 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
2883 "set pixel format", "format" },
2884 { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
2885 "set the number of bits per raw sample", "number" },
2886 { "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
2887 "deprecated use -g 1" },
2888 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
2890 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2891 OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
2892 "rate control override for specific intervals", "override" },
2893 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
2894 OPT_OUTPUT, { .func_arg = opt_video_codec },
2895 "force video codec ('copy' to copy stream)", "codec" },
2896 { "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2898 { "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
2900 { "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
2901 "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2902 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
2903 "select the pass number (1 to 3)", "n" },
2904 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2905 OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
2906 "select two pass log file name prefix", "prefix" },
2907 { "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
2908 "this option is deprecated, use the yadif filter instead" },
2909 { "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
2910 "calculate PSNR of compressed frames" },
2911 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2912 "dump video coding statistics to file" },
2913 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2914 "dump video coding statistics to file", "file" },
2915 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
2916 "set video filters", "filter_graph" },
2917 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2918 OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
2919 "specify intra matrix coeffs", "matrix" },
2920 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2921 OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
2922 "specify inter matrix coeffs", "matrix" },
2923 { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
2924 OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
2925 "specify intra matrix coeffs", "matrix" },
2926 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
2927 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
2928 "top=1/bottom=0/auto=-1 field first", "" },
2929 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2930 "intra_dc_precision", "precision" },
2931 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2932 OPT_OUTPUT, { .func_arg = opt_old2new },
2933 "force video tag/fourcc", "fourcc/tag" },
2934 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2935 "show QP histogram" },
2936 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2937 OPT_OUTPUT, { .off = OFFSET(force_fps) },
2938 "force the selected framerate, disable the best supported framerate selection" },
2939 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2940 OPT_OUTPUT, { .func_arg = opt_streamid },
2941 "set the value of an outfile streamid", "streamIndex:value" },
2942 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2943 OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
2944 "force key frames at specified timestamps", "timestamps" },
2945 { "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
2946 "video bitrate (please use -b:v)", "bitrate" },
2947 { "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2948 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
2949 "use HW accelerated decoding", "hwaccel name" },
2950 { "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2951 OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
2952 "select a device for HW acceleration" "devicename" },
2955 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
2956 "set the number of audio frames to record", "number" },
2957 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
2958 "set audio quality (codec-specific)", "quality", },
2959 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2960 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
2961 "set audio sampling rate (in Hz)", "rate" },
2962 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
2963 OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
2964 "set number of audio channels", "channels" },
2965 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
2967 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
2968 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
2969 "force audio codec ('copy' to copy stream)", "codec" },
2970 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2971 OPT_OUTPUT, { .func_arg = opt_old2new },
2972 "force audio tag/fourcc", "fourcc/tag" },
2973 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2974 "change audio volume (256=normal)" , "volume" },
2975 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
2976 OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
2977 "set sample format", "format" },
2978 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2979 OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
2980 "set channel layout", "layout" },
2981 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
2982 "set audio filters", "filter_graph" },
2983 { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
2984 "set the maximum number of channels to try to guess the channel layout" },
2986 /* subtitle options */
2987 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2988 "disable subtitle" },
2989 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2990 "force subtitle codec ('copy' to copy stream)", "codec" },
2991 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
2992 , "force subtitle tag/fourcc", "fourcc/tag" },
2993 { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
2994 "fix subtitles duration" },
2995 { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
2996 "set canvas size (WxH or abbreviation)", "size" },
2999 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3000 "deprecated, use -channel", "channel" },
3001 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3002 "deprecated, use -standard", "standard" },
3003 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3006 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3007 "set the maximum demux-decode delay", "seconds" },
3008 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3009 "set the initial demux-decode delay", "seconds" },
3010 { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3011 "override the options from ffserver", "" },
3013 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3014 "A comma-separated list of bitstream filters", "bitstream_filters" },
3015 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3016 "deprecated", "audio bitstream_filters" },
3017 { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3018 "deprecated", "video bitstream_filters" },
3020 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3021 "set the audio options to the indicated preset", "preset" },
3022 { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3023 "set the video options to the indicated preset", "preset" },
3024 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3025 "set the subtitle options to the indicated preset", "preset" },
3026 { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3027 "set options from indicated preset file", "filename" },
3028 /* data codec support */
3029 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3030 "force data codec ('copy' to copy stream)", "codec" },
3031 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },