# rtpbin

RTP bin combines the functions of , , and in one element. It allows for multiple RTP sessions that will be synchronized together using RTCP SR packets.

is configured with a number of request pads that define the functionality that is activated, similar to the element.

To use as an RTP receiver, request a recv_rtp_sink_%u pad. The session number must be specified in the pad name. Data received on the recv_rtp_sink_%u pad will be processed in the manager and after being validated forwarded on element. Each RTP stream is demuxed based on the SSRC and send to a . After the packets are released from the jitterbuffer, they will be forwarded to a element. The element will demux the packets based on the payload type and will create a unique pad recv_rtp_src_%u_%u_%u on rtpbin with the session number, SSRC and payload type respectively as the pad name.

To also use as an RTCP receiver, request a recv_rtcp_sink_%u pad. The session number must be specified in the pad name.

If you want the session manager to generate and send RTCP packets, request the send_rtcp_src_%u pad with the session number in the pad name. Packet pushed on this pad contain SR/RR RTCP reports that should be sent to all participants in the session.

To use as a sender, request a send_rtp_sink_%u pad, which will automatically create a send_rtp_src_%u pad. If the session number is not provided, the pad from the lowest available session will be returned. The session manager will modify the SSRC in the RTP packets to its own SSRC and will forward the packets on the send_rtp_src_%u pad after updating its internal state.

The session manager needs the clock-rate of the payload types it is handling and will signal the signal when it needs such a mapping. One can clear the cached values with the signal.

Access to the internal statistics of rtpbin is provided with the get-internal-session property. This action signal gives access to the RTPSession object which further provides action signals to retrieve the internal source and other sources.

