Package io.antmedia

Class AppSettings

  • All Implemented Interfaces:
    Serializable
    @Entity("AppSettings")
@Indexes(@Index(fields=@Field("appName")))
@PropertySource("/WEB-INF/red5-web.properties")
public class AppSettings
extends Object
implements Serializable
    Application Settings for each application running in Ant Media Server. Each setting should have a default value with @Value annotation. Otherwise it breaks compatibility These settings are set for each applications and stored in the file /webapps//WEB_INF/red5-web.properties. Click on any field to see its default value. With version 2.6.2+, you can give the field name as property directly. 2.6.2 is also backward compatible with the old properties. Example: click on aacEncodingEnabled --> The line @Value("${aacEncodingEnabled:#{${"+SETTINGS_AAC_ENCODING_ENABLED+":true}}}") means that You can add aacEncodingEnabled` property to the /webapps//WEB_INF/red5-web.properties as follows ``` aacEncodingEnabled=false ``` SETTINGS_AAC_ENCODING_ENABLED(settings.aacEncodingEnabled) definition provides backward compatibility for old property naming Pay Attention: You don't need to change the configuration file manually anymore. You can do all changes through Web Panel.
    Author:
    mekya
    See Also:
    Serialized Form

    • Field Detail

      • dbId

        @Id
private org.bson.types.ObjectId dbId

      • remoteAllowedCIDR

        @Value("${remoteAllowedCIDR:${settings.remoteAllowedCIDR:127.0.0.1}}")
private String remoteAllowedCIDR
        Comma separated CIDR that rest services are allowed to response Allowed IP addresses to reach REST API, It must be in CIDR format as a.b.c.d/x

      • mp4MuxingEnabled

        @Value("${mp4MuxingEnabled:${settings.mp4MuxingEnabled:false}}")
private boolean mp4MuxingEnabled
        It's mandatory, If it is set true then a mp4 file is created into /streams directory Default value is false

      • webMMuxingEnabled

        @Value("${webMMuxingEnabled:${settings.webMMuxingEnabled:false}}")
private boolean webMMuxingEnabled
        Enable/Disable WebM recording

      • addDateTimeToMp4FileName

        @Value("${addDateTimeToMp4FileName:${settings.addDateTimeToMp4FileName:false}}")
private boolean addDateTimeToMp4FileName
        It's mandatory, Date and time are added to created .mp4 file name, Default value is false

      • fileNameFormat

        @Value("${fileNameFormat:${settings.fileNameFormat:%r%b}}")
private String fileNameFormat
        The format of output mp4 and ts files. To add resolution like stream1_240p.mp4, add %r to the string To add bitrate like stream1_500kbps, add %b to the string Add both for stream1_240p500kbps

      • hlsMuxingEnabled

        @Value("${hlsMuxingEnabled:${settings.hlsMuxingEnabled:true}}")
private boolean hlsMuxingEnabled
        Enable/disable hls recording If it is set true then HLS files are created into /streams and HLS playing is enabled, Default value is true

      • encoderSettingsString

        @Value("${encoderSettingsString:${settings.encoderSettingsString:}}")
private String encoderSettingsString
        Encoder settings in comma separated format This must be set for adaptive streaming, If it is empty SFU mode will be active in WebRTCAppEE, video height, video bitrate, and audio bitrate are set as an example, Ex. 480,300000,96000,360,200000,64000.

      • signalingEnabled

        @Value("${signalingEnabled:${signaling.enabled:false}}")
private boolean signalingEnabled
        This is for making this instance run also as a signaling server. Signaling Server lets Ant Media Server instances behind NAT stream its content to the peer in the Internet

      • signalingAddress

        @Value("${signalingAddress:${signaling.address:}}")
private String signalingAddress
        This is for using another Ant Media instance as signaling server. If your server is behind a NAT it will allow possible connection. It should be full qualified URI like this ws://107.23.25.77:5080/WebRTCAppEE/websocket/signaling

      • hlsListSize

        @Value("${hlsListSize:${settings.hlsListSize:5}}")
private String hlsListSize
        Number of segments(chunks) in m3u8 files Set the maximum number of playlist entries, If 0 the list file will contain all the segments,

      • hlsTime

        @Value("${hlsTime:${settings.hlsTime:2}}")
private String hlsTime
        Duration of segments in m3u8 files Target segment length in seconds, Segment will be cut on the next key frame after this time has passed.

      • uploadExtensionsToS3

        @Value("${uploadExtensionsToS3:${settings.uploadExtensionsToS3:7}}")
private int uploadExtensionsToS3
        Binary entity for uploading the extensions 0 means does not upload, 1 means upload Least significant digit switches mp4 files upload to s3 Second digit switches HLS files upload to s3 Most significant digit switches PNG files upload to s3 Example: 5 ( 101 in binary ) means upload mp4 and PNG but not HLS HLS files still will be saved on the server if deleteHLSFilesOnEnded flag is false

      • s3StorageClass

        @Value("${s3StorageClass:${settings.s3StorageClass:STANDARD}}")
private String s3StorageClass

      • endpointHealthCheckPeriodMs

        @Value("${endpointHealthCheckPeriodMs:${settings.endpoint.healthCheckPeriodMs:2000}}")
private int endpointHealthCheckPeriodMs
        Endpoint will try to republish if error occurs, however the error might get fixed internally in case of small issues without republishing This value is the check time for endpoint in 3 trials For example for 2 seconds, there will be 2 checks in 2 second intervals, if each of them fails it will try to republish in 3rd check.

      • endpointRepublishLimit

        @Value("${endpointRepublishLimit:${settings.endpoint.republishLimit:3}}")
private int endpointRepublishLimit
        This limit is for republishing to a certain endpoint for how many times For example in case we tried to republish 3 times and still got an error We conclude that the endpoint is dead and close it.

      • dashSegDuration

        @Value("${dashSegDuration:${settings.dashSegDuration:6}}")
private String dashSegDuration
        Duration of segments in mpd files, Segments are a property of DASH. A segment is the minimal download unit.

      • dashFragmentDuration

        @Value("${dashFragmentDuration:${settings.dashFragmentDuration:0.5}}")
private String dashFragmentDuration
        Fragments are a property of fragmented MP4 files, Typically a fragment consists of moof + mdat.

      • targetLatency

        @Value("${dashTargetLatency:${settings.dashTargetLatency:3.5}}")
private String targetLatency
        Latency of the DASH streaming,

      • dashWindowSize

        @Value("${dashWindowSize:${settings.dashWindowSize:5}}")
private String dashWindowSize
        DASH window size, Number of files in manifest

      • dashExtraWindowSize

        @Value("${dashExtraWindowSize:${settings.dashExtraWindowSize:5}}")
private String dashExtraWindowSize
        DASH extra window size, Number of segments kept outside of the manifest before removing from disk

      • lLDashEnabled

        @Value("${dashEnableLowLatency:${settings.dash.llEnabled:true}}")
private boolean lLDashEnabled
        Enable low latency dash, This settings is effective if dash is enabled

      • lLHLSEnabled

        @Value("${hlsEnableLowLatency:${settings.dash.llHlsEnabled:false}}")
private boolean lLHLSEnabled
        Enable low latency hls via dash muxer, LLHLS is effective if dash is enabled.

      • hlsEnabledViaDash

        @Value("${hlsEnabledViaDash:${settings.dash.hlsEnabled:false}}")
private boolean hlsEnabledViaDash
        Enable hls through DASH muxer, LLHLS is effective if dash is enabled.

      • useTimelineDashMuxing

        @Value("${useTimelineDashMuxing:${settings.dash.useTimeline:false}}")
private boolean useTimelineDashMuxing
        Use timeline in dash muxing.

      • webRTCEnabled

        @Value("${webRTCEnabled:${settings.webRTCEnabled:true}}")
private boolean webRTCEnabled
        Enable/disable webrtc, It's mandatory, If it is set true then WebRTC playing is enabled, Default value is false

      • useOriginalWebRTCEnabled

        @Value("${useOriginalWebRTCEnabled:${settings.useOriginalWebRTCEnabled:false}}")
private boolean useOriginalWebRTCEnabled
        The flag that sets using the original webrtc stream in streaming, This setting is effective if there is any adaptive bitrate setting, For instance assume that there is adaptive bitrate with 480p and incoming stream is 720p Then if this setting is true, there are two bitrates for playing 720p and 480p, In this case if this setting is false, there is one bitrate for playing that is 480p

      • deleteHLSFilesOnEnded

        @Value("${deleteHLSFilesOnEnded:${settings.deleteHLSFilesOnEnded:true}}")
private boolean deleteHLSFilesOnEnded
        It's mandatory, If this value is true, hls files(m3u8 and ts files) are deleted after the broadcasting has finished, Default value is true.

      • deleteDASHFilesOnEnded

        @Value("${deleteDASHFilesOnEnded:${settings.deleteDASHFilesOnEnded:true}}")
private boolean deleteDASHFilesOnEnded
        If this value is true, dash files(mpd and m4s files) are deleted after the broadcasting has finished.

      • tokenHashSecret

        @Value("${tokenHashSecret:${tokenHashSecret:}}")
private String tokenHashSecret
        The secret string used for creating hash based tokens The key that used in hash generation for hash-based access control.

      • hashControlPublishEnabled

        @Value("${hashControlPublishEnabled:${settings.hashControlPublishEnabled:false}}")
private boolean hashControlPublishEnabled
        It's mandatory, If it is set true then hash based access control enabled for publishing, enable hash control as token for publishing operations using shared secret Default value is false.

      • hashControlPlayEnabled

        @Value("${hashControlPlayEnabled:${settings.hashControlPlayEnabled:false}}")
