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 only when a bridge becomes overloaded (i.e. use Octo
    // only for load balancing). This hasn't been tested much; use RegionBasedBridgeSelectionStrategy unless there's a
    // reason not to.
    // 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 = "127.0.0.1"

    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
  }
  transcription {
    # A templated URL to use for backend (non-jigasi) transcription. The strings "{{MEEETING_ID}}" and "{{REGION}}"
    # will be replaced with the unique meeting ID and the region of the bridge used for transcription. The region is
    # optional. Note no whitespace is allowed in the templates, they have to match exactly.
    // url-template = "wss://{{REGION}}.example.com/recorder/{{MEETING_ID}}"
  }

  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 = []
  }
}
