Efficient tools to build your streaming infrastructure


Nimble Streamer Configuration Parameters Reference

This Nimble Streamer Configuration Parameters Reference page provides information on how to control the behavior of a Nimble Streamer instance. The parameters can be applied using the nimble.conf file. The parameter descriptions are tagged for easier navigation and classification, and each description has the necessary steps to apply the changes, which include restarting the Nimble Streamer instance. The page lists all the configuration parameters available, including parameters for logging, network, performance, transcoder, and more, each of which affects the functionality of the Nimble Streamer instance in different ways.

All described parameters can be applied using nimble.conf file. On Linux it's available as /etc/nimble/nimble.conf, on Windows it's located at the same directory as the main executable.
Important: to apply config changes, you need to re-start Nimble Streamer instance. You can refer to installation instructions for each platform's re-start commands.
On Ubuntu Linux it's re-started by this command:
sudo service nimble restart

Each parameter description has respective tags for easier navigation and classification. You may click on any number of tags from the list above to filter the parameters which are related to certain areas of functionality.


All


Expand all

Collapse all

absolute_path

HLS

Some scenarios require using absolute paths in playlists, especially when using load balancing techniques. This parameter defines absolute path for those cases. Both IP and domain name can be used.
absolute_path = <server>[:<port>]
If your port is 80 then you may skip :<port> part.

access_control_allow_credentials

CORS

When handling CORS, servers can notify clients whether "credentials" (including Cookies and HTTP Authentication data) should be sent with requests. The access_control_allow_credentials parameter allows setting if this will be sent or not.
It's typically used with other CORS parameters: access_control_allow_headers, access_control_allow_origin, access_control_expose_headers
access_control_allow_credentials = (true|false)
Example:
access_control_allow_credentials = true
Example with other parameters:
access_control_allow_origin = *
access_control_allow_credentials = true
access_control_expose_headers = Content-Length
access_control_allow_headers = Range

Further reading:

access_control_allow_headers

CORS

When handling CORS, servers can use Access-Control-Allow-Headers header which indicates which header field names can be used during the actual request. You can use access_control_allow_headers parameters for that.
It's typically used with other CORS parameters:access_control_allow_credentials, access_control_allow_origin, access_control_expose_headers
access_control_allow_headers = <some value>
Example:
access_control_allow_headers = Range
Example with other parameters:
access_control_allow_origin = *
access_control_allow_credentials = true
access_control_expose_headers = Content-Length
access_control_allow_headers = Range

Further reading:

access_control_allow_origin

CORS

Players may require Access-Control-Allow* headers in server responses as part of cross-origin resource sharing technique. An Access-Control-Allow-Origin (ACAO) header indicates which origin sites are allowed. The access_control_allow_credentials parameter allows setting this header.
It's typically used with other CORS parameters:access_control_allow_credentials,access_control_allow_headers,access_control_expose_headers
access_control_allow_origin = <some value>
Example:
access_control_allow_origin = *
Example with other parameters:
access_control_allow_origin = *
access_control_allow_credentials = true
access_control_expose_headers = Content-Length
access_control_allow_headers = Range

Further reading:

access_control_expose_headers

CORS

The Access-Control-Expose-Headers header indicates which headers are safe to expose as part of cross-origin resource sharing technique. The access_control_expose_headers parameter allows setting this header.
It's typically used with other CORS parameters:access_control_allow_credentials,access_control_allow_headers,access_control_allow_origin
access_control_expose_headers = <some value>
Example:
access_control_expose_headers = Content-Length
Example with other parameters:
access_control_allow_origin = *
access_control_allow_credentials = true
access_control_expose_headers = Content-Length
access_control_allow_headers = Range

Further reading:

add_stream_index_to_hls_chunk_name

HLS

Normally Nimble Streamer generates chunk name with the following template: l_<stream_index>_<timestamp>_<number>.ts. To skip stream_index part for certain cases, use this:
add_stream_index_to_hls_chunk_name = false
Notice that with this parameter set to false, different substreams in ABR stream will have the same chunk names (e.g. l_250920_31.ts). It will make Apple devices switch faster between streams as they look up the same chunk name when switching into another resolution, and play from first present chunk if it was not found (so it "jumps back"). For other device types chunk names don't matter.

advertising_preroll_chunk_count

Advertizer
HLS

Some players do not start the playback of live streams from the first chunk in the playlist. So Advertizer pre-rolls might be partially skipped. For this case Advertizer uses the approach controlled byadvertising_preroll_x_start_enabled parameter. However if it doesn't work, you may try setting advertising_preroll_chunk_count. If you specify this number (e.g. 2 or 3), Nimble Streamer will return a playlist with that number of chunks during responding to the first request from a viewer. Once a viewer requests for refresh of the playlist, a normal-size playlist will be returned.
advertising_preroll_chunk_count = <number>
Further reading:

advertising_preroll_x_start_enabled

Advertizer
HLS

Some players do not start the playback of live streams from the first chunk in the playlist. So Advertizer pre-rolls might be partially skipped. For this case Advertizer inserts #EXT-X-START in order to recommend the player to play from the first chunk. It depends on the player to follow this or not. It's enabled by default so if you need not to use it, you can disable it.
advertising_preroll_x_start_enabled = false
Further reading:

advertising_rtmp_wait_key_frame_to_insert_ad

Advertizer
RTMP

If this is enabled, Nimble Streamer will wait for the nearest keyframe to insert an ad into RTMP stream. Knowing keyframe interval and ads content length, this parameter can be used to reduce the waiting time for the next keyframe when exiting from ad break. This parameter is disabled by default.
advertising_rtmp_wait_key_frame_to_insert_ad = true
Further reading:

advertising_session_rules_request_interval

Advertizer

Defines how frequent Nimble Advertizer will request the session handler for updates of ads scenarios. It’s 30 seconds by default.
advertising_session_rules_request_interval = <number>
Further reading:

advertising_sync_interval

Advertizer

Defines how frequent Nimble Advertizer will request the handler for updates of ads scenarios. It’s 10 seconds by default.
advertising_sync_interval = <number>
Further reading:

advertising_transmuxers_count

Advertizer
Performance

This parameter sets a number of threads used for processing Advertizer transmuxing requests. Use it in case you have a high load use cases. It's "1" by default.
advertising_transmuxers_count = <number>
Further reading:

advertising_url

Advertizer

Defines the URL of Nimble Advertizer handler app or a local file path to Advertizer configuration file.
advertising_url = http://server_addr/handler_app | https://server_addr/handler_app | file://path/to/local/config.json
Example:
advertising_url=http://testradiowebsite.com/ads_handler.php
Further reading:

cache_granularity_for_remote_vod

Cache
VOD

When transmuxing VOD content from remote location to HLS or MPEG-DASH, this parameter defines cache granularity in megabytes for storing content from remote storage. This granularity is also used for cleaning the cache. By default it's 1.
cache_granularity_for_remote_vod = <size>
Further reading:

