rtp.h File Reference

#include "config_win32.h"
#include "config_unix.h"
#include <cstddef>
#include <cstdint>
#include "tv.h"
#include "video_codec.h"

Include dependency graph for rtp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	rtcp_app
struct	rtcp_rr
struct	rtcp_rx
struct	rtcp_sdes_item
struct	rtcp_sr
struct	rtp_event

Macros
#define	RTP_MAX_MTU   9000
#define	RTP_MAX_PACKET_LEN   (RTP_MAX_MTU+RTP_PACKET_HEADER_SIZE+MAX_PADDING)
#define	RTP_PACKET_HEADER_SIZE   ((int) (offsetof(rtp_packet, extn_type) - offsetof(rtp_packet, csrc) + sizeof ((rtp_packet *) 0)->extn_type))
#define	RTP_VERSION   2

Typedefs
typedef rtcp_app *(*	rtcp_app_callback) (struct rtp *session, uint32_t rtp_ts, int max_size)
typedef void(*	rtp_callback) (struct rtp *session, rtp_event *e)
typedef struct rtp *	rtp_t

Enumerations
enum	{ IPV4_HDR_LEN = 20 , IPV6_HDR_LEN = 40 , UDP_HDR_LEN = 8 , RTP_HDR_LEN = 12 }
enum	rtcp_sdes_type {   RTCP_SDES_END = 0 , RTCP_SDES_CNAME = 1 , RTCP_SDES_NAME = 2 , RTCP_SDES_EMAIL = 3 ,   RTCP_SDES_PHONE = 4 , RTCP_SDES_LOC = 5 , RTCP_SDES_TOOL = 6 , RTCP_SDES_NOTE = 7 ,   RTCP_SDES_PRIV = 8 }
enum	rtp_event_type {   RX_RTP , RX_RTP_IOV , RX_SR , RX_RR ,   RX_TFRC_RX , RX_SDES , RX_BYE , SOURCE_CREATED ,   SOURCE_DELETED , RX_RR_EMPTY , RX_RTCP_START , RX_RTCP_FINISH ,   RR_TIMEOUT , RX_APP , PEEK_RTP }
enum	rtp_option {   RTP_OPT_PROMISC = 1 , RTP_OPT_WEAK_VALIDATION = 2 , RTP_OPT_FILTER_MY_PACKETS = 3 , RTP_OPT_REUSE_PACKET_BUFS = 4 ,   RTP_OPT_PEEK = 5 , RTP_OPT_RECORD_SOURCE = 6 , RTP_OPT_SEND_BACK = 7 }

Functions
struct	__attribute__ ((packed))
bool	rtcp_recv_r (struct rtp *session, struct timeval *timeout, uint32_t curr_rtp_ts)
bool	rtp_add_csrc (struct rtp *session, uint32_t csrc)
void	rtp_async_start (struct rtp *session, int nr_packets)
void	rtp_async_wait (struct rtp *session)
int	rtp_compute_fract_lost (struct rtp *session, uint32_t ssrc)
bool	rtp_del_csrc (struct rtp *session, uint32_t csrc)
void	rtp_done (struct rtp *session)
void	rtp_flush_recv_buf (struct rtp *session)
uint64_t	rtp_get_bytes_sent (struct rtp *session)
bool	rtp_get_option (struct rtp *session, rtp_option optname, int *optval)
int	rtp_get_recv_buf (struct rtp *session)
const rtcp_rr *	rtp_get_rr (struct rtp *session, uint32_t reporter, uint32_t reportee)
const char *	rtp_get_sdes (struct rtp *session, uint32_t ssrc, rtcp_sdes_type type)
const rtcp_sr *	rtp_get_sr (struct rtp *session, uint32_t ssrc)
struct socket_udp_local *	rtp_get_udp_local_socket (struct rtp *session)
int	rtp_get_udp_rx_port (struct rtp *session)
uint8_t *	rtp_get_userdata (struct rtp *session)
bool	rtp_has_receiver (struct rtp *session)
rtp_t	rtp_init (const char *addr, uint16_t rx_port, uint16_t tx_port, int ttl, double rtcp_bw, int tfrc_on, rtp_callback callback, uint8_t *userdata, int force_ip_version, bool multithreaded)
rtp_t	rtp_init_if (const char *addr, const char *iface, uint16_t rx_port, uint16_t tx_port, int ttl, double rtcp_bw, int tfrc_on, rtp_callback callback, uint8_t *userdata, int force_ip_version, bool multithreaded)
rtp_t	rtp_init_with_udp_socket (struct socket_udp_local *l, struct sockaddr *sa, socklen_t len, rtp_callback callback)
bool	rtp_is_ipv6 (struct rtp *session)
uint32_t	rtp_my_ssrc (struct rtp *session)
bool	rtp_recv (struct rtp *session, struct timeval *timeout, uint32_t curr_rtp_ts) __attribute__((deprecated))
int	rtp_recv_poll_r (struct rtp **sessions, struct timeval *timeout, uint32_t curr_rtp_ts)
bool	rtp_recv_r (struct rtp *session, struct timeval *timeout, uint32_t curr_rtp_ts)
	Receive RTP packets and dispatch them.
void	rtp_send_bye (struct rtp *session)
void	rtp_send_ctrl (struct rtp *session, uint32_t rtp_ts, rtcp_app_callback appcallback, time_ns_t curr_time)
int	rtp_send_data (struct rtp *session, uint32_t rtp_ts, char pt, int m, int cc, const uint32_t *csrc, char *data, int data_len, char *extn, uint16_t extn_len, uint16_t extn_type)
int	rtp_send_data_hdr (struct rtp *session, uint32_t rtp_ts, char pt, int m, int cc, const uint32_t *csrc, char *phdr, int phdr_len, char *data, int data_len, char *extn, uint16_t extn_len, uint16_t extn_type)
int	rtp_send_raw_rtp_data (struct rtp *session, char *buffer, int buffer_len)
bool	rtp_set_encryption_key (struct rtp *session, const char *passphrase)
bool	rtp_set_my_ssrc (struct rtp *session, uint32_t ssrc)
bool	rtp_set_option (struct rtp *session, rtp_option optname, int optval)
bool	rtp_set_recv_buf (struct rtp *session, int bufsize)
void	rtp_set_recv_iov (struct rtp *session, struct msghdr *m)
bool	rtp_set_sdes (struct rtp *session, uint32_t ssrc, rtcp_sdes_type type, const char *value, int length)
bool	rtp_set_send_buf (struct rtp *session, int bufsize)
void	rtp_update (struct rtp *session, time_ns_t curr_time)

Variables
	rtp_packet

Macro Definition Documentation

RTP_MAX_MTU

#define RTP_MAX_MTU   9000

Definition at line 60 of file rtp.h.

Referenced by adjust_params(), and tx_init().

RTP_MAX_PACKET_LEN

#define RTP_MAX_PACKET_LEN   (RTP_MAX_MTU+RTP_PACKET_HEADER_SIZE+MAX_PADDING)

Definition at line 61 of file rtp.h.

Referenced by audio_tx_send_chan(), decode_audio_frame(), decode_video_frame(), process_rtcp_app(), rtcp_recv_r(), rtp_process_data(), rtp_recv(), rtp_recv_data(), rtp_recv_poll_r(), rtp_recv_r(), rtp_send_bye(), rtp_send_bye_now(), rtp_send_data_hdr(), send_rtcp(), tx_send_base(), and udp_reader().

RTP_PACKET_HEADER_SIZE

#define RTP_PACKET_HEADER_SIZE   ((int) (offsetof(rtp_packet, extn_type) - offsetof(rtp_packet, csrc) + sizeof ((rtp_packet *) 0)->extn_type))

Definition at line 128 of file rtp.h.

Referenced by rtp_recv_data(), rtp_send_data_hdr(), and udp_reader().

RTP_VERSION

#define RTP_VERSION   2

Definition at line 59 of file rtp.h.

Referenced by format_rtcp_app().

Typedef Documentation

rtcp_app_callback

typedef rtcp_app *(* rtcp_app_callback) (struct rtp *session, uint32_t rtp_ts, int max_size)

Definition at line 205 of file rtp.h.

rtp_callback

typedef void(* rtp_callback) (struct rtp *session, rtp_event *e)

Definition at line 204 of file rtp.h.

rtp_t

typedef struct rtp* rtp_t

Definition at line 81 of file rtp.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
IPV4_HDR_LEN
IPV6_HDR_LEN
UDP_HDR_LEN
RTP_HDR_LEN

Definition at line 63 of file rtp.h.

     {
        IPV4_HDR_LEN = 20,
        IPV6_HDR_LEN = 40,
        UDP_HDR_LEN  = 8,
        RTP_HDR_LEN  = 12,
 
};

rtcp_sdes_type

enum rtcp_sdes_type

Enumerator
RTCP_SDES_END
RTCP_SDES_CNAME
RTCP_SDES_NAME
RTCP_SDES_EMAIL
RTCP_SDES_PHONE
RTCP_SDES_LOC
RTCP_SDES_TOOL
RTCP_SDES_NOTE
RTCP_SDES_PRIV

Definition at line 208 of file rtp.h.

              {
        RTCP_SDES_END   = 0,
        RTCP_SDES_CNAME = 1,
        RTCP_SDES_NAME  = 2,
        RTCP_SDES_EMAIL = 3,
        RTCP_SDES_PHONE = 4,
        RTCP_SDES_LOC   = 5,
        RTCP_SDES_TOOL  = 6,
        RTCP_SDES_NOTE  = 7,
        RTCP_SDES_PRIV  = 8
} rtcp_sdes_type;

rtp_event_type

enum rtp_event_type

Enumerator
RX_RTP
RX_RTP_IOV
RX_SR
RX_RR
RX_TFRC_RX
RX_SDES
RX_BYE
SOURCE_CREATED
SOURCE_DELETED
RX_RR_EMPTY
RX_RTCP_START
RX_RTCP_FINISH
RR_TIMEOUT
RX_APP
PEEK_RTP

Definition at line 179 of file rtp.h.

             {
        RX_RTP,
        RX_RTP_IOV,
        RX_SR,
        RX_RR,
        RX_TFRC_RX,     /* received TFRC extended report */
        RX_SDES,
        RX_BYE,         /* Source is leaving the session, database entry is still valid                           */
        SOURCE_CREATED,
        SOURCE_DELETED, /* Source has been removed from the database                                              */
        RX_RR_EMPTY,    /* We've received an empty reception report block                                         */
        RX_RTCP_START,  /* Processing a compound RTCP packet about to start. The SSRC is not valid in this event. */
        RX_RTCP_FINISH, /* Processing a compound RTCP packet finished. The SSRC is not valid in this event.       */
        RR_TIMEOUT,
        RX_APP,
        PEEK_RTP
} rtp_event_type;