private boolean hashControlPlayEnabled
        It's mandatory, If it is set true then hash based access control enabled for playing, enable hash control as token for playing operations using shared secret Default value is false.

      • listenerHookURL

        @Value("${listenerHookURL:${settings.listenerHookURL:}}")
private String listenerHookURL
        The URL for action callback You must set this to subscribe some event notifications, For details check: https://antmedia.io/webhook-integration/

      • acceptOnlyStreamsInDataStore

        @Value("${acceptOnlyStreamsInDataStore:${settings.acceptOnlyStreamsInDataStore:false}}")
private boolean acceptOnlyStreamsInDataStore
        The control for publishers It's mandatory, If it is set true you cannot start publishing unless you add the stream id to the database, You can add stream id by REST API. Default value is false.

      • acceptOnlyRoomsInDataStore

        @Value("${acceptOnlyRoomsInDataStore:${settings.acceptOnlyRoomsInDataStore:false}}")
private boolean acceptOnlyRoomsInDataStore
        The control for rooms

      • publishTokenControlEnabled

        @Value("${publishTokenControlEnabled:${settings.publishTokenControlEnabled:false}}")
private boolean publishTokenControlEnabled
        The settings for enabling one-time token control mechanism for accessing resources and publishing Check for details: https://antmedia.io/secure-video-streaming/. Default value is false.

      • playTokenControlEnabled

        @Value("${playTokenControlEnabled:${settings.playTokenControlEnabled:false}}")
private boolean playTokenControlEnabled
        The settings for enabling one-time token control mechanism for accessing resources and publishing It's mandatory, This enables token control, Check for details: https://antmedia.io/secure-video-streaming/. Default value is false.

      • timeTokenSubscriberOnly

        @Value("${timeTokenSubscriberOnly:${settings.timeTokenSubscriberOnly:false}}")
private boolean timeTokenSubscriberOnly
        The settings for accepting only time based token subscribers as connections to the streams

      • enableTimeTokenForPlay

        @Value("${enableTimeTokenForPlay:${settings.enableTimeTokenForPlay:false}}")
private boolean enableTimeTokenForPlay
        The setting for accepting only time based token(TOTP) subscribers as connections to the streams

      • timeTokenSecretForPlay

        @Value("${timeTokenSecretForPlay:#{null}}")
private String timeTokenSecretForPlay
        TOTP(Time-based One Time Password) Token Secret for Playing. If subscriber is not available in database, server checks the TOTP code against this value

      • enableTimeTokenForPublish

        @Value("${enableTimeTokenForPublish:${settings.enableTimeTokenForPublish:false}}")
private boolean enableTimeTokenForPublish
        The settings for accepting only time based token(TOTP) subscribers as connections to the streams

      • timeTokenSecretForPublish

        @Value("${timeTokenSecretForPublish:#{null}}")
private String timeTokenSecretForPublish
        TOTP(Time-based One Time Password) Token Secret for Publishing. If subscriber is not available in database, server checks the TOTP code against this value

      • timeTokenPeriod

        @Value("${timeTokenPeriod:${settings.timeTokenPeriod:60}}")
private int timeTokenPeriod
        period for the generated time token

      • hlsPlayListType

        @Value("${hlsPlayListType:${settings.hlsPlayListType:}}")
private String hlsPlayListType
        It can be event: or vod, Check HLS documentation for EXT-X-PLAYLIST-TYPE.

      • vodFolder

        @Value("${vodFolder:${settings.vodFolder:}}")
private String vodFolder
        The path for manually saved used VoDs Determines the directory to store VOD files.

      • previewOverwrite

        @Value("${previewOverwrite:${settings.previewOverwrite:false}}")
private boolean previewOverwrite
        Overwrite preview files if exist, default value is false If it is set true and new stream starts with the same id, preview of the new one overrides the previous file, If it is false previous file saved with a suffix.

      • stalkerDBServer

        @Value("${stalkerDBServer:${settings.stalkerDBServer:}}")
private String stalkerDBServer
        Address of the Stalker Portal DB server Database host address of IP TV Ministra platform.

      • stalkerDBUsername

        @Value("${stalkerDBUsername:${settings.stalkerDBUsername:}}")
private String stalkerDBUsername
        Username of stalker portal DB Database user name of IP TV Ministra platform.

      • stalkerDBPassword

        @Value("${stalkerDBPassword:${settings.stalkerDBPassword:}}")
private String stalkerDBPassword
        Password of the stalker portal DB User Database password of IP TV Ministra platform.

      • objectDetectionEnabled

        @Value("${objectDetectionEnabled:${settings.objectDetectionEnabled:false}}")
private boolean objectDetectionEnabled
        It's mandatory, The directory contains the tensorflow object detection model If it is set true then object detection algorithm is run for streaming video, Default value is false.

      • createPreviewPeriod

        @Value("${createPreviewPeriod:${settings.createPreviewPeriod:5000}}")
private int createPreviewPeriod
        It's mandatory, This determines the period (milliseconds) of preview (png) file creation, This file is created into /preview directory. Default value is 5000.

      • restartStreamFetcherPeriod

        @Value("${streamFetcherRestartPeriod:${settings.streamFetcherRestartPeriod:0}}")
private int restartStreamFetcherPeriod
        It's mandatory, Restart stream fetcher period in seconds Restart time for fetched streams from external sources, Default value is 0

      • startStreamFetcherAutomatically

        @Value("${streamFetcherAutoStart:${settings.streamFetcherAutoStart:false}}")
private boolean startStreamFetcherAutomatically
        Stream fetchers are started automatically if it is set true

      • streamFetcherBufferTime

        private int streamFetcherBufferTime
        It's mandatory, Stream fetcher buffer time in milliseconds, Stream is buffered for this duration and after that it will be started, Buffering time for fetched streams from external sources. 0 means no buffer, Default value is 0

      • hlsflags

        @Value("${hlsflags:${settings.hlsflags:delete_segments}}")
private String hlsflags
        HLS Flags for FFmpeg HLS Muxer, Please add value by plus prefix in the properties file like this settings.hlsflags=+program_date_time you can add + separated more options like below settings.hlsflags=+program_date_time+round_durations+append_list Separate with + or -. Check for details: https://ffmpeg.org/ffmpeg-formats.html#Options-6

      • mySqlClientPath

        private String mySqlClientPath

      • muxerFinishScript

        @Value("${muxerFinishScript:${settings.muxerFinishScript:}}")
private String muxerFinishScript
        This is a script file path that is called by Runtime when muxing is finished, Bash script file path will be called after stream finishes.

      • webRTCFrameRate

        @Value("${webRTCFrameRate:${settings.webRTCFrameRate:30}}")
private int webRTCFrameRate
        It's mandatory, Determines the frame rate of video publishing to the WebRTC players, Default value is 30 because users are complaining about the 20fps(previous value) and may not know to change it

      • webRTCPortRangeMin

        @Value("${webRTCPortRangeMin:${settings.webrtc.portRangeMin:50000}}")
private int webRTCPortRangeMin
        Min port number of the port range of WebRTC, It's effective when user publishes stream, This value should be less than the webRTCPortRangeMax Determines the minimum port number for WebRTC connections, Default value is 0.

      • webRTCPortRangeMax

        @Value("${webRTCPortRangeMax:${settings.webrtc.portRangeMax:60000}}")
private int webRTCPortRangeMax
        Max port number of the port range of WebRTC, It's effective when user publishes stream In order to port range port this value should be higher than webRTCPortRangeMin

      • stunServerURI

        @Value("${stunServerURI:${settings.webrtc.stunServerURI:stun:stun1.l.google.com:19302}}")
private String stunServerURI
        STUN or TURN Server URI STUN server URI used for WebRTC ICE candidates You can check: https://antmedia.io/learn-webrtc-basics-components/, Default value is stun:stun.l.google.com:19302 STUN or TURN URL can be set for this properoy

      • turnServerUsername

        @Value("${turnServerUsername:${settings.webrtc.turnServerUsername:}}")
private String turnServerUsername
        TURN server username for WebRTC ICE candidates. In order to be effective, #stunServerURI and #turnServerCredential should be set

      • turnServerCredential

        @Value("${turnServerCredential:${settings.webrtc.turnServerCredential:}}")
private String turnServerCredential
        TURN server credentai for WebRTC ICE candidates. In order to be effective, #stunServerURI and #turnServerUsername should be set

      • webRTCTcpCandidatesEnabled

        @Value("${webRTCTcpCandidatesEnabled:${settings.webrtc.tcpCandidateEnabled:false}}")
private boolean webRTCTcpCandidatesEnabled
        It's mandatory, TCP candidates are enabled/disabled.It's effective when user publishes stream It's disabled by default If it is set true then TCP candidates can be used for WebRTC connection, If it is false only UDP port will be used, Default value is true.

      • webRTCSdpSemantics

        @Value("${webRTCSdpSemantics:${settings.webrtc.sdpSemantics:unifiedPlan}}")
private String webRTCSdpSemantics
        WebRTC SDP Semantics It can "planB" or "unifiedPlan"

      • portAllocatorFlags

        @Value("${portAllocatorFlags:${settings.portAllocator.flags:0}}")
private int portAllocatorFlags
        Port Allocator Flags for WebRTC PORTALLOCATOR_DISABLE_UDP = 0x01, PORTALLOCATOR_DISABLE_STUN = 0x02, PORTALLOCATOR_DISABLE_RELAY = 0x04,

      • encoderName

        @Value("${encoderName:${settings.encoding.encoderName:}}")
