GstRSWebRTCSignallableIface

GInterface
    ╰──GstRSWebRTCSignallableIface

consumer-added

consumer_added_callback (GstElement * self,
                         gchararray peer_id,
                         GstElement * webrtcbin,
                         gpointer udata)

def consumer_added_callback (self, peer_id, webrtcbin, udata):
    #python callback for the 'consumer-added' signal

function consumer_added_callback(self: GstElement * self, peer_id: gchararray peer_id, webrtcbin: GstElement * webrtcbin, udata: gpointer udata): {
    // javascript callback for the 'consumer-added' signal
}

This signal can be used to tweak webrtcbin, creating a data channel for example.

Flags: Run Last

consumer-removed

consumer_removed_callback (GstElement * consumer_id,
                           gchararray webrtcbin,
                           GstElement * arg1,
                           gpointer udata)

def consumer_removed_callback (consumer_id, webrtcbin, arg1, udata):
    #python callback for the 'consumer-removed' signal

function consumer_removed_callback(consumer_id: GstElement * consumer_id, webrtcbin: gchararray webrtcbin, arg1: GstElement * arg1, udata: gpointer udata): {
    // javascript callback for the 'consumer-removed' signal
}

This signal is emitted right after the connection with a consumer has been dropped.

Flags: Run Last

end-session

gboolean
end_session_callback (GstElement * self,
                      gchararray session-id,
                      gpointer udata)

def end_session_callback (self, session-id, udata):
    #python callback for the 'end-session' signal

function end_session_callback(self: GstElement * self, session-id: gchararray session-id, udata: gpointer udata): {
    // javascript callback for the 'end-session' signal
}

Notify the signaller that a session should be ended.

Flags: Run Last

error

error_callback (GstElement * self,
                gchararray error,
                gpointer udata)

def error_callback (self, error, udata):
    #python callback for the 'error' signal

function error_callback(self: GstElement * self, error: gchararray error, udata: gpointer udata): {
    // javascript callback for the 'error' signal
}

Flags: Run Last

producer-added

producer_added_callback (GstElement * self,
                         gchararray producer_id,
                         GstStructure * meta,
                         gpointer udata)

def producer_added_callback (self, producer_id, meta, udata):
    #python callback for the 'producer-added' signal

function producer_added_callback(self: GstElement * self, producer_id: gchararray producer_id, meta: GstStructure * meta, udata: gpointer udata): {
    // javascript callback for the 'producer-added' signal
}

Some new producing peer is ready to produce a WebRTC stream.

Flags: Run Last

producer-removed

producer_removed_callback (GstElement * self,
                           gchararray producer_id,
                           GstStructure * meta,
                           gpointer udata)

def producer_removed_callback (self, producer_id, meta, udata):
    #python callback for the 'producer-removed' signal

function producer_removed_callback(self: GstElement * self, producer_id: gchararray producer_id, meta: GstStructure * meta, udata: gpointer udata): {
    // javascript callback for the 'producer-removed' signal
}

Some new producing peer is stopped producing streams.

Flags: Run Last

request-meta

GstStructure *
request_meta_callback (GstElement * self,
                       gpointer udata)

def request_meta_callback (self, udata):
    #python callback for the 'request-meta' signal

function request_meta_callback(self: GstElement * self, udata: gpointer udata): {
    // javascript callback for the 'request-meta' signal
}

The signaller requests a meta about the peer using it

Return: The metadata about the peer represented by the signaller

Flags: Run Last

send-ice

gboolean
send_ice_callback (GstElement * self,
                   gchararray session_id,
                   gchararray candidate,
                   guint sdp_m_line_index,
                   gchararray sdp_mid,
                   gpointer udata)

def send_ice_callback (self, session_id, candidate, sdp_m_line_index, sdp_mid, udata):
    #python callback for the 'send-ice' signal

function send_ice_callback(self: GstElement * self, session_id: gchararray session_id, candidate: gchararray candidate, sdp_m_line_index: guint sdp_m_line_index, sdp_mid: gchararray sdp_mid, udata: gpointer udata): {
    // javascript callback for the 'send-ice' signal
}

Send candidate to the peer.

Flags: Run Last

send-session-description

gboolean
send_session_description_callback (GstElement * self,
                                   gchararray session_id,
                                   GstWebRTCSessionDescription * description,
                                   gpointer udata)

def send_session_description_callback (self, session_id, description, udata):
    #python callback for the 'send-session-description' signal

function send_session_description_callback(self: GstElement * self, session_id: gchararray session_id, description: GstWebRTCSessionDescription * description, udata: gpointer udata): {
    // javascript callback for the 'send-session-description' signal
}

Send description to the peer.

Flags: Run Last

session-requested

session_requested_callback (GstElement * self,
                            gchararray session_id,
                            gchararray peer_id,
                            GstWebRTCSessionDescription * arg2,
                            gpointer udata)

def session_requested_callback (self, session_id, peer_id, arg2, udata):
    #python callback for the 'session-requested' signal

function session_requested_callback(self: GstElement * self, session_id: gchararray session_id, peer_id: gchararray peer_id, arg2: GstWebRTCSessionDescription * arg2, udata: gpointer udata): {
    // javascript callback for the 'session-requested' signal
}

Notify the underlying webrtc object that a session has been requested from the peer.

Flags: Run Last

session-started

session_started_callback (GstElement * self,
                          gchararray arg0,
                          gchararray arg1,
                          gpointer udata)

def session_started_callback (self, arg0, arg1, udata):
    #python callback for the 'session-started' signal

function session_started_callback(self: GstElement * self, arg0: gchararray arg0, arg1: gchararray arg1, udata: gpointer udata): {
    // javascript callback for the 'session-started' signal
}

Notify the underlying webrtc object that a session has started.

Flags: Run Last

handle-ice

g_signal_emit_by_name (self, "handle-ice", session_id, sdp_m_line_index, sdp_mid, candidate);

ret = self.emit ("handle-ice", session_id, sdp_m_line_index, sdp_mid, candidate)

let ret = self.emit ("handle-ice", session_id, sdp_m_line_index, sdp_mid, candidate);

Notify the underlying webrtc object of an ICE candidate.

Flags: Run Last / Action

session-description

g_signal_emit_by_name (self, "session-description", session_id, description);

ret = self.emit ("session-description", session_id, description)

let ret = self.emit ("session-description", session_id, description);

Notify the underlying webrtc object of a received session description

Flags: Run Last / Action

session-ended

g_signal_emit_by_name (self, "session-ended", session-id, &ret);

ret = self.emit ("session-ended", session-id)

let ret = self.emit ("session-ended", session-id);

Notify the underlying webrtc object that a session has ended.

Flags: Run Last / Action

shutdown

g_signal_emit_by_name (self, "shutdown");

ret = self.emit ("shutdown")

let ret = self.emit ("shutdown");

Flags: Run Last / Action

start

g_signal_emit_by_name (self, "start", &ret);

ret = self.emit ("start")

let ret = self.emit ("start");

Starts the signaller, connecting it to the signalling server.

Flags: Run Last / Action

stop

g_signal_emit_by_name (self, "stop", &ret);

ret = self.emit ("stop")

let ret = self.emit ("stop");

Stops the signaller, disconnecting it to the signalling server.

Flags: Run Last / Action