Skip to main content

Configuration File

In this article, we explain the details of the Speech Engine configuration file phxspe.properties, located in the settings subdirectory within the SPE installation directory.
Settings in this configuration file affect the behavior and performance of the Speech Engine.

The configuration file is typically created after the SPE installation — during the first use of phxadmin, the default configuration file phxspe.properties is generated in the settings directory. The file is loaded during SPE startup, meaning you need to restart SPE to apply any changes made to the file.

(If, for any reason, you don't run phxadmin after SPE installation, you can manually create the default configuration by copying the data/phxspe.properties.template file to settings/phxspe.properties.)

note

Phonexia Browser creates a configuration file named phxspe.browser.properties if it's configured to use the Speech Engine in the so-called "embedded" mode (see details about "embedded SPE" mode in the Browser manual). This configuration file is created to keep the "embedded SPE" mode-specific settings separate from the normal configuration.

Manually changing the phxspe.browser.properties file won't have much effect, as the file will be overwritten by the Browser the next time it runs in "embedded SPE" mode.

Below you can find a detailed description of all SPE configuration settings, together with some usage tips.

Generic settings​

server.bind_ip, server.port​

#IP address and port for server listening
server.bind_ip = 0.0.0.0
server.port = 8600

Here you can set the IP address and port where SPE listens for REST queries. The default address 0.0.0.0 means that SPE listens on all local IPv4 addresses.

On machines with multiple assigned IPv4 addresses, if SPE should be accessible only on one of them, set the specific IP address here. The default port is 8600 and can be changed to any other number suitable for your network.

server.identifier​


# Name of server used as ID for RLS and in database log (if 'server.logging.database.identifier' is not specified)
# server.identifier = spe

Here you can set (optional) server name to be used in RLS (Reporting and Licensing Server) reports to identify the server. If it's not specified, the machine hostname is used. If it's not overridden by server.logging.database.identifier value, it is also used to identify the server in logs written into database (writing logs into database can be configured in server.logging.destination). By default it's commented out, i.e. disabled.

server.umask​

# Set umask value for server (Linux only)
# server.umask = 0022

Allows to set the umask file permissions value (valid only on Linux). This setting is by default commented out, i.e. disabled.

Paths, locations​

server.user.home​

# Home directory path. In this folder are stored all the data of all users.
server.user.home = ${application.dir}home

Path to the home directory where data of all SPE users are stored in individual per-user subdirectories. Default is a home subdirectory of the SPE app directory.

For multi-instance SPE deployments, this can be set to a shared location, so that individual SPE instances can access the common data storage. Note that the disk subsystem performance (or network throughput, in the case of networked storage) can be a limiting factor in a such setup – multiple SPE instances would read and write files from/to this location. This should be taken into account when designing the deployment architecture.

For additional details about the home directory, see Speech Engine Home Directory article.

bsapi.path​

# Set path to bsapi directory
# bsapi.path = ${application.dir}bsapi

Path to a directory where data of individual Phonexia speech technologies are stored in per-technology subdirectories. Defaults to bsapi subdirectory of the SPE app directory.

For multi-instance SPE deployments, this can be set to a shared location to save the disk space occupied by individual SPE instances (depending on the number of deployed technologies and their technological models, this directory can take several gigabytes). Centralized common BSAPI (Brno Speech API, which is the heart of Speech Engine, created by Phonexia) location can also be useful for easier maintenance.

Note that the disk subsystem performance (or network throughput, in case of networked storage) can be a limiting factor in such a setup – multiple SPE instances would read (potentially large amounts of) data from this location during SPE initialization.

note

If you change the bsapi.path, you might also want to change the server.shared.path described below.

server.shared.path​

# The directory contains data shared for all users
# Default value is '${application.dir}shared'
server.shared.path = ${application.dir}shared

The path to a directory intended to hold (customized) technology models shared by all SPE users. It defaults to the shared subdirectory within the SPE app directory and exists only in SPE 3.41 or newer.

For additional details about shared models directory, see SPE directory structure article.

note

If you change the server.shared.path, you might also want to change the bsapi.path described preceding.

technologies.configuration​

# Path to technologies configuration technologies.configuration =
${application.dir}settings/technologies.xml

The location of the technologies configuration XML file. By default, it is the technologies.xml file in the settings subdirectory of the SPE application directory.

The technologies.xml file contains the configuration of SPE technologies — specifying which technologies should be initialized, their technology models, and the number of their instances. This file can be created and maintained using the phxadmin app, or even programmatically, as the XML structure is very simple.

For multi-instance SPE deployments, it can be useful to use a shared configuration file to simplify maintenance.

server.license​

# Sets path to license file
# server.license = ${application.dir}license.dat

The location of the license file. By default, it is the license.dat file in the SPE app directory. For multi-instance SPE deployments, using a shared license file can simplify maintenance.

Logging​

server.logging.level​

# Server logging
# Level (trace, debug, information, warning, error, fatal)
server.logging.level = debug

Controls the logging verbosity. Follows the Apache Commons Logging levels – trace is the most verbose log output, fatal is the least verbose. Default value is debug.

tip

For troubleshooting or first steps with SPE, we recommend using trace being the most verbose log output and fatal the least verbose. The default value is debug.

server.logging.destination​

# Destination (console, file, database) - can be comma separated list
specifying
# multiple simultaneous options, e.g. "console,file"
# Logging to database is supported only for MariaDB
server.logging.destination = file,console

Specifies one or more logging targets where the server logs will be written. The default target is file. Starting with SPE 3.51, the default targets include both file and console, making it easier to monitor processing details in real-time via the console, while also preserving the processing history in the log file.

tip

Logging to the console is particularly useful when combined with the trace logging level. This setup is beneficial during initial setup when learning how SPE operates or when you need to observe SPE's immediate reactions to REST queries.

Logging to a database is advantageous when running multiple SPE instances or on different machines, as it allows for centralized log storage in a database. This structured logging can then be used for further analysis or processing. Note that database logging is supported only with an external MariaDB installation (SPE 3.46 and later) or MySQL (up to SPE 3.45), as the built-in SQLite does not support logging.

server.logging.file​

# Path to file where log is stored server.logging.file =
${application.dir}log/phxspe.log

Path and filename to write the log to, if the server.logging.destination setting contains file value. Default value is ${application.dir}log/phxspe.log, i.e. a phxspe.log file in a log subdirectory of the SPE app directory.

server.logging.file.rotation​

# Log file rotation based on log file size or time intervals
server.logging.file.rotation = daily

Sets the log file rotation strategy. It can be time-based (log file rotated after some period), or size-based (log file rotated after reaching some size). Default value is daily, i.e. log file is rotated every day.

Further settings details are described directly in the configuration file.

server.logging.file.purge_count​

# The value specifies the maximum number of archived log files. If the number
is exceeded,
# archived log files are deleted, starting with the oldest.
server.logging.file.purge_count = 5

Sets the log files housekeeping strategy – how many most recent log files to keep. Default value is 5 days.

server.logging.enable_async​

# Use separate thread for logging. It may increase speed of logging but in case
of server crash or if server is killed,
# some logs may be lost. Default is false.
server.logging.enable_async = false

Sets the log writing strategy – whether logging is done in separate thread, or not. Logging using separate thread may increase performance, but in case of SPE crash or when SPE is forcefully killed for some reason, information not yet written to log may be lost. Default value is false, i.e. log writes are performed synchronously, ensuring that all information is written into log.

server.logging.database.identifier​

# Name of server used in log. If it is not specified 'server.identifier' is
used instead. If 'server.identifier' is not specified hostname is used instead.
# server.logging.database.identifier = spe

Optional server name to identify database log records written by this SPE instance. Valid only if the server.logging.destination setting contains database value. If this value is not set, the server.identifier value is used instead. If server.identifier is not set either, the hostname is used to identify the database log records. By default it's commented out, i.e. not set.

Initialization​

server.require_all_configured_technologies​

# Whether server can be started if initialization of some technology fails.
# Initialization of some technology may fail due to invalid license or insufficient processing capacity left
# If set to true - all configured technologies are required to start SPE, i.e. if initialization of any of configured technologies fails, SPE is terminated
# If set to false - SPE starts even if initialization of some technology instance fails during SPE initialization
server.require_all_configured_technologies = true

This setting controls whether all technologies and instances (configured in technologies.xml) must be successfully started during SPE initialization. Starting from SPE 3.51, default value is true, which ensures that SPE initializes exactly as configured; any failed technology instance initialization causes the entire SPE initialization to fail and server is terminated. Setting it to false (the default up to SPE 3.50) allows SPE to be initialized even in "incomplete configuration", i.e. even if some of the technologies instances fail during startup (e.g. due to insufficient memory, incorrect technology model name, etc.).

server.technology_multithread_initialization​

# Set multi-thread technology initialization
# When enabled server use multiple thread to speed up initialization of technologies
server.technology_multithread_initialization = false

This setting controls whether technologies initialization during SPE startup should run in multiple parallel threads, or not. Default value is false, i.e. the initialization runs in single thread.

See SPE multithreaded technologies initialization article for more details.

server.technology_multithread_initialization.n_threads​

# Number of threads for initialization of technologies
# Use 0 for automatic detection
server.technology_multithread_initialization.n_threads = 0

Sets the number of parallel threads to be used for technologies initialization. It is a complementary setting to server.technology_multithread_initialization. Default value is 0, which means that the number of threads will be set automatically to number of CPU cores.

note

The system needs to read various files of various sizes from the BSAPI location during initialization. Using too many parallel threads may cause the disk - or network subsystem (depending on the bsapi.path location) to become a bottleneck due to its throughput. Therefore it's recommended to do some experiments and measurements with various threads numbers to find the optimal setting.

See also SPE multithreaded technologies initialization article for more details.

Database​

server.db.save_results​

# Store results of technologies in database
server.db.save_results = true

Controls whether processing results are cached in the SPE database. Results caching is enabled by default.

If results caching is enabled, result of processing by each technology is saved to database for each file. Repeated request for processing the same file using the same technology, model, etc. then simply returns the cached result, instead of re-processing the file (this behavior can be overridden using cache_disable=true REST query parameter).

server.db.engine​

# Type of database
# Suported are 'SQLite' and 'MariaDB'
# ! Note that 'MySql' is deprecated since SPE 3.46.x, use 'MariaDB' instead.
server.db.engine = SQLite

Specifies the database used for storing internal data such as file information, speaker models, keyword lists, and optionally for caching processing results (as configured in server.db.save_results). The default database is SQLite. Another supported option is MariaDB (or MySQL for SPE versions up to 3.45). Other databases are not supported.

server.db.sqlite.data_source​

# Set SQLite database file server.db.sqlite.data_source =
${application.dir}phxspe.sqlite

Path and filename of SQLite database file. Defaults to phxspe.sqlite file in the SPE app directory.

In multi-instance SPE deployments, using a shared database file can be beneficial, allowing all SPE instances to access the same internal data, such as file information and speaker models. However, using a shared SQLite database might lead to performance bottlenecks. Therefore, it's recommended to test the specific setup to ensure it meets performance requirements.

server.db.mariadb.host, ​

server.db.mariadb.port​

# Database address
# ! Note that the property name was changed from 'server.db.mysql.host' in SPE 3.46.0
# server.db.mariadb.host = 127.0.0.1

# Database port
# ! Note that the property name was changed from 'server.db.mysql.port' in SPE 3.46.0
# server.db.mariadb.port = 3306

MariaDB (SPE 3.46+) or MySQL (up to SPE 3.45) database server address and port.

server.db.mariadb.db, ​

server.db.mariadb.user,   ​

server.db.mariadb.password​

# Name of database
# ! Note that the property name was changed from 'server.db.mysql.db' in SPE 3.46.0
# server.db.mariadb.db = phxspe

# Database user name
# ! Note that the property name was changed from 'server.db.mysql.user' in SPE 3.46.0
# server.db.mariadb.user = phonexia

# Database password
# ! Note that the property name was changed from 'server.db.mysql.password' in SPE 3.46.0
# server.db.mariadb.password = phonexia

MariaDB (SPE 3.46+) or MySQL (up to SPE 3.45) database name, and username and password for the database.

server.db.mariadb.options, ​

server.db.mariadb.max_connections​

# Database options
# ! Note that the property name was changed from 'server.db.mysql.options' in SPE 3.46.0
# server.db.mariadb.options = compress=true;auto-reconnect=true

# Maximum of MariaDB database connections at the time. Default is 32
# ! Note that the property name was changed from 'server.db.mysql.max_connections' in SPE 3.46.0
# server.db.mariadb.max_connections = 32

MariaDB (SPE 3.46+) or MySQL (up to SPE 3.45) connection options - see https://pocoproject.org/docs/Poco.Data.MySQL.SessionImpl.html for details.  Note: host, port, db, user and password are set separately, see preceding. Maximum number of simultaneous connections to MariaDB / MySQL database to be used by SPE.

Audio Source Profile​

server.audio_source_profiles_cache_size​

# Number of recently used Audio Source Profiles hold in cache, if set to 0,
cache is disabled server.audio_source_profiles_cache_size = 64

See Audio Source Profiles cache for more details.

server.bsapi_comparator_fa_cache_size​

# Number of recently used score shifts for false acceptance calibration hold in cache, if set to 0, cache is disabled. Default is 100 000.
# Hold per pair of Audio Source Profile with enabled false acceptance calibration and compared voiceprint. server.bsapi_comparator_fa_cache_size = 100000

See False Acceptance cache for more details.

Runtime​

server.enable_authentication_token​

# Authentication mode
# Set true for authentication with sessions
# Set false for basic authentication
server.enable_authentication_token = true

Controls which user authentication mode should SPE accept – whether X-SessionID authentication token, or HTTP Basic authentication. Default value true enables the X-SessionID authentication, i.e. the HTTP Basic authentication is not available.

Using the authentication token mode (default) means that you need to call the /login endpoint (using HTTP Basic authentication) to get the X-SessionID token and then use this token in HTTP request header for any subsequent REST queries which require authentication.

Using the HTTP Basic authentication (when this setting is set to false) means that you need to use the HTTP Basic authentication – i.e. send the username and password – for each REST query which requires authentication.

server.enable_resource_locker​

# Resource locker
# If enabled every resources (file, speaker model, keyword list etc.) are exclusively locked for modifications during processing.
# This ensures that resource cannot be modified when it is used for processing
server.enable_resource_locker = true

Controls whether the Resource Locker feature is enabled. By default, this feature is turned on, meaning that resources (such as audio files, speaker models, speaker groups, calibration sets, keyword lists, etc.) used by an asynchronous request are locked by SPE to prevent modifications while they are in use. Attempting to modify a locked resource will result in a "Resource is locked" error. Locked resources remain available for reading and can be used by other requests. The lock is automatically released once the request is completed.

If you disable the Resource Locker, ensure that your application fully manages such conflicts. Failing to do so may result in unpredictable behavior if a resource is modified while it is still in use by an asynchronous request.

server.upload_max_filesize​

# File size Limit for upload and registration
# server.upload_max_filesize = 10MB

Allows to set a file size limit for audio files uploaded to SPE storage, e.g. to prevent oversized files to be uploaded. By default, there is no limit.

server.max_metadata_size​

# Limit for maximum upload file metadata size
# server.max_metadata_size = 1KB

Allows to set a file size limit for metadata files uploaded to SPE storage, e.g. to prevent oversized files to be uploaded. By default, there is no limit.

Metadata files (AKA meta-info, meta-files) can be attached to audio files, speaker models, calibration sets, or audio source profiles. Metadata files can contain custom additional information related to the object they are attached to.

See also the article Speech engine meta-files article for additional info.

server.tcp.queue​

# Set maximum length of TCP connection queue.
# if the queue is full, new requests are rejected
# Default is 64
server.tcp.queue = 64

Sets the size of internal queue for incoming TCP connections. Connections waiting in the queue are picked up by a pool of TCP threads (see server.tcp.threads) and processed. If the TCP queue is full, new connections are rejected. Default value is 64 and normally you should not need to change it.

Changing this value can be useful e.g. if there are some occasional peaks in number of requests to SPE – bigger queue can absorb the peak without rejecting the requests.

server.tcp.threads​

# Set maximum threads for TCP connections.
# The threads fetch TCP connections from TCP queue and process them
# Default is 16
server.tcp.threads = 16

Sets the size of the internal pool of TCP processing threads. These threads handle TCP connections waiting in the queue (see server.tcp.queue) and process them. The default value is 16, and typically, this setting does not need to be changed.

However, adjusting this value can be beneficial in applications that generate a high volume of requests. Increasing the number of processing threads allows SPE to handle these requests more quickly.

server.cors_enable​

# Enable CORS (Cross-origin resource sharing).
# Disabled by default
# server.cors_enable = true

Enables or disables the CORS (Cross-Origin Resource Sharing, see e.g. MDN, W3C or Wikipedia article ) support in SPE. By default is CORS support disabled.

Enabling CORS can be useful when interacting with SPE directly from simple web applications that are based purely on client-side code, without any server middleware. For example, in a web application running from a local HTML file, requests are sent from the local file, but responses come from SPE. Without CORS, a web browser will block these interactions.

Tasks​

server.n_workers, server.n_realtime_workers​

# Multithread settings
# Default value -1 means check for technologies configuration and hardware resources and set workers accordingly:
# server.n_workers: either number of configured offline technologies, or number of physical CPU cores, whichever is lower
# server.n_realtime_workers: number of configured stream technologies
server.n_workers = -1 server.n_realtime_workers = -1

Sets the number of task workers for processing audio files (server.n_workers) and real-time streams (server.n_realtime_workers). Starting from SPE 3.51, the default value for both is -1, which allows SPE to automatically determine the optimal number of workers for best performance based on local conditions:

  • The number of file processing workers is set to the lower of either the total number of configured file-processing technologies or the number of physical CPU cores.
  • The number of real-time workers is set to match the total number of configured stream-processing technologies.
caution

This is a crucial setting that can significantly impact SPE performance. It is strongly advised to review the details in the How to configure SPE workers article. Additional information about SPE workers can be found in the Speech Engine and technologies, instances, workers article.

server.n_task_limit​

# Sets limit for number of pending operations.
server.n_task_limit = 1000

Sets the maximum number of "pending" tasks (see the asynchronous requests statuses in REST API documentation).

This value essentially sets the size of the processing queue and, as a result, indirectly determines how quickly the server can react to changes. For example, if the server is busy processing 1,000 tasks and you need to quickly process additional files, you would either have to cancel the 1,000 pending tasks or use the task priorities feature. If the queue were smaller, it would be processed in a reasonable time, making it unnecessary to cancel pending tasks or use priorities, as the new processing requests would be handled quickly enough.

Additional info about SPE processing queue is available in the Speech engine - processing queue article.

server.task_priorities_enable​

# If enabled, server will respects priority of a task configured by HTTP
header.
# Only users with role 'prioritize' can create task with non-default priority.
# Default is true
server.task_priorities_enable = true

Controls whether SPE will support setting task priorities using the X-Priority request HTTP header. By default, task priorities are enabled.

Task priorities can be beneficial in mass-processing applications. For instance, if there is a long queue of files waiting to be processed and another set of files needs to be processed urgently, those files can be submitted with a higher priority. This will inject them to the front of the queue, ensuring they are processed as soon as possible. For more information about task priorities, refer to the Task prioritization section of the REST API documentation and the Audio processing priority article.

server.task_default_priority​

# Task default priority. Priority must be number from 0 to 99. This priority
will be set
# to each task if request doesn't contains any priority or if user doesn't have permission to set it.
# 0 is the highest and 99 is the lowest priority. Default value is 50
server.task_default_priority = 50

Sets the default task priority value. If task priorities are enabled, and task priority is not explicitly specified when creating the task, this priority value will be used. Default value is 50.

server.finished_task_timeout​

# Timeout auto remove finished task
server.finished_task_timeout = 60

Sets the timeout, in seconds, after which finished tasks are automatically removed. The default is 60 seconds.

This setting is relevant when using polling to retrieve the results of asynchronous tasks. For more details, refer to the Asynchronous request - Polling section of the REST API documentation. When polling for the result of an asynchronous task using either GET /pending/{id} or GET /done/{id}, the result is available for retrieval only for a limited time (60 seconds by default). After this period, the result expires, and the GET request returns an HTTP status 404. If this occurs, the only way to retrieve the result is to request re-processing of the file. If results caching is enabled, the result will be returned from the cache, meaning the file does not need to be physically re-processed.

For additional information, see the Speech engine - processing queue article.

Streams​

stream.http.enable​

#Enable HTTP stream subsystem
stream.http.enable = true

Controls whether HTTP streams support is enabled or disabled. By default, HTTP stream support is enabled.

input_stream.http.timeout​

# Set timeout for input HTTP stream in seconds.
# If the input stream doesn't recieve any data for given time, then input stream is closed.
# ! Note that 'stream.http.timeout' is deprecated since SPE 3.23.x
input_stream.http.timeout = 30

Sets the timeout limit for HTTP stream incoming data – when no audio data come from the stream for the defined time, the stream is automatically closed. Default value is 30 seconds.

stream.websocket.enable​

# Enable WebSocket stream subsystem
stream.websocket.enable = true

Controls whether WebSockets streams support is enabled or disabled. WebSockets streams are supported in SPE 3.45 or newer. By default, WebSockets stream support is enabled.

input_stream.websocket.max_payload_size​

# Maximum payload size of a single WebSocket's frame in bytes.
# If bigger frame is received the connection is closed with WebSocket status code 1009
# Default is 4MB
input_stream.websocket.max_payload_size = 4MB

Sets the payload size limit for Web-sockets stream incoming data – when a WebSockets frame is bigger than the defined size, the connection is closed with corresponding error. Default value is 4 megabytes.

stream.rtp.enable​

# Enable RTP stream subsystem
stream.rtp.enable = true

Controls whether RTP streams support is enabled or disabled. By default, RTP stream support is enabled.

stream.rtp.bind_ip​

# IP address for creating input RTP sessions
# ! Note that 'stream.rtp.bind_ip' is deprecated since SPE 3.23.x
input_stream.rtp.bind_ip = 0.0.0.0

Sets the IP address on which the incoming RTP listeners should listen. Default value is 0.0.0.0, i.e. all local IPv4 addresses. On machines with multiple IPv4 addresses assigned, if RTP listeners should listen only on one of them, set the IP address here.

stream.rtp.min_port, ​

stream.rtp.max_port​

# Sets starting port for creating input RTP sessions
# ! Note that 'stream.rtp.min_port' is deprecated since SPE 3.23.x
# ! Note that 'stream.rtp.max_port' is deprecated since SPE 3.23.x
input_stream.rtp.min_port = 10000
input_stream.rtp.max_port = 11000

Sets the port number range for creating incoming RTP listeners. Default is from 10000 to 11000.

input_stream.rtp.stream_limit​

# Number of max opened input RTP sessions in one moment. Use -1 for automatic
detection according to
# input_stream.rtp.min_port and input_stream.rtp.max_port (half of the range, according to RFC 3550
# port numbers requirement).
# ! Note that 'stream.rtp.stream_limit' is deprecated since SPE 3.23.x
input_stream.rtp.stream_limit = -1

Sets the maximum number of simultaneous RTP sessions. Starting from SPE 3.51, default value is -1, which sets the RTP sessions limit based on defined RTP port range (according to RFC 3550, RTP should use even port numbers, i.e. the default range 10000 - 11000 means up to 500 parallel RTP streams).

This value should play well together with server.n_realtime_workers value and also with number of initialized instances of stream technologies.

Additional info can be found in How to configure SPE workers article and also in Speech Engine and technologies, instances, workers… explained article.

input_stream.rtp.timeout​

# Set timeout for input RTP socket in seconds.
# If the input RTP socket don't receive any data for a given time, then the input RTP socket is closed.
# ! Note that 'stream.rtp.timeout' is deprecated since SPE 3.23.x
input_stream.rtp.timeout = 10.0

Sets the timeout limit for RTP stream incoming data – when no audio data come from the stream for the defined time, the stream is automatically closed. Default value is 10 seconds.

output_stream.rtp.timeout​

# Set timeout for output stream RTP socket in seconds.
# If output stream doesn't send any data for more than given time it is closed.
# Prevents stuck streams in case client forgets to close stream.
# (this may occur when client dies or loses output stream ID in some other way)
output_stream.rtp.timeout = 60.0

Sets the timeout limit for RTP stream outgoing data – when no audio data is sent to the stream for the defined time, the stream is automatically closed. Default value is 60 seconds.

Output RTP streams are used e.g. for text-to-speech output, or for audio files playback.

Audio formats​

server.audio_formats.opus.enabled​

# Enable or disable native support for OPUS audio format (Default: true)
# When disbled, audio file will be converted to WAV
server.audio_formats.opus.enabled = true

Controls whether the OPUS audio format support is enabled or disabled. By default it's enabled.

server.audio_formats.flac.enabled​

# Enable or disable native support for FLAC audio format (Default: true)
server.audio_formats.flac.enabled = true

Controls whether the FLAC audio format support is enabled or disabled. By default it's enabled.

audio_converter.enabled​

# Enable or disable audio converter. If set to 'auto' the converter is enabled
# when converter is available in the system (in case of using ffmpeg or sox,
# for other tools the behaviour is same as 'true').
# Possible values: true, false, auto. Default is auto.
audio_converter.enabled = auto

Controls support for automatic audio format conversion via external 3rd party converter, defined in audio_converter.command (see below). By default, audio converter is disabled. Starting from SPE 3.63.0, default value is auto. Automatic detection checks during SPE initialization if the converter can be launched and if yes, then automatically enables it. If the converter is not detected, it's disabled. This automatic detection works only for the two converters supported out-of-the-box, ffmpeg (default) and sox. For other user-defined converters, the "auto" value means the same as "true" (enabled).

Audio converter allows transparent processing of audio formats not natively supported by SPE. When audio converter is enabled and correctly configured, audio files in formats not natively supported by SPE are internally automatically converted to WAV PCM 16-bit, 8 kHz. See audio_converter.command for more details.

audio_converter.command​

# Set converter command
# %1 is for input file
# %2 is for output file
# ffmpeg example:
# audio_converter.command = ffmpeg -loglevel warning -y -i %1 %2
# sox example:
# audio_converter.command = sox %1 %2
audio_converter.command = ffmpeg -loglevel warning -y -i %1 %2

Specifies the command to be used when audio_converter.enabled is set to true. We provide simple examples for ffmpeg (default) and sox, but any other command-line conversion utility that allows specifying input and output file names using the %1 and %2 placeholders, respectively, can also be used.

Please note that due to licensing restrictions, we do not distribute ffmpeg, sox, or any other converters with SPE. These tools need to be downloaded and installed separately.

tip

On Windows, simply put the ffmpeg.exe or sox.exe file to SPE installation directory.

Reporting​

reporting.urls​

# Reporting server addresses
# Comma separated list of URLs
# reporting.urls = server1.com:8777, 192.168.0.10:8777

Allows you to set the address(es) and port(s) of the RLS (Reporting and Licensing Server) that SPE should connect to for two purposes: a) obtaining information about allowed processing capacities, and b) reporting consumed processing capacities. By default, this feature is not enabled, as the connection to RLS must be specifically activated by a flag in the SPE license.