private String encoderName
        Name of the encoder to be used in adaptive bitrate, If there is a GPU, server tries to open h264_nvenc, If there is no GPU, server tries to open libx264 by default Can be h264_nvenc or libx264. If you set h264_nvenc but it cannot be opened then libx264 will be used, Name of the encoder to be used in adaptive bitrate, If there is a GPU, server tries to open h264_nvenc, If there is no GPU, server tries to open libx264 by default

      • encoderPreset

        @Value("${encoderPreset:${settings.encoding.preset:}}")
private String encoderPreset
        Encoder's preset value in adaptive bitrate Libx264 presets are there https://trac.ffmpeg.org/wiki/Encode/H.264 Ant Media Server uses "veryfast" by default

      • encoderProfile

        @Value("${encoderProfile:${settings.encoding.profile:}}")
private String encoderProfile
        Encoder profile in adaptive bitrate, It's baseline by default.

      • encoderLevel

        @Value("${encoderLevel:${settings.encoding.level:}}")
private String encoderLevel
        Encoder level in adaptive bitrate

      • encoderRc

        @Value("${encoderRc:${settings.encoding.rc:}}")
private String encoderRc
        Encoding rate control in adaptive bitrate

      • encoderSpecific

        @Value("${encoderSpecific:${settings.encoding.specific:}}")
private String encoderSpecific
        Encoder specific configuration for libx264 in adaptive bitrate, This is the x264-params in ffmpeg Specific settings for selected encoder, For libx264 please check https://trac.ffmpeg.org/wiki/Encode/H.264

      • encoderThreadCount

        @Value("${encoderThreadCount:${settings.encoding.threadCount:0}}")
private int encoderThreadCount
        Encoder thread count.

      • encoderThreadType

        @Value("${encoderThreadType:${settings.encoding.threadType:0}}")
private int encoderThreadType
        Encoder thread type 0: auto 1: frame 2: slice

      • vp8EncoderSpeed

        @Value("${vp8EncoderSpeed:${settings.encoding.vp8.speed:4}}")
private int vp8EncoderSpeed
        Set quality/speed ratio modifier, Higher values speed up the encode at the cost of quality.

      • vp8EncoderDeadline

        @Value("${vp8EncoderDeadline:${settings.encoding.vp8.deadline:realtime}}")
private String vp8EncoderDeadline
        VP8 Encoder deadline: best good realtime

      • vp8EncoderThreadCount

        @Value("${vp8EncoderThreadCount:${settings.encoding.vp8.threadCount:1}}")
private int vp8EncoderThreadCount
        VP8 Encoder thread count.

      • previewHeight

        @Value("${previewHeight:${settings.previewHeight:480}}")
private int previewHeight
        It's mandatory, Determines the height of preview file, Default value is 480

      • generatePreview

        @Value("${generatePreview:${settings.previewGenerate:false}}")
private boolean generatePreview
        Generate preview if there is any adaptive settings, Preview generation depends on adaptive settings and it's generated by default

      • writeStatsToDatastore

        @Value("${writeStatsToDatastore:${settings.writeStatsToDatastore:true}}")
private boolean writeStatsToDatastore

      • encoderSelectionPreference

        @Value("${encoderSelectionPreference:${settings.encoderSelectionPreference:gpu_and_cpu}}")
private String encoderSelectionPreference
        Can be "gpu_and_cpu" or "only_gpu" "only_gpu" only tries to open the GPU for encoding, If it cannot open the gpu codec it returns false "gpu_and_cpu" first tries to open the GPU for encoding if it does not open, it tries to open the CPU for encoding

      • allowedPublisherCIDR

        @Value("${allowedPublisherCIDR:${settings.allowedPublisherCIDR:}}")
private String allowedPublisherCIDR
        Comma separated CIDR that server accepts/ingests RTMP streams from, Default value is null which means that it accepts/ingests stream from everywhere

      • excessiveBandwidthValue

        @Value("${excessiveBandwidthValue:${settings.excessiveBandwidth.threshold:300000}}")
private int excessiveBandwidthValue
        The excessive bandwidth threshold value

      • excessiveBandwidthCallThreshold

        @Value("${excessiveBandwidthCallThreshold:${settings.excessiveBandwidth.call.threshold:3}}")
private int excessiveBandwidthCallThreshold
        The excessive bandwidth call threshold value

      • excessiveBandwithTryCountBeforeSwitchback

        @Value("${excessiveBandwithTryCountBeforeSwitchback:${settings.excessiveBandwith.tryCount.beforeSwitchback:4}}")
private int excessiveBandwithTryCountBeforeSwitchback

      • excessiveBandwidthAlgorithmEnabled

        @Value("${excessiveBandwidthAlgorithmEnabled:${settings.excessiveBandwidth_enabled:false}}")
private boolean excessiveBandwidthAlgorithmEnabled
        Enable or disable excessive bandwidth algorithm

      • packetLossDiffThresholdForSwitchback

        @Value("${packetLossDiffThresholdForSwitchback:${settings.excessiveBandwidth.packetLossDiffThreshold.forSwitchback:10}}")
private int packetLossDiffThresholdForSwitchback
        packet loss threshold if packetLoss is bigger than this value in ExcessiveBandwidth algorithm, it switches back to lower quality without try every attempts excessiveBandwithTryCountBeforeSwitchback

      • rttMeasurementDiffThresholdForSwitchback

        @Value("${rttMeasurementDiffThresholdForSwitchback:${settings.excessiveBandwidth.rttMeasurementDiffThreshold.forSwitchback:20}}")
private int rttMeasurementDiffThresholdForSwitchback
        rtt measurement threshold diff if rttMeasurement is bigger than this value in ExcessiveBandwidth algorithm, it switches back to lower quality without try every attempts #setTryCountBeforeSwitchback(int)

      • replaceCandidateAddrWithServerAddr

        @Value("${replaceCandidateAddrWithServerAddr:${settings.replaceCandidateAddrWithServerAddr:false}}")
private boolean replaceCandidateAddrWithServerAddr
        Replace candidate addr with server addr, In order to use it you should set serverName in conf/red5.properties

      • appName

        @Value("${appName:${db.app.name:}}")
private String appName
        Applicaiton name for the data store which should exist so that no default value such as LiveApp, WebRTCApp etc.

      • encodingTimeout

        @Value("${encodingTimeout:${settings.encoding.timeout:5000}}")
private int encodingTimeout
        Timeout for encoding If encoder cannot encode a frame in this timeout, streaming is finished by server.

      • webRTCClientStartTimeoutMs

        @Value("${webRTCClientStartTimeoutMs:${settings.webrtc.client.start.timeoutMs:10000}}")
private int webRTCClientStartTimeoutMs
        If webrtc client(publish or play) is not started in this time, it'll close automatically. It's also being used as a timeout to let publisher reconnect in fluctuating networks or ungraceful termination such as closing the browser without closing the connection.

      • defaultDecodersEnabled

        @Deprecated
@Value("${defaultDecodersEnabled:${settings.defaultDecodersEnabled:false}}")
private boolean defaultDecodersEnabled
        Deprecated.
        Set true to enable WebRTC default decoders(such as VP8, VP9) Set false to only enable h264 decoder If it is set true, WebRTC using default decoders(such as VP8, VP9). If it is set false, WebRTC using only default h264 decoder. Default value is false. Deprecated: Use vp8Enabled and h264enabled

      • updateTime

        private long updateTime
        Update time of the setting in the cluster

      • httpForwardingExtension

        @Value("${httpForwardingExtension:${settings.httpforwarding.extension:}}")
private String httpForwardingExtension
        Forwards the http requests with this extension to httpForwardingBaseURL It supports comma separated extensions Like mp4,m3u8 Don't add any leading, trailing white spaces

      • httpForwardingBaseURL

        @Value("${httpForwardingBaseURL:${settings.httpforwarding.baseURL:}}")
private String httpForwardingBaseURL
        Forward the incoming http request to this base url

      • maxAnalyzeDurationMS

        @Value("${maxAnalyzeDurationMS:${settings.rtmp.maxAnalyzeDurationMS:1500}}")
private int maxAnalyzeDurationMS
        Max analyze duration in for determining video and audio existence in RTMP, SRT and Stream Sources

      • disableIPv6Candidates

        @Value("${disableIPv6Candidates:${settings.disableIPv6Candidates:true}}")
private boolean disableIPv6Candidates
        Enable/Disable IPv6 Candidates for WebRTC It's disabled by default

      • rtspPullTransportType

        @Value("${rtspPullTransportType:${settings.rtspPullTransportType:tcp}}")
private String rtspPullTransportType
        Specify the rtsp transport type in pulling IP Camera or RTSP sources It can be tcp or udp

      • rtspTimeoutDurationMs

        @Value("${rtspTimeoutDurationMs:${settings.rtspTimeoutDurationMs:5000}}")
private int rtspTimeoutDurationMs
        Specify the rtsp transport type in pulling IP Camera or RTSP sources It can be tcp or udp

      • maxFpsAccept

        @Value("${maxFpsAccept:${settings.maxFpsAccept:0}}")
private int maxFpsAccept
        Max FPS value in RTMP streams

      • maxResolutionAccept

        @Value("${maxResolutionAccept:${settings.maxResolutionAccept:0}}")
private int maxResolutionAccept
        Max Resolution value in RTMP streams

      • maxBitrateAccept

        @Value("${maxBitrateAccept:${settings.maxBitrateAccept:0}}")
private int maxBitrateAccept
        Max Bitrate value in RTMP streams

      • h264Enabled

        @Value("${h264Enabled:${settings.h264Enabled:true}}")
private boolean h264Enabled
        Enable/Disable h264 encoding It's enabled by default

      • vp8Enabled

        @Value("${vp8Enabled:${settings.vp8Enabled:false}}")