rtp_option

enum rtp_option

Enumerator
RTP_OPT_PROMISC
RTP_OPT_WEAK_VALIDATION
RTP_OPT_FILTER_MY_PACKETS
RTP_OPT_REUSE_PACKET_BUFS
RTP_OPT_PEEK
RTP_OPT_RECORD_SOURCE
RTP_OPT_SEND_BACK

Definition at line 227 of file rtp.h.

             {
        RTP_OPT_PROMISC           = 1,
        RTP_OPT_WEAK_VALIDATION   = 2,
        RTP_OPT_FILTER_MY_PACKETS = 3,
        RTP_OPT_REUSE_PACKET_BUFS = 4,  /* Each data packet is written into the same buffer, */
                                        /* rather than malloc()ing a new buffer each time.   */
        RTP_OPT_PEEK              = 5,
        RTP_OPT_RECORD_SOURCE     = 6,  /* Record network source (sockaddr_storage) at the   */
                                        /* end of the packet                                 */
        RTP_OPT_SEND_BACK         = 7,  // Send to a receiver that is sending to us. Sets also
                                        // RTP_POT_RECORD_SOURCE
} rtp_option;

Function Documentation

__attribute__()

struct __attribute__

(

(packed)

)

Definition at line 81 of file rtp.h.

                                       {
        /* The following are pointers to the data in the packet as    */
        /* it came off the wire. The packet it read in such that the  */
        /* header maps onto the latter part of this struct, and the   */
        /* fields in this first part of the struct point into it. The */
        /* entire packet can be freed by freeing this struct, without */
        /* having to free the csrc, data and extn blocks separately.  */
        /* WARNING: Don't change the size of the first portion of the */
        /* struct without changing RTP_PACKET_HEADER_SIZE to match.   */
        uint32_t        *csrc;
        char            *data;
        int              data_len;
        unsigned char   *extn;
        uint16_t         extn_len;      /* Size of the extension in 32 bit words minus one */
        uint16_t         extn_type;     /* Extension type field in the RTP packet header   */
        /* The following map directly onto the RTP packet header...   */
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        unsigned short   v:2;           /* packet type                */
        unsigned short   p:1;           /* padding flag               */
        unsigned short   x:1;           /* header extension flag      */
        unsigned short   cc:4;          /* CSRC count                 */
        unsigned short   m:1;           /* marker bit                 */
        unsigned short   pt:7;          /* payload type               */
#else
        unsigned short   cc:4;          /* CSRC count                 */
        unsigned short   x:1;           /* header extension flag      */
        unsigned short   p:1;           /* padding flag               */
        unsigned short   v:2;           /* packet type                */
        unsigned short   pt:7;          /* payload type               */
        unsigned short   m:1;           /* marker bit                 */
#endif
        uint16_t          seq;          /* sequence number            */
        uint32_t          ts;           /* timestamp                  */
        uint32_t          ssrc;         /* synchronization source     */
        /* The csrc list, header extension and data follow, but can't */
        /* be represented in the struct.                              */
        uint32_t          send_ts;
        uint32_t          rtt;
} rtp_packet;

References __attribute__::data, seq, and ts.

Referenced by avg_lines(), compute_loss_event(), qfDES(), read_adobe_app14(), read_sos(), and rtp_send_data_hdr().

rtcp_recv_r()

bool rtcp_recv_r	(	struct rtp *	session,
		struct timeval *	timeout,
		uint32_t	curr_rtp_ts )

Similar to rtp_recv_r(), expect that it only receives data from RTCP socket. This should be used when the socket acts as a sender only, therefore rtp_recv_r() is not called. Running rtp_recv_r() instead would cause leaks in this context (because RTP packets are usually pushed into PBUF which is not processed by sender and thus it will grow indefinitely).

Definition at line 2398 of file rtp.c.

{
        UNUSED(curr_rtp_ts);
        struct udp_fd_r fd;
 
        check_database(session);
        udp_fd_zero_r(&fd);
        udp_fd_set_r(session->rtcp_socket, &fd);
        if (udp_select_r(timeout, &fd) > 0) {
                if (udp_fd_isset_r(session->rtcp_socket, &fd)) {
                        uint8_t buffer[RTP_MAX_PACKET_LEN];
                        int buflen;
                        session->rtcp_dest_len = sizeof(session->rtcp_dest);
                        buflen =
                                udp_recvfrom(session->rtcp_socket, (char *)buffer,
                                                RTP_MAX_PACKET_LEN,
                                                (struct sockaddr *) &session->rtcp_dest, &session->rtcp_dest_len);
                        rtp_process_ctrl(session, buffer, buflen);
                }
                check_database(session);
                return true;
        }
        check_database(session);
        return false;
}

References check_database(), rtp::rtcp_dest, rtp::rtcp_dest_len, rtp::rtcp_socket, RTP_MAX_PACKET_LEN, rtp_process_ctrl(), udp_fd_isset_r(), udp_fd_set_r(), udp_fd_zero_r(), udp_recvfrom(), udp_select_r(), and UNUSED.

Referenced by audio_sender_thread(), and ultragrid_rtp_video_rxtx::send_frame_async().

Here is the call graph for this function:

rtp_add_csrc()

bool rtp_add_csrc	(	struct rtp *	session,
		uint32_t	csrc )

rtp_add_csrc: @session: the session pointer (returned by rtp_init()) @csrc: Constributing SSRC identifier

Adds @csrc to list of contributing sources used in SDES items. Used by mixers and transcoders.

Return value: true.

Definition at line 2478 of file rtp.c.

{
        /* Mark csrc as something for which we should advertise RTCP SDES items, */
        /* in addition to our own SDES.                                          */
        source *s;
 
        check_database(session);
        s = get_source(session, csrc);
        if (s == NULL) {
                s = create_source(session, csrc, FALSE);
                debug_msg("Created source 0x%08x as CSRC\n", csrc);
        }
        check_source(s);
        if (!s->should_advertise_sdes) {
                s->should_advertise_sdes = TRUE;
                session->csrc_count++;
                debug_msg("Added CSRC 0x%08" PRIx32 " as CSRC %d\n", csrc,
                          session->csrc_count);
        }
        return true;
}

References check_database(), check_source(), create_source(), rtp::csrc_count, debug_msg, FALSE, get_source(), _source::should_advertise_sdes, and TRUE.

Here is the call graph for this function:

rtp_async_start()

void rtp_async_start	(	struct rtp *	session,
		int	nr_packets )

Definition at line 4027 of file rtp.c.

{
       udp_async_start(session->rtp_socket, nr_packets);
}

References rtp::rtp_socket, and udp_async_start().

Referenced by tx_send_base().

Here is the call graph for this function:

rtp_async_wait()

void rtp_async_wait

(

struct rtp *

session

)

Definition at line 4032 of file rtp.c.

{
       udp_async_wait(session->rtp_socket);
}

References rtp::rtp_socket, and udp_async_wait().

Referenced by tx_send_base().

Here is the call graph for this function:

rtp_compute_fract_lost()

int rtp_compute_fract_lost	(	struct rtp *	session,
		uint32_t	ssrc )

Definition at line 3974 of file rtp.c.

{
        int h;
        source *s;
 
        for (h = 0; h < RTP_DB_SIZE; h++) {
                for (s = session->db[h]; s != NULL; s = s->next) {
                        check_source(s);
                        if (s->ssrc == ssrc) {
                                /* Much of this is taken from A.3 of draft-ietf-avt-rtp-new-01.txt */
                                int extended_max = s->cycles + s->max_seq;
                                int expected = extended_max - s->base_seq + 1;
                                //int lost = expected - s->received;
                                int expected_interval =
                                    expected - s->expected_prior;
                                int received_interval =
                                    s->received - s->received_prior;
                                int lost_interval =
                                    expected_interval - received_interval;
                                int fraction;
                                //uint32_t lsr;
                                //uint32_t dlsr;
 
                                //printf("lost_interval %d\n", lost_interval);
                                s->expected_prior = expected;
                                s->received_prior = s->received;
                                if (expected_interval == 0
                                    || lost_interval <= 0) {
                                        fraction = 0;
                                } else {
                                        fraction =
                                            (lost_interval << 8) /
                                            expected_interval;
                                }
 
                                return fraction;
                        }
                }
        }
        return 0;
}

References _source::base_seq, check_source(), _source::cycles, rtp::db, _source::expected_prior, _source::max_seq, _source::next, _source::received, _source::received_prior, RTP_DB_SIZE, and _source::ssrc.

Here is the call graph for this function:

rtp_del_csrc()

bool rtp_del_csrc	(	struct rtp *	session,
		uint32_t	csrc )

rtp_del_csrc: @session: the session pointer (returned by rtp_init()) @csrc: Constributing SSRC identifier

Removes @csrc from list of contributing sources used in SDES items. Used by mixers and transcoders.

Return values

true	on success, false if @csrc is not a valid source.

Definition at line 2510 of file rtp.c.

{
        source *s;
 
        check_database(session);
        s = get_source(session, csrc);
        if (s == NULL) {
                debug_msg("Invalid source 0x%08x\n", csrc);
                return false;
        }
        check_source(s);
        s->should_advertise_sdes = FALSE;
        session->csrc_count--;
        if (session->last_advertised_csrc >= session->csrc_count) {
                session->last_advertised_csrc = 0;
        }
        return true;
}

References check_database(), check_source(), rtp::csrc_count, debug_msg, FALSE, get_source(), rtp::last_advertised_csrc, and _source::should_advertise_sdes.

Here is the call graph for this function:

rtp_done()

void rtp_done

(

struct rtp *

session

)

rtp_done: @session: the RTP session to finish

Free the state associated with the given RTP session. This function does not send any packets (e.g. an RTCP BYE) - an application which wishes to exit in a clean manner should call rtp_send_bye() first.

Definition at line 3676 of file rtp.c.

{
        int i;
        source *s, *n;
 
        check_database(session);
        /* In delete_source, check database gets called and this assumes */
        /* first added and last removed is us.                           */
        for (i = 0; i < RTP_DB_SIZE; i++) {
                s = session->db[i];
                while (s != NULL) {
                        n = s->next;
                        if (s->ssrc != session->my_ssrc) {
                                delete_source(session, session->db[i]->ssrc);
                        }
                        s = n;
                }
        }
 
        delete_source(session, session->my_ssrc);
 
        /*
         * Introduce a memory leak until we add algorithm-specific
         * cleanup functions.
         if (session->encryption_key != NULL) {
         free(session->encryption_key);
         }
         */
 
        udp_exit(session->rtp_socket);
        udp_exit(session->rtcp_socket);
        free(session->opt);
        free(session);
}

