{"id":13103,"date":"2026-11-10T05:45:32","date_gmt":"2026-11-10T05:45:32","guid":{"rendered":"https:\/\/developer.rdkcentral.com\/documentation\/?page_id=13103"},"modified":"2026-11-10T05:45:35","modified_gmt":"2026-11-10T05:45:35","slug":"rialto","status":"publish","type":"page","link":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/","title":{"rendered":"Rialto"},"content":{"rendered":"\n<p>Rialto provides a solution for implementing AV (audio and video) pipelines of containerised native applications and browsers while keeping hardware-specific handles and system resources within the trusted server process. It acts as an out-of-process media pipeline service: applications running inside containers communicate with a trusted server process that has direct access to the underlying media hardware, GStreamer infrastructure, and DRM subsystems.<\/p>\n\n\n\n<p>At the product level, Rialto enables containerised browser runtimes and native applications to perform encrypted and unencrypted AV playback and web audio mixing, with full Media Source Extensions (MSE) support, while keeping hardware access and platform resource management within the trusted server process. At the module level, Rialto is structured as a client library (<code>RialtoClient<\/code>), a session server binary (<code>RialtoServer<\/code>), and a server manager library (<code>RialtoServerManager<\/code>). The production client\/server and server-manager\/session-server channels use protobuf-based IPC over Unix domain sockets; <code>RialtoServerManagerSim<\/code> is a separate HTTP-based test executable.<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">flowchart LR\n\n%% Styles\nclassDef Apps stroke:#00B9F1,fill:#E6F7FD,stroke-width:2px\nclassDef RDKMW stroke:#75D701,fill:#F1FFE6,stroke-width:2px\nclassDef VL stroke:#808080,fill:#F2F2F2,stroke-width:2px\n\n%% Apps Layer\n    subgraph Apps[\"Apps &amp; Runtimes\"]\n        FBApps[\"Firebolt Apps\"]\n        WPE_RT[\"WPE Runtime\"]\n    end\n\n%% Middleware\n    subgraph RDKMW[\"RDK Core Middleware\"]\n        AM[\"App Manager\"]\n        subgraph RialtoBlock[\"Rialto\"]\n            RC[\"RialtoClient\\n(in-container library)\"]\n            RSM[\"RialtoServerManager\"]\n            RS[\"RialtoServer\\n(out-of-container)\"]\n        end\n        Thunder[\"WPEFramework (Thunder)\"]\n        Westeros[\"Westeros\"]\n    end\n\n%% Vendor Layer\n    subgraph VL[\"Vendor Layer\"]\n        GST[\"GStreamer Pipeline\"]\n        DRM[\"OpenCDM \/ DRM Libraries\"]\n        HAL[\"Platform Media HAL\"]\n    end\n\n    Apps -->|Rialto Client API| RC\n    RC -->|Protobuf RPC over Unix socket| RS\n    RSM -->|spawns &amp; manages| RS\n    AM -->|IServerManagerService API| RSM\n    RS --> GST\n    RS --> DRM\n    GST --> HAL\n\n    class Apps Apps\n    class RDKMW RDKMW\n    class VL VL<\/pre><\/div>\n\n\n\n<p><strong>Key Features &amp; Responsibilities:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>AV Pipeline Management<\/strong>: Exposes <code>IMediaPipeline<\/code> for creating, loading, and controlling AV playback sessions with support for separate audio and video source attachment, MSE data feeding via shared memory, playback rate control, seeking, and quality-of-service reporting.<\/li>\n\n\n\n<li><strong>EME \/ DRM Key Management<\/strong>: Exposes <code>IMediaKeys<\/code> for managing Encrypted Media Extension (EME) key sessions, including key generation, licence updates, session persistence, DRM store management, and cipher mode configuration (CENC, CBC1, CENS, CBCS).<\/li>\n\n\n\n<li><strong>Web Audio Playback<\/strong>: Exposes <code>IWebAudioPlayer<\/code> for mixing PCM audio streams into the current audio output, with priority-based resource allocation for platforms with a limited number of concurrent audio mixers.<\/li>\n\n\n\n<li><strong>Shared Memory Data Channel<\/strong>: Provides a shared memory buffer whose file descriptor is passed from server to client via the <code>GetSharedMemory<\/code> control RPC, allowing media segment data to be transferred without redundant data copies across process boundaries.<\/li>\n\n\n\n<li><strong>Container Lifecycle Management<\/strong>: <code>RialtoServerManager<\/code> spawns and manages one <code>RialtoServer<\/code> process per application, applies resource limits (maximum simultaneous playback sessions and web audio players), manages session server states (UNINITIALIZED, INACTIVE, ACTIVE, NOT_RUNNING, SUSPENDED, ERROR), and performs periodic health checks via a ping\/ack protocol.<\/li>\n\n\n\n<li><strong>Capability Discovery<\/strong>: Exposes <code>IMediaCapabilities<\/code> \u2014 a unified capabilities interface (<code>mediacapabilitiesmodule.proto<\/code>) that reports audio and video decoder capabilities (<code>getSupportedAudioCapabilities()<\/code> \/ <code>getSupportedVideoCapabilities()<\/code>) \u2014 alongside the older <code>IMediaPipelineCapabilities<\/code> and <code>IMediaKeysCapabilities<\/code> interfaces for querying supported MIME types and DRM key systems at runtime. <code>IMediaCapabilities<\/code> supersedes the capability methods of <code>IMediaPipelineCapabilities<\/code>.<\/li>\n\n\n\n<li><strong>Subtitle and Text Track Support<\/strong>: When the platform provides a text track plugin, Rialto attaches a dedicated GStreamer text track sink and manages subtitle rendering through a <code>TextTrackAccessor<\/code>.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Design<\/h2>\n\n\n\n<p>Rialto is designed around strict process isolation. The <code>RialtoClient<\/code> library runs inside the containerised application and translates media control operations into protobuf RPC calls sent over a Unix domain socket; encoded media segments use the shared-memory data path described below. The <code>RialtoServer<\/code> process runs outside any container, holds access to GStreamer and DRM resources, and executes those operations on behalf of the client. This split ensures that hardware handles, DRM contexts, and GStreamer pipelines remain contained within the trusted server process.<\/p>\n\n\n\n<p>The IPC layer is purpose-built to meet Rialto&#8217;s specific requirements: per-connection client identity (pid\/uid), in-band file descriptor passing for sharing memory buffer descriptors, and first-class asynchronous event delivery from server to client. The protobuf service definitions in <code>proto\/<\/code> describe all RPC methods and events for the media pipeline, DRM, web audio, control, and server manager channels.<\/p>\n\n\n\n<p>Shared memory is used for the media data path. The server creates one per-application <code>SharedMemoryBuffer<\/code> when <code>PlaybackService<\/code> switches to ACTIVE, and passes its fd to the client via a <code>GetSharedMemory<\/code> RPC call. The client library maps this buffer and writes encoded media segments through its frame writer; the server reads from the same buffer to feed GStreamer. This design avoids copying the media payload through the socket.<\/p>\n\n\n\n<p>On the server side, GStreamer integration is managed by <code>GstGenericPlayer<\/code>, which wraps GStreamer pipeline construction and element management. The player is driven by a task queue so GStreamer element state changes and data operations run on a single dedicated worker thread. A separate <code>GstDispatcherThread<\/code> attaches a GLib bus watch (<code>gstBusCreateWatch<\/code>) to a private <code>GMainContext<\/code> and runs a <code>GMainLoop<\/code> on its own thread, translating bus messages (state changes, errors, end-of-stream) into server-side events. DRM operations are handled through the OpenCDM wrapper (<code>OcdmSystem<\/code>\/<code>OcdmSession<\/code>).<\/p>\n\n\n\n<p>The <code>RialtoServerManager<\/code> reads its configuration from a JSON file (<code>rialto-config.json<\/code>) at startup and uses it to set environment variables, paths, timeouts, and socket parameters for each spawned <code>RialtoServer<\/code>. It supports pre-loading a configurable number of server processes to reduce application startup latency.<\/p>\n\n\n\n<p>Northbound interaction is through the public C++ factory and interface APIs in <code>media\/public\/include\/<\/code> and <code>serverManager\/public\/include\/<\/code>. Southbound interaction on the server side is through GStreamer, OpenCDM, and optional RDK GStreamer utilities, all abstracted by thin wrapper classes under <code>wrappers\/<\/code>.<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">graph TD\n\n    subgraph Container[\"Application Container\"]\n        AppCode[\"Application \/ Browser\"]\n        subgraph RialtoClientLib[\"RialtoClient Library\"]\n            ClientMP[\"MediaPipeline Client\"]\n            ClientMK[\"MediaKeys Client\"]\n            ClientWA[\"WebAudioPlayer Client\"]\n            ClientCtrl[\"Control Client\"]\n            ClientIPC[\"IPC Client Channel\\n(protobuf over Unix socket)\"]\n        end\n        AppCode -->|IMediaPipeline| ClientMP\n        AppCode -->|IMediaKeys| ClientMK\n        AppCode -->|IWebAudioPlayer| ClientWA\n        AppCode -->|IControl| ClientCtrl\n        ClientMP --> ClientIPC\n        ClientMK --> ClientIPC\n        ClientWA --> ClientIPC\n        ClientCtrl --> ClientIPC\n    end\n\n    subgraph RSMBlock[\"Application Manager Process\\n(RialtoServerManager library)\"]\n        RSMService[\"ServerManagerService\\n(IServerManagerService)\"]\n        RSMConfig[\"ConfigHelper\\n(rialto-config.json)\"]\n        RSMSpawner[\"Session Server App Manager\\n(spawn \/ monitor \/ health-check)\"]\n        RSMService --> RSMConfig\n        RSMService --> RSMSpawner\n    end\n\n    subgraph RSBlock[\"RialtoServer Process (one per app)\"]\n        IPCServer[\"IPC Server Channel\\n(protobuf over Unix socket)\"]\n        SessionMgr[\"SessionServerManager\\n(ISessionServerManager)\"]\n        PlaybackSvc[\"PlaybackService\\n(session lifecycle, shm)\"]\n        subgraph GstPlayerBlock[\"GstGenericPlayer\"]\n            WorkerTh[\"WorkerThread\\n(GStreamer task queue)\"]\n            GstDisp[\"GstDispatcherThread\\n(bus event handling)\"]\n            GstPipeline[\"GStreamer Pipeline\"]\n        end\n        MediaKeys[\"MediaKeysServerInternal\\n(DRM \/ OpenCDM)\"]\n        ShmBuffer[\"SharedMemoryBuffer\\n(anon fd, mmap)\"]\n        IPCServer --> SessionMgr\n        SessionMgr --> PlaybackSvc\n        PlaybackSvc --> WorkerTh\n        PlaybackSvc --> ShmBuffer\n        PlaybackSvc --> MediaKeys\n        WorkerTh --> GstPipeline\n        GstDisp --> GstPipeline\n    end\n\n    ClientIPC -->|Unix domain socket| IPCServer\n    RSMSpawner -->|spawns| RSBlock<\/pre><\/div>\n\n\n\n<h4 class=\"wp-block-heading\">Threading Model<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Threading Architecture<\/strong>: Multi-threaded, with distinct threads for the server&#8217;s main task dispatch, GStreamer operations, and GStreamer bus event handling.<\/li>\n\n\n\n<li><strong>Main Thread (<code>MainThread<\/code>)<\/strong>: A shared event-loop thread on the server side that serialises all non-GStreamer server operations. It accepts tasks from any registered client via <code>enqueueTask()<\/code> or <code>enqueueTaskAndWait()<\/code> and processes them sequentially from a <code>std::deque<\/code>. This thread owns the <code>MediaPipelineServerInternal<\/code>, <code>MediaKeysServerInternal<\/code>, and <code>WebAudioPlayerServerInternal<\/code> objects and ensures they are accessed from a single thread.<\/li>\n\n\n\n<li><strong>Worker Threads<\/strong>:<\/li>\n\n\n\n<li><em><code>WorkerThread<\/code><\/em>: One per <code>GstGenericPlayer<\/code> instance; processes GStreamer player tasks (attach source, push buffer, seek, set rate, flush, etc.) from a <code>std::queue<\/code>. All GStreamer element state changes and data operations are posted to this thread.<\/li>\n\n\n\n<li><em><code>GstDispatcherThread<\/code><\/em>: One per GStreamer pipeline; attaches a GLib bus watch (<code>gstBusCreateWatch<\/code>) to a private <code>GMainContext<\/code> and runs a <code>GMainLoop<\/code>, delivering bus messages (EOS, errors, state changes, QoS events) to the <code>GstGenericPlayer<\/code> client callbacks.<\/li>\n\n\n\n<li><strong>Synchronization<\/strong>: <code>MainThread<\/code> uses a <code>std::mutex<\/code> and <code>std::condition_variable<\/code> to protect the task queue. <code>WorkerThread<\/code> uses the same pattern. <code>GstDispatcherThread<\/code> runs a <code>GMainLoop<\/code> on a private <code>GMainContext<\/code>; an atomic <code>m_isGstreamerDispatcherActive<\/code> flag gates shutdown coordination.<\/li>\n\n\n\n<li><strong>Async \/ Event Dispatch<\/strong>: Client notifications (playback state changes, need-data requests, QoS events) are produced on the worker and dispatcher threads and forwarded over the IPC server channel as protobuf event messages, delivering them asynchronously to the client-side event loop.<\/li>\n<\/ul>\n\n\n\n<h3 class=\"wp-block-heading\">Prerequisites and Dependencies<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">Platform and Integration Requirements<\/h4>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Build Dependencies<\/strong>: <code>protobuf<\/code>, <code>protobuf-native<\/code>, <code>openssl<\/code>, <code>jsoncpp<\/code>, <code>gstreamer1.0<\/code>, <code>gstreamer1.0-plugins-base<\/code>, <code>glib-2.0<\/code>, <code>rdk-gstreamer-utils<\/code>, <code>virtual\/vendor-rdk-gstreamer-utils-platform<\/code>. The <code>servermanager<\/code> package additionally depends on <code>mongoose<\/code>.<\/li>\n\n\n\n<li><strong>HAL<\/strong>: Rialto accesses the platform media pipeline directly through GStreamer elements and the RDK GStreamer utilities wrapper (<code>IRdkGstreamerUtilsWrapper<\/code>). DRM access is through the OpenCDM (<code>open_cdm.h<\/code>) interface.<\/li>\n\n\n\n<li><strong>Process Launching<\/strong>: <code>RialtoServer<\/code> is spawned as a child process by <code>RialtoServerManager<\/code>. The manager library is expected to be hosted by an application manager or framework integration layer.<\/li>\n\n\n\n<li><strong>Configuration Files<\/strong>: <code>rialto-config.json<\/code> (installed from <code>rialto-config.in.json<\/code>). The file specifies environment variables for <code>RialtoServer<\/code>, the server binary path, startup timeout, health-check interval, socket permissions, and number of pre-loaded server processes. On debug builds, an override file at the configured <code>overrides<\/code> path is also read.<\/li>\n\n\n\n<li><strong>Startup Order<\/strong>: <code>RialtoServerManager<\/code> must be running before any application requests <code>initiateApplication()<\/code>. The server manager spawns <code>RialtoServer<\/code> instances on demand; when <code>numOfPreloadedServers<\/code> is configured to a non-zero value, server processes are pre-launched at startup to reduce application connect latency.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h3 class=\"wp-block-heading\">Component State Flow<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">Initialization to Active State<\/h4>\n\n\n\n<p>The lifecycle begins when an application manager or framework calls <code>rialto::servermanager::service::create(stateObserver[, config])<\/code> to obtain an <code>IServerManagerService<\/code> instance. The server manager reads its configuration, then waits for <code>initiateApplication()<\/code> calls. On each call it selects a pre-loaded server when available or spawns a <code>RialtoServer<\/code> process, sends it a <code>SetConfigurationRequest<\/code> over the server-management socket (carrying resource limits, initial state, socket names, and log levels), and monitors its response. The <code>RialtoServer<\/code> receives the configuration, sets up its IPC server socket for clients, initialises the services and shared-memory buffer when entering ACTIVE, and emits a <code>StateChangedEvent<\/code>. The server manager forwards the state change to any registered <code>IStateObserver<\/code> and records the socket name returned by <code>getAppConnectionInfo()<\/code> for the client to connect to.<\/p>\n\n\n\n<p>The component transitions through the following states during its lifecycle: <strong>Initializing<\/strong> (read config, allocate resources) \u2192 <strong>Spawning<\/strong> (fork RialtoServer process, send SetConfiguration) \u2192 <strong>Active<\/strong> (client-facing socket ready, accepting IPC connections) \u2192 <strong>Shutdown<\/strong> (deactivate sessions, unmap shared memory, terminate RialtoServer).<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant AppMgr as Application Manager\n    participant RSM as RialtoServerManager\n    participant RS as RialtoServer\n    participant Client as RialtoClient (in container)\n\n    AppMgr->>RSM: create(stateObserver)\n    RSM->>RSM: Read rialto-config.json\n    AppMgr->>RSM: initiateApplication(appId, ACTIVE, appConfig)\n    RSM->>RS: select preloaded server or spawn RialtoServer process\n    RS-->>RSM: StateChangedEvent(UNINITIALIZED)\n    RSM->>RS: SetConfigurationRequest (socket, resources, logLevels)\n    RS->>RS: Bind client IPC socket + initialise services\n    RS-->>RSM: StateChangedEvent(ACTIVE)\n    RS-->>RSM: SetConfigurationResponse\n    RSM-->>AppMgr: stateChanged(appId, ACTIVE) via IStateObserver\n    Client->>RS: Connect to client socket (RegisterClient RPC)\n    RS-->>Client: RegisterClientResponse (control_handle, schema_version)\n    Client->>RS: GetSharedMemory RPC\n    RS-->>Client: GetSharedMemoryResponse (fd, size)\n    Client->>Client: mmap shared memory buffer<\/pre><\/div>\n\n\n\n<h4 class=\"wp-block-heading\">Runtime State Changes<\/h4>\n\n\n\n<p>During normal operation, the server manager sends periodic <code>PingRequest<\/code> messages to each <code>RialtoServer<\/code>. The server aggregates acknowledgements from its internal session objects and responds with an <code>AckEvent<\/code>. If the configured number of consecutive failed health checks (including timeouts and unsuccessful acknowledgements, <code>numOfPingsBeforeRecovery<\/code>) is reached, the server manager triggers recovery for that server instance.<\/p>\n\n\n\n<p><strong>State Change Triggers:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Application manager calls <code>changeSessionServerState(appId, INACTIVE)<\/code> to suspend an active session; the server manager sends a <code>SetState<\/code> RPC to the corresponding <code>RialtoServer<\/code>, which transitions its services to inactive, releasing active decoder resources.<\/li>\n\n\n\n<li>Application manager calls <code>changeSessionServerState(appId, NOT_RUNNING)<\/code> to terminate a session; the server manager signals the <code>RialtoServer<\/code> to shut down cleanly.<\/li>\n\n\n\n<li>A <code>StateChangedEvent(ERROR)<\/code> from <code>RialtoServer<\/code> indicates a server-side failure; the server manager notifies the registered <code>IStateObserver<\/code> and may recover or restart the server process.<\/li>\n<\/ul>\n\n\n\n<p><strong>Context Switching Scenarios:<\/strong><\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>Transitioning from ACTIVE to INACTIVE suspends media pipeline processing and releases GStreamer decoder resources, while keeping the IPC socket available but destroying the shared-memory buffer; clients must reacquire it after returning to ACTIVE.<\/li>\n\n\n\n<li>Receiving an updated <code>setLogLevels()<\/code> call propagates new <code>LoggingLevels<\/code> values (named per-component <code>LoggingLevel<\/code> enum entries, converted to logger bitmasks internally) to all running <code>RialtoServer<\/code> instances at runtime via the server manager IPC channel.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h3 class=\"wp-block-heading\">Call Flows<\/h3>\n\n\n\n<h4 class=\"wp-block-heading\">Initialization Call Flow<\/h4>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant AppMgr as Application Manager\n    participant RSM as RialtoServerManager\n    participant Config as rialto-config.json\n    participant RS as RialtoServer\n\n    AppMgr->>RSM: create(stateObserver, config)\n    RSM->>Config: Read configuration file\n    Config-->>RSM: sessionServerPath, timeouts, socketPermissions, etc.\n    AppMgr->>RSM: initiateApplication(appId, ACTIVE, appConfig)\n    RSM->>RS: Select preloaded server or fork\/exec RialtoServer\n    RS-->>RSM: StateChangedEvent(UNINITIALIZED)\n    RSM->>RS: SetConfigurationRequest over mgmt socket\n    RS->>RS: Bind client IPC socket\n    RS->>RS: Initialise services + SharedMemoryBuffer (anon fd) on switch to ACTIVE\n    RS-->>RSM: StateChangedEvent(ACTIVE)\n    RS-->>RSM: SetConfigurationResponse\n    RSM-->>AppMgr: IStateObserver::stateChanged(appId, ACTIVE)<\/pre><\/div>\n\n\n\n<h4 class=\"wp-block-heading\">Request Processing Call Flow<\/h4>\n\n\n\n<p>The following shows the data path for an MSE playback session from client API call to GStreamer data injection.<\/p>\n\n\n\n<p>The application supplies encoded media segments to <code>addSegment()<\/code>; RialtoClient&#8217;s internal frame writer copies them into the mapped shared-memory partition using the request metadata retained internally. The client then calls <code>haveData()<\/code> to notify the server, which reads the frames and pushes them into GStreamer without sending the media payload over the socket.<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant App as Application\n    participant RC as RialtoClient\n    participant RS as RialtoServer\n    participant SHM as Shared Memory\n    participant GST as GStreamer Pipeline\n\n    App->>RC: IMediaPipeline::load(MSE, mimeType, url)\n    RC->>RS: LoadRequest (session_id, type, mime_type, url)\n    RS-->>RC: LoadResponse\n    App->>RC: IMediaPipeline::attachSource(MediaSourceAudio)\n    RC->>RS: AttachSourceRequest (session_id, config)\n    RS-->>RC: AttachSourceResponse (source_id)\n    RS->>RC: NeedMediaDataEvent (source_id, request_id, frameCount, shmInfo)\n    RC->>App: IMediaPipelineClient::notifyNeedMediaData(source_id, frameCount, requestId, nullptr)\n    App->>RC: IMediaPipeline::addSegment(needDataRequestId, segment)\n    RC->>SHM: Write encoded media segment via frame writer\n    App->>RC: IMediaPipeline::haveData(status, needDataRequestId)\n    RC->>RS: HaveDataRequest (session_id, status, num_frames, requestId)\n    RS->>SHM: Read media data from shared memory\n    RS->>GST: Push buffer into GStreamer src element (WorkerThread)\n    RS->>RC: NeedMediaDataEvent (next request)<\/pre><\/div>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Internal Modules<\/h2>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Module \/ Class<\/th><th>Description<\/th><th>Key Files<\/th><\/tr><\/thead><tbody><tr><td><code>RialtoClient<\/code><\/td><td>Client-side library providing factory implementations for all public interfaces. Translates API calls into protobuf IPC requests and receives asynchronous event notifications from the server.<\/td><td><code>media\/client\/main\/<\/code>, <code>media\/client\/ipc\/<\/code><\/td><\/tr><tr><td><code>RialtoServer<\/code><\/td><td>Server-side binary hosting the media pipeline, DRM, and web audio services. Accepts IPC connections from <code>RialtoClient<\/code> instances, dispatches operations to GStreamer and OpenCDM, and manages the shared memory buffer.<\/td><td><code>media\/server\/main\/<\/code>, <code>media\/server\/service\/<\/code><\/td><\/tr><tr><td><code>GstGenericPlayer<\/code><\/td><td>GStreamer pipeline manager. Constructs and controls a GStreamer pipeline for AV playback, including source, decryption, audio\/video sink elements. Uses a <code>WorkerThread<\/code> for all player task execution and a <code>GstDispatcherThread<\/code> for bus message handling.<\/td><td><code>media\/server\/gstplayer\/include\/GstGenericPlayer.h<\/code>, <code>media\/server\/gstplayer\/source\/<\/code><\/td><\/tr><tr><td><code>GstWebAudioPlayer<\/code><\/td><td>GStreamer-based web audio player. Manages a separate GStreamer pipeline for PCM audio mixing with the main audio output. Supports priority-based activation.<\/td><td><code>media\/server\/gstplayer\/include\/GstWebAudioPlayer.h<\/code><\/td><\/tr><tr><td><code>SharedMemoryBuffer<\/code><\/td><td>Allocates and manages the anonymous shared memory region used to transfer media segments from client to server. Maintains partitions for multiple concurrent playback sessions and web audio players.<\/td><td><code>media\/server\/main\/include\/SharedMemoryBuffer.h<\/code><\/td><\/tr><tr><td><code>MainThread<\/code><\/td><td>Shared task-queue thread on the server. Serialises all server-side operations except GStreamer tasks. Supports synchronous (<code>enqueueTaskAndWait<\/code>) and asynchronous (<code>enqueueTask<\/code>) posting.<\/td><td><code>media\/server\/main\/include\/MainThread.h<\/code><\/td><\/tr><tr><td><code>RialtoIpc<\/code><\/td><td>Custom protobuf-based IPC library implementing an RPC client and server over Unix domain sockets, with support for file descriptor passing and asynchronous server-to-client events. Both the client-side and server-side libraries are driven by an external event loop supplied by the caller.<\/td><td><code>ipc\/client\/<\/code>, <code>ipc\/server\/<\/code>, <code>ipc\/common\/<\/code><\/td><\/tr><tr><td><code>RialtoServerManager<\/code><\/td><td>Library and simulator (<code>RialtoServerManagerSim<\/code>) that manages the lifecycle of <code>RialtoServer<\/code> processes. Reads <code>rialto-config.json<\/code>, spawns servers on demand, sends configuration, monitors health via ping\/ack, and reports state changes to a registered <code>IStateObserver<\/code>.<\/td><td><code>serverManager\/service\/<\/code>, <code>serverManager\/public\/<\/code><\/td><\/tr><tr><td><code>MediaKeysServerInternal<\/code><\/td><td>Server-side EME\/DRM session manager. Manages OpenCDM key sessions, processes licence requests and updates, handles DRM store operations, and supports common encryption (CENC\/CBCS).<\/td><td><code>media\/server\/main\/include\/MediaKeysServerInternal.h<\/code><\/td><\/tr><tr><td><code>Wrappers<\/code><\/td><td>Thin C++ interface wrappers around GStreamer (<code>GstWrapper<\/code>), GLib (<code>GlibWrapper<\/code>), OpenCDM (<code>OcdmSystem<\/code>, <code>OcdmSession<\/code>), the platform GStreamer utilities (<code>RdkGstreamerUtilsWrapper<\/code>), the text track plugin (<code>TextTrackPluginWrapper<\/code>), and WPEFramework Thunder (<code>ThunderWrapper<\/code>). Used to enable mock injection for unit tests.<\/td><td><code>wrappers\/include\/<\/code>, <code>wrappers\/source\/<\/code><\/td><\/tr><tr><td><code>Logging<\/code><\/td><td>Component-scoped logging subsystem providing <code>RIALTO_LOG_*<\/code> macros at FATAL, ERROR, WARNING, MILESTONE, INFO, and DEBUG levels. Supports per-component log level control at runtime via <code>setLogLevels<\/code>.<\/td><td><code>logging\/include\/RialtoLogging.h<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Component Interactions<\/h2>\n\n\n\n<p>Rialto interacts with platform and system components through three main paths: IPC with client applications (northbound), GStreamer and OpenCDM on the server side (southbound), and the server manager IPC channel for process lifecycle control.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Interaction Matrix<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Target Component \/ Layer<\/th><th>Interaction Purpose<\/th><th>Key APIs \/ Topics<\/th><\/tr><\/thead><tbody><tr><td><strong>Application \/ Browser<\/strong><\/td><td><\/td><td><\/td><\/tr><tr><td><code>RialtoClient<\/code><\/td><td>Receives media pipeline, DRM, and web audio control calls from the application; delivers state change and data-request callbacks<\/td><td><code>IMediaPipeline<\/code>, <code>IMediaKeys<\/code>, <code>IWebAudioPlayer<\/code>, <code>IControl<\/code><\/td><\/tr><tr><td><strong>Server Manager<\/strong><\/td><td><\/td><td><\/td><\/tr><tr><td><code>IServerManagerService<\/code><\/td><td>Application manager controls session server lifecycle, state, and log levels<\/td><td><code>initiateApplication()<\/code>, <code>changeSessionServerState()<\/code>, <code>getAppConnectionInfo()<\/code>, <code>setLogLevels()<\/code><\/td><\/tr><tr><td><code>IStateObserver<\/code><\/td><td>Receives asynchronous state change notifications from RialtoServerManager<\/td><td><code>stateChanged(appId, state)<\/code><\/td><\/tr><tr><td><strong>GStreamer \/ HAL<\/strong><\/td><td><\/td><td><\/td><\/tr><tr><td><code>IGstWrapper<\/code><\/td><td>Wraps GStreamer C API for pipeline construction, element state control, buffer push, seek, and bus polling<\/td><td><code>gst_element_set_state()<\/code>, <code>gst_app_src_push_buffer()<\/code>, GStreamer bus<\/td><\/tr><tr><td><code>IGlibWrapper<\/code><\/td><td>Wraps GLib API for object property access and type system calls needed by GStreamer<\/td><td><code>g_object_set()<\/code>, <code>g_object_get()<\/code><\/td><\/tr><tr><td><code>IRdkGstreamerUtilsWrapper<\/code><\/td><td>Wraps platform-specific RDK GStreamer utility functions used for audio\/video sink configuration<\/td><td>RDK GStreamer utils functions<\/td><\/tr><tr><td><strong>DRM<\/strong><\/td><td><\/td><td><\/td><\/tr><tr><td><code>IOcdmSystem<\/code> \/ <code>IOcdmSession<\/code><\/td><td>OpenCDM interface for DRM key system operations: version query, key session creation, key challenge\/response, secure store management<\/td><td><code>createSession()<\/code>, <code>getLdlSessionsLimit()<\/code>, <code>deleteKeyStore()<\/code>, <code>deleteSecureStore()<\/code>, <code>getDrmTime()<\/code><\/td><\/tr><tr><td><strong>Text Track (optional)<\/strong><\/td><td><\/td><td><\/td><\/tr><tr><td><code>ITextTrackPluginWrapper<\/code><\/td><td>WPEFramework text track plugin interface for subtitle rendering, enabled when <code>RIALTO_ENABLE_TEXT_TRACK<\/code> is set<\/td><td><code>TextTrackAccessor<\/code>, GStreamer text track sink<\/td><\/tr><tr><td><strong>IPC Transport<\/strong><\/td><td><\/td><td><\/td><\/tr><tr><td><code>RialtoIpc<\/code><\/td><td>Protobuf RPC over Unix domain sockets; carries all media pipeline, DRM, web audio, control, and server manager messages<\/td><td>Unix domain sockets, protobuf serialisation, fd passing<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">Events Published<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Event Name<\/th><th>IPC Topic<\/th><th>Trigger Condition<\/th><th>Subscriber<\/th><\/tr><\/thead><tbody><tr><td><code>NeedMediaDataEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>Server requires the next batch of encoded frames for a source<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifyNeedMediaData()<\/code><\/td><\/tr><tr><td><code>PlaybackStateChangeEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>GStreamer pipeline state transitions (PLAYING, PAUSED, EOS, FAILURE, etc.)<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifyPlaybackState()<\/code><\/td><\/tr><tr><td><code>NetworkStateChangeEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>Buffering or network state changes<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifyNetworkState()<\/code><\/td><\/tr><tr><td><code>PositionChangeEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>Periodic playback position update (~every 250 ms)<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifyPosition()<\/code><\/td><\/tr><tr><td><code>QosEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>Video frame or audio sample dropped<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifyQos()<\/code><\/td><\/tr><tr><td><code>BufferUnderflowEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>Audio or video buffer underflow detected<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifyBufferUnderflow()<\/code><\/td><\/tr><tr><td><code>PlaybackInfoEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>Periodic playback info sent ~every 32 ms while in PLAYING state<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifyPlaybackInfo()<\/code><\/td><\/tr><tr><td><code>SourceFlushedEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>Source flush completed<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifySourceFlushed()<\/code><\/td><\/tr><tr><td><code>PlaybackErrorEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>Non-fatal per-source playback error (playback state unchanged)<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifyPlaybackError()<\/code><\/td><\/tr><tr><td><code>FirstFrameReceivedEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>First frame received for a source<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaPipelineClient::notifyFirstFrameReceived()<\/code><\/td><\/tr><tr><td><code>SetLogLevelsEvent<\/code><\/td><td><code>mediapipelinemodule.proto<\/code><\/td><td>Server requests new component log levels (emitted by <code>SetLogLevelsService<\/code>; <code>RialtoClient<\/code> does not currently subscribe to or handle this event)<\/td><td><code>RialtoClient<\/code> (no current handler)<\/td><\/tr><tr><td><code>LicenseRequestEvent<\/code><\/td><td><code>mediakeysmodule.proto<\/code><\/td><td>DRM licence request challenge generated for a key session<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaKeysClient::onLicenseRequest()<\/code><\/td><\/tr><tr><td><code>KeyStatusesChangedEvent<\/code><\/td><td><code>mediakeysmodule.proto<\/code><\/td><td>DRM key status updated for a key session<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaKeysClient::onKeyStatusesChanged()<\/code><\/td><\/tr><tr><td><code>LicenseRenewalEvent<\/code><\/td><td><code>mediakeysmodule.proto<\/code><\/td><td>DRM licence renewal required<\/td><td><code>RialtoClient<\/code> \u2192 <code>IMediaKeysClient::onLicenseRenewal()<\/code><\/td><\/tr><tr><td><code>WebAudioPlayerStateEvent<\/code><\/td><td><code>webaudioplayermodule.proto<\/code><\/td><td>Web audio player state change (IDLE \/ PLAYING \/ PAUSED \/ EOS \/ FAILURE)<\/td><td><code>RialtoClient<\/code> \u2192 <code>IWebAudioPlayerClient::notifyState()<\/code><\/td><\/tr><tr><td><code>ApplicationStateChangeEvent<\/code><\/td><td><code>controlmodule.proto<\/code><\/td><td>Server application state transitions (RUNNING \/ INACTIVE \/ UNKNOWN)<\/td><td><code>RialtoClient<\/code> \u2192 <code>IControlClient::notifyApplicationState()<\/code><\/td><\/tr><tr><td><code>PingEvent<\/code><\/td><td><code>controlmodule.proto<\/code><\/td><td>Periodic server\u2192client keepalive ping<\/td><td><code>RialtoClient<\/code> control module (responds automatically)<\/td><\/tr><tr><td><code>StateChangedEvent<\/code><\/td><td><code>servermanagermodule.proto<\/code><\/td><td><code>RialtoServer<\/code> session state changes<\/td><td><code>RialtoServerManager<\/code> \u2192 <code>IStateObserver::stateChanged()<\/code><\/td><\/tr><tr><td><code>AckEvent<\/code><\/td><td><code>servermanagermodule.proto<\/code><\/td><td>Response to periodic server health-check ping<\/td><td><code>RialtoServerManager<\/code> health-check handler<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">IPC Flow Patterns<\/h3>\n\n\n\n<p><strong>Primary Request \/ Response Flow:<\/strong><\/p>\n\n\n\n<p>The client library serialises each control-plane API call into a protobuf request message and sends it over the per-application Unix domain socket. The server deserialises the request, executes the operation (typically enqueued onto <code>MainThread<\/code> or <code>WorkerThread<\/code>), and serialises the result back as a response message. The shared-memory media path is exempt: <code>IMediaPipeline::addSegment()<\/code> writes frames into the mapped buffer directly, and only the subsequent <code>haveData()<\/code> call sends a <code>HaveDataRequest<\/code> RPC.<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant App as Application\n    participant RC as RialtoClient\n    participant IPC as RialtoIpc (Unix socket)\n    participant RS as RialtoServer\n\n    App->>RC: IMediaPipeline::play()\n    RC->>IPC: PlayRequest (session_id)\n    IPC->>RS: Deserialise PlayRequest\n    RS->>RS: Enqueue play operation on MainThread\n    RS->>RS: MainThread posts GStreamer task to WorkerThread\n    RS->>RS: gst_element_set_state(PLAYING)\n    RS-->>IPC: PlayResponse\n    IPC-->>RC: Deserialise PlayResponse\n    RC-->>App: return true\n    RS->>IPC: PlaybackStateChangeEvent(PLAYING)\n    IPC->>RC: Deserialise event\n    RC->>App: IMediaPipelineClient::notifyPlaybackState(PLAYING)<\/pre><\/div>\n\n\n\n<p><strong>Event Notification Flow:<\/strong><\/p>\n\n\n\n<p>GStreamer bus events (EOS, state change, QoS, error) are received by the <code>GstDispatcherThread<\/code>, translated into server-side events, and forwarded over the IPC server channel as unsolicited event messages.<\/p>\n\n\n\n<div class=\"wp-block-merpress-mermaidjs diagram-source-mermaid\"><pre class=\"mermaid\">sequenceDiagram\n    participant GST as GStreamer Bus\n    participant GstDisp as GstDispatcherThread\n    participant RS as RialtoServer IPC\n    participant RC as RialtoClient\n    participant App as Application\n\n    GST->>GstDisp: GST_MESSAGE_EOS\n    GstDisp->>RS: Enqueue HandleBusMessage on WorkerThread\n    RS->>RS: WorkerThread enqueues EOS notification on MainThread\n    RS->>RC: PlaybackStateChangeEvent(END_OF_STREAM)\n    RC->>App: IMediaPipelineClient::notifyPlaybackState(END_OF_STREAM)<\/pre><\/div>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Implementation Details<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Key External Library Integrations<\/h3>\n\n\n\n<p>Rialto accesses the platform media subsystem directly through the following wrapped interfaces:<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Wrapper \/ Interface<\/th><th>Purpose<\/th><th>Implementation File<\/th><\/tr><\/thead><tbody><tr><td><code>IGstWrapper::gstInit()<\/code><\/td><td>Initialises the GStreamer library<\/td><td><code>wrappers\/source\/GstWrapper.cpp<\/code><\/td><\/tr><tr><td><code>IGstWrapper::gstElementSetState()<\/code><\/td><td>Controls GStreamer pipeline and element state (NULL, READY, PAUSED, PLAYING)<\/td><td><code>wrappers\/source\/GstWrapper.cpp<\/code><\/td><\/tr><tr><td><code>IGstWrapper::gstAppSrcPushBuffer()<\/code><\/td><td>Pushes encoded media buffers into the GStreamer appsrc element<\/td><td><code>wrappers\/source\/GstWrapper.cpp<\/code><\/td><\/tr><tr><td><code>IGstWrapper::gstElementSendEvent()<\/code><\/td><td>Sends seek and flush events to the GStreamer pipeline<\/td><td><code>wrappers\/source\/GstWrapper.cpp<\/code><\/td><\/tr><tr><td><code>IGstWrapper::gstBusCreateWatch()<\/code><\/td><td>Creates a GLib bus watch attached to <code>GstDispatcherThread<\/code>&#8216;s private <code>GMainContext<\/code><\/td><td><code>wrappers\/source\/GstWrapper.cpp<\/code><\/td><\/tr><tr><td><code>IGlibWrapper::gObjectSet()<\/code><\/td><td>Sets GStreamer element properties (video geometry, audio parameters)<\/td><td><code>wrappers\/source\/GlibWrapper.cpp<\/code><\/td><\/tr><tr><td><code>IRdkGstreamerUtilsWrapper<\/code><\/td><td>Provides platform-specific audio\/video sink setup functions<\/td><td><code>wrappers\/source\/RdkGstreamerUtilsWrapper.cpp<\/code><\/td><\/tr><tr><td><code>IOcdmSystem::createSession()<\/code><\/td><td>Creates an OpenCDM DRM session for a given key system<\/td><td><code>wrappers\/source\/OcdmSystem.cpp<\/code><\/td><\/tr><tr><td><code>IOcdmSystem::getLdlSessionsLimit()<\/code><\/td><td>Queries the maximum number of limited-duration licence sessions<\/td><td><code>wrappers\/source\/OcdmSystem.cpp<\/code><\/td><\/tr><tr><td><code>IOcdmSystem::deleteKeyStore()<\/code><\/td><td>Deletes the key store for the active key system<\/td><td><code>wrappers\/source\/OcdmSystem.cpp<\/code><\/td><\/tr><tr><td><code>IOcdmSystem::deleteSecureStore()<\/code><\/td><td>Deletes the DRM secure store for the active key system<\/td><td><code>wrappers\/source\/OcdmSystem.cpp<\/code><\/td><\/tr><tr><td><code>IOcdmSystem::getDrmTime()<\/code><\/td><td>Returns the DRM system clock time<\/td><td><code>wrappers\/source\/OcdmSystem.cpp<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">Key Implementation Logic<\/h3>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>State \/ Lifecycle Management<\/strong>: Session server state (UNINITIALIZED, INACTIVE, ACTIVE, NOT_RUNNING, SUSPENDED, ERROR) is tracked in the <code>RialtoServerManager<\/code>. On the server side, the <code>IPlaybackService<\/code> interface exposes <code>switchToActive()<\/code> and <code>switchToInactive()<\/code> to change service availability. Playback state (IDLE, PLAYING, PAUSED, SEEKING, SEEK_DONE, STOPPED, END_OF_STREAM, FAILURE) is managed within <code>GstGenericPlayer<\/code> and propagated via the <code>GstDispatcherThread<\/code>.<\/li>\n\n\n\n<li>State transition logic: <code>serverManager\/service\/source\/<\/code>, <code>media\/server\/service\/source\/<\/code><\/li>\n\n\n\n<li><strong>Event Processing<\/strong>: GStreamer bus messages are polled by <code>GstDispatcherThread<\/code> in a loop and dispatched to <code>IGstDispatcherThreadClient<\/code> callbacks implemented by <code>GstGenericPlayer<\/code>. The player then enqueues corresponding state or notification events onto the <code>MainThread<\/code> for serialised processing and IPC dispatch. Need-data requests originate from the <code>GstSrc<\/code> element&#8217;s need-data signal, also handled on the <code>WorkerThread<\/code>.<\/li>\n\n\n\n<li><strong>Error Handling Strategy<\/strong>: GStreamer errors received as <code>GST_MESSAGE_ERROR<\/code> are translated into a <code>PlaybackState::FAILURE<\/code> notification to the client. OpenCDM errors are mapped to <code>MediaKeyErrorStatus<\/code> values (OK, FAIL, BAD_SESSION_ID, NOT_SUPPORTED, INVALID_STATE, INTERFACE_NOT_IMPLEMENTED, BUFFER_TOO_SMALL, OUTPUT_RESTRICTED) returned synchronously from <code>IMediaKeys<\/code> methods. IPC-level failures result in the client receiving a failure response or a disconnect notification.<\/li>\n\n\n\n<li><strong>Logging &amp; Diagnostics<\/strong>: All Rialto components use <code>RIALTO_LOG_*<\/code> macros defined in <code>logging\/include\/RialtoLogging.h<\/code>. Log output is per-component (CLIENT, SERVER, IPC, SERVER_MANAGER, COMMON) and per-level (FATAL, ERROR, WARNING, MILESTONE, INFO, DEBUG). Log levels can be reconfigured at runtime via the <code>setLogLevels()<\/code> API on <code>IServerManagerService<\/code>. A custom <code>ILogHandler<\/code> can be registered to redirect server manager logs to an external sink.<\/li>\n\n\n\n<li>RDK Logger component names: <code>RIALTO_COMPONENT_CLIENT<\/code>, <code>RIALTO_COMPONENT_SERVER<\/code>, <code>RIALTO_COMPONENT_IPC<\/code>, <code>RIALTO_COMPONENT_SERVER_MANAGER<\/code>, <code>RIALTO_COMPONENT_COMMON<\/code>.<\/li>\n<\/ul>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n\n\n\n<h2 class=\"wp-block-heading\">Configuration<\/h2>\n\n\n\n<h3 class=\"wp-block-heading\">Key Configuration Files<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Configuration File<\/th><th>Purpose<\/th><th>Override Mechanism<\/th><\/tr><\/thead><tbody><tr><td><code>\/etc\/rialto-config.json<\/code> and <code>\/etc\/rialto-soc.json<\/code><\/td><td>Base and SoC-specific server manager runtime parameters: server binary path, environment variables, timeouts, socket permissions, pre-loaded server count, health-check interval, and log levels<\/td><td>Files are read in order; the SoC file and, on debug builds, the configured override file can replace earlier values<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">Key Configuration Parameters<\/h3>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Parameter<\/th><th>Type<\/th><th>Default<\/th><th>Description<\/th><\/tr><\/thead><tbody><tr><td><code>sessionServerPath<\/code><\/td><td>string<\/td><td><code>\/usr\/bin\/RialtoServer<\/code><\/td><td>Path to the <code>RialtoServer<\/code> executable spawned for each application<\/td><\/tr><tr><td><code>startupTimeoutMs<\/code><\/td><td>int<\/td><td><code>0<\/code><\/td><td>Maximum milliseconds to wait for a <code>RialtoServer<\/code> to become ready (0 = no timeout)<\/td><\/tr><tr><td><code>healthcheckIntervalInSeconds<\/code><\/td><td>int<\/td><td><code>5<\/code><\/td><td>Interval in seconds between server health-check pings<\/td><\/tr><tr><td><code>socketPermissions<\/code><\/td><td>int<\/td><td><code>666<\/code><\/td><td>Chmod-style permissions (e.g. 666) converted to a mode (e.g. 0666) and applied to the client-facing IPC socket file<\/td><\/tr><tr><td><code>socketOwner<\/code><\/td><td>string<\/td><td><code>\"\"<\/code><\/td><td>User name applied via <code>chown<\/code> to the client-facing IPC socket file<\/td><\/tr><tr><td><code>socketGroup<\/code><\/td><td>string<\/td><td><code>\"\"<\/code><\/td><td>Group name applied via <code>chown<\/code> to the client-facing IPC socket file<\/td><\/tr><tr><td><code>numOfPreloadedServers<\/code><\/td><td>int<\/td><td><code>0<\/code><\/td><td>Number of <code>RialtoServer<\/code> processes to pre-launch at startup to reduce application connect latency<\/td><\/tr><tr><td><code>numOfPingsBeforeRecovery<\/code><\/td><td>int<\/td><td><code>3<\/code><\/td><td>Number of consecutive failed health checks (including timeouts and unsuccessful acknowledgements) before the server manager triggers recovery for a server instance<\/td><\/tr><tr><td><code>logLevel<\/code><\/td><td>uint<\/td><td><code>3<\/code><\/td><td>Default numeric logging level (0 = FATAL through 5 = DEBUG) applied to all Rialto components at startup<\/td><\/tr><tr><td><code>environmentVariables<\/code><\/td><td>list<\/td><td><code>XDG_RUNTIME_DIR=\/tmp<\/code>, <code>GST_REGISTRY=\/opt\/.gstreamer\/registry.bin<\/code>, <code>WESTEROS_SINK_USE_ESSRMGR=1<\/code><\/td><td>Environment variables set for every spawned <code>RialtoServer<\/code> process<\/td><\/tr><tr><td><code>extraEnvVariables<\/code><\/td><td>list<\/td><td><code>[]<\/code><\/td><td>Additional environment variables merged into the server environment<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<h3 class=\"wp-block-heading\">Runtime Configuration<\/h3>\n\n\n\n<p>Log levels for all Rialto components can be changed at runtime without restarting any process:<\/p>\n\n\n\n<pre class=\"EnlighterJSRAW\" data-enlighter-language=\"generic\" data-enlighter-theme=\"\" data-enlighter-highlight=\"\" data-enlighter-linenumbers=\"\" data-enlighter-lineoffset=\"\" data-enlighter-title=\"\" data-enlighter-group=\"\">\/\/ Via IServerManagerService API (called by the application manager integration)\nLoggingLevels logLevels;\nlogLevels.defaultLoggingLevel = LoggingLevel::DEBUG;\nlogLevels.clientLoggingLevel = LoggingLevel::DEBUG;\nlogLevels.sessionServerLoggingLevel = LoggingLevel::DEBUG;\nlogLevels.ipcLoggingLevel = LoggingLevel::DEBUG;\nlogLevels.serverManagerLoggingLevel = LoggingLevel::DEBUG;\nlogLevels.commonLoggingLevel = LoggingLevel::DEBUG;\nserverManagerService->setLogLevels(logLevels);<\/pre>\n\n\n\n<h3 class=\"wp-block-heading\">Configuration Persistence<\/h3>\n\n\n\n<p>Persistent configuration is read from <code>rialto-config.json<\/code> at <code>RialtoServerManager<\/code> startup. Runtime log level changes applied via <code>setLogLevels()<\/code> take effect immediately across all active Rialto processes.<\/p>\n\n\n\n<hr class=\"wp-block-separator has-alpha-channel-opacity\"\/>\n","protected":false},"excerpt":{"rendered":"<p>Rialto provides a solution for implementing AV (audio and video) pipelines of containerised native applications [&hellip;]<\/p>\n","protected":false},"author":659,"featured_media":0,"parent":9844,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"_bbp_topic_count":0,"_bbp_reply_count":0,"_bbp_total_topic_count":0,"_bbp_total_reply_count":0,"_bbp_voice_count":0,"_bbp_anonymous_reply_count":0,"_bbp_topic_count_hidden":0,"_bbp_reply_count_hidden":0,"_bbp_forum_subforum_count":0,"footnotes":""},"class_list":["post-13103","page","type-page","status-publish","hentry"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v24.9 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Rialto - RDK Documentation Portal | Documentation<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Rialto - RDK Documentation Portal | Documentation\" \/>\n<meta property=\"og:description\" content=\"Rialto provides a solution for implementing AV (audio and video) pipelines of containerised native applications [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/\" \/>\n<meta property=\"og:site_name\" content=\"RDK Documentation Portal | Documentation\" \/>\n<meta property=\"article:modified_time\" content=\"2026-11-10T05:45:35+00:00\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data1\" content=\"13 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/\",\"url\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/\",\"name\":\"Rialto - RDK Documentation Portal | Documentation\",\"isPartOf\":{\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/#website\"},\"datePublished\":\"2026-11-10T05:45:32+00:00\",\"dateModified\":\"2026-11-10T05:45:35+00:00\",\"breadcrumb\":{\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Documentation\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"RDK Video\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Components\",\"item\":\"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/\"},{\"@type\":\"ListItem\",\"position\":5,\"name\":\"Rialto\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/developer.rdkcentral.com\/documentation\/#website\",\"url\":\"https:\/\/developer.rdkcentral.com\/documentation\/\",\"name\":\"RDK Documentation Portal | Documentation\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/developer.rdkcentral.com\/documentation\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Rialto - RDK Documentation Portal | Documentation","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/","og_locale":"en_US","og_type":"article","og_title":"Rialto - RDK Documentation Portal | Documentation","og_description":"Rialto provides a solution for implementing AV (audio and video) pipelines of containerised native applications [&hellip;]","og_url":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/","og_site_name":"RDK Documentation Portal | Documentation","article_modified_time":"2026-11-10T05:45:35+00:00","twitter_card":"summary_large_image","twitter_misc":{"Est. reading time":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/","url":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/","name":"Rialto - RDK Documentation Portal | Documentation","isPartOf":{"@id":"https:\/\/developer.rdkcentral.com\/documentation\/#website"},"datePublished":"2026-11-10T05:45:32+00:00","dateModified":"2026-11-10T05:45:35+00:00","breadcrumb":{"@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/rialto\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/developer.rdkcentral.com\/documentation\/"},{"@type":"ListItem","position":2,"name":"Documentation","item":"https:\/\/developer.rdkcentral.com\/documentation\/"},{"@type":"ListItem","position":3,"name":"RDK Video","item":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/"},{"@type":"ListItem","position":4,"name":"Components","item":"https:\/\/developer.rdkcentral.com\/documentation\/documentation\/rdk_video_documentation\/components\/"},{"@type":"ListItem","position":5,"name":"Rialto"}]},{"@type":"WebSite","@id":"https:\/\/developer.rdkcentral.com\/documentation\/#website","url":"https:\/\/developer.rdkcentral.com\/documentation\/","name":"RDK Documentation Portal | Documentation","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/developer.rdkcentral.com\/documentation\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"}]}},"_links":{"self":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/13103","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/users\/659"}],"replies":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/comments?post=13103"}],"version-history":[{"count":1,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/13103\/revisions"}],"predecessor-version":[{"id":13104,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/13103\/revisions\/13104"}],"up":[{"embeddable":true,"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/pages\/9844"}],"wp:attachment":[{"href":"https:\/\/developer.rdkcentral.com\/documentation\/wp-json\/wp\/v2\/media?parent=13103"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}