private boolean vp8Enabled
        Enable/Disable vp8 encoding It's disabled by default

      • h265Enabled

        @Value("${h265Enabled:${settings.h265Enabled:false}}")
private boolean h265Enabled
        Enable/disable H265 Encoding Disabled by default

      • dataChannelEnabled

        @Value("${dataChannelEnabled:${settings.dataChannelEnabled:true}}")
private boolean dataChannelEnabled
        Enable/Disable data channel It's disabled by default When data channel is enabled, publisher can send messages to the players

      • dataChannelPlayerDistribution

        @Value("${dataChannelPlayerDistribution:${settings.dataChannelPlayerDistrubution:all}}")
private String dataChannelPlayerDistribution
        Defines the distribution list for player messages it can be none/publisher/all none: player messages are delivered to nobody publisher: player messages are delivered to only publisher all: player messages are delivered to everyone both publisher and all players

      • rtmpIngestBufferTimeMs

        @Value("${rtmpIngestBufferTimeMs:${settings.rtmpIngestBufferTimeMs:0}}")
private long rtmpIngestBufferTimeMs
        RTMP ingesting buffer time in Milliseconds Server buffer this amount of video packet in order to compensate when stream is not received for some time

      • dataChannelWebHookURL

        @Value("${dataChannelWebHookURL:${settings.dataChannelWebHook:}}")
private String dataChannelWebHookURL
        All data channel messages are delivered to these hook as well So that it'll be integrated to any third party application

      • h265EncoderPreset

        private String h265EncoderPreset

      • h265EncoderProfile

        private String h265EncoderProfile

      • h265EncoderRc

        private String h265EncoderRc

      • h265EncoderSpecific

        private String h265EncoderSpecific

      • h265EncoderLevel

        private String h265EncoderLevel

      • heightRtmpForwarding

        @Value("${heightRtmpForwarding:${settings.heightRtmpForwarding:360}}")
private int heightRtmpForwarding
        The height of the stream that is transcoded from incoming WebRTC stream to the RTMP This settings is effective in community edition by default It's also effective WebRTC to RTMP direct forwarding by giving rtmpForward=true in WebSocket communication in Enterprise Edition

      • audioBitrateSFU

        @Value("${audioBitrateSFU:${settings.audioBitrateSFU:96000}}")
private int audioBitrateSFU
        In SFU mode we still transcode the audio to opus and aac This settings determines the audio bitrate for opus and aac It's the bitrate that is used transcoding the audio in AAC and Opus After version(2.3), we directly forward incoming audio to the viewers without transcoding.

      • dashMuxingEnabled

        @Value("${dashMuxingEnabled:${settings.dashMuxingEnabled:false}}")
private boolean dashMuxingEnabled
        Enable/disable dash recording

      • aacEncodingEnabled

        @Value("${aacEncodingEnabled:${settings.aacEncodingEnabled:true}}")
private boolean aacEncodingEnabled
        If aacEncodingEnabled is true, aac encoding will be active even if mp4 or hls muxing is not enabled, If aacEncodingEnabled is false, aac encoding is only activated if mp4 or hls muxing is enabled in the settings, This value should be true if you're sending stream to RTMP endpoints or enable/disable mp4 recording on the fly

      • gopSize

        @Value("${gopSize:${settings.gopSize:0}}")
private int gopSize
        GOP size, AKA key frame interval, GOP size is group of pictures that encoder sends key frame for each group, The unit is not the seconds, Please don't confuse the seconds that are used in key frame intervals If GOP size is 50 and your frame rate is 25, it means that encoder will send key frame for every 2 seconds, Default value is 0 so it uses incoming gop size by default.

      • constantRateFactor

        @Value("${constantRateFactor:${settings.constantRateFactor:23}}")
private String constantRateFactor
        Constant Rate Factor used by x264, x265, VP8, Use values between 4-51

      • webRTCViewerLimit

        @Value("${webRTCViewerLimit:${settings.webRTCViewerLimit:-1}}")
private int webRTCViewerLimit
        Application level WebRTC viewer limit

      • toBeDeleted

        private boolean toBeDeleted
        Set to true when you want to delete an application

      • pullWarFile

        private boolean pullWarFile
        Set to true when the app settings are only created for pulling the war file.

      • warFileOriginServerAddress

        private String warFileOriginServerAddress
        Address of the original place of the war file.

      • jwtSecretKey

        @Value("${jwtSecretKey:${settings.jwtSecretKey:}}")
private String jwtSecretKey
        Application JWT secret key for accessing the REST API

      • jwtControlEnabled

        @Value("${jwtControlEnabled:${settings.jwtControlEnabled:false}}")
private boolean jwtControlEnabled
        Application JWT Control Enabled for accessing the REST API TODO: Remove this field. Just check if jwtSecretKey is not empty then it means jwt filter is enabled

      • ipFilterEnabled

        @Value("${ipFilterEnabled:${settings.ipFilterEnabled:true}}")
private boolean ipFilterEnabled
        Application IP Filter Enabled

      • ingestingStreamLimit

        @Value("${ingestingStreamLimit:${settings.ingestingStreamLimit:-1}}")
private int ingestingStreamLimit
        Application level total incoming stream limit

      • webRTCKeyframeTime

        @Value("${webRTCKeyframeTime:${settings.webRTCKeyframeTime:2000}}")
private int webRTCKeyframeTime
        WebRTC Keyframe Time, Ant Media Server asks key frame for every webRTCKeyframeTime in SFU mode, It's in milliseconds

      • jwtStreamSecretKey

        @Value("${jwtStreamSecretKey:${settings.jwtStreamSecretKey:}}")
private String jwtStreamSecretKey
        Application JWT stream secret key. Provide 32 character or more in length

      • publishJwtControlEnabled

        @Value("${publishJwtControlEnabled:${settings.publishJwtControlEnabled:false}}")
private boolean publishJwtControlEnabled
        The settings for enabling jwt token filter mechanism for accessing resources and publishing

      • playJwtControlEnabled

        @Value("${playJwtControlEnabled:${settings.playJwtControlEnabled:false}}")
private boolean playJwtControlEnabled
        The settings for enabling jwt token filter mechanism for accessing resources and playing

      • dashHttpStreaming

        @Value("${dashHttpStreaming:${settings.dash.httpStreaming:true}}")
private boolean dashHttpStreaming
        Use http streaming in Low Latency Dash, If it's true, it sends files through http If it's false, it writes files to disk directly In order to have Low Latency http streaming should be used

      • s3StreamsFolderPath

        @Value("${s3StreamsFolderPath:${settings.s3.streams.folder.path:streams}}")
private String s3StreamsFolderPath
        It's S3 streams MP4, WEBM and HLS files storage name . It's streams by default.

      • s3PreviewsFolderPath

        @Value("${s3PreviewsFolderPath:${settings.s3.previews.folder.path:previews}}")
private String s3PreviewsFolderPath
        It's S3 stream PNG files storage name . It's previews by default.

      • dashHttpEndpoint

        @Value("${dashHttpEndpoint:${settings.dash.httpEndpoint:}}")
private String dashHttpEndpoint

      • hlsHttpEndpoint

        @Value("${hlsHttpEndpoint:${settings.hlsHttpEndpoint:}}")
private String hlsHttpEndpoint
        Http endpoint to push the HLS stream

      • forceDecoding

        @Value("${forceDecoding:${settings.forceDecoding:false}}")
private boolean forceDecoding
        Force stream decoding even if there is no adaptive setting

      • addOriginalMuxerIntoHLSPlaylist

        @Value("${addOriginalMuxerIntoHLSPlaylist:${settings.addOriginalMuxerIntoHlsPlaylist:true}}")
private boolean addOriginalMuxerIntoHLSPlaylist
        Add the original hls stream to the playlist if adaptive bitrate setting is enabled

      • s3RecordingEnabled

        @Value("${s3RecordingEnabled:${settings.s3RecordingEnabled:false}}")
private boolean s3RecordingEnabled
        Application JWT Control Enabled

      • s3AccessKey

        @Value("${s3AccessKey:${settings.s3AccessKey:}}")
private String s3AccessKey
        S3 Access key

      • s3SecretKey

        @Value("${s3SecretKey:${settings.s3SecretKey:}}")
private String s3SecretKey
        S3 Secret Key

      • s3BucketName

        @Value("${s3BucketName:${settings.s3BucketName:}}")
private String s3BucketName
        S3 Bucket Name

      • s3RegionName

        @Value("${s3RegionName:${settings.s3RegionName:}}")
private String s3RegionName
        S3 Region Name

      • s3Endpoint

        @Value("${s3Endpoint:${settings.s3Endpoint:}}")
private String s3Endpoint
        S3 Endpoint

      • s3CacheControl

        @Value("${s3CacheControl:${settings.s3CacheControl:no-store, no-cache, must-revalidate, max-age=0}}")
private String s3CacheControl
        S3 Cache Control Metadata

      • s3Permission

        @Value("${s3Permission:${settings.s3Permission:public-read}}")
private String s3Permission

      • hlsEncryptionKeyInfoFile

        @Value("${hlsEncryptionKeyInfoFile:${settings.hlsEncryptionKeyInfoFile:}}")
private String hlsEncryptionKeyInfoFile
        HLS Encryption key info file full path. Format of the file ``` key URI key file path IV (optional) `` The first line of key_info_file specifies the key URI written to the playlist. The key URL is used to access the encryption key during playback. The second line specifies the path to the key file used to obtain the key during the encryption process. The key file is read as a single packed array of 16 octets in binary format. The optional third line specifies the initialization vector (IV) as a hexadecimal string to be used instead of the segment sequence number (default) for encryption. Changes to key_info_file will result in segment encryption with the new key/IV and an entry in the playlist for the new key URI/IV if hls_flags periodic_rekey is enabled. Key info file example: ``` http://server/file.key /path/to/file.key 0123456789ABCDEF0123456789ABCDEF ```

      • jwksURL

        @Value("${jwksURL:${settings.jwksURL:}}")