cache_path

Cache

Defines a path to the disk cache storage. By default it's "/var/cache/nimble".
cache_path = <path>
Further reading:

cdn_origin

Network

There are cases when Nimble Streamer is placed behind the reverse proxy. This is usually done for security reasons. To get IP address of end user for geo stats and hotlinking protection, Nimble needs to process X-Forwarded-For HTTP header for incoming connection. To make it work, you need to add the following parameter.
cdn_origin = true
Further reading:

chunk_cache_control

Cache
HLS
Network

By default, Nimble Streamer sets Cache-Control header for chunks to "no-cache". To change this behavior, use this parameter to set proper value for it.
chunk_cache_control = <value>
Example:
chunk_cache_control = max-age=120
This will set 120 seconds as maximum age for chunks cache.

client_inactivity_timeout

Network

This parameter defines a timeout for a socket to close outgoing connection in case of session inactivity. The default value is 60.
client_inactivity_timeout = <time>
Example:
client_inactivity_timeout = 120

crossdomain_xml

CORS

The "crossdomain.xml" file gives the player permission to talk to servers other than the one it's hosted on. As per Adobe, a cross-domain policy file is an XML document that grants a web client permission to handle data across multiple domains. When a client hosts content from a particular source domain and that content makes requests directed towards a domain other than its own, the remote domain would need to host a cross-domain policy file that grants access to the source domain, | allowing the client to continue with the transaction.
If you'd like to define complete file content, you can create crossdomain.xml with XML based on Adobe's spec examples, and use the following parameter to point Nimble Streamer to that file:
crossdomain_xml = <file path>
Example:
crossdomain_xml = /etc/nimble/crossdomain.xml
Further reading:

crossdomain_xml_allow_access_from_domain

CORS

The "crossdomain.xml" file gives the player permission to talk to servers other than the one it's hosted on. As per Adobe, a cross-domain policy file is an XML document that grants a web client permission to handle data across multiple domains. When a client hosts content from a particular source domain and that content makes requests directed towards a domain other than its own, the remote domain would need to host a cross-domain policy file that grants access to the source domain, | | allowing the client to continue with the transaction.
Nimble Streamer can generate such file with a custom domain name. You can use the following parameter to define that domain name:
crossdomain_xml_allow_access_from_domain = <domain.name>
Example:
crossdomain_xml_allow_access_from_domain = wmspanel.com
Further reading:

custom_pd_exts

Progressive download
VOD

If you need to handle progressive download or re-streaming for any extension other then the extensions supported by default, you can use this parameter:
custom_pd_exts = <list>
Example:
custom_pd_exts=nff,ts
This will enable support for .NFF and .TS
Further reading:

dash_ad_marker_format

Advertizer
DASH
SCTE-35

Nimble Streamer allows forwarding the SCTE-35 markers from MPEG-TS and HLS input to MPEG-DASH output. Whatever input marker types are used, Nimble will transform them into one of supported markers for DASH. The following parameter defines the output type.
dash_ad_marker_format= <xml|bin>
"xml" will generate "Clear XML" ourput, "bin" will generat "Base64-encoded binary" output.
Further reading:

dash_hard_reset_enabled

MPEG-DASH

There are cases when the source incoming stream has glitches in timestamps. In this case Nimble Streamer tries to make compensations but if this happens for some time, the player stops the playback and the output MPEG-DASH stops operating correctly. Use this parameter to make a reset for output MPEG-DASH stream to use actual timestamps. The player will need to be restarted but the stream itself will be working fine for all new viewers. Use this parameter only if you have issues with | MPEG-DASH playback.
dash_hard_reset_enabled = true
Further reading:

dash_live_profiles

MPEG-DASH

MPEG-DASH allows specifying certain profile in a manifest. You can use the following parameter to specify it
dash_live_profiles = urn:mpeg:dash:profile:isoff-live:2011
The profile above is the default one but you can use any other from the list of supported profiles.
As example of other profiles, this is how you enable HbbTV in MPEG-DASH streams:
dash_live_profiles = urn:hbbtv:dash:profile:isoff-live:2012,urn:mpeg:dash:profile:isoff-live:2011
Further reading:

dash_ready_segments

MPEG-DASH

MPEG-DASH manifest is generated only after a certain number of segments are available for delivery. You can use the following parameter to specify it. The default value is 3.
dash_ready_segments = <number>
Further reading:

dvb_subtitles_processing_enabled

HLS
MPEG-TS
Subtitles
Transcoder

Nimble Streamer allows passing through the DVB subtitles from incoming MPEG-TS and HLS streams into output MPEG-TS and HLS delivery. If original stream has some markers in it, they will be passed through into the outgoing stream. To enable this feature use this parameter.
This parameter also enables DVB forwarding for Live Transcoder, see related article.
dvb_subtitles_processing_enabled = true
Further reading:

dvr_default_writer_threads

DVR
HLS

This parameter sets a number of "default" threads used to record DVR archives. It's "1" by default.
dvr_default_writer_threads = 2
Further reading:

dvr_hls_add_program_date_time

DVR
HLS

If you need to enable EXT-X-PROGRAM-DATE-TIME for your DVR chunk lists, you need to add this parameter.
dvr_hls_add_program_date_time = true
Further reading:

dvr_management_threads

DVR
Management

This parameter sets the number of threads used to cleanup DVR and export MP4 from DVR archives. By default it's "1".
dvr_management_threads = 2
Further reading:

dvr_thumbnails_enabled

DVR

You can get thumbnails of recorded DVR using specific URL and it's always enabled by default. To disable it, use this parameter:
dvr_thumbnails_enabled = false
Further reading:

transcoder_change_params_on_the_fly_enabled

Transcoder
WebRTC

This parameter helps transcoder to survive from WebRTC encoding changes like resolution, without impact on resulting picture.
transcoder_change_params_on_the_fly_enabled = true
Further reading:

dvr_transmuxer_threads

DVR
Performance

This parameter is responsible for transmuxing stored DVR content into outgoing streams. It's 1 worker thread by default, if you largely use DVR playback, you should increase this number - check further analysis description below.
dvr_transmuxer_threads = <number>
Further reading:

enable_etag

HLS
MPEG-DASH

Enables sending ETag header for requested resources and processing of If-None-Match header in requests. By default, it's "false".
enable_etag = true
Further reading:

enable_ims_processing

HLS
MPEG-DASH

Some CDNs may use "If-Modifier-Since" header to avoid downloading the same piece of content multiple times. Nimble Streamer may honor this header, you can use this parameter to initiate it. By default, it's "false".
enable_ims_processing = true
Further reading:

enable_ipv6

Network

This parameter makes Nimble Streamer support IPv6.
enable_ipv6 = true

enable_pd_for_remote_vod

Progressive download
VOD

Use this parameter if you'd like to enable the processing of progressive download from remote HTTP storage.
enable_pd_for_remote_vod = true
Further reading:

enable_tasks

Performance

