## RTPSession

    GObject
        ╰──RTPSession

The RTP session manager object

### Signals

#### 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

`data` –

a GstBuffer with the application-dependant data or NULL if there was no data

`udata` –
No description available

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` –
No description available

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` –
No description available

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

`fci` –

a GstBuffer with the FCI data from the FB packet or NULL if there was no FCI

`udata` –
No description available

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` –
No description available

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` –
No description available

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` –
No description available

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` –
No description available

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` –
No description available

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` –
No description available
`arg0` –
No description available
`arg1` –
No description available
`arg2` –
No description available
`arg3` –
No description available
`udata` –
No description available
Returns ( guint ) –
No description available

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

`early` –

TRUE if the packet is early, FALSE if it is regular

`udata` –
No description available
Returns ( gboolean ) –

TRUE if the RTCP buffer should NOT be suppressed, FALSE if suppressing it is acceptable

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` –
No description available

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` –
No description available

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` –
No description available

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` –
No description available

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` –
No description available

Flags: Run Last

### Action Signals

#### get-source-by-ssrc

    g_signal_emit_by_name (session, "get-source-by-ssrc", ssrc, &ret);

    ret = session.emit ("get-source-by-ssrc", ssrc)

    let ret = session.emit ("get-source-by-ssrc", ssrc);

Request the RTPSource object with SSRC ssrc in session.

Parameters:

`session` ( GstElement * ) –

the object which received the signal

`ssrc` ( guint ) –

the SSRC of the RTPSource

Returns ( RTPSource * ) –
No description available

Flags: Run Last / Action

#### send-rtcp

    g_signal_emit_by_name (session, "send-rtcp", max_delay);

    ret = session.emit ("send-rtcp", max_delay)

    let ret = session.emit ("send-rtcp", max_delay);

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` ( GstElement * ) –

the object which received the signal

`max_delay` ( guint64 ) –

The maximum delay after which the feedback will not be useful anymore

Flags: Run Last / Action

#### send-rtcp-full

    g_signal_emit_by_name (session, "send-rtcp-full", max_delay, &ret);

    ret = session.emit ("send-rtcp-full", max_delay)

    let ret = session.emit ("send-rtcp-full", max_delay);

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` ( GstElement * ) –

the object which received the signal

`max_delay` ( guint64 ) –

The maximum delay after which the feedback will not be useful anymore

Returns ( gboolean ) –

TRUE if the new RTCP packet could be scheduled within the requested delay, FALSE otherwise.

Flags: Run Last / Action

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

#### num-sources

    “num-sources” guint

The number of 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)

#### sdes

    “sdes” GstStructure *

The SDES items of this session

Flags : Read / Write

#### sources

    “sources” GValueArray *

An array of all known sources in the session

Flags : Read

#### stats

    “stats” GstStructure *

Various session statistics. This property returns a GstStructure with name application/x-rtp-session-stats with the following fields:

- "rtx-drop-count" G_TYPE_UINT The number of retransmission events dropped (due to bandwidth constraints)
- "sent-nack-count" G_TYPE_UINT Number of NACKs sent
- "recv-nack-count" G_TYPE_UINT Number of NACKs received
- "source-stats" G_TYPE_BOXED GValueArray of stats for all RTP sources (Since 1.8)

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)<  >;

The results of the search are