private String jwksURL

      • forceAspectRatioInTranscoding

        @Value("${forceAspectRatioInTranscoding:${settings.forceAspectRationInTranscoding:false}}")
private boolean forceAspectRatioInTranscoding
        This settings forces the aspect ratio to match the incoming aspect ratio perfectly. For instance, if the incoming source is 1280x720 and there is an adaptive bitrate with 480p There is no integer value that makes this equation true 1280/720 = x/480 -> x = 853.333 So Ant Media Server can change the video height to match the aspect ratio perfectly. This is critical when there are multi-bitrates in the dash streaming. Because dash requires perfect match of aspect ratios of all streams The disadvantage of this approach is that there may be have some uncommon resolutions at the result of the transcoding. So that default value is false

      • webhookAuthenticateURL

        @Value("${webhookAuthenticateURL:${settings.webhookAuthenticateURL:}}")
private String webhookAuthenticateURL
        Enable Webhook Authentication when publishing streams

      • maxAudioTrackCount

        @Value("${maxAudioTrackCount:${settings.maxAudioTrackCount:-1}}")
private int maxAudioTrackCount
        The maximum audio track in a multitrack playing connection If it is -1 then a new audio track connection is established for each track otherwise, audio connections are established as many as this value and the limited connections are shared between tracks.

      • maxVideoTrackCount

        @Value("${maxVideoTrackCount:${settings.maxVideoTrackCount:-1}}")
private int maxVideoTrackCount
        The maximum video track in a multitrack playing connection If it is -1 then a new video track connection is established for each track otherwise, video connections are established as many as this value and the limited connections are shared between tracks.

      • vodUploadFinishScript

        @Value("${vodUploadFinishScript:${settings.vodUploadFinishScript:}}")
private String vodUploadFinishScript
        This is a script file path that is called by Runtime when VoD upload is finished, Bash script file path will be called after upload process finishes.

      • contentSecurityPolicyHeaderValue

        @Value("${contentSecurityPolicyHeaderValue:${settings.contentSecurityPolicyHeaderValue:}}")
private String contentSecurityPolicyHeaderValue
        Value of the content security policy header(csp) The new Content-Security-Policy HTTP response header helps you reduce XSS risks on modern browsers by declaring which dynamic resources are allowed to load. https://content-security-policy.com/

      • rtmpPlaybackEnabled

        @Value("${rtmpPlaybackEnabled:${settings.rtmpPlaybackEnabled:false}}")
private boolean rtmpPlaybackEnabled
        RTMP playback is not maintained and its support will be removed completely. It also causes some stability issues on the server side. We highly recommend users to use CMAF(DASH) instead of RTMP playback

      • originEdgeIdleTimeout

        @Value("${originEdgeConnectionIdleTimeout:${settings.originEdgeIdleTimeout:2}}")
private int originEdgeIdleTimeout
        The maximum idle time between origin and edge connection. After this timeout connection will be re-established if the stream is still active on origin.

      • addDateTimeToHlsFileName

        @Value("${addDateTimeToHlsFileName:${settings.addDateTimeToHlsFileName:false}}")
private boolean addDateTimeToHlsFileName
        It's mandatory, Date and time are added to created .m3u8 and .ts file name, Default value is false

      • playWebRTCStreamOnceForEachSession

        @Value("${playWebRTCStreamOnceForEachSession:${settings.playWebRTCStreamOnceForEachSession:true}}")
private boolean playWebRTCStreamOnceForEachSession
        This setting prevents playing stream id more than once in the same websocket/webrtc session. If it is true, trying to play stream id more than once in the same websocket session will produce 'already playing' error Default value is true. It uses session id to match subscriber

      • statsBasedABREnabled

        @Value("${statsBasedABRAlgorithmEnabled:${settings.statsBasedABREnabled:true}}")
private boolean statsBasedABREnabled
        Enables the WebRTC statistics based Adaptive Bitrate switch algorithm

      • abrDownScalePacketLostRatio

        @Value("${abrDownScalePacketLostRatio:${settings.abrDownScalePacketLostRatio:1}}")
private float abrDownScalePacketLostRatio
        Packet lost percentage to decide serving video with lower resolution

      • abrUpScalePacketLostRatio

        @Value("${abrUpScalePacketLostRatio:${settings.abrUpScalePacketLostRatio:0.1f}}")
private float abrUpScalePacketLostRatio
        Packet lost percentage to decide serving video with higher resolution

      • abrUpScaleRTTMs

        @Value("${abrUpScaleRTTMs:${settings.abrUpScaleRTTMs:150}}")
private int abrUpScaleRTTMs
        Round trip time in ms to decide serving video with higher resolution

      • abrUpScaleJitterMs

        @Value("${abrUpScaleJitterMs:${settings.abrUpScaleJitterMs:30}}")
private int abrUpScaleJitterMs
        Jitter in ms to decide serving video with higher resolution

      • clusterCommunicationKey

        @Value("${clusterCommunicationKey:${settings.clusterCommunicationKey:#{ T(org.apache.commons.lang3.RandomStringUtils).randomAlphanumeric(32)}}}")
private String clusterCommunicationKey
        Key that is being used to validate the requests between communication in the cluster nodes In initialization no matter if spring or field definition is effective, the important thing is that having some random value

      • id3TagEnabled

        @Value("${id3TagEnabled:false}")
private boolean id3TagEnabled
        Enables the ID3 Tag support for HLS

      • sendAudioLevelToViewers

        @Value("${sendAudioLevelToViewers:true}")
private boolean sendAudioLevelToViewers
        Ant Media Server can get the audio level from incoming RTP Header in WebRTC streaming and send to the viewers. It's very useful in video conferencing to detect if user speaks. Ant Media Server sends audio level through webrtc data channel with JSON format { "streamId":${streamId}, "eventType": "UPDATE_AUDIO_LEVEL", "audioLevel": ${audioLevel}, "command": "event" } ${streamId} is the id of the stream that this messages carries its audio level ${audioLevel} is the audio level of the stream. It's between 0 and 127. If it's 0, it means audio level is max. If it's 127, it means it's audio level is min. Ant Media Server sends audio level 5 times in a second

    • Constructor Detail

      • AppSettings

        public AppSettings()

    • Method Detail

      • isWriteStatsToDatastore

        public boolean isWriteStatsToDatastore()

      • setWriteStatsToDatastore

        public void setWriteStatsToDatastore​(boolean writeStatsToDatastore)

      • isAddDateTimeToMp4FileName

        public boolean isAddDateTimeToMp4FileName()

      • setAddDateTimeToMp4FileName

        public void setAddDateTimeToMp4FileName​(boolean addDateTimeToMp4FileName)

      • isMp4MuxingEnabled

        public boolean isMp4MuxingEnabled()

      • setMp4MuxingEnabled

        public void setMp4MuxingEnabled​(boolean mp4MuxingEnabled)

      • setFileNameFormat

        public void setFileNameFormat​(String fileNameFormat)

      • getFileNameFormat

        public String getFileNameFormat()

      • isHlsMuxingEnabled

        public boolean isHlsMuxingEnabled()

      • setHlsMuxingEnabled

        public void setHlsMuxingEnabled​(boolean hlsMuxingEnabled)

      • isDashMuxingEnabled

        public boolean isDashMuxingEnabled()

      • setSignalingEnabled

        public void setSignalingEnabled​(boolean signalingEnabled)

      • isSignalingEnabled

        public boolean isSignalingEnabled()

      • setSignalingAddress

        public void setSignalingAddress​(String signalingAddress)

      • getSignalingAddress

        public String getSignalingAddress()

      • setDashMuxingEnabled

        public void setDashMuxingEnabled​(boolean dashMuxingEnabled)

      • getEndpointRepublishLimit

        public int getEndpointRepublishLimit()

      • setEndpointRepublishLimit

        public void setEndpointRepublishLimit​(int endpointRepublishLimit)

      • getEndpointHealthCheckPeriodMs

        public int getEndpointHealthCheckPeriodMs()

      • setEndpointHealthCheckPeriodMs

        public void setEndpointHealthCheckPeriodMs​(int endpointHealthCheckPeriodMs)

      • getHlsPlayListType

        public String getHlsPlayListType()

      • setHlsPlayListType

        public void setHlsPlayListType​(String hlsPlayListType)

      • setUploadExtensionsToS3

        public void setUploadExtensionsToS3​(int uploadExtensionsToS3)

      • getUploadExtensionsToS3

        public int getUploadExtensionsToS3()

      • setS3StorageClass

        public void setS3StorageClass​(String s3StorageClass)

      • getS3StorageClass

        public String getS3StorageClass()

      • getHlsTime

        public String getHlsTime()

      • setHlsTime

        public void setHlsTime​(String hlsTime)

      • getHlsListSize

        public String getHlsListSize()

      • setHlsListSize

        public void setHlsListSize​(String hlsListSize)

      • isWebRTCEnabled

        public boolean isWebRTCEnabled()

      • setWebRTCEnabled

        public void setWebRTCEnabled​(boolean webRTCEnabled)

      • getEncoderSettingsString

        public String getEncoderSettingsString()

      • setEncoderSettingsString

        public void setEncoderSettingsString​(String encoderSettingsString)

      • isDeleteHLSFilesOnEnded

        public boolean isDeleteHLSFilesOnEnded()

      • setDeleteHLSFilesOnEnded

        public void setDeleteHLSFilesOnEnded​(boolean deleteHLSFilesOnEnded)

      • getListenerHookURL

        public String getListenerHookURL()

      • setListenerHookURL

        public void setListenerHookURL​(String listenerHookURL)

      • isAcceptOnlyStreamsInDataStore

        public boolean isAcceptOnlyStreamsInDataStore()

      • setAcceptOnlyStreamsInDataStore

        public void setAcceptOnlyStreamsInDataStore​(boolean acceptOnlyStreamsInDataStore)

      • isAcceptOnlyRoomsInDataStore

        public boolean isAcceptOnlyRoomsInDataStore()

      • setAcceptOnlyRoomsInDataStore

        public void setAcceptOnlyRoomsInDataStore​(boolean acceptOnlyRoomsInDataStore)

      • isObjectDetectionEnabled

        public boolean isObjectDetectionEnabled()

      • getVodFolder

        public String getVodFolder()

      • setVodFolder

        public void setVodFolder​(String vodFolder)

      • getCreatePreviewPeriod

        public int getCreatePreviewPeriod()

      • setCreatePreviewPeriod

        public void setCreatePreviewPeriod​(int period)

      • isPreviewOverwrite

        public boolean isPreviewOverwrite()

      • setPreviewOverwrite

        public void setPreviewOverwrite​(boolean previewOverwrite)

      • getStalkerDBServer

        public String getStalkerDBServer()

      • setStalkerDBServer

        public void setStalkerDBServer​(String stalkerDBServer)

      • getStalkerDBUsername

        public String getStalkerDBUsername()

      • setStalkerDBUsername

        public void setStalkerDBUsername​(String stalkerDBUsername)

      • getStalkerDBPassword

        public String getStalkerDBPassword()

      • setStalkerDBPassword

        public void setStalkerDBPassword​(String stalkerDBPassword)

      • getRestartStreamFetcherPeriod

        public int getRestartStreamFetcherPeriod()

      • setRestartStreamFetcherPeriod

        public void setRestartStreamFetcherPeriod​(int restartStreamFetcherPeriod)

      • getStreamFetcherBufferTime

        public int getStreamFetcherBufferTime()

      • setStreamFetcherBufferTime

        public void setStreamFetcherBufferTime​(int streamFetcherBufferTime)

      • getHlsflags

        public String getHlsflags()

      • setHlsflags

        public void setHlsflags​(String hlsflags)

      • getMySqlClientPath

        public String getMySqlClientPath()

      • setMySqlClientPath

        public void setMySqlClientPath​(String mySqlClientPath)

      • isPublishTokenControlEnabled

        public boolean isPublishTokenControlEnabled()

      • setPublishTokenControlEnabled

        public void setPublishTokenControlEnabled​(boolean publishTokenControlEnabled)

      • isPlayTokenControlEnabled

        public boolean isPlayTokenControlEnabled()

      • setPlayTokenControlEnabled

        public void setPlayTokenControlEnabled​(boolean playTokenControlEnabled)

      • isTimeTokenSubscriberOnly

        @Deprecated