also has signals (#GstRtpBin::request-rtp-encoder, , and ) to dynamically request for RTP and RTCP encoders and decoders in order to support SRTP. The encoders must provide the pads rtp_sink_%u and rtp_src_%u for RTP and rtcp_sink_%u and rtcp_src_%u for RTCP. The session number will be used in the pad name. The decoders must provide rtp_sink and rtp_src for RTP and rtcp_sink and rtcp_src for RTCP. The decoders will be placed before the element, thus they must support SSRC demuxing internally.

has signals (#GstRtpBin::request-aux-sender and to dynamically request an element that can be used to create or merge additional RTP streams. AUX elements are needed to implement FEC or retransmission (such as RFC 4588). An AUX sender must have one sink_%u pad that matches the sessionid in the signal and it should have 1 or more src_%u pads. For each src_%\u pad, a session will be made (if needed) and the pad will be linked to the session send_rtp_sink pad. Each session will then expose its source pad as send_rtp_src_%u on . An AUX receiver has 1 src_%u pad that much match the sessionid in the signal and 1 or more sink_%u pads. A session will be made for each sink_%u pad when the corresponding recv_rtp_sink_%u pad is requested on . The signal can be used to provide a custom element to perform arrival time smoothing, reordering and optionally packet loss detection and retransmission requests.

## Example pipelines

     gst-launch-1.0 udpsrc port=5000 caps="application/x-rtp, ..." ! .recv_rtp_sink_0 \
         rtpbin ! rtptheoradepay ! theoradec ! xvimagesink

Receive RTP data from port 5000 and send to the session 0 in rtpbin.

     gst-launch-1.0 rtpbin name=rtpbin \
             v4l2src ! videoconvert ! ffenc_h263 ! rtph263ppay ! rtpbin.send_rtp_sink_0 \
                       rtpbin.send_rtp_src_0 ! udpsink port=5000                            \
                       rtpbin.send_rtcp_src_0 ! udpsink port=5001 sync=false async=false    \
                       udpsrc port=5005 ! rtpbin.recv_rtcp_sink_0                           \
             audiotestsrc ! amrnbenc ! rtpamrpay ! rtpbin.send_rtp_sink_1                   \
                       rtpbin.send_rtp_src_1 ! udpsink port=5002                            \
                       rtpbin.send_rtcp_src_1 ! udpsink port=5003 sync=false async=false    \
                       udpsrc port=5007 ! rtpbin.recv_rtcp_sink_1

Encode and payload H263 video captured from a v4l2src. Encode and payload AMR audio generated from audiotestsrc. The video is sent to session 0 in rtpbin and the audio is sent to session 1. Video packets are sent on UDP port 5000 and audio packets on port 5002. The video RTCP packets for session 0 are sent on port 5001 and the audio RTCP packets for session 0 are sent on port 5003. RTCP packets for session 0 are received on port 5005 and RTCP for session 1 is received on port 5007. Since RTCP packets from the sender should be sent as soon as possible and do not participate in preroll, sync=false and async=false is configured on udpsink

     gst-launch-1.0 -v rtpbin name=rtpbin                                          \
         udpsrc caps="application/x-rtp,media=(string)video,clock-rate=(int)90000,encoding-name=(string)H263-1998" \
                 port=5000 ! rtpbin.recv_rtp_sink_0                                \
             rtpbin. ! rtph263pdepay ! ffdec_h263 ! xvimagesink                    \
          udpsrc port=5001 ! rtpbin.recv_rtcp_sink_0                               \
          rtpbin.send_rtcp_src_0 ! udpsink port=5005 sync=false async=false        \
         udpsrc caps="application/x-rtp,media=(string)audio,clock-rate=(int)8000,encoding-name=(string)AMR,encoding-params=(string)1,octet-align=(string)1" \
                 port=5002 ! rtpbin.recv_rtp_sink_1                                \
             rtpbin. ! rtpamrdepay ! amrnbdec ! alsasink                           \
          udpsrc port=5003 ! rtpbin.recv_rtcp_sink_1                               \
          rtpbin.send_rtcp_src_1 ! udpsink port=5007 sync=false async=false

Receive H263 on port 5000, send it through rtpbin in session 0, depayload, decode and display the video. Receive AMR on port 5002, send it through rtpbin in session 1, depayload, decode and play the audio. Receive server RTCP packets for session 0 on port 5001 and RTCP packets for session 1 on port 5003. These packets will be used for session management and synchronisation. Send RTCP reports for session 0 on port 5005 and RTCP reports for session 1 on port 5007.

## Hierarchy

    GObject
        ╰──GInitiallyUnowned
            ╰──GstObject
                ╰──GstElement
                    ╰──GstBin
                        ╰──rtpbin

## Implemented interfaces

    GstChildProxy

## Factory details

Authors: – Wim Taymans

Classification: – `Filter/Network/RTP`

Rank – none

Plugin – rtpmanager

Package – GStreamer Good Plug-ins

## Pad Templates

### `recv_fec_sink_%u_%u`

Sink template for receiving Forward Error Correction packets, in the form recv_fec_sink_<session_idx>_<fec_stream_idx>

See for example usage

    application/x-rtp:

Presence – request

Direction – sink

Object type – GstPad

### `recv_rtcp_sink_%u`

    application/x-rtcp:
    application/x-srtcp:

Presence – request

Direction – sink

Object type – GstPad

### `recv_rtp_sink_%u`

    application/x-rtp:
    application/x-srtp:

Presence – request

Direction – sink

Object type – GstPad

### `recv_rtp_src_%u_%u_%u`

    application/x-rtp:

Presence – sometimes

Direction – src

Object type – GstPad

### `send_fec_src_%u_%u`

Src template for sending Forward Error Correction packets, in the form send_fec_src_<session_idx>_<fec_stream_idx>

See for example usage

    application/x-rtp:

Presence – sometimes

Direction – src

Object type – GstPad

### `send_rtcp_src_%u`

    application/x-rtcp:
    application/x-srtcp:

Presence – request

Direction – src

Object type – GstPad

### `send_rtp_sink_%u`

    application/x-rtp:

Presence – request

Direction – sink

Object type – GstPad

### `send_rtp_src_%u`

    application/x-rtp:
    application/x-srtp:

Presence – sometimes

Direction – src

Object type – GstPad

## Signals

### new-jitterbuffer

    new_jitterbuffer_callback (GstElement * rtpbin,
                               GstElement * jitterbuffer,
                               guint session,
                               guint ssrc,
                               gpointer udata)

    def new_jitterbuffer_callback (rtpbin, jitterbuffer, session, ssrc, udata):
        #python callback for the 'new-jitterbuffer' signal

    function new_jitterbuffer_callback(rtpbin: GstElement * rtpbin, jitterbuffer: GstElement * jitterbuffer, session: guint session, ssrc: guint ssrc, udata: gpointer udata): {
        // javascript callback for the 'new-jitterbuffer' signal
    }

Notify that a new jitterbuffer was created for session and ssrc. This signal can, for example, be used to configure jitterbuffer.

Parameters:

`rtpbin` –

the object which received the signal

`jitterbuffer` –

the new jitterbuffer

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

Since : 1.4

### new-storage

    new_storage_callback (GstElement * rtpbin,
                          GstElement * storage,
                          guint session,
                          gpointer udata)

    def new_storage_callback (rtpbin, storage, session, udata):
        #python callback for the 'new-storage' signal

    function new_storage_callback(rtpbin: GstElement * rtpbin, storage: GstElement * storage, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'new-storage' signal
    }

Notify that a new storage was created for session. This signal can, for example, be used to configure storage.

Parameters:

`rtpbin` –

the object which received the signal

`storage` –

the new storage

`session` –

the session

`udata` –
No description available

Flags: Run Last

Since : 1.14

### on-bye-ssrc

    on_bye_ssrc_callback (GstElement * rtpbin,
                          guint session,
                          guint ssrc,
                          gpointer udata)

    def on_bye_ssrc_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-bye-ssrc' signal

    function on_bye_ssrc_callback(rtpbin: GstElement * rtpbin, session: guint session, 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:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### on-bye-timeout

    on_bye_timeout_callback (GstElement * rtpbin,
                             guint session,
                             guint ssrc,
                             gpointer udata)

    def on_bye_timeout_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-bye-timeout' signal

    function on_bye_timeout_callback(rtpbin: GstElement * rtpbin, session: guint session, 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:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### on-new-sender-ssrc

    on_new_sender_ssrc_callback (GstElement * rtpbin,
                                 guint session,
                                 guint ssrc,
                                 gpointer udata)

    def on_new_sender_ssrc_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-new-sender-ssrc' signal

    function on_new_sender_ssrc_callback(rtpbin: GstElement * rtpbin, session: guint session, 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:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the sender SSRC

`udata` –
No description available

Flags: Run Last

Since : 1.8

### on-new-ssrc

    on_new_ssrc_callback (GstElement * rtpbin,
                          guint session,
                          guint ssrc,
                          gpointer udata)

    def on_new_ssrc_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-new-ssrc' signal

    function on_new_ssrc_callback(rtpbin: GstElement * rtpbin, session: guint session, ssrc: guint ssrc, udata: gpointer udata): {
        // javascript callback for the 'on-new-ssrc' signal
    }

Notify of a new SSRC that entered session.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### on-npt-stop

    on_npt_stop_callback (GstElement * rtpbin,
                          guint session,
                          guint ssrc,
                          gpointer udata)

    def on_npt_stop_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-npt-stop' signal

    function on_npt_stop_callback(rtpbin: GstElement * rtpbin, session: guint session, ssrc: guint ssrc, udata: gpointer udata): {
        // javascript callback for the 'on-npt-stop' signal
    }

Notify that SSRC sender has sent data up to the configured NPT stop time.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### on-sender-ssrc-active

    on_sender_ssrc_active_callback (GstElement * rtpbin,
                                    guint session,
                                    guint ssrc,
                                    gpointer udata)

    def on_sender_ssrc_active_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-sender-ssrc-active' signal

    function on_sender_ssrc_active_callback(rtpbin: GstElement * rtpbin, session: guint session, 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:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the sender SSRC

`udata` –
No description available

Flags: Run Last

Since : 1.8

### on-sender-timeout

    on_sender_timeout_callback (GstElement * rtpbin,
                                guint session,
                                guint ssrc,
                                gpointer udata)

    def on_sender_timeout_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-sender-timeout' signal

    function on_sender_timeout_callback(rtpbin: GstElement * rtpbin, session: guint session, 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:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### on-ssrc-active

    on_ssrc_active_callback (GstElement * rtpbin,
                             guint session,
                             guint ssrc,
                             gpointer udata)

    def on_ssrc_active_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-ssrc-active' signal

    function on_ssrc_active_callback(rtpbin: GstElement * rtpbin, session: guint session, 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:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### on-ssrc-collision

    on_ssrc_collision_callback (GstElement * rtpbin,
                                guint session,
                                guint ssrc,
                                gpointer udata)

    def on_ssrc_collision_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-ssrc-collision' signal

    function on_ssrc_collision_callback(rtpbin: GstElement * rtpbin, session: guint session, ssrc: guint ssrc, udata: gpointer udata): {
        // javascript callback for the 'on-ssrc-collision' signal
    }

Notify when we have an SSRC collision

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### on-ssrc-sdes

    on_ssrc_sdes_callback (GstElement * rtpbin,
                           guint session,
                           guint ssrc,
                           gpointer udata)

    def on_ssrc_sdes_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-ssrc-sdes' signal

    function on_ssrc_sdes_callback(rtpbin: GstElement * rtpbin, session: guint session, ssrc: guint ssrc, udata: gpointer udata): {
        // javascript callback for the 'on-ssrc-sdes' signal
    }

Notify of a SSRC that is active, i.e., sending RTCP.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### on-ssrc-validated

    on_ssrc_validated_callback (GstElement * rtpbin,
                                guint session,
                                guint ssrc,
                                gpointer udata)

    def on_ssrc_validated_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-ssrc-validated' signal

    function on_ssrc_validated_callback(rtpbin: GstElement * rtpbin, session: guint session, ssrc: guint ssrc, udata: gpointer udata): {
        // javascript callback for the 'on-ssrc-validated' signal
    }

Notify of a new SSRC that became validated.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### on-timeout

    on_timeout_callback (GstElement * rtpbin,
                         guint session,
                         guint ssrc,
                         gpointer udata)

    def on_timeout_callback (rtpbin, session, ssrc, udata):
        #python callback for the 'on-timeout' signal

    function on_timeout_callback(rtpbin: GstElement * rtpbin, session: guint session, ssrc: guint ssrc, udata: gpointer udata): {
        // javascript callback for the 'on-timeout' signal
    }

Notify of an SSRC that has timed out

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`ssrc` –

the SSRC

`udata` –
No description available

Flags: Run Last

### payload-type-change

    payload_type_change_callback (GstElement * rtpbin,
                                  guint session,
                                  guint pt,
                                  gpointer udata)

    def payload_type_change_callback (rtpbin, session, pt, udata):
        #python callback for the 'payload-type-change' signal

    function payload_type_change_callback(rtpbin: GstElement * rtpbin, session: guint session, pt: guint pt, udata: gpointer udata): {
        // javascript callback for the 'payload-type-change' signal
    }

Signal that the current payload type changed to pt in session.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`pt` –

the pt

`udata` –
No description available

Flags: Run Last

### request-aux-receiver

    GstElement *
    request_aux_receiver_callback (GstElement * rtpbin,
                                   guint session,
                                   gpointer udata)

    def request_aux_receiver_callback (rtpbin, session, udata):
        #python callback for the 'request-aux-receiver' signal

    function request_aux_receiver_callback(rtpbin: GstElement * rtpbin, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'request-aux-receiver' signal
    }

Request an AUX receiver element for the given session. The AUX element will be added to the bin.

If no handler is connected, no AUX element will be used.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.4

### request-aux-sender

    GstElement *
    request_aux_sender_callback (GstElement * rtpbin,
                                 guint session,
                                 gpointer udata)

    def request_aux_sender_callback (rtpbin, session, udata):
        #python callback for the 'request-aux-sender' signal

    function request_aux_sender_callback(rtpbin: GstElement * rtpbin, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'request-aux-sender' signal
    }

Request an AUX sender element for the given session. The AUX element will be added to the bin.

If no handler is connected, no AUX element will be used.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.4

### request-fec-decoder

    GstElement *
    request_fec_decoder_callback (GstElement * rtpbin,
                                  guint session,
                                  gpointer udata)

    def request_fec_decoder_callback (rtpbin, session, udata):
        #python callback for the 'request-fec-decoder' signal

    function request_fec_decoder_callback(rtpbin: GstElement * rtpbin, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'request-fec-decoder' signal
    }

Request a FEC decoder element for the given session. The element will be added to the bin after the pt demuxer. If there are multiple ssrc's and pt's in session, this signal may be called multiple times for the same session each corresponding to a newly discovered ssrc.

If no handler is connected, no FEC decoder will be used.

Warning: usage of this signal is not appropriate for the BUNDLE case, connect to instead.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session index

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.14

### request-fec-decoder-full

    GstElement *
    request_fec_decoder_full_callback (GstElement * rtpbin,
                                       guint session,
                                       guint ssrc,
                                       guint pt,
                                       gpointer udata)

    def request_fec_decoder_full_callback (rtpbin, session, ssrc, pt, udata):
        #python callback for the 'request-fec-decoder-full' signal

    function request_fec_decoder_full_callback(rtpbin: GstElement * rtpbin, session: guint session, ssrc: guint ssrc, pt: guint pt, udata: gpointer udata): {
        // javascript callback for the 'request-fec-decoder-full' signal
    }

Request a FEC decoder element for the given session. The element will be added to the bin after the pt demuxer. If there are multiple ssrc's and pt's in session, this signal may be called multiple times for the same session each corresponding to a newly discovered ssrc and payload type, those are provided as parameters.

If no handler is connected, no FEC decoder will be used.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session index

`ssrc` –

the ssrc of the stream

`pt` –

the payload type

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.20

### request-fec-encoder

    GstElement *
    request_fec_encoder_callback (GstElement * rtpbin,
                                  guint session,
                                  gpointer udata)

    def request_fec_encoder_callback (rtpbin, session, udata):
        #python callback for the 'request-fec-encoder' signal

    function request_fec_encoder_callback(rtpbin: GstElement * rtpbin, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'request-fec-encoder' signal
    }

Request a FEC encoder element for the given session. The element will be added to the bin after the RTPSession.

If no handler is connected, no FEC encoder will be used.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session index

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.14

### request-jitterbuffer

    GstElement *
    request_jitterbuffer_callback (GstElement * rtpbin,
                                   guint session,
                                   gpointer udata)

    def request_jitterbuffer_callback (rtpbin, session, udata):
        #python callback for the 'request-jitterbuffer' signal

    function request_jitterbuffer_callback(rtpbin: GstElement * rtpbin, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'request-jitterbuffer' signal
    }

Request a jitterbuffer element for the given session.

If no handler is connected, the default jitterbuffer will be used.

Note: The provided element is expected to conform to the API exposed by the standard . Runtime checks will be made to determine whether it exposes properties and signals before attempting to set, call or connect to them, and some functionalities of may not be available when that is not the case.

This should be considered experimental API, as the standard jitterbuffer API is susceptible to change, provided elements will have to update their custom jitterbuffer's API to match the API of if and when it changes.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.18

### request-pt-map

    GstCaps *
    request_pt_map_callback (GstElement * rtpbin,
                             guint session,
                             guint pt,
                             gpointer udata)

    def request_pt_map_callback (rtpbin, session, pt, udata):
        #python callback for the 'request-pt-map' signal

    function request_pt_map_callback(rtpbin: GstElement * rtpbin, session: guint session, pt: guint pt, udata: gpointer udata): {
        // javascript callback for the 'request-pt-map' signal
    }

Request the payload type as GstCaps for pt in session.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`pt` –

the pt

`udata` –
No description available
Returns (GstCaps *) –
No description available

Flags: Run Last

### request-rtcp-decoder

    GstElement *
    request_rtcp_decoder_callback (GstElement * rtpbin,
                                   guint session,
                                   gpointer udata)

    def request_rtcp_decoder_callback (rtpbin, session, udata):
        #python callback for the 'request-rtcp-decoder' signal

    function request_rtcp_decoder_callback(rtpbin: GstElement * rtpbin, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'request-rtcp-decoder' signal
    }

Request an RTCP decoder element for the given session. The decoder element will be added to the bin if not previously added.

If no handler is connected, no encoder will be used.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.4

### request-rtcp-encoder

    GstElement *
    request_rtcp_encoder_callback (GstElement * rtpbin,
                                   guint session,
                                   gpointer udata)

    def request_rtcp_encoder_callback (rtpbin, session, udata):
        #python callback for the 'request-rtcp-encoder' signal

    function request_rtcp_encoder_callback(rtpbin: GstElement * rtpbin, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'request-rtcp-encoder' signal
    }

Request an RTCP encoder element for the given session. The encoder element will be added to the bin if not previously added.

If no handler is connected, no encoder will be used.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.4

### request-rtp-decoder

    GstElement *
    request_rtp_decoder_callback (GstElement * rtpbin,
                                  guint session,
                                  gpointer udata)

    def request_rtp_decoder_callback (rtpbin, session, udata):
        #python callback for the 'request-rtp-decoder' signal

    function request_rtp_decoder_callback(rtpbin: GstElement * rtpbin, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'request-rtp-decoder' signal
    }

Request an RTP decoder element for the given session. The decoder element will be added to the bin if not previously added.

If no handler is connected, no encoder will be used.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.4

### request-rtp-encoder

    GstElement *
    request_rtp_encoder_callback (GstElement * rtpbin,
                                  guint session,
                                  gpointer udata)

    def request_rtp_encoder_callback (rtpbin, session, udata):
        #python callback for the 'request-rtp-encoder' signal

    function request_rtp_encoder_callback(rtpbin: GstElement * rtpbin, session: guint session, udata: gpointer udata): {
        // javascript callback for the 'request-rtp-encoder' signal
    }

Request an RTP encoder element for the given session. The encoder element will be added to the bin if not previously added.

If no handler is connected, no encoder will be used.

Parameters:

`rtpbin` –

the object which received the signal

`session` –

the session

`udata` –
No description available
Returns (GstElement *) –
No description available

Flags: Run Last

Since : 1.4

## Action Signals

### clear-pt-map

    g_signal_emit_by_name (rtpbin, "clear-pt-map");

    ret = rtpbin.emit ("clear-pt-map")

    let ret = rtpbin.emit ("clear-pt-map");

Clear all previously cached pt-mapping obtained with .

Parameters:

`rtpbin` (GstElement *) –

the object which received the signal

Flags: Run Last / Action

### clear-ssrc

    g_signal_emit_by_name (rtpbin, "clear-ssrc", id, ssrc);

    ret = rtpbin.emit ("clear-ssrc", id, ssrc)

    let ret = rtpbin.emit ("clear-ssrc", id, ssrc);

Remove all pads from rtpssrcdemux element associated with the specified ssrc. This delegate the action signal to the rtpssrcdemux element associated with the specified session.

Parameters:

`rtpbin` (GstElement *) –

the object which received the signal

`id` (guint) –

the session id

`ssrc` (guint) –

the ssrc

Flags: Run Last / Action

Since : 1.20

### get-internal-session

    g_signal_emit_by_name (rtpbin, "get-internal-session", id, &ret);

    ret = rtpbin.emit ("get-internal-session", id)

    let ret = rtpbin.emit ("get-internal-session", id);

Request the internal RTPSession object as GObject in session id.

Parameters:

`rtpbin` (GstElement *) –

the object which received the signal

`id` (guint) –

the session id

Returns (RTPSession *) –
No description available

Flags: Run Last / Action

### get-internal-storage

    g_signal_emit_by_name (rtpbin, "get-internal-storage", id, &ret);

    ret = rtpbin.emit ("get-internal-storage", id)

    let ret = rtpbin.emit ("get-internal-storage", id);

Request the internal RTPStorage object as GObject in session id. This is the internal storage used by the RTPStorage element, which is used to keep a backlog of received RTP packets for the session id.

Parameters:

`rtpbin` (GstElement *) –

the object which received the signal

`id` (guint) –

the session id

Returns (GObject *) –
No description available

Flags: Run Last / Action

Since : 1.14

### get-session

    g_signal_emit_by_name (rtpbin, "get-session", id, &ret);

    ret = rtpbin.emit ("get-session", id)

    let ret = rtpbin.emit ("get-session", id);

Request the related GstRtpSession as GstElement related with session id.

Parameters:

`rtpbin` (GstElement *) –

the object which received the signal

`id` (guint) –

the session id

Returns (GstElement *) –
No description available

Flags: Run Last / Action

Since : 1.8

### get-storage

    g_signal_emit_by_name (rtpbin, "get-storage", id, &ret);

    ret = rtpbin.emit ("get-storage", id)

    let ret = rtpbin.emit ("get-storage", id);

Request the RTPStorage element as GObject in session id. This element is used to keep a backlog of received RTP packets for the session id.

Parameters:

`rtpbin` (GstElement *) –

the object which received the signal

`id` (guint) –

the session id

Returns (GstElement *) –
No description available

Flags: Run Last / Action

Since : 1.16

### reset-sync

    g_signal_emit_by_name (rtpbin, "reset-sync");

    ret = rtpbin.emit ("reset-sync")

    let ret = rtpbin.emit ("reset-sync");

Reset all currently configured lip-sync parameters and require new SR packets for all streams before lip-sync is attempted again.

Parameters:

`rtpbin` (GstElement *) –

the object which received the signal

Flags: Run Last / Action

## Properties

### add-reference-timestamp-meta

    “add-reference-timestamp-meta” gboolean

When syncing to a RFC7273 clock or after clock synchronization via RTCP or inband NTP-64 header extensions has happened, add GstReferenceTimestampMeta to buffers with the original reconstructed reference clock timestamp.

Flags : Read / Write

Default value : false

### autoremove

    “autoremove” gboolean

Automatically remove timed out sources

Flags : Read / Write

Default value : false

### buffer-mode

    “buffer-mode” RTPJitterBufferMode *

Control the buffering and timestamping mode used by the jitterbuffer.

Flags : Read / Write

Default value : slave (1)

### do-lost

    “do-lost” gboolean

Send an event downstream when a packet is lost

Flags : Read / Write

Default value : false

### do-retransmission

    “do-retransmission” gboolean

Enables RTP retransmission on all streams. To control retransmission on a per-SSRC basis, connect to the signal and set the property on the object instead.

Flags : Read / Write

Default value : false

### do-sync-event

    “do-sync-event” gboolean

Send event downstream when a stream is synchronized to the sender

Flags : Read / Write

Default value : false

### drop-on-latency

    “drop-on-latency” gboolean

Tells the jitterbuffer to never exceed the given latency in size

Flags : Read / Write

Default value : false

### fec-decoders

    “fec-decoders” GstStructure *

Used to provide a factory used to build the FEC decoder for a given session, as a command line alternative to .

Expects a GstStructure in the form session_id (gint) -> factory (string)

Flags : Read / Write

Default value :

    application/x-rtp-fec-decoders;

### fec-encoders

    “fec-encoders” GstStructure *

Used to provide a factory used to build the FEC encoder for a given session, as a command line alternative to .

Expects a GstStructure in the form session_id (gint) -> factory (string)

Flags : Read / Write

Default value :

    application/x-rtp-fec-encoders;

### ignore-pt

    “ignore-pt” gboolean

Do not demultiplex based on PT values

Flags : Read / Write

Default value : false

### latency

    “latency” guint

Default amount of ms to buffer in the jitterbuffers

Flags : Read / Write

Default value : 200

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

### max-rtcp-rtp-time-diff

    “max-rtcp-rtp-time-diff” gint

Maximum amount of time in ms that the RTP time in RTCP SRs is allowed to be ahead (-1 disabled)

Flags : Read / Write

Default value : 1000

### max-streams

    “max-streams” guint

The maximum number of streams to create for one session

Flags : Read / Write

Default value : -1

### max-ts-offset

    “max-ts-offset” gint64

Used to set an upper limit of how large a time offset may be. This is used to protect against unrealistic values as a result of either client,server or clock issues.

Flags : Read / Write

Default value : 3000000000

### max-ts-offset-adjustment

    “max-ts-offset-adjustment” guint64

Syncing time stamps to NTP time adds a time offset. This parameter specifies the maximum number of nanoseconds per frame that this time offset may be adjusted with. This is used to avoid sudden large changes to time stamps.

Flags : Read / Write

Default value : 0

### min-ts-offset

    “min-ts-offset” guint64

Used to set an lower limit for when a time offset is deemed large enough to be useful for sync corrections.

When streaming for instance audio, even very small ts_offsets cause audible glitches. This property is used for controlling how sensitive the adjustments should be to small deviations in ts_offset, occurring for instance due to jittery network conditions or system load.

Flags : Read / Write

Default value : 4000000

### ntp-sync

    “ntp-sync” gboolean

Set the NTP time from the sender reports as the running-time on the buffers. When both the sender and receiver have sychronized running-time, i.e. when the clock and base-time is shared between the receivers and the and the senders, this option can be used to synchronize receivers on multiple machines.

Flags : Read / Write

Default value : false

### ntp-time-source

    “ntp-time-source” GstRtpNtpTimeSource *

NTP time source for RTCP packets

Flags : Read / Write

Default value : ntp (0)

### rfc7273-sync

    “rfc7273-sync” gboolean

Synchronize received streams to the RFC7273 clock (requires clock and offset to be provided)

Flags : Read / Write

Default value : false

### rtcp-sync

    “rtcp-sync” Rtcpsync *

If not synchronizing (directly) to the NTP clock, determines how to sync the various streams.

Flags : Read / Write

Default value : always (0)

### rtcp-sync-interval

    “rtcp-sync-interval” guint

Determines how often to sync streams using RTCP data or inband NTP-64 header extensions.

Flags : Read / Write

Default value : 0

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

Sets the default RTP profile of newly created RTP sessions. The profile can be changed afterwards on a per-session basis.

Flags : Read / Write

Default value : avp (1)

### sdes

    “sdes” GstStructure *

The SDES items of this session

Flags : Read / Write

### ts-offset-smoothing-factor

    “ts-offset-smoothing-factor” guint

Controls the weighting between previous and current timestamp offsets in a running moving average (RMA): ts_offset_average(n) = ((ts-offset-smoothing-factor - 1) * ts_offset_average(n - 1) + ts_offset(n)) / ts-offset-smoothing-factor

This can stabilize the timestamp offset and prevent unnecessary skew corrections due to jitter introduced by network or system load.

Flags : Read / Write

Default value : 0

### update-ntp64-header-ext

    “update-ntp64-header-ext” gboolean

Whether RTP NTP header extension should be updated with actual NTP time. If not, use the NTP time from buffer timestamp metadata

Flags : Read / Write

Default value : true

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

### Rtcpsync

#### Members

`always` (0) – always
`initial` (1) – initial
`rtp-info` (2) – rtp-info

The results of the search are