References check_database(), rtp::db, delete_source(), rtp::my_ssrc, _source::next, rtp::opt, rtp::rtcp_socket, RTP_DB_SIZE, rtp::rtp_socket, _source::ssrc, and udp_exit().

Referenced by am_participant::~am_participant(), audio_done(), audio_receiver_process_message(), audio_sender_process_message(), rtp_video_rxtx::destroy_rtp_device(), and vidcap_rtsp_done().

Here is the call graph for this function:

rtp_flush_recv_buf()

void rtp_flush_recv_buf

(

struct rtp *

session

)

rtp_flush_recv_buf: Flushes receiver buffer contents. @session: The RTP Session.

Definition at line 3964 of file rtp.c.

{
        udp_flush_recv_buf(session->rtp_socket);
}

References rtp::rtp_socket, and udp_flush_recv_buf().

Referenced by audio_receiver_thread().

Here is the call graph for this function:

rtp_get_bytes_sent()

uint64_t rtp_get_bytes_sent

(

struct rtp *

session

)

Definition at line 3969 of file rtp.c.

{
        return session->rtp_bytes_sent;
}

References rtp::rtp_bytes_sent.

rtp_get_option()

bool rtp_get_option	(	struct rtp *	session,
		rtp_option	optname,
		int *	optval )

rtp_get_option: @session: The RTP session. @optname: The option name, see rtp_option. @optval: The return value.

Retrieves the value of a session option. See rtp_option for documentation on the options and their legal values.

Returns

true and the value of the option in optval on success, else false.

Definition at line 1352 of file rtp.c.

{
        switch (optname) {
        case RTP_OPT_WEAK_VALIDATION:
                *optval = session->opt->wait_for_rtcp;
                break;
        case RTP_OPT_PROMISC:
                *optval = session->opt->promiscuous_mode;
                break;
        case RTP_OPT_FILTER_MY_PACKETS:
                *optval = session->opt->filter_my_packets;
                break;
        case RTP_OPT_REUSE_PACKET_BUFS:
                *optval = session->opt->reuse_bufs;
                break;
        default:
                *optval = 0;
                debug_msg
                    ("Ignoring unknown option (%d) in call to rtp_get_option().\n",
                     optname);
                return false;
        }
        return true;
}

References debug_msg, options::filter_my_packets, rtp::opt, options::promiscuous_mode, options::reuse_bufs, RTP_OPT_FILTER_MY_PACKETS, RTP_OPT_PROMISC, RTP_OPT_REUSE_PACKET_BUFS, RTP_OPT_WEAK_VALIDATION, and options::wait_for_rtcp.

rtp_get_recv_buf()

int rtp_get_recv_buf

(

struct rtp *

session

)

Definition at line 3944 of file rtp.c.

{
        return udp_get_recv_buf(session->rtp_socket);
}

References rtp::rtp_socket, and udp_get_recv_buf().

Referenced by ultragrid_rtp_video_rxtx::receiver_loop().

Here is the call graph for this function:

rtp_get_rr()

const rtcp_rr * rtp_get_rr	(	struct rtp *	session,
		uint32_t	reporter,
		uint32_t	reportee )

rtp_get_rr: @session: the session pointer (returned by rtp_init()) @reporter: participant originating receiver report @reportee: participant included in receiver report

Retrieve the latest receiver report on @reportee made by @reporter. Provides an indication of other receivers reception service.

Return value: A pointer to a rtcp_rr structure on success, NULL otherwise. The pointer must not be freed.

Definition at line 2707 of file rtp.c.

{
        check_database(session);
        return get_rr(session, reporter, reportee);
}

References check_database(), and get_rr().

Referenced by process_rr().

Here is the call graph for this function:

rtp_get_sdes()

const char * rtp_get_sdes	(	struct rtp *	session,
		uint32_t	ssrc,
		rtcp_sdes_type	type )

rtp_get_sdes: @session: the session pointer (returned by rtp_init()) @ssrc: the SSRC identifier of a participant @type: the SDES information to retrieve

Recovers session description (SDES) information on participant identified with @ssrc. The SDES information associated with a source is updated when receiver reports are received. There are several different types of SDES information, e.g. username, location, phone, email. These are enumerated by rtcp_sdes_type.

Return value: pointer to string containing SDES description if received, NULL otherwise.

Definition at line 2631 of file rtp.c.

{
        source *s;
 
        check_database(session);
 
        s = get_source(session, ssrc);
        if (s == NULL) {
                debug_msg("Invalid source 0x%08x\n", ssrc);
                return NULL;
        }
        check_source(s);
 
        switch (type) {
        case RTCP_SDES_CNAME:
                return s->sdes_cname;
        case RTCP_SDES_NAME:
                return s->sdes_name;
        case RTCP_SDES_EMAIL:
                return s->sdes_email;
        case RTCP_SDES_PHONE:
                return s->sdes_phone;
        case RTCP_SDES_LOC:
                return s->sdes_loc;
        case RTCP_SDES_TOOL:
                return s->sdes_tool;
        case RTCP_SDES_NOTE:
                return s->sdes_note;
        case RTCP_SDES_PRIV:
                return s->sdes_priv;
        default:
                /* This includes RTCP_SDES_PRIV and RTCP_SDES_END */
                debug_msg("Unknown SDES item (type=%d)\n", type);
        }
        return NULL;
}

References check_database(), check_source(), debug_msg, get_source(), RTCP_SDES_CNAME, RTCP_SDES_EMAIL, RTCP_SDES_LOC, RTCP_SDES_NAME, RTCP_SDES_NOTE, RTCP_SDES_PHONE, RTCP_SDES_PRIV, RTCP_SDES_TOOL, _source::sdes_cname, _source::sdes_email, _source::sdes_loc, _source::sdes_name, _source::sdes_note, _source::sdes_phone, _source::sdes_priv, _source::sdes_tool, and type.

Referenced by format_rtcp_sdes().

Here is the call graph for this function:

rtp_get_sr()

const rtcp_sr * rtp_get_sr	(	struct rtp *	session,
		uint32_t	ssrc )

rtp_get_sr: @session: the session pointer (returned by rtp_init()) @ssrc: identifier of source

Retrieve the latest sender report made by sender with @ssrc identifier.

Return value: A pointer to an rtcp_sr structure on success, NULL otherwise. The pointer must not be freed.

Definition at line 2679 of file rtp.c.

{
        /* Return the last SR received from this ssrc. The */
        /* caller MUST NOT free the memory returned to it. */
        source *s;
 
        check_database(session);
 
        s = get_source(session, ssrc);
        if (s == NULL) {
                return NULL;
        }
        check_source(s);
        return s->sr;
}

References check_database(), check_source(), get_source(), and _source::sr.

Here is the call graph for this function:

rtp_get_udp_local_socket()

struct socket_udp_local * rtp_get_udp_local_socket

(

struct rtp *

session

)

Definition at line 4037 of file rtp.c.

{
        return udp_get_local(session->rtp_socket);
}

References rtp::rtp_socket, and udp_get_local().

Referenced by audio_play_mixer_ctl().

Here is the call graph for this function:

rtp_get_udp_rx_port()

int rtp_get_udp_rx_port

(

struct rtp *

session

)

Definition at line 4042 of file rtp.c.

{
        return udp_get_udp_rx_port(session->rtp_socket);
}

References rtp::rtp_socket, and udp_get_udp_rx_port().

Referenced by set_audio_spec_to_vrxtx(), and vidcap_rtsp_init().

Here is the call graph for this function:

rtp_get_userdata()

uint8_t * rtp_get_userdata

(

struct rtp *

session

)

rtp_get_userdata: @session: The RTP session.

This function returns the userdata pointer that was passed to the rtp_init() or rtp_init_if() function when creating this session.

Returns: pointer to userdata.

Definition at line 1386 of file rtp.c.

{
        check_database(session);
        return session->userdata;
}

References check_database(), and rtp::userdata.

Referenced by rtp_recv_callback().

Here is the call graph for this function:

rtp_has_receiver()

bool rtp_has_receiver

(

struct rtp *

session

)

Definition at line 4016 of file rtp.c.

{
        return !session->opt->send_back ||
               !udp_is_server_mode_blackhole(session->rtp_socket);
}

References rtp::opt, rtp::rtp_socket, options::send_back, and udp_is_server_mode_blackhole().

Referenced by audio_tx_send(), rtp_process_data(), and tx_send_base().

Here is the call graph for this function:

rtp_init()

rtp_t rtp_init	(	const char *	addr,
		uint16_t	rx_port,
		uint16_t	tx_port,
		int	ttl,
		double	rtcp_bw,
		int	tfrc_on,
		rtp_callback	callback,
		uint8_t *	userdata,
		int	force_ip_version,
		bool	multithreaded )

rtp_init: @addr: IP destination of this session (unicast or multicast), as an ASCII string. May be a host name, which will be looked up, or may be an IPv4 dotted quad or IPv6 literal adddress. @rx_port: The port to which to bind the UDP socket @tx_port: The port to which to send UDP packets @ttl: The TTL for both multicast and unicast (-1 for default) @rtcp_bw: The total bandwidth (in units of bytes per second) that is allocated to RTCP. @callback: See section on rtp_callback. @userdata: Opaque data associated with the session. See rtp_get_userdata().

Returns: An opaque session identifier to be used in future calls to the RTP library functions, or NULL on failure.

Definition at line 999 of file rtp.c.

{
        return rtp_init_if(addr, NULL, rx_port, tx_port, ttl, rtcp_bw, tfrc_on,
                           callback, userdata, force_ip_version, multithreaded);
}

References callback, rtp::rtcp_bw, rtp_init_if(), rtp::tfrc_on, and rtp::userdata.

Here is the call graph for this function:

rtp_init_if()

rtp_t rtp_init_if	(	const char *	addr,
		const char *	iface,
		uint16_t	rx_port,
		uint16_t	tx_port,
		int	ttl,
		double	rtcp_bw,
		int	tfrc_on,
		rtp_callback	callback,
		uint8_t *	userdata,
		int	force_ip_version,
		bool	multithreaded )

rtp_init_if: @addr: IP destination of this session (unicast or multicast), as an ASCII string. May be a host name, which will be looked up, or may be an IPv4 dotted quad or IPv6 literal adddress. @iface: If the destination of the session is multicast, the optional interface to bind to. May be NULL, in which case the default multicast interface as determined by the system will be used. @rx_port: The port to which to bind the UDP socket @tx_port: The port to which to send UDP packets @ttl: The TTL for both multicast and unicast (-1 for default) @rtcp_bw: The total bandwidth (in units of ___) that is allocated to RTCP. @callback: See section on rtp_callback. @userdata: Opaque data associated with the session. See rtp_get_userdata(). @force_ip_version if IPv4 or IPv4 is requested, pass 4 or 6 respectively, otherwise 0 @multithreaded if set to true uses separate thread to receive data (performance optimization)