This parameter enabled server-side tasks control.
enable_tasks = true
Further reading:

enable_vod_subtitles

VOD
Subtitles

Nimble Streamer provides subtitles for VOD if they are available. This behavior is enabled by default, but you can disable it using this command.
enable_vod_subtitles = false
Further reading:

hls_ad_auto_splice_in_enabled

Advertizer
HLS
MPEG-TS
SCTE-35

This parameter enables automatic insertion of EXT-X-CUE-IN tag after EXT-X-CUE-OUT, it's false by default.
hls_ad_auto_splice_in_enabled = true
Further reading:

hls_ad_marker_format

Advertizer
HLS
MPEG-TS
SCTE-35

Nimble Streamer allows forwarding the SCTE-35 markers from MPEG-TS and HLS input to MPEG-TS and HLS output. Whatever input marker types are used, Nimble will transform them into one of supported markers for HLS or its analog for MPEG-TS. The following parameter defines the output type.
hls_ad_marker_format = <daterange|cue|cue-short|cue-short+oatcls|splicepoint>
"cue" means Nimble will use CUE-OUT and CUE-IN markers,"cue-short" will produce CUE-OUT markers in short format (#EXT-X-CUE-OUT:<duration>), "cue-short+oatcls" will produce CUE-OUT markers in short format (#EXT-X-CUE-OUT:) with additional #EXT-OATCLS-SCTE35 marker, "splicepoint" will trigger the SPLICEPOINT-SCTE35 marker, "daterange" will produce DATERANGE marker. The default type is "daterange".
Further reading:

hls_ad_splice_out_cont_marker_enabled

Advertizer
HLS
MPEG-TS
SCTE-35

This parameter enables automatic insertion of EXT-X-CUE-OUT-CONT tags after EXT-X-CUE-OUT, it's false by default.
hls_ad_splice_out_cont_marker_enabled = true
Further reading:

hls_ad_scte35_forwarding_enabled

Advertizer
HLS
SCTE-35

This parameter enables forwarding of SCTE-35 markers into HLS stream, it's false by default.
hls_ad_scte35_forwarding_enabled = true
Further reading:

hls_add_closed_caption_none

HLS
Subtitles

By default, Apple devices show closed caption button for HLS streams. In order to prevent this, HLS spec requires the HLS playlist to include "CLOSED-CAPTIONS=NONE" field for each stream. This parameter adds that field.
hls_add_closed_caption_none = true
Further reading:

hls_add_program_date_time

HLS

If you need to enable EXT-X-PROGRAM-DATE-TIME for your HLS chunk lists, you need to add this parameter.
hls_add_program_date_time = true
Further reading:

hls_fmp4_hard_reset_enabled

HLS

There are cases when the source incoming stream has glitches in timestamps. In this case Nimble Streamer tries to make compensations but if this happens for some time, the player stops the playback and the output fMP4 HLS stops operating correctly. Use this parameter to make a reset for output fMP4 stream to use actual timestamps. The player will need to be restarted but the stream itself will be working fine for all new viewers. Use this parameter only if you have issues with fMP4 HLS playback.
hls_fmp4_hard_reset_enabled = true
Further reading:

hls_ignore_pps_changes

HLS

Enable this option to avoid inserting DISCONTINUITY on each PPS change in the stream.
hls_ignore_pps_changes = true
Further reading:

hls_pull_in_keep_alive_mode_enabled

HLS

Enabled keep-alive mode for pulled HLS streams. By default it's false.
hls_pull_in_keep_alive_mode_enabled = true
Further reading:

http_origin

HLS
MPEG-DASH
Re-streaming
VOD
Network

This parameter disables the addition of session information to output streams, Nimble will not force a client to have it. By default it's disabled. If you'd like to disable it on application level only, read related article.
http_origin = true
Further reading:

icecast_chunk_duration_sec

Audio
Icecast

This is a size of Icecast chunk. The default value is 6 seconds.
icecast_chunk_duration_sec = <duration>
Further reading:

icecast_forward_metadata_through_encoder_enabled

Audio
Icecast
Transcoder

This parameter enables passing Icecast metadata through Live Transcoder, see related article for details.
icecast_forward_metadata_through_encoder_enabled = true
Further reading:

icecast_metadata_list_size

Audio
Icecast
Transcoder

This parameter defines a size of Icecast metadata array per stream for the purpose of passing through Live Transcoder. The default value is 30 seconds.
icecast_metadata_list_size = <number>
Further reading:

icecast_reset_adts_mpeg_version_enabled

Audio
Icecast

Resets MPEG version in ADTS header of incoming stream while generating Icecast output. Otherwise some Apple devices may not play Icecast.
icecast_reset_adts_mpeg_version_enabled = true
Further reading:

icecast_update_metadata_request_enabled

Audio
Icecast

When Icecast is received in push mode, the metadata is pushed separately via special requests. It's enabled by default so Nimble Streamer allows accepting that input. If you need this to be disabled, use this parameter.
icecast_update_metadata_request_enabled = false
Further reading:

init_hls_sequence_by_timestamp

HLS

If you want to initialize HLS sequence (segment index) based on stream timestamps, enable this parameter.
init_hls_sequence_by_timestamp = true
Further reading:

keep_request_params_enabled

HLS
MPEG-DASH

Nimble Streamer keeps parameters from input URL in HLS and MPEG-DASH playlists so if anything is appended to playback URL, it's added for chunklists and chunks.
If you need to stop passing through any parameters and cut them off, you can set keep_request_params_enabled parameter, it's enabled by default.
keep_request_params_enabled = false
If you'd like to keep the order of parameters passed to the playlist, use "keep-order" value.
keep_request_params_enabled = keep-order
Further reading:

listen_interfaces

Network

By default, Nimble Streamer listens for incoming client request via the port specified byport parameter on all available interfaces. You may specify exact interfaces to listen at via this parameter.
The default value is "listen_interfaces = *".
listen_interfaces = <list>
Example:
listen_interfaces = 127.0.0.1, 172.16.1.9

live_pull_threads

Performance
HLS

This parameter sets a number of threads used for pulling live HLS for further processing in Nimble Streamer. Use it in case you have a high load use cases. By default it's "1".
live_pull_threads = <threads count>
Further reading:

live_transmuxing_buffer

HLS
MPEG-DASH

Nimble Streamer internal transmuxer buffer sometimes may not be enough to fit generated HLS chunk. This may lead to errors like "cannot allocate buffer message body" in Nimble Streamer logs. This parameter allows defining live transmuxing buffer size in MBs. By default it's "64".
live_transmuxing_buffer = <size>
Further reading:

log_access

Logging

This parameter enables access log. You may set it to be saved to access.log file and syslog. You may use these values in any combinations, e.g. specify only syslog. Access log record contains the following fields:
client_ip - - [date] "request" return_code bytes_received bytes_sent time_to_process_request_in_microseconds "referrer" "user-agent"
You may use "file" and "syslog" values together or separately.
log_access = file, syslog
Example:
log_access = file
Further reading:

log_advertisements

Advertizer
Logging

Enables logging of Nimble Advertizer activities.
log_advertisements = true
Further reading:

log_sessions

Logging

Besides connections stats, you can log session the same way. Session log contains one entry for playback session and URL used to open the session. Nimble uses session IDs to track specific player sessions, not just for logs aggregation. It's enabled via log_sessions parameter which works the same way as log_access.
Session log records contains the following fields:
client IP - - [date] "request" return_code "referrer" "user-agent" - session_duration session_id bytes_in bytes_out
log_sessions = file, syslog
Example:
log_sessions = file
Further reading:

logging

Logging

This parameter is used for getting information about what happens inside of Nimble. If not specified, it will use "info".
For logging, you may use both Nimble log files and syslog. Possible values for both types are error, info, verbose and debug. The syntax is
logging = file:<value>, syslog:<value>
or
logging = <value>, syslog:<value>
Examples:
logging = file
logging = info, syslog:error
logging = info, syslog:info
logging = file:info, syslog:error

management_listen_interfaces

API
Management
Network

Specifies which IP addresses will be used for accepting API requests. If it's not set, the API requests are not accepted.
Default value: not set
Examples:
management_listen_interfaces = * - all available interfaces are used
management_listen_interfaces = 127.0.0.1, 192.168.0.1

Further reading:

management_log_access

Logging

This parameter enables access log for Nimble management native API.
management_log_access = true
Further reading:

management_port

API
Management
Network

Specifies which port is used to listen to API requests.
Default value: 8082
Example:
management_port = 8086
Further reading:

management_ssl_port

API
Management
Network
SSL

This parameter defines port for working with Nimble native API via SSL
management_ssl_port = <port>
Further reading:

management_token

API
Management
Network

Specifies the token (i.e. password) which is used for authorizing API requests. See Making authorized requests section below for details.
Default value: not set, if this parameter is missing, there will be no authorization made and anyone will be able to get information.
Example:
management_token = mypassword
Further reading:

max_advertising_download_sessions

Advertizer

Defines how many concurrent sessions Nimble Advertizer will use for downloading the files which contain ads. If handler specifies more files that defined in this parameter, the extra files will be queued and downloaded in their turn. It’s 10 sessions by default.
max_advertising_download_sessions = <number>
Further reading:

max_audio_filter_threads

Audio
Performance
Transcoder

Max number of threads which Nimble recommends for filter to be used. By default it's 4.
max_audio_filter_threads = <number>
Further reading:

max_cache_size

Performance
Cache

This parameters defines a maximum size of RAM data cache in megabytes. It's 64 MB by default.
max_cache_size = <number>
Further reading:

max_disk_cache_size

Performance
Cache

This parameters defines is a size of file cache measured in MB. It's 4096 MB by default.
max_disk_cache_size = <number>
Further reading:

max_forwarded_klv_streams

MPEG-TS

This parameters defines maximum number of KLV streams which will be passed through. By default it's 0 so the feature is disabled.
max_forwarded_klv_streams = <number>
Further reading:

max_libx264_encoder_threads

Performance
Transcoder

Max number of threads which Nimble recommends for libx264 encoder library to be used. It's "16" by default.
max_libx264_encoder_threads = <number>
Further reading:

max_log_file_size

Logging

Log files can be rotated, so you can define max size of each log file. max_log_file_size defines the size of each file. It's measured in MBs and it's 128.
It's typically used withmax_log_files_to_keep parameter.
max_log_file_size = <size>
Example:
max_log_file_size = 100
max_log_files_to_keep = 25

max_log_files_to_keep

Logging

Log files can be rotated, so you can define the number of files in rotation. max_log_files_to_keep defines maximum number of files.
It's typically used withmax_log_file_size parameter.

max_log_files_to_keep = <number>
Example:
max_log_file_size = 100
max_log_files_to_keep = 25

max_origin_playlist_size

HLS
Re-streaming

During HLS re-streaming, Nimble can limit the size of origin playlist (e.g. if some large DVR is being re-streamed). By default it's 2MB.
max_origin_playlist_size = <size>
Further reading:

max_video_filter_threads

Performance
Transcoder

Max number of threads which Nimble recommends for filter to be used. By default it's 8.
max_video_filter_threads = <number>
Further reading:

merge_pd_sessions

Progressive download

Some players do not honor session IDs assigned by Nimble which doesn't allow calculating stats properly. By default when that happens, Nimble Streamer calculate each request as separate session. If you set this parameter to true, Nimble will use URL, IP and user agent name so make its own session and calculate stats more precisely. This parameter is set to false by default.
merge_pd_sessions = true
Further reading:

mpeg2ts_camera_threads

UDP
Performance
MPEG-TS

Nimble Streamer can process incoming MPEG2TS streams via HTTP/UDP/HLS for further transmuxing. If you use it extensively and have around 80 load on your CPU - which probably means you process around 400-500 Mbps of streams - you may use mpeg2ts_camera_threads parameter.
mpeg2ts_camera_threads defines number of threads for processing MPEG-TS HTTP/HLS/UDP input streams. Increase this number to decrease the load on single thread. Dy default it's "1".
mpeg2ts_camera_threads = <number>
Further reading:

mpeg2ts_pat_pmt_msec_interval

UDP

This parameter defines a time to retransmit for PAT and PMT tables. By default it's 100 milliseconds.
mpeg2ts_pat_pmt_msec_interval = <time>
Further reading:

mpeg2ts_pcr_retransmit_msec_interval

UDP

This parameter defines a time to retransmit PCR. By default it's 20 milliseconds.
mpeg2ts_pcr_retransmit_msec_interval = <time>
Further reading:

mpeg2ts_sdt_msec_interval

UDP

This parameter defines a time to retransmit for SDT. It's "500" by default.
mpeg2ts_sdt_msec_interval = <time>
Further reading:

mpeg2ts_timestamp_overrun_processing_enabled

UDP

This parameter enabled the support for smooth 33bit MPEGTS timestamp overflow processing using monotonic timestamp by accumulating the differences between the current timestamp and previous timestamp. By default it's disabled.
mpeg2ts_timestamp_overrun_processing_enabled = true
Further reading:

mpeg2ts_instant_camera_remove

UDP
MPEG-TS

Part of default behavior for MPEGTS-based streams in Nimble Streamer is that when the input is interrupted for some reason, the output stream is still available. This goes on until the 30 seconds timeout breaks it, or the input is resumed. This parameter allows interrupting the output streaming right at the moment when the input is interrupted.
mpeg2ts_instant_camera_remove = true
Further reading:

mpegts_for_audio_vod

Audio
HLS
VOD

If your media is audio-only, Nimble Streamer produces audio-only HLS with significantly reduced size. However some players require MPEG-TS chunks, e.g. old STBs etc. This parameter enables generating VOD HLS with MPEG-TS chunks. The mode is created specifically for the mentioned scenario only. In all other cases, this option works the same as default "HLS" option.
mpegts_for_audio_vod = true
Further reading:

mpegts_inactivity_check_interval

UDP

If you process MPEG2TS streams, you may need to set inactivity check interval.
mpegts_inactivity_check_interval = 20 means stream will be restarted after 3 * mpegts_inactivity_check_interval = 60 seconds.
The problem is that sometimes MPEG2TS streams stop sending data for some period and then start again. This period may be more than default 15 seconds, hence the separate parameter for controlling it.
mpegts_inactivity_check_interval = <seconds>
Further reading:

mpegts_join_timestamps_enabled

UDP

Some encoders send their samples split by parts to other samples, and all those parts have the same timestamp. This option allows joining those parts to be processed as one sample. It works on receiving side for AVC and HEVC. It's false by default.
mpegts_join_timestamps_enabled = true
Further reading:

mpegts_latm_probe_enabled

UDP

With this parameter Nimble will try to determine LATM codec type in case it's not defined. It's false by default.
mpegts_latm_probe_enabled = true
Further reading:

nimble_audio_index

Audio
HLS
MPEG-DASH
VOD

When streaming VOD HLS, you may need to specify an exact video and/or audio track to use for playback. Nimble Streamer supports MP4 tracks selection for HLS and you may use nimble_audio_index parameter for it. If you need to use other parameters' name, you can use the following parameter.
nimble_audio_index = <name for audio>
It's typically used withnimble_video_index parameter.
Example:
nimble_audio_index = audioIndex
nimble_video_index = videoIndex

Further reading:

nimble_video_index

Audio
HLS
MPEG-DASH
VOD

When streaming VOD HLS, you may need to specify an exact video and/or audio track to use for playback. Nimble Streamer supports MP4 tracks selection for HLS and you may use nimble_video_index parameter for it. If you need to use other parameters' name, you can use the following parameter.
nimble_video_index = <name for video>
It's typically used withnimble_audio_index parameter.
Example:
nimble_audio_index = audioIndex
nimble_video_index = videoIndex

Further reading:

nvenc_context_cache_enable

Performance
Transcoder

Some complex transcoding scenarios may result excessive load on NVENC GPU hardware, this is a known issue for NVENC. One of approaches is to use NVENC contexts caching mechanism in Nimble Streamer Transcoder described inNVENC context cache for Live Transcoder article.
nvenc_context_cache_enable parameter enables using context cache.
It must be used withnvenc_context_cache_init,nvenc_context_create_lock andnvenc_context_reuse_enable parameters.
nvenc_context_cache_enable = true
Example:
nvenc_context_cache_enable = true
nvenc_context_cache_init = 0:32:32,1:32:32,2:16:16,3:16:16
nvenc_context_create_lock = true
nvenc_context_reuse_enable = true

Further reading:

nvenc_context_cache_init

Performance
Transcoder

Some complex transcoding scenarios may result excessive load on NVENC GPU hardware, this is a known issue for NVENC. One of approaches is to use NVENC contexts caching mechanism in Nimble Streamer Transcoder described inNVENC context cache for Live Transcoder article.
You can set transcoder to create contexts at the start. You can specify how many contexts will be created for each graphic unit for encoding and for decoding sessions.
nvenc_context_cache_init parameter does that.
It must be used withnvenc_context_cache_enable,nvenc_context_create_lock andnvenc_context_reuse_enable parameters.
nvenc_context_cache_init = 0:<EC>:<DC>,1:<EC>:<DC>,N:<EC>:<DC>
Example:
nvenc_context_cache_enable = true
nvenc_context_cache_init = 0:32:32,1:32:32,2:16:16,3:16:16
nvenc_context_create_lock = true
nvenc_context_reuse_enable = true

Further reading:

nvenc_context_create_lock

Performance
Transcoder

Some complex transcoding scenarios may result excessive load on NVENC GPU hardware, this is a known issue for NVENC. One of approaches is to use NVENC contexts caching mechanism in Nimble Streamer Transcoder described inNVENC context cache for Live Transcoder article.
In order to handle context cache efficiently, the transcoder needs to lock the calls for NVidia drivers APIs to itself. This allows making the queue for the contexts creation and control this exclusively which improves the performance significantly.
nvenc_context_create_lock parameter enables this lock.
It must be used withnvenc_context_cache_enable,nvenc_context_cache_init andnvenc_context_reuse_enable parameters.
nvenc_context_create_lock = true
Example:
nvenc_context_cache_enable = true
nvenc_context_cache_init = 0:32:32,1:32:32,2:16:16,3:16:16
nvenc_context_create_lock = true
nvenc_context_reuse_enable = true

Further reading:

nvenc_context_reuse_enable

Performance
Transcoder

Some complex transcoding scenarios may result excessive load on NVENC GPU hardware, this is a known issue for NVENC. One of approaches is to use NVENC contexts caching mechanism in Nimble Streamer Transcoder described inNVENC context cache for Live Transcoder article.
When a new context is created on top of those created on transcoder start, it will be released once the encoder or decoder session is over.
nvenc_context_reuse_enable makes those contexts available for further re-use.
It must be used withnvenc_context_cache_enable,nvenc_context_cache_init andnvenc_context_create_lock parameters.
nvenc_context_reuse_enable = true
Example:
nvenc_context_cache_enable = true
nvenc_context_cache_init = 0:32:32,1:32:32,2:16:16,3:16:16
nvenc_context_create_lock = true
nvenc_context_reuse_enable = true

Further reading:

nvenc_context_share_lock_enable

Performance
Transcoder

Some complex transcoding scenarios may result excessive load on the NVENC GPU hardware which may affect the performance and result errors. You may find the following lines in Nimble Streamer logs: "Failed to encode on appropriate rate" or "Failed to decode on appropriate rate". This is a known issue for NVENC.
The recommended approach is to re-use shared context to optimize resource usage. Please readNVENC shared context usage article for all details.
nvenc_context_share_lock_enable parameter prevents the errors related to NVENC decoding when using shared contexts.
It must be used withnvenc_context_share_enable parameter.
nvenc_context_share_enable = true
nvenc_context_share_lock_enable = true

Further reading:

nvenc_context_share_enable

Performance
Transcoder

Some complex transcoding scenarios may result excessive load on the NVENC GPU hardware which may affect the performance and result errors. You may find the following lines in Nimble Streamer logs: "Failed to encode on appropriate rate" or "Failed to decode on appropriate rate". This is a known issue for NVENC.
The recommended approach is to re-use shared context to optimize resource usage. Please readNVENC shared context usage article for all details.
nvenc_context_share_enable parameter allows re-using shared context to optimize resource usage.
It must be used withnvenc_context_share_lock_enable parameter.
nvenc_context_share_enable = true
nvenc_context_share_lock_enable = true

Further reading:

panel_access_proxy

Network

If admin user registers Nimble Streamer instance in WMSPanel using --proxy proxy_url parameter, this proxy_url value will be stored in the following parameter:
panel_access_proxy = <url>

panel_domain

Network

The following parameter defines domain which Nimble Streamer uses for syncing with WMSPanel.
It must be used withpanel_port parameter.
panel_domain = <url>
panel_port = <value>

panel_port

Network

The following parameter port which Nimble Streamer uses for syncing with WMSPanel.
It must be used withpanel_domain parameter.
panel_domain = <url>
panel_port = <value>

panel_password

Network

This parameter defines password which Nimble Streamer uses for syncing with WMSPanel.
It must be used withpanel_uuid parameter.
panel_uuid = <user>
panel_password = <password>

panel_uuid

Network

This parameter defines username which Nimble Streamer uses for syncing with WMSPanel.
It must be used withpanel_password parameter.
panel_uuid = <user>
panel_password = <password>

panel_server_name

Network

The following parameter defines server name after registering it in WMSPanel using --server-name parameter of regutil during installation.
panel_server_name = <name>

pass_headers

HLS
Re-streaming

When re-streaming content, you may need to pass through headers from player to origin server. Nimble can make a pass-through along with adding headers' prefixes. To enable this, use "pass_headers" parameter.
It should be used withpassed_header_prefix parameter.
pass_headers = true
Example:
pass_headers = true
passed_header_prefix = X-Passthru-

Further reading:

passed_header_prefix

HLS
Re-streaming

When re-streaming content, you may need to pass through headers from player to origin server. Nimble can make a pass-through along with adding headers' prefixes. To use a prefix for passed headers, use this parameter. The default value is "X-Peer-Header-".
It should be used withpass_headers parameter.
passed_header_prefix = <prefix>
Example:
pass_headers = true
passed_header_prefix = X-Passthru-

Further reading:

playlist_cache_control

Cache
HLS
Network

By default, Nimble Streamer sets Cache-Control header for playlists to "no-cache". To change this behavior, use this parameter to set proper value for it.
playlist_cache_control = <value>
Example:
playlist_cache_control = max-age=30
This will set 30 seconds as maximum age for playlist cache.

port

Network

Contains port number which Nimble is listening to. Default value is 8081.
port = 80

port = 80, 8081
Further reading:

ram_cache_for_vod_threshold

Cache
VOD

This parameter specifies the ratio of how much RAM may be used for VOD cache. E.g. 0.5 means 50. By default it's "0.8".
ram_cache_for_vod_threshold = <ratio>
Further reading:

restreaming_add_x_forwarded_for

Network
Re-streaming

When Nimble Streamer is re-streaming a stream using HLS re-streaming routes, is passes X-Forwarded-For HTTP header from incoming connections to origin server. To disable this behavior and stop using this header, you need to set this parameter to false.
restreaming_add_x_forwarded_for = false

restrict_session_ip

Network

By default Nimble Streamer checks user session ID against his IP address to avoid fraud. If this needs to be overlapped for telecom-related reasons, you can disable it by setting up this parameter. This will make Nimble skip IP address check for each session. Refer to article below for more details.
restrict_session_ip = false
Further reading:

restrict_session_url

Network

By default, every stream is checked for has consistent URL after all redirects, i.e. it has to have the same IP/domain, application and stream, regardless of what parameters are added. If some element is changed, e.g. other IP or stream name, then Nimble stops processing that stream. This can be disabled by this parameter.
restrict_session_url = false
Further reading:

rtmp_buffer_items

RTMP
Performance

When using RTMP pull by request, it takes some time to start the playback on viewer side. So RTMP buffer items count an be specified on origin so the edge could get bigger buffer to provide it to the player. So the player will get several chunks almost immediately and start playback in a second without buffering.
rtmp_buffer_items = <buffer_size>
Example:
rtmp_buffer_items = 4096
Further reading:

rtmp_camera_worker_threads

RTMP
Performance

Number of threads used for processing published RTMP streams. By default it's 1.
rtmp_camera_worker_threads = <number>
Example:
rtmp_camera_worker_threads = 2
Further reading:

rtmp_check_stream_id_for_protocol_control_messages

RTMP

Some versions of AWS Elemental encoder has issues with RTMP handshake which make them deny connections. THis parameter fixes this behavior.
rtmp_check_stream_id_for_protocol_control_messages = false
Further reading:

rtmp_fcsubscribe_enabled

RTMP

If Nimble Streamer pulls RTMP streams from Flash Media Server, a fcSubscribe parameter is required to be sent to that software. This parameter enables this behavior.
rtmp_fcsubscribe_enabled = true
Further reading:

rtmp_handshake_client_version_disabled

RTMP
Red5

Red5 server requires special handling of client version during handshake. Set this parameter to allow working with Red5 via RTMP.
Limelight Realtime Streaming service uses Red5 so it needs it as well.
rtmp_handshake_client_version_disabled = true
Further reading:

rtmp_instant_pull_remove

RTMP

Use this parameter to immediately disconnect from pulled RTMP source indicating that stream is stopped/not available anymore.
rtmp_instant_pull_remove = true
Further reading:

rtmp_max_viewers

RTMP
Performance

In some high loaded systems the number of simultaneous RTMP connections can be significant. By default Nimble processes 2500 simultaneous connections per each RTMP working thread, but you can increase/decrease this value with this parameter.
rtmp_max_viewers = <number>
Example:
rtmp_max_viewers = 3000
Further reading:

rtmp_publisher_inactivity_check_interval

RTMP

This parameter allows configuring RTMP publisher inactivity check interval. Nimble Streamer disconnects publisher if it's inactive on 3rd check, so setting interval allows defining total time. If it's set to "3", this will cause 9 seconds inactivity timeout. Setting to "5" will disconnect publisher after 15 seconds of inactivity. By default it's "20".
rtmp_publisher_inactivity_check_interval = <interval>
Example:
rtmp_publisher_inactivity_check_interval = 4
This will set total inactivity timeout to 12 seconds.
Further reading:

rtmp_publisher_threads

RTMP

If Nimble instance is re-publishing a large amount of RTMP streams, this parameter allows increasing working threads for RTMP publisher. One publisher handles approximately 150 output republished streams. If you have more than 150 republished streams, this needs to be set to "2". If more than 300, that would be "3" etc. By default it's "1".
rtmp_publisher_threads = <number>
Example:
rtmp_publisher_threads = 4
This will allow republishing up to 600 streams.
Further reading:

rtmp_screen_illegal_chars_in_stream_name

RTMP

This parameter enables screening illegal characters (special characters, spaces) in RTMP stream name published to Nimble, replacing them to "_".
rtmp_screen_illegal_chars_in_stream_name = true
Further reading:

rtmp_worker_threads

RTMP
Performance

This parameter sets the RTMP working thread count. It's "4" by default.
rtmp_worker_threads = <number>
Further reading:

rtsp_max_viewers

RTSP
Performance

In some high loaded systems the number of simultaneous RTSP connections can be significant. By default Nimble processes 2500 simultaneous connections per each RTSP working thread, but you can increase/decrease this value with this parameter.
rtsp_max_viewers = <number>
Example:
rtsp_max_viewers = 3000
Further reading:

rtsp_worker_threads

RTSP
Performance

This parameter sets the RTSP working thread count. It's "4" by default.
rtsp_worker_threads = <number>
Further reading:

scte35_processing_enabled

Advertizer
HLS
MPEG-TS
SCTE-35

Nimble Streamer allows processing the SCTE-35 markers: passthrough via MPEG-TS and HLS, ads insertion and API SCTE-35 injection. To enable SCTE-35 processing for all related features, use this parameter.
scte35_processing_enabled = true
Further reading:

scte35_forwarding_enabled

HLS
MPEG-TS
Transcoder
SCTE-35

Nimble Streamer allows passing through the SCTE-35 markers via Live Transcoder. If original stream has some markers in it, they will be passed through into the outgoing streams of Transcoder. To enable this feature use this parameter, and it works only ifscte35_processing_enabled is enabled. It also overrides any Transcoder scenario settings related for SCTE-35 forwarding.
scte35_forwarding_enabled = true
Further reading:

self_redirect_pd_sessions

Progressive download
VOD

By default, when Nimble Streamer gets request for streaming a file via progressive download, it redirects the player to the same URL with session ID added. If you don't need this behavior, you can use this parameter.
self_redirect_pd_sessions = false
Further reading:

server_name

SSL

When applying SSL certificates and keys to a certain set of domains, this parameter describes server name patterns to apply certificate to. Read article below for full description.
server_name = <list>
Example:
server_name = *.wmspanel.com ~^.*\.wmspanel.com$
Further reading:

server_playlist_sync_url

Server playlists

Defines the location of server playlist configuration file, either HTTP/HTTPS URL or local file. If the URL doesn't begin with http or https, it's considered as a local file.
server_playlist_sync_url = <location>
Example:
server_playlist_sync_url = http://127.0.0.1:8085/server_playlist.json
server_playlist_sync_url = /home/user/config/server_playlist.json

Further reading:

server_playlist_sync_interval

Server playlists

Defines synchronization interval for playlist in millisesonds, i.e how often server playlist configuration file will be updated by Nimble Streamer. So playlist update will be applied to Nimble within this time frame. By default it's 10000.
If playlist task has SyncInterval parameter then SyncInterval will overlap the server_playlist_sync_interval.
If playlist cannot be found, Nimble will retry every sync interval period.
server_playlist_sync_interval = <milliseconds>
Example:
server_playlist_sync_interval = 10000
Further reading:

session_timeout

Network

Each streaming session has its ID to handle precise stats calculation and other related capabilities. The default timeout for expiring session IDs is 60 minutes. This parameter allows changing it.
session_timeout = <time>
Example:
session_timeout = 10

sldp_add_steady_timestamps

SLDP

This parameter enables synchronized playback for SLDP.
sldp_add_steady_timestamps = true
Further reading:

split_chunk_on_ad_marker

Advertizer
HLS
MPEG-TS
SCTE-35

When SCTE-35 marker arrives, Nimble typically splits chunks upon marker's arrival. However you can control this behavior using this parameter. The following values can be set:

  • "any" - splits by both "immediate" markers and markers with timestamp;
  • "time" - split only by markers with timestamp;
  • "none" - do not split chunks by markers at all.
split_chunk_on_ad_marker = ("any"|"time"|"none")
Further reading:

srt_multipoint_listener_enabled

UDP
SRT

Multiple SRT Pull-mode clients may request stream when Nimble Streamer provides SRT in "Listen" mode. Use this parameter to enable multipoint listener feature.
srt_multipoint_listener_enabled = true
Further reading:

ssl_certificate

SSL

This parameter defines full path to SSL certificate located at your server. Read article below for full description of usage.
ssl_certificate = <path>
Example:
ssl_certificate = /conf/cert/default.crt
ssl_certificate_key = /conf/cert/default.key.dec

Further reading:

ssl_certificate_key

SSL

This parameter defines a full path to SSL certificate key located at your server. Read article below for full description of usage.
ssl_certificate_key = <key>
Example:
ssl_certificate = /conf/cert/default.crt
ssl_certificate_key = /conf/cert/default.key.dec

Further reading:

ssl_certificate_key_pass

SSL

you use encryption for your SSL certificate key, you need to specify a password using this parameter. It's optional, so if you don't use encryption, don't add this into the config. Read article below for full description of usage.
ssl_certificate_key_pass = <path>

Example:
ssl_certificate = /conf/cert/default.crt
ssl_certificate_key = /conf/cert/default.key.dec
ssl_certificate_key_pass = Passw0rd_123@#$

Further reading:

ssl_ciphers

SSL

This parameter specifies the enabled ciphers. The ciphers are specified in the format understood by the OpenSSL library, for example:
ssl_ciphers = <string>
Example:
ssl_ciphers = "ALL:!aNULL:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP"
Further reading:

ssl_http2_enabled

SSL
HTTP/2

This parameter enables HTTP/2 processing through SSL, making HLS and MPEG-DASH live streaming be available via HTTP/2.
ssl_http2_enabled = true
Further reading:

ssl_port

SSL

This parameter defines port number for SSL connections of HTTP-based protocols.
ssl_port = <port[, port]>
By default, Nimble Streamer handles connections via the port specified in config atport parameter, usually it's port 8081. If you need Nimble Streamer to handle connections via SSL only, please set this parameter to 0, like this:
port = 0
If it has some other value, Nimble still handles streaming connections through 2 ports via both HTTP and HTTPS. If you remove "port" parameter, Nimble will use default value "8081".
Examples:
ssl_port = 443
port = 0

Multiple ports:
ssl_port = 8077, 8087
Further reading:

ssl_prefer_server_ciphers

SSL

This parameter defines that server ciphers should be preferred over client ciphers when using the SSLv3 and TLS protocols.
ssl_prefer_server_ciphers = true
Further reading:

ssl_protocols

SSL

This parameter parameter what SSL protocols are used. It requires the list of protocols separated by spaces. Full list of supported protocols is: SSLv2, SSLv3, TLSv1, TLSv1.1, TLSv1.2. The default protocols are TLSv1, TLSv1.1 and TLSv1.2.
ssl_protocols = <list>
Example:
ssl_protocols = TLSv1 TLSv1.1 TLSv1.2
Further reading:

strip_port_from_session_host

Network

By default, WMSPanel doesn't take into consideration port number in URL for calculating statistics. E.g. if you have 1 view for http://site.com:8081/app/stream and 1 view for http://site.com:80/app/stream from the same viewer, WMSPanel will consider them as 2 views for http://site.com/app/stream for that viewer.
If you'd like to distinct sessions' URLs by port, use this parameters.
strip_port_from_session_host = false

thumbnail_transmuxer_threads

DVR
Performance

When thumbnail generation is enabled and you see that your DVR thread is consuming too much resources, you can add working threads by using this parameter. By default, it's "1".
thumbnail_transmuxer_threads = <number>
Further reading:

transmuxer_threads

VOD
Performance
HLS
MPEG-DASH

This parameter parameter sets a number of threads used for processing VOD HLS/MPEG-DASH transmuxing requests. Use it in case you have a high load use cases.
transmuxer_threads = <threads count>
Further reading:

udp_so_receive_buffer

UDP
MPEG-TS
RTSP

If you see any image artifacts or video freeze when receiving content through UDP via MPEG-TS or RTSP, Nimble allows increasing UDP buffer by setting this parameter. It's defined in bytes, by default it's "1048576".
udp_so_receive_buffer = <size>
Further reading:

udp_so_send_buffer

UDP
MPEG-TS

Nimble allows increasing UDP send buffer by setting this parameter. By default uses the value defined by kernel.
udp_so_send_buffer = <size>
Further reading:

update_geoip_database

Paywall

When using Nimble Streamer WMSAuth geo-location restriction, Nimble instance automatically updates geo-location database - it will be checking and updating the geo IP database once a day from WMSPanel. If you'd like to disable this behavior, use this parameter.
update_geoip_database = false
Further reading:

update_origin_session_params

Network
Re-streaming

When Nimble Streamer performs HLS re-streaming and origin source changes URL parameters, Nimble will use them for further requests within the session. If you'd like to disable this behavior, use this parameter.
update_origin_session_params = false
Further reading:

user_agent

Re-streaming

When Nimble Streamer performs HLS re-streaming, you may specify the user agent name for accessing origin server. Use this parameter to set the name.
user_agent = <User-Agent-Name>
Further reading:

video_filter_preserve_cc_enabled

Transcoder

When a stream is up-scaled via filter (e.g. from 29.97FPS to 59.94FPS), the closed captions are doubled in the video stream. Closed captions are embedded into frames, FPS filter duplicates frames with all side data, and this leads to duplicated characters. To fix that, add the following parameter.
video_filter_preserve_cc_enabled = true
Further reading:

video_filter_reset_by_pts_enabled

Transcoder

If you have MPEG-TS input and if you use FPS filter in transcoder, and if input gets time gap, the output will hang up. This parameter forces resetting video filter in case of time gaps.
video_filter_reset_by_pts_enabled = true
Further reading:

vod_cache_min_storage_time

Cache
VOD

If you've setvod_cache_timeout parameter and you need your disk cache to be cleaned up after some minimum amount of time using LRU approach, use this parameter. Read related article for more details. It specifies amount of hours for storing cached items. By default, it's "1". This parameter supports several measurement units like "10s", "10m", "10h" which stand for seconds, minutes and hours respectively. If they are not specified, then an hour is the default unit.
vod_cache_min_storage_time = <time>
Further reading:

vod_cache_timeout

Cache
VOD

This parameter defines a maximum life time of VOD disk cache chunks in hours. The default value is "24" - chunks are stored for 24 hours after the last request. Read related article for more details. This parameter supports several measurement units like 10s, 10m, 10h which stand for seconds, minutes and hours respectively. If they are not specified, then an hour is the default unit.
vod_cache_timeout = <time>
Further reading:

vod_chunk_duration

HLS
MPEG-DASH
VOD

This parameter allows to set VOD chunk duration in seconds, between 1 and 50. By default it's "6".
vod_chunk_duration = <duration>
Further reading:

vod_subtitle_chunk_duration_sec

VOD
Subtitles

This parameter defines the duration (in seconds) of subtitles chunks. By default its' "500".
vod_subtitle_chunk_duration_sec = <duration>
Further reading:

vod_subtitle_default_language_id

VOD
Subtitles

Use this parameter if you use SRT or WebVTT subtitles file for a VOD file and would like to define default language. By default it's "eng".
vod_subtitle_default_language_id = <alpha3 code>
Example:
vod_subtitle_default_language_id = fra
Further reading:

vod_to_ram_cache_first

HLS
MPEG-DASH
VOD

This parameter enables using RAM cache prior to disk cache in VOD scenarios.
vod_to_ram_cache_first = true
Further reading:

vod_transmuxing_buffer

HLS
MPEG-DASH
VOD

Nimble Streamer internal transmuxer buffer sometimes may not be enough to fit generated HLS chunk. This may lead to "[tmux1] E: buffer is too small to generate" error in Nimble Streamer logs. This parameter allows defining this buffer size in MBs. By default it's "64".
vod_transmuxing_buffer = <size>
Further reading:

webrtc_whep_support

WebRTC

This parameter enables WebRTC WHEP playback in Nimble Streamer.
webrtc_whep_support = true
Further reading:

webrtc_whep_worker_threads

WebRTC

This parameter sets the number of working threads for WHEP sessions processing. It's "1" by default.
webrtc_whep_worker_threads = <number>
Example:
webrtc_whep_worker_threads = 2
Further reading:

webrtc_whep_max_viewers

WebRTC

In some high load cases the number of simultaneous WHEP connections can be significant. By default Nimble processes 2500 simultaneous connections per each WHEP working thread, but you can increase/decrease this value with this parameter.
webrtc_whep_max_viewers = <number>
Example:
webrtc_whep_max_viewers = 2500
Further reading:

webrtc_whip_support

WebRTC

This parameter enables WebRTC WHIP ingest processing in Nimble Streamer.
webrtc_whip_support = true
Further reading:

websocket_live_max_viewers

SLDP
Performance

In some high loaded systems the number of simultaneous SLDP connections can be significant. By default Nimble processes 2500 simultaneous connections per each SLDP working thread, but you can increase/decrease this value with this parameter.
websocket_live_max_viewers = <number>
Further reading:

websocket_live_worker_threads

SLDP
Performance

This parameter sets the SLDP working thread count. It's "4" by default.
websocket_live_worker_threads = <number>
Further reading:

wmsauth_geo_deny_error_code

Paywall

When using geo-location restrictions, Nimble Streamer returns 403 response code if a viewer is not allowed to view the stream via HTTP protocol. Use this parameter to return other code.
wmsauth_geo_deny_error_code = <code>
It's typically used withwmsauth_ip_range_deny_error_code parameter.
Example:
wmsauth_geo_deny_error_code = 451
wmsauth_ip_range_deny_error_code = 451

Further reading:

wmsauth_ip_range_deny_error_code

Paywall

When using IP-based restrictions, Nimble Streamer returns 403 response code if a viewer is not allowed to view the stream via HTTP protocol. Use this parameter to return other code.
It's typically used withwmsauth_geo_deny_error_code parameter.
wmsauth_ip_range_deny_error_code = <code>
Example:
wmsauth_geo_deny_error_code = 451
wmsauth_ip_range_deny_error_code = 451

Further reading:

worker_threads

Performance

This parameter defines number of threads for handling incoming HTTP connections. It's "1" by default.
worker_threads = <number>
Further reading:

Expand all

Collapse all