You can specify multiple RLS addresses. If SPE cannot contact the primary RLS (due to connection issues, the RLS being down, etc.), it will attempt to connect to the other specified RLS addresses.

reporting.ssl.enabled​

# Enable/disable SSL connection for sending reports to reporting server
reporting.ssl.enabled = false

Controls whether SSL should be used for connection between SPE and RLS, or not. By default, SSL is disabled.

reporting.ssl.ca_file​

# Set path to Root CA certificate
# reporting.ssl.ca_file = ./root_ca.crt

Specifies the path to the root certificate authority certificate file for SSL support. By default, this option is commented out, as SSL support is disabled by default.

reporting.ssl.certificate_file​

# Path to certificate file
# reporting.ssl.certificate_file = ./spe_certificate.crt

Sets path to certificate file, for SSL support. By default, it's commented out, as SSL support is disabled by default.

reporting.ssl.private_key_file​

# Path to private key file
# reporting.ssl.private_key_file = ./spe_private.key

Sets path to private key file, for SSL support. By default, it's commented out, as SSL support is disabled by default.

reporting.ssl.private_key_password​

# Private key password. Leave empty or commented out, when password is not used
# reporting.ssl.private_key_password =

Sets password for private key, if used. If private key is not password-protected, leave this settings blank or commented out. By default it's commented out, as SSL support is disabled by default.