Creates and initializes an RTP session.

Returns: An opaque session identifier to be used in future calls to the RTP library functions, or NULL on failure.

Definition at line 1034 of file rtp.c.

{
        struct rtp *session;
        int i, j;
        char *cname;
        char *hname;
 
#ifdef _WIN32
        if (multithreaded) {
                log_msg(LOG_LEVEL_WARNING, "Multithreaded RTP is not recommended for MSW due to internal locking within Winsock implementation.\n");
        }
#endif
 
        if (force_ip_version != 0 && force_ip_version != 4 && force_ip_version != 6) {
                log_msg(LOG_LEVEL_ERROR, "IP version must be either 4 or 6 (or 0)\n");
                return NULL;
        }
        if (ttl < -1 || ttl > 255) {
                log_msg(LOG_LEVEL_ERROR, "ttl must be in range [0..255] or -1, %d given\n", ttl);
                return NULL;
        }
        if (rx_port % 2) {
                log_msg(LOG_LEVEL_WARNING, "RTP: rx_port should be even, using %d.\n", rx_port);
        }
        if (tx_port % 2) {
                log_msg(LOG_LEVEL_WARNING, "RTP: tx_port should be even, using %d.\n", tx_port);
        }
 
        session = (struct rtp *)malloc(sizeof(struct rtp));
        memset(session, 0, sizeof(struct rtp));
 
        session->magic = 0xfeedface;
        session->opt = (options *) malloc(sizeof(options));
        session->userdata = userdata;
        session->mt_recv = multithreaded;
        session->send_rtcp_to_origin =
            (tx_port == 0 && is_host_loopback(addr)) ||
            strcmp(addr, IN6_BLACKHOLE_SERVER_MODE_STR) == 0;
 
        if (rx_port == 0) {
                const unsigned random_off = (ug_rand() % (IPPORT_MAX - IPPORT_DYNAMIC + 1)) & ~1U;
                for (unsigned i = 0; i <= (IPPORT_MAX - IPPORT_DYNAMIC) - 1; i += 2) {
                        int port = IPPORT_DYNAMIC + ((random_off + i) % (IPPORT_MAX - IPPORT_DYNAMIC + 1));
                        // this stuff is not atomic. but... it cannot be done in this way, either
                        int ret = udp_port_pair_is_free(force_ip_version, port);
                        if (ret == 0) {
                                rx_port = port;
                                break;
                        }
                }
                if (rx_port == 0) {
                        log_msg(LOG_LEVEL_ERROR, "Unable to find empty RTP port pair!\n");
                } else {
                        verbose_msg("Found empty UDP port pair %d/%d\n", rx_port, rx_port + 1);
                }
        } else {
                MSG(VERBOSE, "Bound to ports %d/%d\n", rx_port, rx_port + 1);
        }
        if (tx_port == 0) {
                tx_port = rx_port;
        }
        session->rtp_socket = udp_init_if(addr, iface, rx_port, tx_port, ttl, force_ip_version, multithreaded);
 
        session->rtcp_socket =
            udp_init_if(addr, iface, (uint16_t) (rx_port + (rx_port ? 1 : 0)),
                        (uint16_t) (tx_port + (tx_port ? 1 : 0)), ttl, force_ip_version, false);
 
        init_opt(session);
 
        if (session->rtp_socket == NULL || session->rtcp_socket == NULL) {
                printf("Unable to open network\n");
                free(session);
                return NULL;
        }
 
        hname = udp_host_addr(session->rtp_socket);
        free(hname);
 
        session->my_ssrc = ug_rand();
        session->callback = callback;
        session->invalid_rtp_count = 0;
        session->invalid_rtcp_count = 0;
        session->bye_count = 0;
        session->csrc_count = 0;
        session->ssrc_count = 0;
        session->ssrc_count_prev = 0;
        session->sender_count = 0;
        session->initial_rtcp = TRUE;
        session->sending_bye = FALSE;
        session->avg_rtcp_size = -1;    /* Sentinal value: reception of first packet starts initial value... */
        session->we_sent = FALSE;
        session->rtcp_bw = rtcp_bw;
        session->sdes_count_pri = 0;
        session->sdes_count_sec = 0;
        session->sdes_count_ter = 0;
        session->rtp_seq = (uint16_t) ug_rand();
        session->rtp_pcount = 0;
        session->mhdr = NULL;
        session->tfrc_on = tfrc_on;
        session->rtp_bcount = 0;
        session->rtp_bytes_sent = 0;
        session->last_update =
                session->last_rtcp_send_time =
                session->next_rtcp_send_time = get_time_in_ns();
        session->encryption_enabled = 0;
        session->encryption_algorithm = NULL;
 
        /* Calculate when we're supposed to send our first RTCP packet... */
        session->next_rtcp_send_time += rtcp_interval(session) * NS_IN_SEC;
 
        /* Initialise the source database... */
        for (i = 0; i < RTP_DB_SIZE; i++) {
                session->db[i] = NULL;
        }
        session->last_advertised_csrc = 0;
 
        /* Initialize sentinels in rr table */
        for (i = 0; i < RTP_DB_SIZE; i++) {
                for (j = 0; j < RTP_DB_SIZE; j++) {
                        session->rr[i][j].next = &session->rr[i][j];
                        session->rr[i][j].prev = &session->rr[i][j];
                }
        }
 
        /* Create a database entry for ourselves... */
        create_source(session, session->my_ssrc, FALSE);
        cname = get_cname(session->rtp_socket);
        rtp_set_sdes(session, session->my_ssrc, RTCP_SDES_CNAME, cname,
                     strlen(cname));
        free(cname);            /* cname is copied by rtp_set_sdes()... */
 
        log_msg(LOG_LEVEL_DEBUG, "Created new RTP session with SSRC 0x%08x.\n",
                  session->my_ssrc);
 
        return session;
}

References rtp::avg_rtcp_size, rtp::bye_count, callback, rtp::callback, create_source(), rtp::csrc_count, rtp::db, rtp::encryption_algorithm, rtp::encryption_enabled, FALSE, get_cname(), get_time_in_ns(), IN6_BLACKHOLE_SERVER_MODE_STR, init_opt(), rtp::initial_rtcp, rtp::invalid_rtcp_count, rtp::invalid_rtp_count, IPPORT_DYNAMIC, IPPORT_MAX, is_host_loopback(), rtp::last_advertised_csrc, rtp::last_rtcp_send_time, rtp::last_update, LOG_LEVEL_DEBUG, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), rtp::magic, rtp::mhdr, MSG, rtp::mt_recv, rtp::my_ssrc, _rtcp_rr_wrapper::next, rtp::next_rtcp_send_time, NS_IN_SEC, rtp::opt, _rtcp_rr_wrapper::prev, rtp::rr, rtp::rtcp_bw, rtcp_interval(), RTCP_SDES_CNAME, rtp::rtcp_socket, rtp::rtp_bcount, rtp::rtp_bytes_sent, RTP_DB_SIZE, rtp::rtp_pcount, rtp::rtp_seq, rtp_set_sdes(), rtp::rtp_socket, rtp::sdes_count_pri, rtp::sdes_count_sec, rtp::sdes_count_ter, rtp::send_rtcp_to_origin, rtp::sender_count, rtp::sending_bye, rtp::ssrc_count, rtp::ssrc_count_prev, rtp::tfrc_on, TRUE, udp_host_addr(), udp_init_if(), udp_port_pair_is_free(), ug_rand(), rtp::userdata, verbose_msg, and rtp::we_sent.

Referenced by initialize_audio_network(), rtp_video_rxtx::initialize_network(), rtp_init(), and vidcap_rtsp_init().

Here is the call graph for this function:

rtp_init_with_udp_socket()

rtp_t rtp_init_with_udp_socket	(	struct socket_udp_local *	l,
		struct sockaddr *	sa,
		socklen_t	len,
		rtp_callback	callback )

Definition at line 1175 of file rtp.c.

{
        struct rtp *session;
        int i, j;
        char *cname;
        char *hname;
        int ttl = 127;        /*  FIXME */
        int tfrc_on = FALSE;  /*  FIXME */
 
        session = (struct rtp *)malloc(sizeof(struct rtp));
        memset(session, 0, sizeof(struct rtp));
 
        session->magic = 0xfeedface;
        session->opt = (options *) malloc(sizeof(options));
        // socket is not designated to receiving
        session->userdata = 0;
        session->mt_recv = false;
        session->send_rtcp_to_origin = true;
 
        session->rtp_socket = udp_init_with_local(l, sa, len);
        session->rtcp_socket = udp_init_if("localhost", NULL, 0, 0, ttl, 6, false);
 
        init_opt(session);
 
        if (session->rtp_socket == NULL || session->rtcp_socket == NULL) {
                printf("Unable to open network\n");
                free(session);
                return NULL;
        }
 
        hname = udp_host_addr(session->rtp_socket);
        free(hname);
 
        session->my_ssrc = ug_rand();
        session->callback = callback;
        session->invalid_rtp_count = 0;
        session->invalid_rtcp_count = 0;
        session->bye_count = 0;
        session->csrc_count = 0;
        session->ssrc_count = 0;
        session->ssrc_count_prev = 0;
        session->sender_count = 0;
        session->initial_rtcp = TRUE;
        session->sending_bye = FALSE;
        session->avg_rtcp_size = -1;    /* Sentinal value: reception of first packet starts initial value... */
        session->we_sent = FALSE;
        session->rtcp_bw = 5 * 1024 * 1024;       /*  FIXME */
        session->sdes_count_pri = 0;
        session->sdes_count_sec = 0;
        session->sdes_count_ter = 0;
        session->rtp_seq = (uint16_t) ug_rand();
        session->rtp_pcount = 0;
        session->mhdr = NULL;
        session->tfrc_on = tfrc_on;
        session->rtp_bcount = 0;
        session->rtp_bytes_sent = 0;
        session->last_update =
                session->last_rtcp_send_time =
                session->next_rtcp_send_time = get_time_in_ns();
        session->encryption_enabled = 0;
        session->encryption_algorithm = NULL;
 
        /* Calculate when we're supposed to send our first RTCP packet... */
        session->next_rtcp_send_time += NS_IN_SEC * rtcp_interval(session);
 
        /* Initialise the source database... */
        for (i = 0; i < RTP_DB_SIZE; i++) {
                session->db[i] = NULL;
        }
        session->last_advertised_csrc = 0;
 
        /* Initialize sentinels in rr table */
        for (i = 0; i < RTP_DB_SIZE; i++) {
                for (j = 0; j < RTP_DB_SIZE; j++) {
                        session->rr[i][j].next = &session->rr[i][j];
                        session->rr[i][j].prev = &session->rr[i][j];
                }
        }
 
        /* Create a database entry for ourselves... */
        create_source(session, session->my_ssrc, FALSE);
        cname = get_cname(session->rtp_socket);
        rtp_set_sdes(session, session->my_ssrc, RTCP_SDES_CNAME, cname,
                     strlen(cname));
        free(cname);            /* cname is copied by rtp_set_sdes()... */
 
        log_msg(LOG_LEVEL_DEBUG, "Created new RTP session with SSRC 0x%08x.\n",
                  session->my_ssrc);
 
        return session;
}

