Package io.antmedia

Class AppSettings

java.lang.Object
io.antmedia.AppSettings
All Implemented Interfaces:
Serializable
@Entity("AppSettings") @Indexes(@Index(fields=@Field("appName"),options=@IndexOptions(unique=true,name="appName_unique_index"))) @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:

  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      See Also:

    • 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.

    • hlsSegmentType

      @Value("${hlsSegmentType:mpegts}") private String hlsSegmentType
      HLS Muxer segment type. It can be "mpegts" or "fmp4" fmp4 is compatible to play the HEVC HLS Streams

    • 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("${restartStreamFetcherPeriod:${settings.streamFetcherRestartPeriod:0}}") private int restartStreamFetcherPeriod
      Period of restarting stream fetchers automaticallyin seconds. If it's more than 0, stream fetcher (aka. stream source) are restarted every seconds that is specified in this parameter. Restart time for fetched streams from external sources, Default value is 0

    • startStreamFetcherAutomatically

      @Value("${startStreamFetcherAutomatically:false}") private boolean startStreamFetcherAutomatically
      Flag to specify Stream sources whether to start automatically when server is started. If it is true, stream sources are started automatically when server is started If it's false, stream sources need to be started programmatically or manually by the user

    • streamFetcherBufferTime

      @Value("${streamFetcherBufferTime:0}") private int streamFetcherBufferTime
      Stream fetcher buffer time in milliseconds, Stream is buffered for this duration and after that it will be started. It's also good for re-ordering packets. 0 means no buffer, Default value is 0

    • hlsflags

      @Value("${hlsflags:${settings.hlsflags:delete_segments+program_date_time}}") 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:3}}") private String rtspPullTransportType
      Specify the rtsp transport type in pulling IP Camera or RTSP sources It can have string or integer values. One value can be given at a time as string. It can be udp, tcp udp_multicast, http, https Multiple values can be given at a time by OR operation udp -> 1 << 0 = 1 tcp -> 1 << 1 = 2 udp_multicast -> 1 << 2 = 4 http -> 1 << 8 = 256 https -> 1 << 9 = 512 Default value is 3 which is udp(1) OR tcp(2) 0x01 | 0x10 = 0x11 = 3

    • rtspTimeoutDurationMs

      @Value("${rtspTimeoutDurationMs:${settings.rtspTimeoutDurationMs:5000}}") private int rtspTimeoutDurationMs
      Specify the rtspTimeoutDurationMs in pulling IP Camera or RTSP sources

    • 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:false}") 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

    • hwScalingEnabled

      @Value("${hwScalingEnabled:${settings.encoding.hwScalingEnabled:false}}") private boolean hwScalingEnabled
      Enable/disable video frame scaling in GPU when there is an adaptive bitrate

    • firebaseAccountKeyJSON

      @Value("${firebaseAccountKeyJSON:#{null}}") private String firebaseAccountKeyJSON
      Firebase Service Account Key JSON to send push notification through Firebase Cloud Messaging

    • subscriberAuthenticationKey

      @Value("${subscriberAuthenticationKey:#{ T(org.apache.commons.lang3.RandomStringUtils).randomAlphanumeric(32)}}") private String subscriberAuthenticationKey
      This is JWT Secret to authenticate the user for push notifications. JWT token should be generated with the following secret: subscriberId(username, email, etc.) + subscriberAuthenticationKey

    • apnsServer

      @Value("${apnsServer:api.sandbox.push.apple.com}") private String apnsServer
      (Apple Push Notification) Apple Push Notification Server Default value is development enviroment(api.sandbox.push.apple.com) and production enviroment is api.push.apple.com

    • apnTeamId

      @Value("${apnTeamId:#{null}}") private String apnTeamId
      APN(Apple Push Notification) team id

    • apnPrivateKey

      @Value("${apnPrivateKey:#{null}}") private String apnPrivateKey
      APN(Apple Push Notification) private key

    • apnKeyId

      @Value("${apnKeyId:#{null}}") private String apnKeyId
      APN(Apple Push Notification) key Id

    • webhookRetryCount

      @Value("${webhookRetryCount:0}") private int webhookRetryCount
      Retry count on webhook POST failure

    • secureAnalyticEndpoint

      @Value("${secureAnalyticEndpoint:false}") private boolean secureAnalyticEndpoint
      If it's false, jwt token should be send in analytic events to the AnalyticsEventLogger. It uses jwtSecretKey for the secret key

    • webhookRetryDelay

      @Value("${webhookRetryAttemptDelay:1000}") private long webhookRetryDelay
      Delay in milliseconds between webhook attempts on POST failure.

    • webhookPlayAuthUrl

      @Value("${webhookPlayAuthUrl:}") private String webhookPlayAuthUrl
      Webhook webrtc play authentication url.

    • recordingSubfolder

      @Value("${recordingSubfolder:#{null}}") private String recordingSubfolder
      Subfolder for the recording files (mp4 and webm)

    • webhookContentType

      @Value("${webhookContentType:#{ T(org.apache.http.entity.ContentType).APPLICATION_JSON.getMimeType() }}") private String webhookContentType
      The content type that is used in the webhook POST request It's added for backward compatibility. Default value is application/json. Older version is using application/x-www-form-urlencoded as content type. If you don't want to change the content type, you can set this value to application/x-www-form-urlencoded

    • iceGatheringTimeoutMs

      @Value("${iceGatheringTimeoutMs:2000}") private long iceGatheringTimeoutMs

    • customSettings

      @Value("${customSettings:{}}") private org.json.simple.JSONObject customSettings

    • relayRTMPMetaDataToMuxers

      @Value("${relayRTMPMetaDataToMuxers:true}") private boolean relayRTMPMetaDataToMuxers
      Relay RTMP metadata to muxers. It's true by default RTMP can have metadata and it can be used for playback synchronization. If it's true, Ant Media Server relays the metadata to muxers. Currently, HLSMuxer supports this feature through Muxer.writeMetaData(String, long)

    • dropWebRTCIngestIfNoPacketReceived

      @Value("${dropWebRTCIngestIfNoPacketReceived:false}") private boolean dropWebRTCIngestIfNoPacketReceived
      Drop webrtc ingest if no packet received. It's false by default because video or audio may be disabled in the stream It checks the audio/video packets in the WebRTC ingest stream. If no audio or no video packets are received in the webRTCClientStartTimeoutMs, it drops the stream.

  • Constructor Details

    • AppSettings

      public AppSettings()

  • Method Details

    • isWriteStatsToDatastore

      public boolean isWriteStatsToDatastore()

    • getCustomSetting

      public Object getCustomSetting(String key)

    • setCustomSetting

      public void setCustomSetting(String key, Object value)

    • 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)

    • encodersList2Str

      public static String encodersList2Str(List<EncoderSettings> encoderSettingsList)

    • encodersStr2List

      public static List<EncoderSettings> encodersStr2List(String encoderSettingsString)

    • getEncoderSettingsString

      public String getEncoderSettingsString()

    • getEncoderSettings

      public List<EncoderSettings> getEncoderSettings()

    • setEncoderSettings

      public void setEncoderSettings(List<EncoderSettings> settings)

    • 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)

    • isHwScalingEnabled

      public boolean isHwScalingEnabled()

    • setHwScalingEnabled

      public void setHwScalingEnabled(boolean hwScalingEnabled)

    • getFirebaseAccountKeyJSON

      public String getFirebaseAccountKeyJSON()

    • setFirebaseAccountKeyJSON

      public void setFirebaseAccountKeyJSON(String firebaseAccountKeyJSON)

    • getSubscriberAuthenticationKey

      public String getSubscriberAuthenticationKey()

    • setSubscriberAuthenticationKey

      public void setSubscriberAuthenticationKey(String subscriberAuthenticationKey)

    • getApnsServer

      public String getApnsServer()

    • getApnPrivateKey

      public String getApnPrivateKey()

    • getApnKeyId

      public String getApnKeyId()

    • getApnTeamId

      public String getApnTeamId()

    • setApnTeamId

      public void setApnTeamId(String apnTeamId)

    • setApnPrivateKey

      public void setApnPrivateKey(String apnPrivateKey)

    • setApnKeyId

      public void setApnKeyId(String apnKeyId)

    • setApnsServer

      public void setApnsServer(String apnsServer)

    • getWebhookRetryCount

      public int getWebhookRetryCount()

    • setWebhookRetryCount

      public void setWebhookRetryCount(int webhookRetryCount)

    • getWebhookRetryDelay

      public long getWebhookRetryDelay()

    • setWebhookRetryDelay

      public void setWebhookRetryDelay(long webhookRetryDelay)

    • isWebhookPlayAuthEnabled

      public boolean isWebhookPlayAuthEnabled()

    • getWebhookPlayAuthUrl

      public String getWebhookPlayAuthUrl()

    • setWebhookPlayAuthUrl

      public void setWebhookPlayAuthUrl(String webhookPlayAuthUrl)

    • isSecureAnalyticEndpoint

      public boolean isSecureAnalyticEndpoint()

    • setSecureAnalyticEndpoint

      public void setSecureAnalyticEndpoint(boolean secureAnalyticEndpoint)

    • getHlsSegmentType

      public String getHlsSegmentType()

    • setHlsSegmentType

      public void setHlsSegmentType(String hlsSegmentType)

    • getRecordingSubfolder

      public String getRecordingSubfolder()

    • setRecordingSubfolder

      public void setRecordingSubfolder(String recordingSubfolder)

    • getWebhookContentType

      public String getWebhookContentType()

    • setWebhookContentType

      public void setWebhookContentType(String webhookContentType)

    • getIceGatheringTimeoutMs

      public long getIceGatheringTimeoutMs()

    • setIceGatheringTimeoutMs

      public void setIceGatheringTimeoutMs(long iceGatheringTimeoutMs)

    • getCustomSettings

      public org.json.simple.JSONObject getCustomSettings()

    • setCustomSettings

      public void setCustomSettings(org.json.simple.JSONObject customSettings)

    • isRelayRTMPMetaDataToMuxers

      public boolean isRelayRTMPMetaDataToMuxers()
      Returns:
      the relayRTMPMetaDataToMuxers

    • setRelayRTMPMetaDataToMuxers

      public void setRelayRTMPMetaDataToMuxers(boolean relayRTMPMetaDataToMuxers)
      Parameters:
      relayRTMPMetaDataToMuxers - the relayRTMPMetaDataToMuxers to set

    • isDropWebRTCIngestIfNoPacketReceived

      public boolean isDropWebRTCIngestIfNoPacketReceived()
      Returns:
      the dropWebRTCIngestIfNoPacketReceived

    • setDropWebRTCIngestIfNoPacketReceived

      public void setDropWebRTCIngestIfNoPacketReceived(boolean dropWebRTCIngestIfNoPacketReceived)
      Parameters:
      dropWebRTCIngestIfNoPacketReceived - the dropWebRTCIngestIfNoPacketReceived to set

    • getDbId

      public org.bson.types.ObjectId getDbId()
      Returns:
      the dbId