jicofo {
// Authentication with external services
authentication {
// Setting enabled=false is the same as type=NONE
enabled = false
// The type of authentication. Supported values are XMPP, JWT or NONE (default).
type = NONE
// The pattern of authentication URL.
# login-url =
authentication-lifetime = 24 hours
enable-auto-login = true
}
// Configuration related to jitsi-videobridge
bridge {
// The maximum number of participants in a single conference to put on one bridge (use -1 for no maximum).
max-bridge-participants = 80
// The default assumed average stress per participant. This value is only used when a bridge does not report its
// own value.
average-participant-stress = 0.01
// The assumed time that an endpoint takes to start contributing fully to the load on a bridge. To avoid allocating
// a burst of endpoints to the same bridge, the bridge stress is adjusted by adding the number of new endpoints
// in the last [participant-rampup-time] multiplied by [average-participant-stress].
participant-rampup-interval = 20 seconds
// The stress level above which a bridge is considered overstressed.
stress-threshold = 0.8
// The amount of to wait before retrying using a failed bridge.
failure-reset-threshold = 1 minute
// The bridge selection strategy. The built-in strategies are:
// SingleBridgeSelectionStrategy: Use the least loaded bridge, do not split a conference between bridges (Octo).
// SplitBridgeSelectionStrategy: Use a separate bridge for each participant (for testing).
// RegionBasedBridgeSelectionStrategy: Attempt to put each participant in a bridge in their local region (i.e. use
// Octo for geo-location).
// IntraRegionBridgeSelectionStrategy: Use additional bridges when a bridge becomes overloaded (i.e. use Octo for
// load balancing).
// VisitorSelectionStrategy: Use separate strategies and bridges for visitors and participants. In this case,
// visitor-selection-strategy and participant-selection-strategy should be defined
//
// Additionally, you can use the fully qualified class name for custom BridgeSelectionStrategy implementations.
selection-strategy = SingleBridgeSelectionStrategy
// Uncomment and define these if your primary selection strategy is VisitorSelectionStrategy
# visitor-selection-strategy = RegionBasedBridgeSelectionStrategy
# participant-selection-strategy = RegionBasedBridgeSelectionStrategy
// The topology selection strategy.
topology-strategy = SingleMeshTopologyStrategy
// A partition of regions into groups that are "close" to each other (regions not specified here will be assumed
// to be in a group of their own). When selecting a bridge for a region R, existing conference bridge in R's group
// of regions will all be considered to match the region.
// For example, with the sample values below, if a conference has a bridge in "us-east" and a participant in
// "us-west" joins, the bridge in "us-east" will be used because "us-east" and "us-west" are in the same group.
// region-groups = [
// [ "us-east", "us-west" ],
// [ "eu-central", "eu-west"]
// ]
health-checks {
// Whether jicofo should perform periodic health checks to the connected bridges.
enabled = true
// The interval at which to perform health checks.
interval = 10 seconds
// When a health checks times out, jicofo will retry and only consider it fail after the retry fails. This
// configures the delay between the original health check timing out and the second health check being sent.
// It is a duration and defaults to half the [interval].
# retry-delay = 5 seconds
// Use the lack of presence to infer unhealthy status instead of sending explicit health check requests.
use-presence = false
// A bridge will be consider unhealthy unless we've received its presence in that period.
presence-timeout = 45 seconds
}
// The JID of the MUC to be used as a brewery for bridge instances.
# brewery-jid = jvbbrewery@example.com
// The XMPP connection to use to communicate with Jitsi Videobridge instances.
// Either `Client` or `Service` (case-sensitive). See the corresponding XMPP connection configuration under `xmpp`.
// Note that if no separate Service connection has been configured, all services will automatically use the
// Client connection.
xmpp-connection-name = Service
// Detect bridge failure based on endpoints that request a restart due to an ICE failure.
ice-failure-detection {
enabled = false
// Count the number of restart requests in the last `interval`.
interval = 2 minutes
// The minimum number of endpoints on the bridge before this check is enabled.
min-endpoints = 30
// The threshold, in terms of fraction of endpoints that requested a restart in the last `interval`, above which
// the bridge will be considered failing ICE.
threshold = 0.1
// Once the "failing ICE" state is entered, the bridge will stay in it at least this long (refreshed as long as
// the condition is met).
timeout = 10 minutes
}
load-redistribution {
// Whether automatic redistribution of endpoints away from overloaded bridges is enabled.
enabled = false
// The interval at which to run.
interval = 1 minute
// The threshold above which to redistribute endpoints away from a bridge. This needs to be higher than
// jicofo.bridge.stress-threshold.
stress-threshold = 0.9
// The amount of time to wait before moving more endpoints away from a bridge.
timeout = 3 minutes
// The number of endpoints to move away from a bridge at a time.
endpoints = 10
}
}
// Configure the codecs and RTP extensions to be used in the offer sent to clients.
codec {
video {
av1 {
enabled = true
pt = 41
// Payload type for the associated RTX stream. Set to -1 to disable RTX.
rtx-pt = 42
enable-remb = true
}
vp8 {
enabled = true
pt = 100
// Payload type for the associated RTX stream. Set to -1 to disable RTX.
rtx-pt = 96
enable-remb = true
}
vp9 {
enabled = true
pt = 101
// Payload type for the associated RTX stream. Set to -1 to disable RTX.
rtx-pt = 97
enable-remb = true
}
h264 {
enabled = true
pt = 107
// Payload type for the associated RTX stream. Set to -1 to disable RTX.
rtx-pt = 99
enable-remb = true
}
}
audio {
opus {
enabled = true
pt = 111
minptime = 10
use-inband-fec = true
red {
enabled = false
pt = 112
}
}
telephone-event {
enabled = true
pt = 126
}
}
// RTP header extensions
rtp-extensions {
audio-level {
enabled = true
id = 1
}
av1-dependency-descriptor {
enabled = true
id = 11
}
video-layers-allocation {
enabled = false
id = 12
}
tof {
// TOF is currently disabled, because we don't support it in the bridge
// (and currently clients seem to not use it when abs-send-time is
// available).
enabled = false
id = 2
}
abs-send-time {
enabled = true
id = 3
}
rid {
enabled = false
id = 4
}
tcc {
enabled = true
id = 5
}
video-content-type {
enabled = false
id = 7
}
framemarking {
enabled = false
id = 9
}
mid {
enabled = false
id = 10
}
extmap-allow-mixed = true
}
}
conference {
// Whether to automatically grant the 'owner' role to the first participant in the conference (and subsequently to
// the next in line when the current owner leaves).
enable-auto-owner = true
// Can be used to disable moderator checks for starting a recording or placing a call
enable-moderator-checks = true
// How long to wait for the initial participant in a conference.
initial-timeout = 15 seconds
// The maximum number of sources an endpoint is allowed to signal in a conferencee.
max-ssrcs-per-user = 20
// The maximum number of ssrc-groups an endpoint is allowed to signal in a conferencee.
max-ssrc-groups-per-user = ${jicofo.conference.max-ssrcs-per-user}
// How long a participant's media session will be kept alive once it remains the only participant in the room.
single-participant-timeout = 20 seconds
// The minimum number of participants required for the conference to be started.
min-participants = 2
// The maximum number of participants that can send their audio at the same time.
max-audio-senders = 999999
// The maximum number of participants that can send their video at the same time.
max-video-senders = 999999
// Whether to strip simulcast when signaling sources to receivers.
strip-simulcast = true
// Whether to use SSRC rewriting for participants that support it.
use-ssrc-rewriting = true
// Whether to use a JSON encoding of sources instead of the standard Jingle encoding (only used for participants
// that signal support for JSON encoded sources).
use-json-encoded-sources = true
shared-document {
// If `true` the shared document uses a random name. Otherwise, it uses the conference name.
use-random-name = false
}
// How much to delay signaling Jingle source-add and source-remove in order to batch them and reduce the number of
// messages (based on conference size). The values are in milliseconds.
source-signaling-delays = {
// Conferences with size <50 will have delay=0.
// Conferences with size between 50 and 99 will have delay=500 ms.
#50 = 500
// Conferences with size >=100 have delay=1000 ms.
#100 = 1000
}
// The method to use when re-inviting participants. Either RestartJingle (terminate and re-create the whole jingle
// session) or ReplaceTransport (send a transport-replace).
reinvite-method = "RestartJingle"
// Rate limits for a participant requesting an ICE restart.
restart-request-rate-limits {
// Never accept a request unless at least `min-interval` has passed since the last request
min-interval = 5 seconds
// Accept at most `max-requests` per `interval`
max-requests = 5
interval = 1 minute
}
}
// Configuration for the internal health checks performed by jicofo.
health {
// Whether to perform health checks.
enabled = false
// The interval between health checks. If set to 0, periodic health checks will not be performed.
interval = 10 seconds
# The timeout for a health check
timeout = 30 seconds
# If performing a health check takes longer than this, it is considered unsuccessful.
max-check-duration = 20 seconds
# The prefix to use when creating MUC rooms for the purpose of health checks.
room-name-prefix = "__jicofo-health-check"
}
jibri {
// The JID of the MUC to be used as a brewery for jibri instances for streaming.
# brewery-jid = "jibribrewery@example.com"
// How many times to retry a given Jibri request before giving up. Set to -1 to allow infinite retries.
num-retries = 5
// How long to wait for Jibri to start recording from the time it accepts a START request.
pending-timeout = 90 seconds
// The XMPP connection to use to communicate with Jibri instances. Either `Client` or `Service` (case-sensitive).
// See the corresponding XMPP connection configuration under `xmpp`.
// Note that if no separate Service connection has been configured, all services will automatically use the
// Client connection.
xmpp-connection-name = Client
// Enable use of private addresses for ICE for jibri
use-private-address-connectivity = true
}
jibri-sip {
// The JID of the MUC to be used as a brewery for jibri instances for SIP.
# brewery-jid = "jibrisipbrewery@example.com"
}
jigasi {
// The JID of the MUC to be used as a brewery for jigasi instances.
# brewery-jid = "jigasibrewery@example.com"
// The XMPP connection to use to communicate with Jigasi instances. Either `Client` or `Service` (case-sensitive).
// See the corresponding XMPP connection configuration under `xmpp`.
// Note that if no separate Service connection has been configured, all services will automatically use the
// Client connection.
xmpp-connection-name = Client
// Enable use of private addresses for ICE for jigasi
use-private-address-connectivity = true
}
// The region in which the machine is running.
#local-region="us-east-1"
// Controls the metrics accessible at /metrics (but not /stats).
metrics {
// A subset of the metrics are re-calculated and updated periodically. This controls how often.
update-interval = 30 seconds
}
octo {
// Whether or not to use Octo. Note that when enabled, its use will be determined by
// $jicofo.bridge.selection-strategy. There's a corresponding flag in the JVB and these
// two MUST be in sync (otherwise bridges will crash because they won't know how to
// deal with octo channels).
enabled = false
// Whether to allow bridges with different versions to be used in the same conference. Intended only for testing.
allow-mixed-versions = false
// Whether bridge-to-bridge communication should use SCTP datachannels (as opposed to websockets)
sctp-datachannels = ${jicofo.sctp.enabled}
}
rest {
enabled = true
port = 8888
host = "0.0.0.0"
prometheus {
// Enable the prometheus /metrics endpoint.
enabled = true
}
conference-request {
// Enable the conference-request endpoint
enabled = true
}
move-endpoints {
// Enable the move-endpoint API.
enabled = true
}
debug {
enabled = true
}
pin {
enabled = true
}
}
sctp {
// Whether to allocate SCTP channels on the bridge (only when the client advertises support, and SCTP is
// enabled in the per-conference configuration).
enabled = true
}
# Visitors are endpoints which are allowed to receive audio/video in a conference, but not send any. For better
# scalability visitors are not members of the conferencec MUC. Instead, they login to a separate XMPP server and join
# a separate "visitor MUC" associated with the conference MUC. Presence from the main MUC is propagated to the set of
# associated visitor MUCs.
#
# Jicofo connects to a set of XMPP servers used only for visitors (configured under `jicofoo.xmpp.visitors`). It's
# its responsibility to select a "visitor node" for each endpoint that requests to join a conference and redirect
# it to that node.
visitors {
# Whether visitors (XMPP MUC members with role "visitor") should be invited into the conference.
enabled = false
# The maximum number of participants in the main room, after which conference requests will be redirected to
# visitor nodes.
max-participants = 50
# The maximum number of visitors per node (visitor MUC). Note that this is not a hard limit: once it is reached for
# all available visitor nodes, visitors are redirected to the visitor MUC with fewest visitors.
max-visitors-per-node = 500
# After a visitor is redirected to a vnode, the amount of time to count it toward the vnode's visitor count
# even before its presence shows up. This stops vnodes from getting overloaded when many visitors join simultaneously.
vnode-join-latency-interval = 60 seconds
# The minimum interval at which notification counts are updated
notification-interval = 15 seconds
# The visitors process has two parts:
# 1. Endpoints are redirected to a vnode, and they join that separate MUC as visitors. They still don't receive
# presence for the main participants and do not have Jingle sessions.
# 2. The visitors' and main MUCs are connected together (visitors now receive presence for participants), and
# jicofo starts Jingle sessions with visitors (visitors now receive media for participants).
#
# With this option enabled the second part is started automatically as soon as any visitors join. Otherwise, jicofo
# waits to receive a <broadcast enabled=true> extension from one of the moderators in the conference.
auto-enable-broadcast = true
# Whether to require the "visitorsEnabled" flag in the MUC config form before enabling visitors for a conference.
# This allows the visitors option to be controlled per-conference.
require-muc-config-flag = false
# Whether to evaluate visitorsLive room flag, which can be controlled server-side
# via the room-metadata service
enable-live-room = false
}
xmpp {
// Whether to use JitsiXmppStringprep to validate JIDs. If set to false uses the default validation in Smack.
use-jitsi-jid-validation = true
// The separate XMPP connection used for communication with clients (endpoints).
client {
enabled = true
hostname = "localhost"
port = 5222
# The domain to use for login.
#domain =
# The domain where XMPP pings will be sent and where components will be discovered.
#xmpp-domain =
username = "focus"
resource = ${jicofo.xmpp.client.username}
#password =
// How long to wait for a response to a stanza before giving up.
reply-timeout = 15 seconds
// The JID/domain of the MUC service used for conferencing.
# conference-muc-jid = conference.example.com
// A flag to suppress the TLS certificate verification.
disable-certificate-verification = false
// The JID of the mod_client_proxy component if used. It will be trusted to encode the JID of the original
// sender in the resource part of the JID.
#client-proxy = focus.example.com
// Use TLS between Jicofo and the XMPP server
// Only disable this if your xmpp connection is on loopback!
use-tls = true
}
// The separate XMPP connection used for internal services (currently only jitsi-videobridge).
service {
enabled = false
hostname = "localhost"
port = 6222
#domain =
# The domain where XMPP pings will be sent and where components will be discovered.
#xmpp-domain =
username = "focus"
resource = ${jicofo.xmpp.service.username}
#password =
// How long to wait for a response to a stanza before giving up.
reply-timeout = 15 seconds
// A flag to suppress the TLS certificate verification.
disable-certificate-verification = false
// Use TLS between Jicofo and the XMPP server
// Only disable this if your xmpp connection is on loopback!
use-tls = true
}
// Additional XMPP environments to use for visitor nodes, mapped by an id/name.
visitors {
#v1 {
#enabled=true
#conference-service = conference.v1.example.com
#hostname = 127.0.0.1
#domain = "auth.v1.example.com"
#port = 7222
#password = "changeme"
#disable-certificate-verification = true
# The domain where XMPP pings will be sent and where components will be discovered.
#xmpp-domain =
#}
}
// The list of domains with trusted services. Only members logged in to these domains can declare themselves to be
// Jibri instances.
trusted-domains = []
}
}