References rtp::avg_rtcp_size, rtp::bye_count, callback, rtp::callback, create_source(), rtp::csrc_count, rtp::db, rtp::encryption_algorithm, rtp::encryption_enabled, FALSE, get_cname(), get_time_in_ns(), init_opt(), rtp::initial_rtcp, rtp::invalid_rtcp_count, rtp::invalid_rtp_count, rtp::last_advertised_csrc, rtp::last_rtcp_send_time, rtp::last_update, len, LOG_LEVEL_DEBUG, log_msg(), rtp::magic, rtp::mhdr, rtp::mt_recv, rtp::my_ssrc, _rtcp_rr_wrapper::next, rtp::next_rtcp_send_time, NS_IN_SEC, rtp::opt, _rtcp_rr_wrapper::prev, rtp::rr, rtp::rtcp_bw, rtcp_interval(), RTCP_SDES_CNAME, rtp::rtcp_socket, rtp::rtp_bcount, rtp::rtp_bytes_sent, RTP_DB_SIZE, rtp::rtp_pcount, rtp::rtp_seq, rtp_set_sdes(), rtp::rtp_socket, rtp::sdes_count_pri, rtp::sdes_count_sec, rtp::sdes_count_ter, rtp::send_rtcp_to_origin, rtp::sender_count, rtp::sending_bye, rtp::ssrc_count, rtp::ssrc_count_prev, rtp::tfrc_on, TRUE, udp_host_addr(), udp_init_if(), udp_init_with_local(), ug_rand(), rtp::userdata, and rtp::we_sent.

Referenced by am_participant::am_participant().

Here is the call graph for this function:

rtp_is_ipv6()

bool rtp_is_ipv6

(

struct rtp *

session

)

Definition at line 4022 of file rtp.c.

{
        return udp_is_ipv6(session->rtp_socket);
}

References rtp::rtp_socket, and udp_is_ipv6().

Referenced by audio_tx_send_chan(), h264_sdp_video_rxtx::sdp_add_video(), set_audio_spec_to_vrxtx(), tx_send_base(), and tx_send_jpeg().

Here is the call graph for this function:

rtp_my_ssrc()

uint32_t rtp_my_ssrc

(

struct rtp *

session

)

rtp_my_ssrc: @session: The RTP Session.

Returns: The SSRC we are currently using in this session. Note that our SSRC can change at any time (due to collisions) so applications must not store the value returned, but rather should call this function each time they need it.

Definition at line 1401 of file rtp.c.

{
        check_database(session);
        return session->my_ssrc;
}

References check_database(), and rtp::my_ssrc.

Referenced by audio_sender_process_message(), filter_event(), format_rtcp_sr(), ultragrid_rtp_video_rxtx::get_ssrc(), initialize_audio_network(), rtp_video_rxtx::initialize_network(), process_rr(), rtp_video_rxtx::process_sender_message(), report_stats(), rtp_process_ctrl(), rtp_update(), send_rtcp(), and vidcap_rtsp_init().

Here is the call graph for this function:

rtp_recv()

bool rtp_recv	(	struct rtp *	session,
		struct timeval *	timeout,
		uint32_t	curr_rtp_ts )

rtp_recv: @session: the session pointer (returned by rtp_init()) @timeout: the amount of time that rtcp_recv() is allowed to block @curr_rtp_ts: the current time expressed in units of the media timestamp.

Receive RTP packets and dispatch them.

Return values

true	if data received, false if the timeout occurred.

Deprecated

Use thread-safe rtp_recv_r() instead.

Definition at line 2297 of file rtp.c.

{
        check_database(session);
        udp_fd_zero();
        udp_fd_set(session->rtp_socket);
        udp_fd_set(session->rtcp_socket);
        if (udp_select(timeout) > 0) {
                if (udp_fd_isset(session->rtp_socket)) {
                        rtp_recv_data(session, curr_rtp_ts);
                }
                if (udp_fd_isset(session->rtcp_socket)) {
                        uint8_t buffer[RTP_MAX_PACKET_LEN];
                        int buflen;
                        buflen =
                            udp_recv(session->rtcp_socket, (char *)buffer,
                                     RTP_MAX_PACKET_LEN);
                        rtp_process_ctrl(session, buffer, buflen);
                }
                check_database(session);
                return true;
        }
        check_database(session);
        return false;
}

References check_database(), rtp::rtcp_socket, RTP_MAX_PACKET_LEN, rtp_process_ctrl(), rtp_recv_data(), rtp::rtp_socket, udp_fd_isset(), udp_fd_set(), udp_fd_zero(), udp_recv(), and udp_select().

Here is the call graph for this function:

rtp_recv_poll_r()

int rtp_recv_poll_r	(	struct rtp **	sessions,
		struct timeval *	timeout,
		uint32_t	curr_rtp_ts )

rtp_recv_poll_r: The meaning is as above with except that this function polls for first nonempty stream and returns data.

Parameters

sessions	null-terminated list of rtp sessions.
timeout	timeout
cur_rtp_ts	list null-terminated of timestamps for each session

Returns

received bytes

Definition at line 2434 of file rtp.c.

{
        struct rtp **current;
        struct udp_fd_r fd;
 
        udp_fd_zero_r(&fd);
 
        for(current = sessions; *current != NULL; ++current) {
                check_database(*current);
                udp_fd_set_r((*current)->rtp_socket, &fd);
                udp_fd_set_r((*current)->rtcp_socket, &fd);
        }
        if (udp_select_r(timeout, &fd) > 0) {
                int received_bytes = 0;
                for(current = sessions; *current != NULL; ++current) {
                        if (udp_fd_isset_r((*current)->rtp_socket, &fd)) {
                                received_bytes = rtp_recv_data(*current, curr_rtp_ts);
                        }
                        if (udp_fd_isset_r((*current)->rtcp_socket, &fd)) {
                                uint8_t buffer[RTP_MAX_PACKET_LEN];
                                int buflen;
                                buflen =
                                    udp_recv((*current)->rtcp_socket, (char *)buffer,
                                             RTP_MAX_PACKET_LEN);
                                rtp_process_ctrl(*current, buffer, buflen);
                        }
                        check_database(*current);
                }
                return received_bytes;
        }
        //check_database(session);
        return 0;
}

References check_database(), RTP_MAX_PACKET_LEN, rtp_process_ctrl(), rtp_recv_data(), udp_fd_isset_r(), udp_fd_set_r(), udp_fd_zero_r(), udp_recv(), and udp_select_r().

Here is the call graph for this function:

rtp_recv_r()

bool rtp_recv_r	(	struct rtp *	session,
		struct timeval *	timeout,
		uint32_t	curr_rtp_ts )

Receive RTP packets and dispatch them.

Reentrant variant of rtp_recv()

Currently, this function is the only one of rtp_recv family eligible for multithreaded receiving.

Parameters

session	the session pointer (returned by rtp_init())
timeout	the amount of time that rtcp_recv() is allowed to block
curr_rtp_ts	the current time expressed in units of the media timestamp.

Return values

true	if data received
false	if the timeout occurred

Definition at line 2338 of file rtp.c.

{
        struct udp_fd_r fd;
        
        check_database(session);
        if (session->mt_recv) {
                bool ret = false;
                if (udp_not_empty(session->rtp_socket, timeout)) {
                        rtp_recv_data(session, curr_rtp_ts);
                        ret = true;
                }
                udp_fd_zero_r(&fd);
                udp_fd_set_r(session->rtcp_socket, &fd);
                struct timeval no_wait_tv = { .tv_sec = 0, .tv_usec = 0 };
 
                if (udp_select_r(&no_wait_tv, &fd) > 0) {
                        uint8_t buffer[RTP_MAX_PACKET_LEN];
                        int buflen;
                        session->rtcp_dest_len = sizeof(session->rtcp_dest);
                        buflen =
                                udp_recvfrom(session->rtcp_socket, (char *)buffer,
                                                RTP_MAX_PACKET_LEN,
                                                (struct sockaddr *) &session->rtcp_dest, &session->rtcp_dest_len);
                        rtp_process_ctrl(session, buffer, buflen);
                        ret = true;
                }
                return ret; // NOLINTNEXTLINE(readability-else-after-return)
        } else {
                udp_fd_zero_r(&fd);
                udp_fd_set_r(session->rtp_socket, &fd);
                udp_fd_set_r(session->rtcp_socket, &fd);
                if (udp_select_r(timeout, &fd) > 0) {
                        if (udp_fd_isset_r(session->rtp_socket, &fd)) {
                                rtp_recv_data(session, curr_rtp_ts);
                        }
                        if (udp_fd_isset_r(session->rtcp_socket, &fd)) {
                                uint8_t buffer[RTP_MAX_PACKET_LEN];
                                int buflen;
                                session->rtcp_dest_len = sizeof(session->rtcp_dest);
                                buflen =
                                        udp_recvfrom(session->rtcp_socket, (char *)buffer,
                                                        RTP_MAX_PACKET_LEN,
                                                        (struct sockaddr *) &session->rtcp_dest, &session->rtcp_dest_len);
                                rtp_process_ctrl(session, buffer, buflen);
                        }
                        check_database(session);
                        return true;
                }
        }
        check_database(session);
        return false;
}

References check_database(), rtp::mt_recv, rtp::rtcp_dest, rtp::rtcp_dest_len, rtp::rtcp_socket, RTP_MAX_PACKET_LEN, rtp_process_ctrl(), rtp_recv_data(), rtp::rtp_socket, udp_fd_isset_r(), udp_fd_set_r(), udp_fd_zero_r(), udp_not_empty(), udp_recvfrom(), and udp_select_r().

Referenced by audio_receiver_thread(), ultragrid_rtp_video_rxtx::receiver_loop(), h264_rtp_video_rxtx::send_frame(), h264_sdp_video_rxtx::send_frame(), and vidcap_rtsp_thread().

Here is the call graph for this function:

rtp_send_bye()

void rtp_send_bye

(

struct rtp *

session

)

rtp_send_bye: @session: The RTP session

