Nimble Streamer Configuration Parameters Reference

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.

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:

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:

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:

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:

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.

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:

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:

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:

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:

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:

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:

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:

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:

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

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:

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.

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

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

This parameter makes Nimble Streamer support IPv6.
enable_ipv6 = true

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:

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

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:

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:

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:

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:

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

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:

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:

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:

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

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

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:

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

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

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:

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:

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:

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

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:

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

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:

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:

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:

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

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:

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

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:

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

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

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

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:

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 number of threads which Nimble recommends for filter to be used. By default it's 4.
max_audio_filter_threads = <number>
Further reading:

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

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:

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

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

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

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 number of threads which Nimble recommends for filter to be used. By default it's 8.
max_video_filter_threads = <number>
Further reading:

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:

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:

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:

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

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

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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>

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>

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>

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>

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>

This parameter adds any additional text to Server HTTP header.
E.g. if you add "server_id = SomeTextID" then Server header will be as following:
Server: Nimble/4.1.3-3 (SomeTextID)
server_id = <some_id>

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

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:

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:

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.

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

port = 80, 8081
Further reading:

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:

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

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:

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:

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:

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:

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:

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:

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:

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:

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:

This parameter enables accepting RTMP connections from proxy using PROXY v1 protocol .
rtmp_proxy_support_enabled = true
Further reading:

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:

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:

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:

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

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:

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

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:

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:

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:

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:

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:

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:

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

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

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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

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:

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

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:

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

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:

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:

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

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:

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

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:

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:

When using restrictions for number of simultaneous connections or bandwidth, Nimble Streamer returns 403 response code if the limit is reached. A viewer is not allowed to view the stream via HTTP protocol after that. Use this parameter to return other code.
wmsauth_max_connections_bw_deny_error_code = <code>
Example:
wmsauth_max_connections_bw_deny_error_code = 429
Further reading:

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