Nimble Streamer configuration parameters reference

This page describes parameters of Nimble Streamer which allow controlling server instance behavior.


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 and chunk lists, 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 by advertising_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_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.
advertising_url = http://server_addr/handler_app | https://server_addr/handler_app
Example:
advertising_url=http://testradiowebsite.com/ads_handler.php
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_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.
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_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_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:

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_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_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:

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 disable keep_request_params_enabled parameter, it's enabled by default.
keep_request_params_enabled = false
Further reading:

listen_interfaces

Network

By default, Nimble Streamer listens for incoming client request via the port specified by port 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

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 "user-agent" session_duration session_id
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_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 with max_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 with max_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

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 and mpeg2ts_lock_free_enabled parameters.
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".
It must be used with mpeg2ts_lock_free_enabled parameter.
mpeg2ts_camera_threads = <number>
mpeg2ts_lock_free_enabled = true

Further reading:

mpeg2ts_lock_free_enabled

UDP
Performance

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 and mpeg2ts_lock_free_enabled parameters.
mpeg2ts_lock_free_enabled disables thread lock for better CPU load distribution and optimizes streams processing. By default it's "false".
It must be used with mpeg2ts_camera_threads parameter.
mpeg2ts_camera_threads = <number>
mpeg2ts_lock_free_enabled = true

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:

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 with nimble_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 with nimble_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 in NVENC context cache for Live Transcoder article.
nvenc_context_cache_enable parameter enables using context cache.
It must be used with nvenc_context_cache_init, nvenc_context_create_lock and nvenc_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 in NVENC 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 with nvenc_context_cache_enable, nvenc_context_create_lock and nvenc_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 in NVENC 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 with nvenc_context_cache_enable, nvenc_context_cache_init and nvenc_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 in NVENC 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 with nvenc_context_cache_enable, nvenc_context_cache_init and nvenc_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 read NVENC 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 with nvenc_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 read NVENC 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 with nvenc_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 with panel_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 with panel_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 with panel_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 with panel_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 with passed_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 with pass_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:

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_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

Limelight Realtime Streaming service requires special handling of client version during handshake. Set this parameter to allow publishing RTMP to Limelight RTS.
rtmp_handshake_client_version_disabled = 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_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 if scte35_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:

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

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_port

SSL

This parameter defines port number for SSL connections of HTTP-based protocols.
ssl_port = <port>
By default, Nimble Streamer handles connections via the port specified in config at port 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".
Example:
ssl_port = 443
port = 0

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 when streaming 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 "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

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 need your disk cache to be cleaned up after some minimum amount of time using LRU approach, use this parameter which specifies amount of hours for cached item. 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. 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
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:

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 with wmsauth_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 with wmsauth_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

Install Nimble Streamer now
Install now
Free trial of WMSPanel included

This website or its third-party tools use cookies, which are necessary to its functioning and required to achieve the purposes illustrated in the Privacy Policy. If you want to know more or withdraw your consent to all or some of the cookies, please refer to the Privacy Policy.
By closing this banner, scrolling this page, clicking a link or continuing to browse otherwise, you agree to the use of cookies.