Sends a BYE message on the RTP session, indicating that this participant is leaving the session. The process of sending a BYE may take some time, and this function will block until it is complete. During this time, RTCP events are reported to the application via the callback function (data packets are silently discarded).

Definition at line 3598 of file rtp.c.

{
        uint8_t buffer[RTP_MAX_PACKET_LEN];
        int buflen;
        double new_interval;
 
        check_database(session);
 
        /* "...a participant which never sent an RTP or RTCP packet MUST NOT send  */
        /* a BYE packet when they leave the group." (section 6.3.7 of RTP spec)    */
        if ((session->we_sent == FALSE) && (session->initial_rtcp == TRUE)) {
                debug_msg("Silent BYE\n");
                return;
        }
 
        /* If the session is small, send an immediate BYE. Otherwise, we delay and */
        /* perform BYE reconsideration as needed.                                  */
        if (session->ssrc_count < 50) {
                rtp_send_bye_now(session);
        } else {
                time_ns_t curr_time = get_time_in_ns();
                session->sending_bye = TRUE;
                session->last_rtcp_send_time =
                        session->next_rtcp_send_time = curr_time;
                session->bye_count = 1;
                session->initial_rtcp = TRUE;
                session->we_sent = FALSE;
                session->sender_count = 0;
                session->avg_rtcp_size = 70.0 + RTP_LOWER_LAYER_OVERHEAD;       /* FIXME */
                session->next_rtcp_send_time += (rtcp_interval(session) / (session->csrc_count + 1)) * NS_IN_SEC;
 
                debug_msg("Preparing to send BYE...\n");
                while (1) {
                        /* Schedule us to block in udp_select() until the time we are due to send our */
                        /* BYE packet. If we receive an RTCP packet from another participant before   */
                        /* then, we are woken up to handle it...                                      */
                        long long us = (session->next_rtcp_send_time - curr_time) / NS_IN_US;
                        lldiv_t d = lldiv(us, US_IN_SEC);
                        struct timeval timeout = { .tv_sec = d.quot, .tv_usec = d.rem };
                        udp_fd_zero();
                        udp_fd_set(session->rtcp_socket);
                        if ((udp_select(&timeout) > 0)
                            && udp_fd_isset(session->rtcp_socket)) {
                                /* We woke up because an RTCP packet was received; process it... */
                                buflen =
                                    udp_recv(session->rtcp_socket,
                                             (char *)buffer,
                                             RTP_MAX_PACKET_LEN);
                                rtp_process_ctrl(session, buffer, buflen);
                        }
                        /* Is it time to send our BYE? */
                        time_ns_t curr_time = get_time_in_ns();
                        new_interval =
                            rtcp_interval(session) / (session->csrc_count + 1);
                        time_ns_t new_send_time = session->last_rtcp_send_time + new_interval * NS_IN_SEC;
                        if (curr_time > new_send_time) {
                                debug_msg("Sent BYE...\n");
                                rtp_send_bye_now(session);
                                break;
                        }
                        /* No, we reconsider... */
                        session->next_rtcp_send_time = new_send_time;
                        debug_msg("Reconsidered sending BYE... delay = %f\n",
                                  (session->next_rtcp_send_time - curr_time) / (double) NS_IN_SEC);
                        /* ...and perform housekeeping in the usual manner */
                        rtp_update(session, curr_time);
                }
        }
}

References rtp::avg_rtcp_size, rtp::bye_count, check_database(), rtp::csrc_count, debug_msg, FALSE, get_time_in_ns(), rtp::initial_rtcp, rtp::last_rtcp_send_time, rtp::next_rtcp_send_time, NS_IN_SEC, NS_IN_US, rtcp_interval(), rtp::rtcp_socket, RTP_LOWER_LAYER_OVERHEAD, RTP_MAX_PACKET_LEN, rtp_process_ctrl(), rtp_send_bye_now(), rtp_update(), rtp::sender_count, rtp::sending_bye, rtp::ssrc_count, TRUE, udp_fd_isset(), udp_fd_set(), udp_fd_zero(), udp_recv(), udp_select(), US_IN_SEC, and rtp::we_sent.

Here is the call graph for this function:

rtp_send_ctrl()

void rtp_send_ctrl	(	struct rtp *	session,
		uint32_t	rtp_ts,
		rtcp_app_callback	appcallback,
		time_ns_t	curr_time )

rtp_send_ctrl: @session: the session pointer (returned by rtp_init()) @rtp_ts: the current time expressed in units of the media timestamp. @appcallback: a callback to create an APP RTCP packet, if needed.

Checks RTCP timer and sends RTCP data when nececessary. The interval between RTCP packets is randomized over an interval that depends on the session bandwidth, the number of participants, and whether the local participant is a sender. This function should be called at least once per second, and can be safely called more frequently.

Definition at line 3409 of file rtp.c.

{
        /* Send an RTCP packet, if one is due... */
 
        check_database(session);
        if (curr_time > session->next_rtcp_send_time) {
                /* The RTCP transmission timer has expired. The following */
                /* implements draft-ietf-avt-rtp-new-02.txt section 6.3.6 */
                int h;
                source *s;
                double new_interval =
                    rtcp_interval(session) / (session->csrc_count + 1);
                time_ns_t new_send_time = session->last_rtcp_send_time + new_interval * NS_IN_SEC;
                if (curr_time > new_send_time) {
                        send_rtcp(session, rtp_ts, appcallback);
                        session->initial_rtcp = FALSE;
                        session->last_rtcp_send_time = curr_time;
                        session->next_rtcp_send_time = curr_time + (rtcp_interval(session) / (session->csrc_count +
                                                         1)) * NS_IN_SEC;
                        /* We're starting a new RTCP reporting interval, zero out */
                        /* the per-interval statistics.                           */
                        session->sender_count = 0;
                        for (h = 0; h < RTP_DB_SIZE; h++) {
                                for (s = session->db[h]; s != NULL; s = s->next) {
                                        check_source(s);
                                        s->sender = FALSE;
                                }
                        }
                } else {
                        session->next_rtcp_send_time = new_send_time;
                }
                session->ssrc_count_prev = session->ssrc_count;
        }
        check_database(session);
}

References check_database(), check_source(), rtp::csrc_count, rtp::db, FALSE, rtp::initial_rtcp, rtp::last_rtcp_send_time, _source::next, rtp::next_rtcp_send_time, NS_IN_SEC, rtcp_interval(), RTP_DB_SIZE, send_rtcp(), _source::sender, rtp::sender_count, rtp::ssrc_count, and rtp::ssrc_count_prev.

Referenced by audio_receiver_thread(), audio_sender_thread(), audio_tx_send_standard(), ultragrid_rtp_video_rxtx::receiver_loop(), h264_rtp_video_rxtx::send_frame(), h264_sdp_video_rxtx::send_frame(), and ultragrid_rtp_video_rxtx::send_frame_async().

Here is the call graph for this function:

rtp_send_data()

int rtp_send_data	(	struct rtp *	session,
		uint32_t	rtp_ts,
		char	pt,
		int	m,
		int	cc,
		const uint32_t *	csrc,
		char *	data,
		int	data_len,
		char *	extn,
		uint16_t	extn_len,
		uint16_t	extn_type )

rtp_send_data: @session: the session pointer (returned by rtp_init()) @rtp_ts: The timestamp reflects the sampling instant of the first octet of the RTP data to be sent. The timestamp is expressed in media units. @pt: The payload type identifying the format of the data. @m: Marker bit, interpretation defined by media profile of payload. @cc: Number of contributing sources (excluding local participant) @csrc: Array of SSRC identifiers for contributing sources. @data: The RTP data to be sent. @data_len: The size @data in bytes. @extn: Extension data (if present). @extn_len: size of @extn in bytes. @extn_type: extension type indicator.

Send an RTP packet. Most media applications will only set the @session, @rtp_ts, @pt, @m, @data, @data_len arguments.

Mixers and translators typically set additional contributing sources arguments (@cc, @csrc).

Extensions fields (@extn, @extn_len, @extn_type) are for including application specific information. When the widest amount of inter-operability is required these fields should be avoided as some applications discard packets with extensions they do not recognize.

Return value: Number of bytes transmitted.

Definition at line 2742 of file rtp.c.

{
        return rtp_send_data_hdr(session, rtp_ts, pt, m, cc, csrc, NULL, 0,
                                 data, data_len, extn, extn_len, extn_type);
}

References rtp_send_data_hdr().

Referenced by audio_tx_send_standard(), and tx_send_h264().

Here is the call graph for this function:

rtp_send_data_hdr()

int rtp_send_data_hdr	(	struct rtp *	session,
		uint32_t	rtp_ts,
		char	pt,
		int	m,
		int	cc,
		const uint32_t *	csrc,
		char *	phdr,
		int	phdr_len,
		char *	data,
		int	data_len,
		char *	extn,
		uint16_t	extn_len,
		uint16_t	extn_type )

Definition at line 2752 of file rtp.c.