reporting.ssl.cipher_list​

# Set SSL cipher list (default: ALL:!COMPLEMENTOFDEFAULT:!eNULL)
# For more details, see https://www.openssl.org/docs/man1.1.0/apps/ciphers.html
# reporting.ssl.cipher_list = ALL:!COMPLEMENTOFDEFAULT:!eNULL
# Set SSL cipher list (default: ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH)
# For more details, see https://www.openssl.org/docs/man1.0.2/apps/ciphers.html
# reporting.ssl.cipher_list = ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH

Sets list of ciphers to use when SSL is enabled for reporting. The list should use OpenSSL cipher-list format, see (SPE < 3.38) or see (SPE >= 3.40) for more information. By default, this option is commented out, SSL support is disabled.

External​

external.technologies.tts_connectors​

# Enable external TTS (Text To Speech) connectors.
# A comma separated list of connector's folder names.
# Connectors can be found in 'external/technologies/tts' folder.
# Each connector needs configuration file 'connector.properties' in its folder.
# Please create configuration according to 'connector.properties.template' file before you enable it.
# external.technologies.tts_connectors = acapela

Specifies the external TTS (Text To Speech) connectors to be initialized during SPE startup. The connectors should be listed as directory names located in the external/technologies/tts directory, separated by commas.

Phonexia provides a TTS connector (currently available for Linux only) for the Acapela TTS Server. Note: You must have your own Acapela TTS Server installation and license to use the Acapela TTS connector.