RTC Engine implementation.

RTC Engine is an abstraction layer responsible for linking together different types of Endpoints. From the implementation point of view, RTC Engine is a Membrane.Pipeline.

Messages

The RTC Engine works by sending messages which notify user logic about important events. To receive RTC Engine messages you have to register your process so that RTC Engine will know where to send them. All messages RTC Engine can emit are described in Membrane.RTC.Engine.Message docs.

Registering for messages

Registration can be done using register/2 e.g.

Engine.register(rtc_engine, self())

This will register your process to receive RTC Engine messages. You can register multiple processes to receive messages from an RTC Engine instance. In such a case each message will be sent to each registered process.

Endpoints

Endpoints are Membrane.Bins able to publish their own tracks and subscribe to tracks from other Endpoints. One can think about Endpoint as an entity responsible for handling some specific task. An Endpoint can be added and removed using add_endpoint/3 and remove_endpoint/2 respectively.

There are two types of Endpoints:

• Standalone Endpoints - they are in most cases spawned only once per RTC Engine instance and they are not associated with any client.
• Client Endpoints - they are associated with some client. Associating Endpoint with client will send some Media Events to the Endpoint's Client Library e.g. one which indicates which tracks belong to which client.

Currently RTC Engine ships with the implementation of the following Endpoints:

• Membrane.RTC.Engine.Endpoint.WebRTC which is responsible for establishing a connection with some WebRTC client (mainly browser) and exchanging media with it. WebRTC Endpoint is a Client Endpoint.
• Membrane.RTC.Engine.Endpoint.HLS which is responsible for receiving media tracks from all other Endpoints and saving them to files by creating HLS playlists. HLS Endpoint is a Standalone Endpoint.
• Membrane.RTC.Engine.Endpoint.RTSP which is responsible for connecting to a remote RTSP stream source and sending the appropriate media track to other Endpoints. RTSP Endpoint is a Standalone Endpoint.
• Membrane.RTC.Engine.Endpoint.File which is responsible for reading track from a file, payloading it into RTP, and sending it to other Endpoints. File Endpoint is a Standalone Endpoint.
• Membrane.RTC.Engine.Endpoint.SIP which is responsible for establishing a connection with some SIP device (e.g. phone) and exchanging media with it. SIP Endpoint is a Standalone Endpoint.
• Membrane.RTC.Engine.Endpoint.Recording which is responsible for saving incoming tracks to pointed storages. Recording Endpoint is a Standalone Endpoint.

Each of these endpoints is available as a separate package. Refer to the appropriate package for usage examples:

• membrane_rtc_engine_webrtc
• membrane_rtc_engine_hls
• membrane_rtc_engine_rtsp
• membrane_rtc_engine_file
• membrane_rtc_engine_sip
• membrane_rtc_engine_recording

User can also implement custom Endpoints, see Custom Endpoints guide.

Readiness state

Each endpoint is presumed to be initially inactive and has to declare itself ready to fully join the Engine.

Before it does, it:

• will not receive notifications about other endpoints and their metadata
• will not receive information about tracks
• will not be able to publish any tracks
• will not be able to update their metadata

When declaring itself as ready, the endpoint also has an opportunity to set their metadata. To mark the endpoint as active, it has to send the ready_action_t/0.

Example

@impl true
def handle_other({:media_event, %{type: "join", metadata: metadata}}, _context, state) do
  {{:ok, notify: {:ready, metadata}}, state}
end

@impl true
def handle_other(:ready, _context, state) do
  Membrane.Logger.debug("Succesfully activated the endpoint")
  {:ok, state}
end