{
        int vlen, buffer_len, i, rc, pad, pad_len __attribute__((unused));
        uint8_t *buffer = NULL;
        rtp_packet *packet = NULL;
        uint8_t initVec[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
#ifdef _WIN32
        WSABUF *send_vector = NULL;
#else
        struct iovec send_vector[3];
#endif
        int send_vector_len;
 
        void *d; // to be freed after packet is sent
 
        check_database(session);
 
        assert((data == NULL && data_len == 0)
               || (data != NULL && data_len > 0));
 
        vlen = 12;
        if (session->tfrc_on) {
                vlen += 4;
                if (session->new_rtt)
                        vlen += 4;
        }
        buffer_len = vlen + (4 * cc);
 
        if (extn != NULL) {
                buffer_len += (extn_len + 1) * 4;
        }
 
        /* Do we need to pad this packet to a multiple of 64 bits? */
        /* This is only needed if encryption is enabled, since DES */
        /* only works on multiples of 64 bits. We just calculate   */
        /* the amount of padding to add here, so we can reserve    */
        /* space - the actual padding is added later.              */
#ifdef NDEF
        /* FIXME: This is broken, due to scatter send [csp]        *//* FIXME */
        if ((session->encryption_enabled) &&
            ((buffer_len % session->encryption_pad_length) != 0)) {
                pad = TRUE;
                pad_len =
                    session->encryption_pad_length -
                    (buffer_len % session->encryption_pad_length);
                buffer_len += pad_len;
                assert((buffer_len % session->encryption_pad_length) == 0);
        } else {
                pad = FALSE;
                pad_len = 0;
        }
#endif
        pad = FALSE;            /* FIXME */
        pad_len = 0;
 
        /* Allocate memory for the packet... */
        assert(buffer_len < RTP_MAX_PACKET_LEN);
        /* we dont always need 20 (12|16) but this seems to work. LG */
#ifdef _WIN32
        d = (uint8_t *) malloc(3 * sizeof(WSABUF) + 20 + RTP_PACKET_HEADER_SIZE);
        send_vector = d;
        buffer = (uint8_t *) d + 3 * sizeof(WSABUF);
#else
        d = buffer = (uint8_t *) malloc(20 + RTP_PACKET_HEADER_SIZE);
#endif
        packet = (rtp_packet *)(void *) buffer;
 
#ifdef _WIN32
        send_vector[0].buf = (char *) (buffer + RTP_PACKET_HEADER_SIZE);
        send_vector[0].len = buffer_len;
#else
        send_vector[0].iov_base = buffer + RTP_PACKET_HEADER_SIZE;
        send_vector[0].iov_len = buffer_len;
#endif
        send_vector_len = 1;
 
        /* These are internal pointers into the buffer... */
#ifdef NDEF
        packet->csrc = (uint32_t *) (buffer + RTP_PACKET_HEADER_SIZE + vlen);
        packet->extn =
            (uint8_t *) (buffer + RTP_PACKET_HEADER_SIZE + vlen + (4 * cc));
        packet->data =
            (uint8_t *) (buffer + RTP_PACKET_HEADER_SIZE + vlen + (4 * cc));
        if (extn != NULL) {
                packet->data += (extn_len + 1) * 4;
        }
#endif
        /* ...and the actual packet header... */
        packet->v = 2;
        packet->p = pad;
        packet->x = (extn != NULL);
        packet->cc = cc;
        packet->m = m;
        packet->pt = pt;
        packet->seq = htons(session->rtp_seq++);
        packet->ts = htonl(rtp_ts);
        packet->ssrc = htonl(session->my_ssrc);
 
        /* ... do tfrc stuff... */
        if (session->tfrc_on) {
                packet->send_ts = htonl(get_local_mediatime());
                if (session->new_rtt) {
                        packet->rtt = htonl(session->cmp_rtt);
                        /* hopefully this will set the 7th bit */
                        packet->pt = packet->pt | 64;
                } else
                        packet->pt = packet->pt & 63;   /* this should clear the 7th bit */
        }
 
        /* ...now the CSRC list... */
        for (i = 0; i < cc; i++) {
                packet->csrc[i] = htonl(csrc[i]);
        }
        /* ...a header extension? */
        if (extn != NULL) {
                /* We don't use the packet->extn_type field here, that's for receive only... */
                uint16_t *base = (uint16_t *)(void *) packet->extn;
                base[0] = htons(extn_type);
                base[1] = htons(extn_len);
                memcpy(packet->extn + 4, extn, extn_len * 4);
        }
        /* ...the payload header... */
        if (phdr != NULL) {
#ifdef _WIN32
                send_vector[send_vector_len].buf = phdr;
                send_vector[send_vector_len].len = phdr_len;
#else
                send_vector[send_vector_len].iov_base = phdr;
                send_vector[send_vector_len].iov_len = phdr_len;
#endif
                send_vector_len++;
        }
        /* ...and the media data... */
        if (data_len > 0) {
#ifdef _WIN32
                send_vector[send_vector_len].buf = (void *) data;
                send_vector[send_vector_len].len = data_len;
#else
                send_vector[send_vector_len].iov_base = (void *) data;
                send_vector[send_vector_len].iov_len = data_len;
#endif
                send_vector_len++;
        }
#ifdef NDEF                     /* FIXME */
        /* ...and any padding... */
        if (pad) {
                for (i = 0; i < pad_len; i++) {
                        buffer[buffer_len + RTP_PACKET_HEADER_SIZE - pad_len +
                               i] = 0;
                }
                buffer[buffer_len + RTP_PACKET_HEADER_SIZE - 1] = (char)pad_len;
        }
#endif
 
        /* Finally, encrypt if desired... */
        if (session->encryption_enabled) {
                assert((buffer_len % session->encryption_pad_length) == 0);
                (session->encrypt_func) (session,
                                         buffer + RTP_PACKET_HEADER_SIZE,
                                         buffer_len, initVec);
        }
 
        rc = udp_sendv(session->rtp_socket, send_vector, send_vector_len, d);
        if (rc == -1) {
                log_msg(LOG_LEVEL_WARNING, "sending RTP packet: %s", ug_strerror(errno));
        }
 
        /* Update the RTCP statistics... */
        session->we_sent = TRUE;
        session->rtp_pcount += 1;
        session->rtp_bcount += buffer_len;
        session->rtp_bytes_sent += buffer_len + data_len;
        session->last_rtp_send_time = get_time_in_ns();
 
        check_database(session);
        return rc;
}

References __attribute__(), check_database(), rtp::cmp_rtt, rtp::encrypt_func, rtp::encryption_enabled, rtp::encryption_pad_length, FALSE, get_local_mediatime(), get_time_in_ns(), rtp::last_rtp_send_time, LOG_LEVEL_WARNING, log_msg(), rtp::my_ssrc, rtp::new_rtt, rtp::rtp_bcount, rtp::rtp_bytes_sent, RTP_MAX_PACKET_LEN, rtp_packet, RTP_PACKET_HEADER_SIZE, rtp::rtp_pcount, rtp::rtp_seq, rtp::rtp_socket, rtp::tfrc_on, TRUE, udp_sendv(), ug_strerror(), and rtp::we_sent.

Referenced by audio_tx_send_chan(), rtp_send_data(), tx_send_base(), tx_send_h264(), and tx_send_jpeg().

Here is the call graph for this function:

rtp_send_raw_rtp_data()

int rtp_send_raw_rtp_data	(	struct rtp *	session,
		char *	buffer,
		int	buffer_len )

Definition at line 1518 of file rtp.c.

{
        return udp_send(session->rtp_socket, buffer, buffer_len);
}

References rtp::rtp_socket, and udp_send().

Here is the call graph for this function:

rtp_set_encryption_key()

bool rtp_set_encryption_key	(	struct rtp *	session,
		const char *	passphrase )

rtp_set_encryption_key: @session: The RTP session. @passphrase: The user-provided "pass phrase" to map to an encryption key.

Converts the user supplied key into a form suitable for use with RTP and install it as the active key. Passing in NULL as the passphrase disables encryption. The passphrase is converted into a DES key as specified in RFC1890, that is:

• convert to canonical form
• derive an MD5 hash of the canonical form
• take the first 56 bits of the MD5 hash
• add parity bits to form a 64 bit key

Note that versions of rat prior to 4.1.2 do not convert the passphrase to canonical form before taking the MD5 hash, and so will not be compatible for keys which are non-invarient under this step.

Determine from the user's encryption key which encryption mechanism we're using. Per the RTP RFC, if the key is of the form

 string/key

then "string" is the name of the encryption algorithm, and "key" is the key to be used. If no / is present, then the algorithm is assumed to be (the appropriate variant of) DES.

Definition at line 3742 of file rtp.c.

{
        char *canonical_passphrase;
        u_char hash[16];
        MD5CTX context;
        char *slash;
 
        check_database(session);
        if (session->encryption_algorithm != NULL) {
                free(session->encryption_algorithm);
                session->encryption_algorithm = NULL;
        }
 
        if (passphrase == NULL) {
                /* A NULL passphrase means disable encryption... */
                session->encryption_enabled = 0;
                check_database(session);
                return true;
        }
 
        debug_msg("Enabling RTP/RTCP encryption\n");
        session->encryption_enabled = 1;
 
        /*
         * Determine which algorithm we're using.
         */
 
        slash = strchr(passphrase, '/');
        if (slash == 0) {
                session->encryption_algorithm = strdup("DES");
        } else {
                int l = slash - passphrase;
                session->encryption_algorithm = malloc(l + 1);
                strncpy(session->encryption_algorithm, passphrase, l);
                session->encryption_algorithm[l] = '\0';
                passphrase = slash + 1;
        }
 
        debug_msg("Initializing encryption, algorithm is '%s'\n",
                  session->encryption_algorithm);
 
        /* Step 1: convert to canonical form, comprising the following steps:  */
        /*   a) convert the input string to the ISO 10646 character set, using */
        /*      the UTF-8 encoding as specified in Annex P to ISO/IEC          */
        /*      10646-1:1993 (ASCII characters require no mapping, but ISO     */
        /*      8859-1 characters do);                                         */
        /*   b) remove leading and trailing white space characters;            */
        /*   c) replace one or more contiguous white space characters by a     */
        /*      single space (ASCII or UTF-8 0x20);                            */
        /*   d) convert all letters to lower case and replace sequences of     */
        /*      characters and non-spacing accents with a single character,    */
        /*      where possible.                                                */
        canonical_passphrase = strdup(passphrase);      /* FIXME */
 
        /* Step 2: derive an MD5 hash */
        MD5Init(&context);
        MD5Update(&context, (u_char *) canonical_passphrase,
                  strlen(canonical_passphrase));
        MD5Final((u_char *) hash, &context);
        free(canonical_passphrase);
 
        /* Initialize the encryption algorithm we've received */
 
        if (strcmp(session->encryption_algorithm, "DES") == 0) {
                return des_initialize(session, hash, sizeof(hash)); // NOLINTNEXTLINE(readability-else-after-return)
        } else if (strcmp(session->encryption_algorithm, "Rijndael") == 0) {
                return rijndael_initialize(session, hash, sizeof(hash)); // NOLINTNEXTLINE(readability-else-after-return)
        } else {
                debug_msg("Encryption algorithm \"%s\" not found\n",
                          session->encryption_algorithm);
                return false;
        }
}

References check_database(), debug_msg, des_initialize(), rtp::encryption_algorithm, rtp::encryption_enabled, MD5Final(), MD5Init(), MD5Update(), and rijndael_initialize().

Here is the call graph for this function:

rtp_set_my_ssrc()

bool rtp_set_my_ssrc	(	struct rtp *	session,
		uint32_t	ssrc )

rtp_set_my_ssrc: @session: the RTP session @ssrc: the SSRC to be used by the RTP session

This function coerces the local SSRC identifer to be ssrc. For this function to succeed it must be called immediately after rtp_init or rtp_init_if. The intended purpose of this function is to co-ordinate SSRC's between layered sessions, it should not be used otherwise.

Definition at line 1278 of file rtp.c.

{
        source *s;
        uint32_t h;
 
        if (session->ssrc_count != 1 && session->sender_count != 0) {
                return false;
        }
        /* Remove existing source */
        h = ssrc_hash(session->my_ssrc);
        s = session->db[h];
        session->db[h] = NULL;
        /* Fill in new ssrc       */
        session->my_ssrc = ssrc;
        s->ssrc = ssrc;
        h = ssrc_hash(ssrc);
        /* Put source back        */
        session->db[h] = s;
        return true;
}

References rtp::db, rtp::my_ssrc, rtp::sender_count, _source::ssrc, rtp::ssrc_count, and ssrc_hash().

Here is the call graph for this function:

rtp_set_option()

bool rtp_set_option	(	struct rtp *	session,
		rtp_option	optname,
		int	optval )

rtp_set_option: @session: The RTP session. @optname: The option name, see rtp_option. @optval: The value to set.

Sets the value of a session option. See rtp_option for documentation on the options and their legal values.

Definition at line 1308 of file rtp.c.

{
        switch (optname) {
        case RTP_OPT_WEAK_VALIDATION:
                session->opt->wait_for_rtcp = optval;
                break;
        case RTP_OPT_PROMISC:
                session->opt->promiscuous_mode = optval;
                break;
        case RTP_OPT_FILTER_MY_PACKETS:
                session->opt->filter_my_packets = optval;
                break;
        case RTP_OPT_REUSE_PACKET_BUFS:
                session->opt->reuse_bufs = optval;
                break;
        case RTP_OPT_RECORD_SOURCE:
                session->opt->record_source = optval;
                break;
        case RTP_OPT_SEND_BACK:
                session->opt->send_back = optval;
                if (optval) {
                        session->opt->record_source = TRUE;
                }
                break;
        default:
                debug_msg
                    ("Ignoring unknown option (%d) in call to rtp_set_option().\n",
                     optname);
                return false;
        }
        return true;
}

References debug_msg, options::filter_my_packets, rtp::opt, options::promiscuous_mode, options::record_source, options::reuse_bufs, RTP_OPT_FILTER_MY_PACKETS, RTP_OPT_PROMISC, RTP_OPT_RECORD_SOURCE, RTP_OPT_REUSE_PACKET_BUFS, RTP_OPT_SEND_BACK, RTP_OPT_WEAK_VALIDATION, options::send_back, TRUE, and options::wait_for_rtcp.

Referenced by init_opt(), initialize_audio_network(), rtp_video_rxtx::initialize_network(), and vidcap_rtsp_init().

rtp_set_recv_buf()

bool rtp_set_recv_buf	(	struct rtp *	session,
		int	bufsize )

Sets receiver buffer size

Parameters

session	the RTP Session
bufsize	requested recv network buffer size

Definition at line 3938 of file rtp.c.

{
        return udp_set_recv_buf(session->rtp_socket, bufsize);
}

References rtp::rtp_socket, and udp_set_recv_buf().

Referenced by audio_update_recv_buf(), initialize_audio_network(), rtp_video_rxtx::initialize_network(), ultragrid_rtp_video_rxtx::receiver_loop(), and vidcap_rtsp_init().

Here is the call graph for this function:

rtp_set_recv_iov()

void rtp_set_recv_iov	(	struct rtp *	session,
		struct msghdr *	m )

Definition at line 1513 of file rtp.c.

{
        session->mhdr = m;
}

References rtp::mhdr.

rtp_set_sdes()

bool rtp_set_sdes	(	struct rtp *	session,
		uint32_t	ssrc,
		rtcp_sdes_type	type,
		const char *	value,
		int	length )

rtp_set_sdes: @session: the session pointer (returned by rtp_init()) @ssrc: the SSRC identifier of a participant @type: the SDES type represented by @value @value: the SDES description @length: the length of the description

Sets session description information associated with participant @ssrc. Under normal circumstances applications always use the @ssrc of the local participant, this SDES information is transmitted in receiver reports. Setting SDES information for other participants affects the local SDES entries, but are not transmitted onto the network.

Return values

returns

true if participant exists, false otherwise.

Definition at line 2546 of file rtp.c.

{
        source *s;
        char *v;
 
        check_database(session);
 
        s = get_source(session, ssrc);
        if (s == NULL) {
                debug_msg("Invalid source 0x%08x\n", ssrc);
                return false;
        }
        check_source(s);
 
        v = (char *)malloc(length + 1);
        memset(v, '\0', length + 1);
        memcpy(v, value, length);
 
        switch (type) {
        case RTCP_SDES_CNAME:
                if (s->sdes_cname)
                        free(s->sdes_cname);
                s->sdes_cname = v;
                break;
        case RTCP_SDES_NAME:
                if (s->sdes_name)
                        free(s->sdes_name);
                s->sdes_name = v;
                break;
        case RTCP_SDES_EMAIL:
                if (s->sdes_email)
                        free(s->sdes_email);
                s->sdes_email = v;
                break;
        case RTCP_SDES_PHONE:
                if (s->sdes_phone)
                        free(s->sdes_phone);
                s->sdes_phone = v;
                break;
        case RTCP_SDES_LOC:
                if (s->sdes_loc)
                        free(s->sdes_loc);
                s->sdes_loc = v;
                break;
        case RTCP_SDES_TOOL:
                if (s->sdes_tool)
                        free(s->sdes_tool);
                s->sdes_tool = v;
                break;
        case RTCP_SDES_NOTE:
                if (s->sdes_note)
                        free(s->sdes_note);
                s->sdes_note = v;
                break;
        case RTCP_SDES_PRIV:
                if (s->sdes_priv)
                        free(s->sdes_priv);
                s->sdes_priv = v;
                break;
        default:
                debug_msg("Unknown SDES item (type=%d, value=%s)\n", type, v);
                free(v);
                check_database(session);
                return false;
        }
        check_database(session);
        return true;
}

References check_database(), check_source(), debug_msg, get_source(), RTCP_SDES_CNAME, RTCP_SDES_EMAIL, RTCP_SDES_LOC, RTCP_SDES_NAME, RTCP_SDES_NOTE, RTCP_SDES_PHONE, RTCP_SDES_PRIV, RTCP_SDES_TOOL, _source::sdes_cname, _source::sdes_email, _source::sdes_loc, _source::sdes_name, _source::sdes_note, _source::sdes_phone, _source::sdes_priv, _source::sdes_tool, and type.

Referenced by initialize_audio_network(), rtp_video_rxtx::initialize_network(), process_rtcp_sdes(), rtp_init_if(), rtp_init_with_udp_socket(), and vidcap_rtsp_init().

Here is the call graph for this function:

rtp_set_send_buf()

bool rtp_set_send_buf	(	struct rtp *	session,
		int	bufsize )

Sets sender buffer size

Parameters

session	the RTP Session
bufsize	requested send network buffer size

Definition at line 3954 of file rtp.c.

{
        return udp_set_send_buf(session->rtp_socket, bufsize);
}

References rtp::rtp_socket, and udp_set_send_buf().

Referenced by rtp_video_rxtx::initialize_network(), and vidcap_rtsp_init().

Here is the call graph for this function:

rtp_update()

void rtp_update	(	struct rtp *	session,
		time_ns_t	curr_time )

rtp_update: @session: the session pointer (returned by rtp_init())

Trawls through the internal data structures and performs housekeeping. This function should be called at least once per second. It uses an internal timer to limit the number of passes through the data structures to once per second, it can be safely called more frequently.

Definition at line 3456 of file rtp.c.

{
        /* Perform housekeeping on the source database... */
        int h;
        source *s, *n;
 
        if (curr_time - session->last_update < 1 * NS_IN_SEC) {
                /* We only perform housekeeping once per second... */
                return;
        }
        session->last_update = curr_time;
 
        /* Update we_sent (section 6.3.8 of RTP spec) */
        time_ns_t delay = curr_time - session->last_rtp_send_time;
        if (delay >= 2 * NS_IN_SEC * rtcp_interval(session)) {
                session->we_sent = FALSE;
        }
 
        check_database(session);
 
        for (h = 0; h < RTP_DB_SIZE; h++) {
                for (s = session->db[h]; s != NULL; s = n) {
                        check_source(s);
                        n = s->next;
                        /* Expire sources which haven't been heard from for a int time.   */
                        /* Section 6.2.1 of the RTP specification details the timers used. */
 
                        /* How int since we last heard from this source?  */
                        delay = curr_time - s->last_active;
 
                        /* Check if we've received a BYE packet from this source.    */
                        /* If we have, and it was received more than 2 seconds ago   */
                        /* then the source is deleted. The arbitrary 2 second delay  */
                        /* is to ensure that all delayed packets are received before */
                        /* the source is timed out.                                  */
                        if (s->got_bye && (delay > 2 * NS_IN_SEC)) {
                                debug_msg
                                    ("Deleting source 0x%08" PRIx32 " due to reception of BYE %f seconds ago...\n",
                                     s->ssrc, (double) delay / NS_IN_SEC);
                                delete_source(session, s->ssrc);
                        }
 
                        /* Sources are marked as inactive if they haven't been heard */
                        /* from for more than 2 intervals (RTP section 6.3.5)        */
                        if ((s->ssrc != rtp_my_ssrc(session))
                            && (delay > (session->rtcp_interval * 2 * NS_IN_SEC))) {
                                if (s->sender) {
                                        s->sender = FALSE;
                                        session->sender_count--;
                                }
                        }
 
                        /* If a source hasn't been heard from for more than 5 RTCP   */
                        /* reporting intervals, we delete it from our database...    */
                        if ((s->ssrc != rtp_my_ssrc(session))
                            && (delay > (session->rtcp_interval * 5 * NS_IN_SEC))) {
                                debug_msg
                                    ("Deleting source 0x%08" PRIx32 " due to timeout...\n",
                                     s->ssrc);
                                delete_source(session, s->ssrc);
                        }
                }
        }
 
        /* Timeout those reception reports which haven't been refreshed for a int time */
        timeout_rr(session, curr_time);
        check_database(session);
}

References check_database(), check_source(), rtp::db, debug_msg, delete_source(), FALSE, _source::got_bye, _source::last_active, rtp::last_rtp_send_time, rtp::last_update, _source::next, NS_IN_SEC, rtcp_interval(), rtp::rtcp_interval, RTP_DB_SIZE, rtp_my_ssrc(), _source::sender, rtp::sender_count, _source::ssrc, timeout_rr(), and rtp::we_sent.

Referenced by audio_receiver_thread(), audio_sender_thread(), ultragrid_rtp_video_rxtx::receiver_loop(), rtp_send_bye(), h264_rtp_video_rxtx::send_frame(), h264_sdp_video_rxtx::send_frame(), ultragrid_rtp_video_rxtx::send_frame_async(), and vidcap_rtsp_thread().

Here is the call graph for this function:

Variable Documentation

rtp_packet

rtp_packet

Definition at line 126 of file rtp.h.

Referenced by decode_frame_by_pt(), decode_frame_h264(), decode_frame_jpeg(), decode_video_frame(), decode_yuri_audio_frame(), decode_yuri_video_frame(), rtp_recv_callback(), rtp_recv_data(), and rtp_send_data_hdr().