public boolean isTimeTokenSubscriberOnly()
        Deprecated.
        Returns:

      • setTimeTokenSubscriberOnly

        @Deprecated
public void setTimeTokenSubscriberOnly​(boolean timeTokenSubscriberOnly)
        Deprecated.

      • isEnableTimeTokenForPlay

        public boolean isEnableTimeTokenForPlay()

      • setEnableTimeTokenForPlay

        public void setEnableTimeTokenForPlay​(boolean enableTimeTokenForPlay)

      • isEnableTimeTokenForPublish

        public boolean isEnableTimeTokenForPublish()

      • setEnableTimeTokenForPublish

        public void setEnableTimeTokenForPublish​(boolean enableTimeTokenForPublish)

      • getMuxerFinishScript

        public String getMuxerFinishScript()

      • setMuxerFinishScript

        public void setMuxerFinishScript​(String muxerFinishScript)

      • getWebRTCFrameRate

        public int getWebRTCFrameRate()

      • setWebRTCFrameRate

        public void setWebRTCFrameRate​(int webRTCFrameRate)

      • getTokenHashSecret

        public String getTokenHashSecret()

      • setTokenHashSecret

        public void setTokenHashSecret​(String tokenHashSecret)

      • isHashControlPlayEnabled

        public boolean isHashControlPlayEnabled()

      • setHashControlPlayEnabled

        public void setHashControlPlayEnabled​(boolean hashControlPlayEnabled)

      • isHashControlPublishEnabled

        public boolean isHashControlPublishEnabled()

      • setHashControlPublishEnabled

        public void setHashControlPublishEnabled​(boolean hashControlPublishEnabled)

      • resetDefaults

        public void resetDefaults()

      • getWebRTCPortRangeMax

        public int getWebRTCPortRangeMax()

      • setWebRTCPortRangeMax

        public void setWebRTCPortRangeMax​(int webRTCPortRangeMax)

      • getWebRTCPortRangeMin

        public int getWebRTCPortRangeMin()

      • setWebRTCPortRangeMin

        public void setWebRTCPortRangeMin​(int webRTCPortRangeMin)

      • getStunServerURI

        public String getStunServerURI()

      • setStunServerURI

        public void setStunServerURI​(String stunServerURI)

      • isWebRTCTcpCandidatesEnabled

        public boolean isWebRTCTcpCandidatesEnabled()

      • setWebRTCTcpCandidatesEnabled

        public void setWebRTCTcpCandidatesEnabled​(boolean webRTCTcpCandidatesEnabled)

      • getEncoderName

        public String getEncoderName()

      • setEncoderName

        public void setEncoderName​(String encoderName)

      • getEncoderPreset

        public String getEncoderPreset()

      • setEncoderPreset

        public void setEncoderPreset​(String encoderPreset)

      • getEncoderProfile

        public String getEncoderProfile()

      • setEncoderProfile

        public void setEncoderProfile​(String encoderProfile)

      • getEncoderLevel

        public String getEncoderLevel()

      • setEncoderLevel

        public void setEncoderLevel​(String encoderLevel)

      • getEncoderRc

        public String getEncoderRc()

      • setEncoderRc

        public void setEncoderRc​(String encoderRc)

      • getEncoderSpecific

        public String getEncoderSpecific()

      • setEncoderSpecific

        public void setEncoderSpecific​(String encoderSpecific)

      • getPreviewHeight

        public int getPreviewHeight()

      • setPreviewHeight

        public void setPreviewHeight​(int previewHeight)

      • isUseOriginalWebRTCEnabled

        public boolean isUseOriginalWebRTCEnabled()

      • setUseOriginalWebRTCEnabled

        public void setUseOriginalWebRTCEnabled​(boolean useOriginalWebRTCEnabled)

      • getRemoteAllowedCIDR

        public String getRemoteAllowedCIDR()

      • setRemoteAllowedCIDR

        public void setRemoteAllowedCIDR​(String remoteAllowedCIDR)
        the getAllowedCIDRList and setAllowedCIDRList are synchronized because ArrayList may throw concurrent modification
        Parameters:
        remoteAllowedCIDR -

      • getAllowedCIDRList

        public Queue<org.apache.catalina.util.NetMask> getAllowedCIDRList()

      • getAllowedPublisherCIDR

        public String getAllowedPublisherCIDR()

      • setAllowedPublisherCIDR

        public void setAllowedPublisherCIDR​(String allowedPublisherCIDR)

      • getAllowedPublisherCIDRList

        public Queue<org.apache.catalina.util.NetMask> getAllowedPublisherCIDRList()

      • fillFromInput

        private List<String> fillFromInput​(String input,
                                   Queue<org.apache.catalina.util.NetMask> target)
        Fill a NetMask list from a string input containing a comma-separated list of (hopefully valid) NetMasks.
        Parameters:
        input - The input string
        target - The list to fill
        Returns:
        a string list of processing errors (empty when no errors)

      • getEncoderSelectionPreference

        public String getEncoderSelectionPreference()

      • setEncoderSelectionPreference

        public void setEncoderSelectionPreference​(String encoderSelectionPreference)

      • getExcessiveBandwidthCallThreshold

        public int getExcessiveBandwidthCallThreshold()

      • setExcessiveBandwidthCallThreshold

        public void setExcessiveBandwidthCallThreshold​(int excessiveBandwidthCallThreshold)

      • getExcessiveBandwidthValue

        public int getExcessiveBandwidthValue()

      • setExcessiveBandwidthValue

        public void setExcessiveBandwidthValue​(int excessiveBandwidthValue)

      • getPortAllocatorFlags

        public int getPortAllocatorFlags()

      • setPortAllocatorFlags

        public void setPortAllocatorFlags​(int flags)

      • getExcessiveBandwithTryCountBeforeSwitchback

        public int getExcessiveBandwithTryCountBeforeSwitchback()

      • isExcessiveBandwidthAlgorithmEnabled

        public boolean isExcessiveBandwidthAlgorithmEnabled()

      • getPacketLossDiffThresholdForSwitchback

        public int getPacketLossDiffThresholdForSwitchback()

      • getRttMeasurementDiffThresholdForSwitchback

        public int getRttMeasurementDiffThresholdForSwitchback()

      • setExcessiveBandwithTryCountBeforeSwitchback

        public void setExcessiveBandwithTryCountBeforeSwitchback​(int excessiveBandwithTryCountBeforeSwitchback)

      • setExcessiveBandwidthAlgorithmEnabled

        public void setExcessiveBandwidthAlgorithmEnabled​(boolean excessiveBandwidthAlgorithmEnabled)

      • setPacketLossDiffThresholdForSwitchback

        public void setPacketLossDiffThresholdForSwitchback​(int packetLossDiffThresholdForSwitchback)

      • setRttMeasurementDiffThresholdForSwitchback

        public void setRttMeasurementDiffThresholdForSwitchback​(int rttMeasurementDiffThresholdForSwitchback)

      • isReplaceCandidateAddrWithServerAddr

        public boolean isReplaceCandidateAddrWithServerAddr()

      • setReplaceCandidateAddrWithServerAddr

        public void setReplaceCandidateAddrWithServerAddr​(boolean replaceCandidateAddrWithServerAddr)

      • getUpdateTime

        public long getUpdateTime()

      • setUpdateTime

        public void setUpdateTime​(long updateTime)

      • setAppName

        public void setAppName​(String appName)

      • getAppName

        public String getAppName()

      • getEncodingTimeout

        public int getEncodingTimeout()

      • setEncodingTimeout

        public void setEncodingTimeout​(int encodingTimeout)

      • isDefaultDecodersEnabled

        public boolean isDefaultDecodersEnabled()

      • setDefaultDecodersEnabled

        public void setDefaultDecodersEnabled​(boolean defaultDecodersEnabled)

      • getHttpForwardingExtension

        public String getHttpForwardingExtension()

      • setHttpForwardingExtension

        public void setHttpForwardingExtension​(String httpForwardingExtension)

      • getHttpForwardingBaseURL

        public String getHttpForwardingBaseURL()

      • setHttpForwardingBaseURL

        public void setHttpForwardingBaseURL​(String httpForwardingBaseURL)

      • getMaxAnalyzeDurationMS

        public int getMaxAnalyzeDurationMS()

      • setMaxAnalyzeDurationMS

        public void setMaxAnalyzeDurationMS​(int maxAnalyzeDurationMS)

      • isGeneratePreview

        public boolean isGeneratePreview()

      • setGeneratePreview

        public void setGeneratePreview​(boolean generatePreview)

      • isDisableIPv6Candidates

        public boolean isDisableIPv6Candidates()

      • setDisableIPv6Candidates

        public void setDisableIPv6Candidates​(boolean disableIPv6Candidates)

      • getRtspPullTransportType

        public String getRtspPullTransportType()

      • setRtspPullTransportType

        public void setRtspPullTransportType​(String rtspPullTransportType)

      • getRtspTimeoutDurationMs

        public int getRtspTimeoutDurationMs()

      • setRtspTimeoutDurationMs

        public void setRtspTimeoutDurationMs​(int rtspTimeoutDurationMs)

      • getMaxResolutionAccept

        public int getMaxResolutionAccept()

      • setMaxResolutionAccept

        public void setMaxResolutionAccept​(int maxResolutionAccept)

      • isH264Enabled

        public boolean isH264Enabled()

      • setH264Enabled

        public void setH264Enabled​(boolean h264Enabled)

      • isVp8Enabled

        public boolean isVp8Enabled()

      • setVp8Enabled

        public void setVp8Enabled​(boolean vp8Enabled)

      • isH265Enabled

        public boolean isH265Enabled()

      • setH265Enabled

        public void setH265Enabled​(boolean h265Enabled)

      • isDataChannelEnabled

        public boolean isDataChannelEnabled()

      • setDataChannelEnabled

        public void setDataChannelEnabled​(boolean dataChannelEnabled)

      • getDataChannelPlayerDistribution

        public String getDataChannelPlayerDistribution()

      • setDataChannelPlayerDistribution

        public void setDataChannelPlayerDistribution​(String dataChannelPlayerDistribution)

      • getRtmpIngestBufferTimeMs

        public long getRtmpIngestBufferTimeMs()

      • setRtmpIngestBufferTimeMs

        public void setRtmpIngestBufferTimeMs​(long rtmpIngestBufferTimeMs)

      • setDataChannelWebHookURL

        public void setDataChannelWebHookURL​(String dataChannelWebHookURL)

      • getEncoderThreadCount

        public int getEncoderThreadCount()

      • setEncoderThreadCount

        public void setEncoderThreadCount​(int encoderThreadCount)

      • getEncoderThreadType

        public int getEncoderThreadType()

      • setEncoderThreadType

        public void setEncoderThreadType​(int encoderThreadType)

      • getWebRTCClientStartTimeoutMs

        public int getWebRTCClientStartTimeoutMs()

      • setWebRTCClientStartTimeoutMs

        public void setWebRTCClientStartTimeoutMs​(int webRTCClientStartTimeout)

      • getH265EncoderProfile

        public String getH265EncoderProfile()

      • getH265EncoderPreset

        public String getH265EncoderPreset()

      • getH265EncoderLevel

        public String getH265EncoderLevel()

      • getH265EncoderSpecific

        public String getH265EncoderSpecific()

      • getH265EncoderRc

        public String getH265EncoderRc()

      • setH265EncoderLevel

        public void setH265EncoderLevel​(String encoderLevel)

      • setH265EncoderPreset

        public void setH265EncoderPreset​(String preset)

      • setH265EncoderProfile

        public void setH265EncoderProfile​(String profile)

      • setH265EncoderRc

        public void setH265EncoderRc​(String encoderRc)

      • setH265EncoderSpecific

        public void setH265EncoderSpecific​(String encoderSpecific)

      • isWebMMuxingEnabled

        public boolean isWebMMuxingEnabled()

      • setWebMMuxingEnabled

        public void setWebMMuxingEnabled​(boolean webMMuxingEnabled)

      • getVp8EncoderSpeed

        public int getVp8EncoderSpeed()

      • setVp8EncoderSpeed

        public void setVp8EncoderSpeed​(int vp8EncoderSpeed)

      • getVp8EncoderDeadline

        public String getVp8EncoderDeadline()

      • setVp8EncoderDeadline

        public void setVp8EncoderDeadline​(String vp8EncoderDeadline)

      • getVp8EncoderThreadCount

        public int getVp8EncoderThreadCount()

      • setVp8EncoderThreadCount

        public void setVp8EncoderThreadCount​(int vp8EncoderThreadCount)

      • getWebRTCSdpSemantics

        public String getWebRTCSdpSemantics()

      • setWebRTCSdpSemantics

        public void setWebRTCSdpSemantics​(String webRTCSdpSemantics)

      • isStartStreamFetcherAutomatically

        public boolean isStartStreamFetcherAutomatically()

      • setStartStreamFetcherAutomatically

        public void setStartStreamFetcherAutomatically​(boolean startStreamFetcherAutomatically)

      • isDeleteDASHFilesOnEnded

        public boolean isDeleteDASHFilesOnEnded()

      • setDeleteDASHFilesOnEnded

        public void setDeleteDASHFilesOnEnded​(boolean deleteDASHFilesOnEnded)

      • getTargetLatency

        public String getTargetLatency()

      • setTargetLatency

        public void setTargetLatency​(String targetLatency)

      • getHeightRtmpForwarding

        public int getHeightRtmpForwarding()

      • setHeightRtmpForwarding

        public void setHeightRtmpForwarding​(int heightRtmpForwarding)

      • getAudioBitrateSFU

        public int getAudioBitrateSFU()

      • setAudioBitrateSFU

        public void setAudioBitrateSFU​(int audioBitrateSFU)

      • setAacEncodingEnabled

        public void setAacEncodingEnabled​(boolean aacEncodingEnabled)

      • isAacEncodingEnabled

        public boolean isAacEncodingEnabled()

      • getGopSize

        public int getGopSize()

      • setGopSize

        public void setGopSize​(int gopSize)

      • getConstantRateFactor

        public String getConstantRateFactor()

      • setConstantRateFactor

        public void setConstantRateFactor​(String constantRateFactor)

      • getWebRTCViewerLimit

        public int getWebRTCViewerLimit()

      • setWebRTCViewerLimit

        public void setWebRTCViewerLimit​(int webRTCViewerLimit)

      • getDashFragmentDuration

        public String getDashFragmentDuration()

      • setDashFragmentDuration

        public void setDashFragmentDuration​(String dashFragmentDuration)

      • getDashSegDuration

        public String getDashSegDuration()

      • setDashSegDuration

        public void setDashSegDuration​(String dashSegDuration)

      • getDashWindowSize

        public String getDashWindowSize()

      • setDashWindowSize

        public void setDashWindowSize​(String dashWindowSize)

      • getDashExtraWindowSize

        public String getDashExtraWindowSize()

      • setDashExtraWindowSize

        public void setDashExtraWindowSize​(String dashExtraWindowSize)

      • getJwtSecretKey

        public String getJwtSecretKey()

      • setJwtSecretKey

        public void setJwtSecretKey​(String jwtSecretKey)

      • isJwtControlEnabled

        public boolean isJwtControlEnabled()

      • setJwtControlEnabled

        public void setJwtControlEnabled​(boolean jwtControlEnabled)

      • isIpFilterEnabled

        public boolean isIpFilterEnabled()

      • setIpFilterEnabled

        public void setIpFilterEnabled​(boolean ipFilterEnabled)

      • getIngestingStreamLimit

        public int getIngestingStreamLimit()

      • setIngestingStreamLimit

        public void setIngestingStreamLimit​(int ingestingStreamLimit)

      • getTimeTokenPeriod

        public int getTimeTokenPeriod()

      • setTimeTokenPeriod

        public void setTimeTokenPeriod​(int timeTokenPeriod)

      • isToBeDeleted

        public boolean isToBeDeleted()

      • setToBeDeleted

        public void setToBeDeleted​(boolean toBeDeleted)

      • isPullWarFile

        public boolean isPullWarFile()

      • setPullWarFile

        public void setPullWarFile​(boolean pullWarFile)

      • getWebRTCKeyframeTime

        public int getWebRTCKeyframeTime()

      • setWebRTCKeyframeTime

        public void setWebRTCKeyframeTime​(int webRTCKeyframeTime)

      • getJwtStreamSecretKey

        public String getJwtStreamSecretKey()

      • setJwtStreamSecretKey

        public void setJwtStreamSecretKey​(String jwtStreamSecretKey)

      • isPublishJwtControlEnabled

        public boolean isPublishJwtControlEnabled()

      • setPublishJwtControlEnabled

        public void setPublishJwtControlEnabled​(boolean publishJwtControlEnabled)

      • isPlayJwtControlEnabled

        public boolean isPlayJwtControlEnabled()

      • setPlayJwtControlEnabled

        public void setPlayJwtControlEnabled​(boolean playJwtControlEnabled)

      • islLDashEnabled

        public boolean islLDashEnabled()

      • setlLDashEnabled

        public void setlLDashEnabled​(boolean lLDashEnabled)

      • islLHLSEnabled

        public boolean islLHLSEnabled()

      • setlLHLSEnabled

        public void setlLHLSEnabled​(boolean lLHLSEnabled)

      • isHlsEnabledViaDash

        public boolean isHlsEnabledViaDash()

      • setHlsEnabledViaDash

        public void setHlsEnabledViaDash​(boolean hlsEnabledViaDash)

      • isUseTimelineDashMuxing

        public boolean isUseTimelineDashMuxing()

      • setUseTimelineDashMuxing

        public void setUseTimelineDashMuxing​(boolean useTimelineDashMuxing)

      • isDashHttpStreaming

        public boolean isDashHttpStreaming()

      • setDashHttpStreaming

        public void setDashHttpStreaming​(boolean dashHttpStreaming)

      • getS3StreamsFolderPath

        public String getS3StreamsFolderPath()

      • getDashHttpEndpoint

        public String getDashHttpEndpoint()

      • isS3RecordingEnabled

        public boolean isS3RecordingEnabled()

      • setS3RecordingEnabled

        public void setS3RecordingEnabled​(boolean s3RecordingEnabled)

      • getS3SecretKey

        public String getS3SecretKey()

      • setS3SecretKey

        public void setS3SecretKey​(String s3SecretKey)

      • getS3AccessKey

        public String getS3AccessKey()

      • setS3AccessKey

        public void setS3AccessKey​(String s3AccessKey)

      • getS3RegionName

        public String getS3RegionName()

      • setS3RegionName

        public void setS3RegionName​(String s3RegionName)

      • getS3BucketName

        public String getS3BucketName()

      • setS3BucketName

        public void setS3BucketName​(String s3BucketName)

      • getS3Endpoint

        public String getS3Endpoint()

      • setS3Endpoint

        public void setS3Endpoint​(String s3Endpoint)

      • getS3CacheControl

        public String getS3CacheControl()

      • setS3CacheControl

        public void setS3CacheControl​(String s3CacheControl)

      • setDashHttpEndpoint

        public void setDashHttpEndpoint​(String dashHttpEndpoint)

      • getHlsEncryptionKeyInfoFile

        public String getHlsEncryptionKeyInfoFile()

      • setHlsEncryptionKeyInfoFile

        public void setHlsEncryptionKeyInfoFile​(String hlsEncryptionKeyInfoFile)

      • setS3StreamsFolderPath

        public void setS3StreamsFolderPath​(String s3StreamsFolderPath)

      • getS3PreviewsFolderPath

        public String getS3PreviewsFolderPath()

      • setS3PreviewsFolderPath

        public void setS3PreviewsFolderPath​(String s3PreviewsFolderPath)

      • isForceDecoding

        public boolean isForceDecoding()

      • setForceDecoding

        public void setForceDecoding​(boolean forceDecoding)

      • isAddOriginalMuxerIntoHLSPlaylist

        public boolean isAddOriginalMuxerIntoHLSPlaylist()

      • setAddOriginalMuxerIntoHLSPlaylist

        public void setAddOriginalMuxerIntoHLSPlaylist​(boolean addOriginalMuxerIntoHLSPlaylist)

      • getJwksURL

        public String getJwksURL()

      • setJwksURL

        public void setJwksURL​(String jwksURL)

      • getWebhookAuthenticateURL

        public String getWebhookAuthenticateURL()

      • setWebhookAuthenticateURL

        public void setWebhookAuthenticateURL​(String webhookAuthenticateURL)

      • isForceAspectRatioInTranscoding

        public boolean isForceAspectRatioInTranscoding()

      • setForceAspectRatioInTranscoding

        public void setForceAspectRatioInTranscoding​(boolean forceAspectRatioInTranscoding)

      • getS3Permission

        public String getS3Permission()

      • setS3Permission

        public void setS3Permission​(String s3Permission)

      • getMaxAudioTrackCount

        public int getMaxAudioTrackCount()

      • setMaxAudioTrackCount

        public void setMaxAudioTrackCount​(int maxAudioTrackCount)

      • getWarFileOriginServerAddress

        public String getWarFileOriginServerAddress()

      • setWarFileOriginServerAddress

        public void setWarFileOriginServerAddress​(String warFileOriginServerAddress)

      • setVodUploadFinishScript

        public void setVodUploadFinishScript​(String vodUploadFinishScript)

      • getMaxVideoTrackCount

        public int getMaxVideoTrackCount()

      • setMaxVideoTrackCount

        public void setMaxVideoTrackCount​(int maxVideoTrackCount)

      • getContentSecurityPolicyHeaderValue

        public String getContentSecurityPolicyHeaderValue()

      • setContentSecurityPolicyHeaderValue

        public void setContentSecurityPolicyHeaderValue​(String contentSecurityPolicyHeaderValue)

      • getTurnServerUsername

        public String getTurnServerUsername()

      • setTurnServerUsername

        public void setTurnServerUsername​(String turnServerUsername)

      • getTurnServerCredential

        public String getTurnServerCredential()

      • setTurnServerCredential

        public void setTurnServerCredential​(String turnServerCredential)

      • getHlsHttpEndpoint

        public String getHlsHttpEndpoint()

      • setHlsHttpEndpoint

        public void setHlsHttpEndpoint​(String hlsHttpEndpoint)

      • isRtmpPlaybackEnabled

        public boolean isRtmpPlaybackEnabled()

      • setRtmpPlaybackEnabled

        public void setRtmpPlaybackEnabled​(boolean rtmpPlaybackEnabled)

      • getOriginEdgeIdleTimeout

        public int getOriginEdgeIdleTimeout()

      • setOriginEdgeIdleTimeout

        public void setOriginEdgeIdleTimeout​(int originEdgeIdleTimeout)

      • isAddDateTimeToHlsFileName

        public boolean isAddDateTimeToHlsFileName()

      • setAddDateTimeToHlsFileName

        public void setAddDateTimeToHlsFileName​(boolean addDateTimeToHlsFileName)

      • isPlayWebRTCStreamOnceForEachSession

        public boolean isPlayWebRTCStreamOnceForEachSession()

      • setPlayWebRTCStreamOnceForEachSession

        public void setPlayWebRTCStreamOnceForEachSession​(boolean playWebRTCStreamOnceForEachSession)

      • isStatsBasedABREnabled

        public boolean isStatsBasedABREnabled()

      • setStatsBasedABREnabled

        public void setStatsBasedABREnabled​(boolean statsBasedABREnabled)

      • getAbrDownScalePacketLostRatio

        public float getAbrDownScalePacketLostRatio()

      • setAbrDownScalePacketLostRatio

        public void setAbrDownScalePacketLostRatio​(float abrDownScalePacketLostRatio)

      • getAbrUpScalePacketLostRatio

        public float getAbrUpScalePacketLostRatio()

      • setAbrUpScalePacketLostRatio

        public void setAbrUpScalePacketLostRatio​(float abrUpScalePacketLostRatio)

      • getAbrUpScaleRTTMs

        public int getAbrUpScaleRTTMs()

      • setAbrUpScaleRTTMs

        public void setAbrUpScaleRTTMs​(int abrUpScaleRTTMs)

      • getAbrUpScaleJitterMs

        public int getAbrUpScaleJitterMs()

      • setAbrUpScaleJitterMs

        public void setAbrUpScaleJitterMs​(int abrUpScaleJitterMs)

      • getClusterCommunicationKey

        public String getClusterCommunicationKey()

      • setClusterCommunicationKey

        public void setClusterCommunicationKey​(String clusterCommunicationKey)

      • getMaxFpsAccept

        public int getMaxFpsAccept()

      • setMaxFpsAccept

        public void setMaxFpsAccept​(int maxFpsAccept)

      • getDataChannelWebHookURL

        public String getDataChannelWebHookURL()

      • getVodUploadFinishScript

        public String getVodUploadFinishScript()

      • setObjectDetectionEnabled

        public void setObjectDetectionEnabled​(boolean objectDetectionEnabled)

      • isId3TagEnabled

        public boolean isId3TagEnabled()

      • setId3TagEnabled

        public void setId3TagEnabled​(boolean id3TagEnabled)

      • isSendAudioLevelToViewers

        public boolean isSendAudioLevelToViewers()

      • setSendAudioLevelToViewers

        public void setSendAudioLevelToViewers​(boolean sendAudioLevelToViewers)

      • getTimeTokenSecretForPublish

        public String getTimeTokenSecretForPublish()

      • setTimeTokenSecretForPublish

        public void setTimeTokenSecretForPublish​(String timeTokenSecretForPublish)

      • getTimeTokenSecretForPlay

        public String getTimeTokenSecretForPlay()

      • setTimeTokenSecretForPlay

        public void setTimeTokenSecretForPlay​(String timeTokenSecretForPlay)