rtpsession
The RTP session manager models participants with unique SSRC in an RTP session. This session can be used to send and receive RTP and RTCP packets. Based on what REQUEST pads are requested from the session manager, specific functionality can be activated.
The session manager currently implements RFC 3550 including:
-
RTP packet validation based on consecutive sequence numbers.
-
Maintenance of the SSRC participant database.
-
Keeping per participant statistics based on received RTCP packets.
-
Scheduling of RR/SR RTCP packets.
-
Support for multiple sender SSRC.
The rtpsession will not demux packets based on SSRC or payload type, nor will it correct for packet reordering and jitter. Use rtpssrcdemux, rtpptdemux and GstRtpJitterBuffer in addition to rtpsession to perform these tasks. It is usually a good idea to use rtpbin, which combines all these features in one element.
To use rtpsession as an RTP receiver, request a recv_rtp_sink pad, which will automatically create recv_rtp_src pad. Data received on the recv_rtp_sink pad will be processed in the session and after being validated forwarded on the recv_rtp_src pad.
To also use rtpsession as an RTCP receiver, request a recv_rtcp_sink pad, which will automatically create a sync_src pad. Packets received on the RTCP pad will be used by the session manager to update the stats and database of the other participants. SR packets will be forwarded on the sync_src pad so that they can be used to perform inter-stream synchronisation when needed.
If you want the session manager to generate and send RTCP packets, request the send_rtcp_src pad. Packet pushed on this pad contain SR/RR RTCP reports that should be sent to all participants in the session.
To use rtpsession as a sender, request a send_rtp_sink pad, which will automatically create a send_rtp_src pad. The session manager will forward the packets on the send_rtp_src pad after updating its internal state.
The session manager needs the clock-rate of the payload types it is handling and will signal the request-pt-map signal when it needs such a mapping. One can clear the cached values with the clear-pt-map signal.
Example pipelines
gst-launch-1.0 udpsrc port=5000 caps="application/x-rtp, ..." ! .recv_rtp_sink rtpsession .recv_rtp_src ! rtptheoradepay ! theoradec ! xvimagesink
Receive theora RTP packets from port 5000 and send them to the depayloader, decoder and display. Note that the application/x-rtp caps on udpsrc should be configured based on some negotiation process such as RTSP for this pipeline to work correctly.
gst-launch-1.0 udpsrc port=5000 caps="application/x-rtp, ..." ! .recv_rtp_sink rtpsession name=session \
.recv_rtp_src ! rtptheoradepay ! theoradec ! xvimagesink \
udpsrc port=5001 caps="application/x-rtcp" ! session.recv_rtcp_sink
Receive theora RTP packets from port 5000 and send them to the depayloader, decoder and display. Receive RTCP packets from port 5001 and process them in the session manager. Note that the application/x-rtp caps on udpsrc should be configured based on some negotiation process such as RTSP for this pipeline to work correctly.
gst-launch-1.0 videotestsrc ! theoraenc ! rtptheorapay ! .send_rtp_sink rtpsession .send_rtp_src ! udpsink port=5000
Send theora RTP packets through the session manager and out on UDP port 5000.
gst-launch-1.0 videotestsrc ! theoraenc ! rtptheorapay ! .send_rtp_sink rtpsession name=session .send_rtp_src \
! udpsink port=5000 session.send_rtcp_src ! udpsink port=5001
Send theora RTP packets through the session manager and out on UDP port 5000. Send RTCP packets on port 5001. Note that this pipeline will not preroll correctly because the second udpsink will not preroll correctly (no RTCP packets are sent in the PAUSED state). Applications should manually set and keep (see gst_element_set_locked_state) the RTCP udpsink to the PLAYING state.
Hierarchy
GObject ╰──GInitiallyUnowned ╰──GstObject ╰──GstElement ╰──rtpsession
Factory details
Authors: – Wim Taymans
Classification: – Filter/Network/RTP
Rank – none
Plugin – gstrtpmanager
Package – GStreamer Good Plug-ins
Pad Templates
Signals
clear-pt-map
clear_pt_map_callback (GstElement * sess, gpointer udata)
def clear_pt_map_callback (sess, udata):
#python callback for the 'clear-pt-map' signal
function clear_pt_map_callback(sess: GstElement * sess, udata: gpointer udata): {
// javascript callback for the 'clear-pt-map' signal
}
Clear the cached pt-maps requested with request-pt-map.
Parameters:
sess
–
the object which received the signal
udata
–
no-more-pads
no_more_pads_callback (GstElement * param_0, gpointer udata)
def no_more_pads_callback (param_0, udata):
#python callback for the 'no-more-pads' signal
function no_more_pads_callback(param_0: GstElement * param_0, udata: gpointer udata): {
// javascript callback for the 'no-more-pads' signal
}
Parameters:
param_0
–
udata
–
Flags: Run Last
on-bye-ssrc
on_bye_ssrc_callback (GstElement * sess, guint ssrc, gpointer udata)
def on_bye_ssrc_callback (sess, ssrc, udata):
#python callback for the 'on-bye-ssrc' signal
function on_bye_ssrc_callback(sess: GstElement * sess, ssrc: guint ssrc, udata: gpointer udata): {
// javascript callback for the 'on-bye-ssrc' signal
}
Notify of an SSRC that became inactive because of a BYE packet.
Parameters:
sess
–
the object which received the signal
ssrc
–
the SSRC
udata
–
Flags: Run Last
on-bye-timeout
on_bye_timeout_callback (GstElement * sess, guint ssrc, gpointer udata)
def on_bye_timeout_callback (sess, ssrc, udata):
#python callback for the 'on-bye-timeout' signal
function on_bye_timeout_callback(sess: GstElement * sess, ssrc: guint ssrc, udata: gpointer udata): {
// javascript callback for the 'on-bye-timeout' signal
}
Notify of an SSRC that has timed out because of BYE
Parameters:
sess
–
the object which received the signal
ssrc
–
the SSRC
udata
–
Flags: Run Last
on-new-sender-ssrc
on_new_sender_ssrc_callback (GstElement * sess, guint ssrc, gpointer udata)
def on_new_sender_ssrc_callback (sess, ssrc, udata):
#python callback for the 'on-new-sender-ssrc' signal
function on_new_sender_ssrc_callback(sess: GstElement * sess, ssrc: guint ssrc, udata: gpointer udata): {
// javascript callback for the 'on-new-sender-ssrc' signal
}
Notify of a new sender SSRC that entered session.
Parameters:
sess
–
the object which received the signal
ssrc
–
the sender SSRC
udata
–
Flags: Run Last
Since : 1.8
on-new-ssrc
on_new_ssrc_callback (GstElement * sess, guint ssrc, gpointer udata)
def on_new_ssrc_callback (sess, ssrc, udata):
#python callback for the 'on-new-ssrc' signal
function on_new_ssrc_callback(sess: GstElement * sess, ssrc: guint ssrc, udata: gpointer udata): {
// javascript callback for the 'on-new-ssrc' signal
}
Notify of a new SSRC that entered session.
Parameters:
sess
–
the object which received the signal
ssrc
–
the SSRC
udata
–
Flags: Run Last
on-sender-ssrc-active
on_sender_ssrc_active_callback (GstElement * sess, guint ssrc, gpointer udata)
def on_sender_ssrc_active_callback (sess, ssrc, udata):
#python callback for the 'on-sender-ssrc-active' signal
function on_sender_ssrc_active_callback(sess: GstElement * sess, ssrc: guint ssrc, udata: gpointer udata): {
// javascript callback for the 'on-sender-ssrc-active' signal
}
Notify of a sender SSRC that is active, i.e., sending RTCP.
Parameters:
sess
–
the object which received the signal
ssrc
–
the sender SSRC
udata
–
Flags: Run Last
Since : 1.8
on-sender-timeout
on_sender_timeout_callback (GstElement * sess, guint ssrc, gpointer udata)
def on_sender_timeout_callback (sess, ssrc, udata):
#python callback for the 'on-sender-timeout' signal
function on_sender_timeout_callback(sess: GstElement * sess, ssrc: guint ssrc, udata: gpointer udata): {
// javascript callback for the 'on-sender-timeout' signal
}
Notify of a sender SSRC that has timed out and became a receiver
Parameters:
sess
–
the object which received the signal
ssrc
–
the SSRC
udata
–
Flags: Run Last
on-ssrc-active
on_ssrc_active_callback (GstElement * sess, guint ssrc, gpointer udata)
def on_ssrc_active_callback (sess, ssrc, udata):
#python callback for the 'on-ssrc-active' signal
function on_ssrc_active_callback(sess: GstElement * sess, ssrc: guint ssrc, udata: gpointer udata): {
// javascript callback for the 'on-ssrc-active' signal
}
Notify of a SSRC that is active, i.e., sending RTCP.
Parameters:
sess
–
the object which received the signal
ssrc
–
the SSRC
udata
–
Flags: Run Last
on-ssrc-collision
on_ssrc_collision_callback (GstElement * param_0, guint arg0, gpointer udata)
def on_ssrc_collision_callback (param_0, arg0, udata):
#python callback for the 'on-ssrc-collision' signal
function on_ssrc_collision_callback(param_0: GstElement * param_0, arg0: guint arg0, udata: gpointer udata): {
// javascript callback for the 'on-ssrc-collision' signal
}
Parameters:
param_0
–
arg0
–
udata
–
Flags: Run Last
on-ssrc-sdes
on_ssrc_sdes_callback (GstElement * session, guint src, gpointer udata)
def on_ssrc_sdes_callback (session, src, udata):
#python callback for the 'on-ssrc-sdes' signal
function on_ssrc_sdes_callback(session: GstElement * session, src: guint src, udata: gpointer udata): {
// javascript callback for the 'on-ssrc-sdes' signal
}
Notify that a new SDES was received for SSRC.
Parameters:
session
–
the object which received the signal
src
–
the SSRC
udata
–
Flags: Run Last
on-ssrc-validated
on_ssrc_validated_callback (GstElement * param_0, guint arg0, gpointer udata)
def on_ssrc_validated_callback (param_0, arg0, udata):
#python callback for the 'on-ssrc-validated' signal
function on_ssrc_validated_callback(param_0: GstElement * param_0, arg0: guint arg0, udata: gpointer udata): {
// javascript callback for the 'on-ssrc-validated' signal
}
Parameters:
param_0
–
arg0
–
udata
–
Flags: Run Last
on-timeout
on_timeout_callback (GstElement * sess, guint ssrc, gpointer udata)
def on_timeout_callback (sess, ssrc, udata):
#python callback for the 'on-timeout' signal
function on_timeout_callback(sess: GstElement * sess, ssrc: guint ssrc, udata: gpointer udata): {
// javascript callback for the 'on-timeout' signal
}
Notify of an SSRC that has timed out
Parameters:
sess
–
the object which received the signal
ssrc
–
the SSRC
udata
–
Flags: Run Last
pad-added
pad_added_callback (GstElement * param_0, GstPad * arg0, gpointer udata)
def pad_added_callback (param_0, arg0, udata):
#python callback for the 'pad-added' signal
function pad_added_callback(param_0: GstElement * param_0, arg0: GstPad * arg0, udata: gpointer udata): {
// javascript callback for the 'pad-added' signal
}
Parameters:
param_0
–
arg0
–
udata
–
Flags: Run Last
pad-removed
pad_removed_callback (GstElement * param_0, GstPad * arg0, gpointer udata)
def pad_removed_callback (param_0, arg0, udata):
#python callback for the 'pad-removed' signal
function pad_removed_callback(param_0: GstElement * param_0, arg0: GstPad * arg0, udata: gpointer udata): {
// javascript callback for the 'pad-removed' signal
}
Parameters:
param_0
–
arg0
–
udata
–
Flags: Run Last
request-pt-map
GstCaps * request_pt_map_callback (GstElement * sess, guint pt, gpointer udata)
def request_pt_map_callback (sess, pt, udata):
#python callback for the 'request-pt-map' signal
function request_pt_map_callback(sess: GstElement * sess, pt: guint pt, udata: gpointer udata): {
// javascript callback for the 'request-pt-map' signal
}
Request the payload type as GstCaps for pt.
Parameters:
sess
–
the object which received the signal
pt
–
the pt
udata
–
Flags: Run Last
Properties
bandwidth
“bandwidth” gdouble
The bandwidth of the session in bytes per second (0 for auto-discover)
Flags : Read / Write
Default value : 0
max-dropout-time
“max-dropout-time” guint
The maximum time (milliseconds) of missing packets tolerated.
Flags : Read / Write
Default value : 60000
max-misorder-time
“max-misorder-time” guint
The maximum time (milliseconds) of misordered packets tolerated.
Flags : Read / Write
Default value : 2000
ntp-time-source
“ntp-time-source” GstRtpNtpTimeSource *
NTP time source for RTCP packets
Flags : Read / Write
Default value : ntp (0)
num-active-sources
“num-active-sources” guint
The number of active sources in the session
Flags : Read
Default value : 0
probation
“probation” guint
Consecutive packet sequence numbers to accept the source
Flags : Read / Write
Default value : 2
rtcp-fraction
“rtcp-fraction” gdouble
The RTCP bandwidth of the session in bytes per second (or as a real fraction of the RTP bandwidth if < 1.0)
Flags : Read / Write
Default value : 0.05
rtcp-min-interval
“rtcp-min-interval” guint64
Minimum interval between Regular RTCP packet (in ns)
Flags : Read / Write
Default value : 5000000000
rtcp-rr-bandwidth
“rtcp-rr-bandwidth” gint
The RTCP bandwidth used for receivers in bytes per second (-1 = default)
Flags : Read / Write
Default value : -1
rtcp-rs-bandwidth
“rtcp-rs-bandwidth” gint
The RTCP bandwidth used for senders in bytes per second (-1 = default)
Flags : Read / Write
Default value : -1
rtcp-sync-send-time
“rtcp-sync-send-time” gboolean
Use send time or capture time for RTCP sync (TRUE = send time, FALSE = capture time)
Flags : Read / Write
Default value : true
rtp-profile
“rtp-profile” GstRTPProfile *
RTP profile to use
Flags : Read / Write
Default value : avp (1)
stats
“stats” GstStructure *
Various statistics
Flags : Read
Default value :
application/x-rtp-session-stats, rtx-drop-count=(uint)0, sent-nack-count=(uint)0, recv-nack-count=(uint)0, source-stats=(GValueArray)< >, rtx-count=(uint)0, recv-rtx-req-count=(uint)0, sent-rtx-req-count=(uint)0;
use-pipeline-clock
“use-pipeline-clock” gboolean
Use the pipeline running-time to set the NTP time in the RTCP SR messages (DEPRECATED: Use ntp-time-source property)
Flags : Read / Write
Default value : false
Named constants
GstRtpNtpTimeSource
Members
ntp
(0) – NTP time based on realtime clock
unix
(1) – UNIX time based on realtime clock
running-time
(2) – Running time based on pipeline clock
clock-time
(3) – Pipeline clock time
Signals
get-source-by-ssrc
RTPSource * get_source_by_ssrc_callback (GstElement * session, guint ssrc, gpointer udata)
def get_source_by_ssrc_callback (session, ssrc, udata):
#python callback for the 'get-source-by-ssrc' signal
function get_source_by_ssrc_callback(session: GstElement * session, ssrc: guint ssrc, udata: gpointer udata): {
// javascript callback for the 'get-source-by-ssrc' signal
}
Request the RTPSource object with SSRC ssrc in session.
Parameters:
session
–
the object which received the signal
ssrc
–
the SSRC of the RTPSource
udata
–
on-app-rtcp
on_app_rtcp_callback (GstElement * session, guint subtype, guint ssrc, gchararray name, GstBuffer * data, gpointer udata)
def on_app_rtcp_callback (session, subtype, ssrc, name, data, udata):
#python callback for the 'on-app-rtcp' signal
function on_app_rtcp_callback(session: GstElement * session, subtype: guint subtype, ssrc: guint ssrc, name: gchararray name, data: GstBuffer * data, udata: gpointer udata): {
// javascript callback for the 'on-app-rtcp' signal
}
Notify that a RTCP APP packet has been received
Parameters:
session
–
the object which received the signal
subtype
–
The subtype of the packet
ssrc
–
The SSRC/CSRC of the packet
name
–
The name of the packet
udata
–
Flags: Run Last
on-bye-ssrc
on_bye_ssrc_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_bye_ssrc_callback (session, src, udata):
#python callback for the 'on-bye-ssrc' signal
function on_bye_ssrc_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-bye-ssrc' signal
}
Notify of an SSRC that became inactive because of a BYE packet.
Parameters:
session
–
the object which received the signal
src
–
the RTPSource that went away
udata
–
Flags: Run Last
on-bye-timeout
on_bye_timeout_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_bye_timeout_callback (session, src, udata):
#python callback for the 'on-bye-timeout' signal
function on_bye_timeout_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-bye-timeout' signal
}
Notify of an SSRC that has timed out because of BYE
Parameters:
session
–
the object which received the signal
src
–
the RTPSource that timed out
udata
–
Flags: Run Last
on-feedback-rtcp
on_feedback_rtcp_callback (GstElement * session, guint type, guint fbtype, guint sender_ssrc, guint media_ssrc, GstBuffer * fci, gpointer udata)
def on_feedback_rtcp_callback (session, type, fbtype, sender_ssrc, media_ssrc, fci, udata):
#python callback for the 'on-feedback-rtcp' signal
function on_feedback_rtcp_callback(session: GstElement * session, type: guint type, fbtype: guint fbtype, sender_ssrc: guint sender_ssrc, media_ssrc: guint media_ssrc, fci: GstBuffer * fci, udata: gpointer udata): {
// javascript callback for the 'on-feedback-rtcp' signal
}
Notify that a RTCP feedback packet has been received
Parameters:
session
–
the object which received the signal
type
–
Type of RTCP packet, will be GST_RTCP_TYPE_RTPFB or GST_RTCP_TYPE_RTPFB
fbtype
–
The type of RTCP FB packet, probably part of GstRTCPFBType
sender_ssrc
–
The SSRC of the sender
media_ssrc
–
The SSRC of the media this refers to
udata
–
Flags: Run Last
on-new-sender-ssrc
on_new_sender_ssrc_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_new_sender_ssrc_callback (session, src, udata):
#python callback for the 'on-new-sender-ssrc' signal
function on_new_sender_ssrc_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-new-sender-ssrc' signal
}
Notify of a new sender SSRC that entered session.
Parameters:
session
–
the object which received the signal
src
–
the new sender RTPSource
udata
–
Flags: Run Last
Since : 1.8
on-new-ssrc
on_new_ssrc_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_new_ssrc_callback (session, src, udata):
#python callback for the 'on-new-ssrc' signal
function on_new_ssrc_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-new-ssrc' signal
}
Notify of a new SSRC that entered session.
Parameters:
session
–
the object which received the signal
src
–
the new RTPSource
udata
–
Flags: Run Last
on-receiving-rtcp
on_receiving_rtcp_callback (GstElement * session, GstBuffer * buffer, gpointer udata)
def on_receiving_rtcp_callback (session, buffer, udata):
#python callback for the 'on-receiving-rtcp' signal
function on_receiving_rtcp_callback(session: GstElement * session, buffer: GstBuffer * buffer, udata: gpointer udata): {
// javascript callback for the 'on-receiving-rtcp' signal
}
This signal is emitted when receiving an RTCP packet before it is handled by the session. It can be used to extract custom information from RTCP packets.
Parameters:
session
–
the object which received the signal
buffer
–
the GstBuffer containing the RTCP packet that was received
udata
–
Flags: Run Last
Since : 1.6
on-sender-ssrc-active
on_sender_ssrc_active_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_sender_ssrc_active_callback (session, src, udata):
#python callback for the 'on-sender-ssrc-active' signal
function on_sender_ssrc_active_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-sender-ssrc-active' signal
}
Notify of a sender SSRC that is active, i.e., sending RTCP.
Parameters:
session
–
the object which received the signal
src
–
the active sender RTPSource
udata
–
Flags: Run Last
Since : 1.8
on-sender-timeout
on_sender_timeout_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_sender_timeout_callback (session, src, udata):
#python callback for the 'on-sender-timeout' signal
function on_sender_timeout_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-sender-timeout' signal
}
Notify of an SSRC that was a sender but timed out and became a receiver.
Parameters:
session
–
the object which received the signal
src
–
the RTPSource that timed out
udata
–
Flags: Run Last
on-sending-nacks
guint on_sending_nacks_callback (GstElement * param_0, guint arg0, guint arg1, GArray * arg2, GstBuffer * arg3, gpointer udata)
def on_sending_nacks_callback (param_0, arg0, arg1, arg2, arg3, udata):
#python callback for the 'on-sending-nacks' signal
function on_sending_nacks_callback(param_0: GstElement * param_0, arg0: guint arg0, arg1: guint arg1, arg2: GArray * arg2, arg3: GstBuffer * arg3, udata: gpointer udata): {
// javascript callback for the 'on-sending-nacks' signal
}
Parameters:
param_0
–
arg0
–
arg1
–
arg2
–
arg3
–
udata
–
Flags: Run Last
on-sending-rtcp
gboolean on_sending_rtcp_callback (GstElement * session, GstBuffer * buffer, gboolean early, gpointer udata)
def on_sending_rtcp_callback (session, buffer, early, udata):
#python callback for the 'on-sending-rtcp' signal
function on_sending_rtcp_callback(session: GstElement * session, buffer: GstBuffer * buffer, early: gboolean early, udata: gpointer udata): {
// javascript callback for the 'on-sending-rtcp' signal
}
This signal is emitted before sending an RTCP packet, it can be used to add extra RTCP Packets.
Parameters:
session
–
the object which received the signal
buffer
–
the GstBuffer containing the RTCP packet about to be sent
udata
–
Flags: Run Last
on-ssrc-active
on_ssrc_active_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_ssrc_active_callback (session, src, udata):
#python callback for the 'on-ssrc-active' signal
function on_ssrc_active_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-ssrc-active' signal
}
Notify of a SSRC that is active, i.e., sending RTCP.
Parameters:
session
–
the object which received the signal
src
–
the active RTPSource
udata
–
Flags: Run Last
on-ssrc-collision
on_ssrc_collision_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_ssrc_collision_callback (session, src, udata):
#python callback for the 'on-ssrc-collision' signal
function on_ssrc_collision_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-ssrc-collision' signal
}
Notify when we have an SSRC collision
Parameters:
session
–
the object which received the signal
src
–
the RTPSource that caused a collision
udata
–
Flags: Run Last
on-ssrc-sdes
on_ssrc_sdes_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_ssrc_sdes_callback (session, src, udata):
#python callback for the 'on-ssrc-sdes' signal
function on_ssrc_sdes_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-ssrc-sdes' signal
}
Notify that a new SDES was received for SSRC.
Parameters:
session
–
the object which received the signal
src
–
the RTPSource
udata
–
Flags: Run Last
on-ssrc-validated
on_ssrc_validated_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_ssrc_validated_callback (session, src, udata):
#python callback for the 'on-ssrc-validated' signal
function on_ssrc_validated_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-ssrc-validated' signal
}
Notify of a new SSRC that became validated.
Parameters:
session
–
the object which received the signal
src
–
the new validated RTPSource
udata
–
Flags: Run Last
on-timeout
on_timeout_callback (GstElement * session, RTPSource * src, gpointer udata)
def on_timeout_callback (session, src, udata):
#python callback for the 'on-timeout' signal
function on_timeout_callback(session: GstElement * session, src: RTPSource * src, udata: gpointer udata): {
// javascript callback for the 'on-timeout' signal
}
Notify of an SSRC that has timed out
Parameters:
session
–
the object which received the signal
src
–
the RTPSource that timed out
udata
–
Flags: Run Last
send-rtcp
send_rtcp_callback (GstElement * session, guint64 max_delay, gpointer udata)
def send_rtcp_callback (session, max_delay, udata):
#python callback for the 'send-rtcp' signal
function send_rtcp_callback(session: GstElement * session, max_delay: guint64 max_delay, udata: gpointer udata): {
// javascript callback for the 'send-rtcp' signal
}
Requests that the RTPSession initiate a new RTCP packet as soon as possible within the requested delay.
This sets feedback to TRUE if not already done before.
Parameters:
session
–
the object which received the signal
max_delay
–
The maximum delay after which the feedback will not be useful anymore
udata
–
send-rtcp-full
gboolean send_rtcp_full_callback (GstElement * session, guint64 max_delay, gpointer udata)
def send_rtcp_full_callback (session, max_delay, udata):
#python callback for the 'send-rtcp-full' signal
function send_rtcp_full_callback(session: GstElement * session, max_delay: guint64 max_delay, udata: gpointer udata): {
// javascript callback for the 'send-rtcp-full' signal
}
Requests that the RTPSession initiate a new RTCP packet as soon as possible within the requested delay.
This sets feedback to TRUE if not already done before.
Parameters:
session
–
the object which received the signal
max_delay
–
The maximum delay after which the feedback will not be useful anymore
udata
–
TRUE if the new RTCP packet could be scheduled within the requested delay, FALSE otherwise.
Since : 1.6
Properties
bandwidth
“bandwidth” gdouble
The bandwidth of the session in bits per second (0 for auto-discover)
Flags : Read / Write
Default value : 0
disable-sr-timestamp
“disable-sr-timestamp” gboolean
Whether sender reports should be timestamped
Flags : Read / Write
Default value : false
favor-new
“favor-new” gboolean
Resolve SSRC conflict in favor of new sources
Flags : Read / Write
Default value : false
internal-source
“internal-source” RTPSource *
The internal source element of the session (deprecated)
Flags : Read
internal-ssrc
“internal-ssrc” guint
The internal SSRC used for the session (deprecated)
Flags : Read / Write
Default value : 0
max-dropout-time
“max-dropout-time” guint
The maximum time (milliseconds) of missing packets tolerated.
Flags : Read / Write
Default value : 60000
max-misorder-time
“max-misorder-time” guint
The maximum time (milliseconds) of misordered packets tolerated.
Flags : Read / Write
Default value : 2000
num-active-sources
“num-active-sources” guint
The number of active sources in the session
Flags : Read
Default value : 0
probation
“probation” guint
Consecutive packet sequence numbers to accept the source
Flags : Read / Write
Default value : 2
rtcp-feedback-retention-window
“rtcp-feedback-retention-window” guint64
Duration during which RTCP Feedback packets are retained (in ns)
Flags : Read / Write
Default value : 2000000000
rtcp-fraction
“rtcp-fraction” gdouble
The fraction of the bandwidth used for RTCP in bits per second (or as a real fraction of the RTP bandwidth if < 1)
Flags : Read / Write
Default value : 0.05
rtcp-immediate-feedback-threshold
“rtcp-immediate-feedback-threshold” guint
The maximum number of members of a RTP session for which immediate feedback is used (DEPRECATED: has no effect and is not needed)
Flags : Read / Write
Default value : 3
rtcp-min-interval
“rtcp-min-interval” guint64
Minimum interval between Regular RTCP packet (in ns)
Flags : Read / Write
Default value : 5000000000
rtcp-mtu
“rtcp-mtu” guint
The maximum size of the RTCP packets
Flags : Read / Write
Default value : 1400
rtcp-reduced-size
“rtcp-reduced-size” gboolean
Use Reduced Size RTCP for feedback packets
Flags : Read / Write
Default value : false
rtcp-rr-bandwidth
“rtcp-rr-bandwidth” gint
The RTCP bandwidth used for receivers in bits per second (-1 = default)
Flags : Read / Write
Default value : -1
rtcp-rs-bandwidth
“rtcp-rs-bandwidth” gint
The RTCP bandwidth used for senders in bits per second (-1 = default)
Flags : Read / Write
Default value : -1
rtp-profile
“rtp-profile” GstRTPProfile *
RTP profile to use for this session
Flags : Read / Write
Default value : avp (1)
stats
“stats” GstStructure *
Various statistics
Flags : Read
Default value :
application/x-rtp-session-stats, rtx-drop-count=(uint)0, sent-nack-count=(uint)0, recv-nack-count=(uint)0, source-stats=(GValueArray)< >;
RTPSource
GObject ╰──RTPSource
A source in the RTPSession
conflicting_addresses: GList of conflicting addresses
Properties
disable-rtcp
“disable-rtcp” gboolean
Disable sending RTCP packets for this source
Flags : Read / Write
Default value : false
is-csrc
“is-csrc” gboolean
If this SSRC is acting as a contributing source
Flags : Read
Default value : false
max-dropout-time
“max-dropout-time” guint
The maximum time (milliseconds) of missing packets tolerated.
Flags : Read / Write
Default value : 60000
max-misorder-time
“max-misorder-time” guint
The maximum time (milliseconds) of misordered packets tolerated.
Flags : Read / Write
Default value : 2000
probation
“probation” guint
Consecutive packet sequence numbers to accept the source
Flags : Read / Write
Default value : 2
sdes
“sdes” GstStructure *
The SDES information for this source
Flags : Read
Default value :
application/x-rtp-source-sdes;
stats
“stats” GstStructure *
The stats of this source
Flags : Read
Default value :
application/x-rtp-source-stats, ssrc=(uint)0, internal=(boolean)false, validated=(boolean)false, received-bye=(boolean)false, is-csrc=(boolean)false, is-sender=(boolean)false, seqnum-base=(int)-1, clock-rate=(int)-1, octets-sent=(guint64)0, packets-sent=(guint64)0, octets-received=(guint64)0, packets-received=(guint64)0, bytes-received=(guint64)0, bitrate=(guint64)0, packets-lost=(int)0, jitter=(uint)0, sent-pli-count=(uint)0, recv-pli-count=(uint)0, sent-fir-count=(uint)0, recv-fir-count=(uint)0, sent-nack-count=(uint)0, recv-nack-count=(uint)0, recv-packet-rate=(uint)0, have-sr=(boolean)false, sr-ntptime=(guint64)0, sr-rtptime=(uint)0, sr-octet-count=(uint)0, sr-packet-count=(uint)0, sent-rb=(boolean)false, sent-rb-fractionlost=(uint)0, sent-rb-packetslost=(int)0, sent-rb-exthighestseq=(uint)0, sent-rb-jitter=(uint)0, sent-rb-lsr=(uint)0, sent-rb-dlsr=(uint)0, have-rb=(boolean)false, rb-fractionlost=(uint)0, rb-packetslost=(int)0, rb-exthighestseq=(uint)0, rb-jitter=(uint)0, rb-lsr=(uint)0, rb-dlsr=(uint)0, rb-round-trip=(uint)0;
The results of the search are