include/ortp/rtpsession.h File Reference

The RtpSession api. More...

#include <ortp/port.h>
#include <ortp/rtp.h>
#include <ortp/payloadtype.h>
#include <ortp/sessionset.h>
#include <ortp/rtcp.h>
#include <ortp/str_utils.h>
#include <ortp/rtpsignaltable.h>
#include <ortp/event.h>

Go to the source code of this file.

Data Structures

struct  _JBParameters
struct  _JitterControl
struct  _WaitPoint
struct  _RtpTransport
struct  _RtpStream
struct  _RtcpStream
struct  _RtpSession

Defines

#define rtp_session_set_flag(session, flag)   (session)->flags|=(flag)
#define rtp_session_unset_flag(session, flag)   (session)->flags&=~(flag)

Typedefs

typedef struct _JBParameters JBParameters
typedef struct _JitterControl JitterControl
typedef struct _WaitPoint WaitPoint
typedef struct _RtpTransport RtpTransport
typedef struct _RtpStream RtpStream
typedef struct _RtcpStream RtcpStream
typedef struct _RtpSession RtpSession

Enumerations

enum  RtpSessionMode { RTP_SESSION_RECVONLY, RTP_SESSION_SENDONLY, RTP_SESSION_SENDRECV }

Functions

RtpSessionrtp_session_new (int mode)
void rtp_session_set_scheduling_mode (RtpSession *session, int yesno)
void rtp_session_set_blocking_mode (RtpSession *session, int yesno)
void rtp_session_set_profile (RtpSession *session, RtpProfile *profile)
void rtp_session_set_send_profile (RtpSession *session, RtpProfile *profile)
void rtp_session_set_recv_profile (RtpSession *session, RtpProfile *profile)
RtpProfilertp_session_get_profile (RtpSession *session)
RtpProfilertp_session_get_send_profile (RtpSession *session)
RtpProfilertp_session_get_recv_profile (RtpSession *session)
int rtp_session_signal_connect (RtpSession *session, const char *signal_name, RtpCallback cb, unsigned long user_data)
int rtp_session_signal_disconnect_by_callback (RtpSession *session, const char *signal_name, RtpCallback cb)
void rtp_session_set_ssrc (RtpSession *session, uint32_t ssrc)
void rtp_session_set_seq_number (RtpSession *session, uint16_t seq)
uint16_t rtp_session_get_seq_number (RtpSession *session)
void rtp_session_enable_jitter_buffer (RtpSession *session, bool_t enabled)
bool_t rtp_session_jitter_buffer_enabled (const RtpSession *session)
void rtp_session_set_jitter_buffer_params (RtpSession *session, const JBParameters *par)
void rtp_session_get_jitter_buffer_params (RtpSession *session, JBParameters *par)
void rtp_session_set_jitter_compensation (RtpSession *session, int milisec)
void rtp_session_enable_adaptive_jitter_compensation (RtpSession *session, bool_t val)
bool_t rtp_session_adaptive_jitter_compensation_enabled (RtpSession *session)
void rtp_session_set_time_jump_limit (RtpSession *session, int miliseconds)
int rtp_session_set_local_addr (RtpSession *session, const char *addr, int port)
int rtp_session_get_local_port (const RtpSession *session)
int rtp_session_set_remote_addr_and_port (RtpSession *session, const char *addr, int rtp_port, int rtcp_port)
int rtp_session_set_remote_addr (RtpSession *session, const char *addr, int port)
void rtp_session_set_sockets (RtpSession *session, int rtpfd, int rtcpfd)
void rtp_session_set_transports (RtpSession *session, RtpTransport *rtptr, RtpTransport *rtcptr)
ortp_socket_t rtp_session_get_rtp_socket (const RtpSession *session)
ortp_socket_t rtp_session_get_rtcp_socket (const RtpSession *session)
int rtp_session_set_dscp (RtpSession *session, int dscp)
int rtp_session_get_dscp (const RtpSession *session)
int rtp_session_set_multicast_ttl (RtpSession *session, int ttl)
int rtp_session_get_multicast_ttl (RtpSession *session)
int rtp_session_set_multicast_loopback (RtpSession *session, int yesno)
int rtp_session_get_multicast_loopback (RtpSession *session)
int rtp_session_set_send_payload_type (RtpSession *session, int paytype)
int rtp_session_get_send_payload_type (const RtpSession *session)
int rtp_session_get_recv_payload_type (const RtpSession *session)
int rtp_session_set_recv_payload_type (RtpSession *session, int pt)
int rtp_session_set_payload_type (RtpSession *session, int pt)
void rtp_session_set_symmetric_rtp (RtpSession *session, bool_t yesno)
void rtp_session_set_connected_mode (RtpSession *session, bool_t yesno)
void rtp_session_enable_rtcp (RtpSession *session, bool_t yesno)
mblk_t * rtp_session_recvm_with_ts (RtpSession *session, uint32_t user_ts)
mblk_t * rtp_session_create_packet (RtpSession *session, int header_size, const uint8_t *payload, int payload_size)
mblk_t * rtp_session_create_packet_with_data (RtpSession *session, uint8_t *payload, int payload_size, void(*freefn)(void *))
mblk_t * rtp_session_create_packet_in_place (RtpSession *session, uint8_t *buffer, int size, void(*freefn)(void *))
int rtp_session_sendm_with_ts (RtpSession *session, mblk_t *mp, uint32_t userts)
int rtp_session_recv_with_ts (RtpSession *session, uint8_t *buffer, int len, uint32_t ts, int *have_more)
int rtp_session_send_with_ts (RtpSession *session, const uint8_t *buffer, int len, uint32_t userts)
void rtp_session_register_event_queue (RtpSession *session, OrtpEvQueue *q)
void rtp_session_unregister_event_queue (RtpSession *session, OrtpEvQueue *q)
float rtp_session_compute_send_bandwidth (RtpSession *session)
float rtp_session_compute_recv_bandwidth (RtpSession *session)
void rtp_session_send_rtcp_APP (RtpSession *session, uint8_t subtype, const char *name, const uint8_t *data, int datalen)
uint32_t rtp_session_get_current_send_ts (RtpSession *session)
uint32_t rtp_session_get_current_recv_ts (RtpSession *session)
void rtp_session_flush_sockets (RtpSession *session)
void rtp_session_release_sockets (RtpSession *session)
void rtp_session_resync (RtpSession *session)
void rtp_session_reset (RtpSession *session)
void rtp_session_destroy (RtpSession *session)
const rtp_stats_t * rtp_session_get_stats (const RtpSession *session)
void rtp_session_reset_stats (RtpSession *session)
void rtp_session_set_data (RtpSession *session, void *data)
void * rtp_session_get_data (const RtpSession *session)
void rtp_session_set_recv_buf_size (RtpSession *session, int bufsize)
uint32_t rtp_session_ts_to_time (RtpSession *session, uint32_t timestamp)
uint32_t rtp_session_time_to_ts (RtpSession *session, int millisecs)
void rtp_session_make_time_distorsion (RtpSession *session, int milisec)
void rtp_session_set_source_description (RtpSession *session, const char *cname, const char *name, const char *email, const char *phone, const char *loc, const char *tool, const char *note)
void rtp_session_add_contributing_source (RtpSession *session, uint32_t csrc, const char *cname, const char *name, const char *email, const char *phone, const char *loc, const char *tool, const char *note)
void rtp_session_remove_contributing_sources (RtpSession *session, uint32_t csrc)
mblk_t * rtp_session_create_rtcp_sdes_packet (RtpSession *session)
void rtp_session_get_last_recv_time (RtpSession *session, struct timeval *tv)
int rtp_session_bye (RtpSession *session, const char *reason)
int rtp_session_get_last_send_error_code (RtpSession *session)
void rtp_session_clear_send_error_code (RtpSession *session)
int rtp_session_get_last_recv_error_code (RtpSession *session)
void rtp_session_clear_recv_error_code (RtpSession *session)
void rtp_session_init (RtpSession *session, int mode)
void rtp_session_uninit (RtpSession *session)


Detailed Description

The RtpSession api.

The RtpSession objects represent a RTP session: once it is configured with local and remote network addresses and a payload type is given, it let you send and recv a media stream.


Function Documentation

int rtp_session_bye ( RtpSession session,
const char *  reason 
)

Sends a RTCP bye packet.

Parameters:
session RtpSession
reason the reason phrase.

mblk_t* rtp_session_create_packet ( RtpSession session,
int  header_size,
const uint8_t *  payload,
int  payload_size 
)

Allocates a new rtp packet. In the header, ssrc and payload_type according to the session's context. Timestamp and seq number are not set, there will be set when the packet is going to be sent with rtp_session_sendm_with_ts(). If payload_size is zero, thus an empty packet (just a RTP header) is returned.

Parameters:
session a rtp session.
header_size the rtp header size. For standart size (without extensions), it is RTP_FIXED_HEADER_SIZE
payload data to be copied into the rtp packet.
payload_size size of data carried by the rtp packet.
Returns:
a rtp packet in a mblk_t (message block) structure.

mblk_t* rtp_session_create_packet_in_place ( RtpSession session,
uint8_t *  buffer,
int  size,
void(*)(void *)  freefn 
)

Creates a new rtp packet using the buffer given in arguments (no copy). In the header, ssrc and payload_type according to the session's context. Timestamp and seq number are not set, there will be set when the packet is going to be sent with rtp_session_sendm_with_ts(). can be NULL, in that case payload will be kept untouched.

Parameters:
session a rtp session.
buffer a buffer that contains first just enough place to write a RTP header, then the data to send.
size the size of the buffer
freefn a function that will be called once the buffer is no more needed (the data has been sent).
Returns:
a rtp packet in a mblk_t (message block) structure.

mblk_t* rtp_session_create_packet_with_data ( RtpSession session,
uint8_t *  payload,
int  payload_size,
void(*)(void *)  freefn 
)

Creates a new rtp packet using the given payload buffer (no copy). The header will be allocated separetely. In the header, ssrc and payload_type according to the session's context. Timestamp and seq number are not set, there will be set when the packet is going to be sent with rtp_session_sendm_with_ts(). oRTP will send this packet using libc's sendmsg() (if this function is availlable!) so that there will be no packet concatenation involving copies to be done in user-space. can be NULL, in that case payload will be kept untouched.

Parameters:
session a rtp session.
payload the data to be sent with this packet
payload_size size of data
freefn a function that will be called when the payload buffer is no more needed.
Returns:
: a rtp packet in a mblk_t (message block) structure.

void rtp_session_destroy ( RtpSession session  ) 

Destroys a rtp session. All memory allocated for the RtpSession is freed.

Parameters:
session a rtp session.

void rtp_session_enable_rtcp ( RtpSession session,
bool_t  yesno 
)

By default oRTP automatically sends RTCP SR or RR packets. If yesno is set to FALSE, the RTCP sending of packet is disabled. This functionnality might be needed for some equipments that do not support RTCP, leading to a traffic of ICMP errors on the network. It can also be used to save bandwidth despite the RTCP bandwidth is actually and usually very very low.

void rtp_session_flush_sockets ( RtpSession session  ) 

rtp_session_flush_sockets: : a rtp session

Flushes the sockets for all pending incoming packets. This can be usefull if you did not listen to the stream for a while and wishes to start to receive again. During the time no receive is made packets get bufferised into the internal kernel socket structure.

uint32_t rtp_session_get_current_recv_ts ( RtpSession session  ) 

Same thing as rtp_session_get_current_send_ts() except that it's for an incoming stream. Works only on scheduled mode.

Parameters:
session a rtp session.
Returns:
the theoritical that would have to be receive now.

uint32_t rtp_session_get_current_send_ts ( RtpSession session  ) 

When the rtp session is scheduled and has started to send packets, this function computes the timestamp that matches to the present time. Using this function can be usefull when sending discontinuous streams. Some time can be elapsed between the end of a stream burst and the begin of a new stream burst, and the application may be not not aware of this elapsed time. In order to get a valid (current) timestamp to pass to rtp_session_send_with_ts() or rtp_session_sendm_with_ts(), the application may use rtp_session_get_current_send_ts().

Parameters:
session a rtp session.
Returns:
the current send timestamp for the rtp session.

void* rtp_session_get_data ( const RtpSession session  ) 

Parameters:
session a rtp session
Returns:
the void pointer previously set using rtp_session_set_data()

int rtp_session_get_dscp ( const RtpSession session  ) 

rtp_session_get_dscp: : a rtp session

Returns the DSCP (Differentiated Services Code Point) for outgoing RTP packets.

void rtp_session_get_last_recv_time ( RtpSession session,
struct timeval *  tv 
)

Gets last time a valid RTP or RTCP packet was received.

Parameters:
session RtpSession to get last receive time from.
tv Pointer to struct timeval to fill.

int rtp_session_get_local_port ( const RtpSession session  ) 

rtp_session_get_local_port: : a rtp session for which rtp_session_set_local_addr() or rtp_session_set_remote_addr() has been called

This function can be useful to retrieve the local port that was randomly choosen by rtp_session_set_remote_addr() when rtp_session_set_local_addr() was not called.

Returns: the local port used to listen for rtp packets, -1 if not set.

int rtp_session_get_multicast_loopback ( RtpSession session  ) 

rtp_session_get_multicast_loopback: : a rtp session

Returns the multicast loopback state of rtp session (true or false).

int rtp_session_get_multicast_ttl ( RtpSession session  ) 

rtp_session_get_multicast_ttl: : a rtp session

Returns the TTL (Time-To-Live) for outgoing multicast packets.

RtpProfile* rtp_session_get_profile ( RtpSession session  ) 

Parameters:
session a rtp session
DEPRECATED! Returns current send profile. Use rtp_session_get_send_profile() or rtp_session_get_recv_profile()

int rtp_session_get_recv_payload_type ( const RtpSession session  ) 

Parameters:
session a rtp session
Returns:
the payload type currently used in incoming rtp packets

RtpProfile* rtp_session_get_recv_profile ( RtpSession session  ) 

Parameters:
session a rtp session
Returns current receive profile.

int rtp_session_get_send_payload_type ( const RtpSession session  ) 

Parameters:
session a rtp session
Returns:
the payload type currently used in outgoing rtp packets

RtpProfile* rtp_session_get_send_profile ( RtpSession session  ) 

Parameters:
session a rtp session
Returns current send profile.

const rtp_stats_t* rtp_session_get_stats ( const RtpSession session  ) 

Retrieve the session's statistics.

RtpSession* rtp_session_new ( int  mode  ) 

Creates a new rtp session. If the session is able to send data (RTP_SESSION_SENDONLY or RTP_SESSION_SENDRECV), then a random SSRC number is choosed for the outgoing stream.

Parameters:
mode One of the RtpSessionMode flags.
Returns:
the newly created rtp session.

int rtp_session_recv_with_ts ( RtpSession session,
uint8_t *  buffer,
int  len,
uint32_t  ts,
int *  have_more 
)

NOTE: use of this function is discouraged when sending payloads other than pcm/pcmu/pcma/adpcm types. rtp_session_recvm_with_ts() does better job.

Tries to read the bytes of the incoming rtp stream related to timestamp ts. In case where the user supplied buffer is not large enough to get all the data related to timestamp ts, then *( have_more) is set to 1 to indicate that the application should recall the function with the same timestamp to get more data.

When the rtp session is scheduled (see rtp_session_set_scheduling_mode() ), and the blocking mode is on (see rtp_session_set_blocking_mode() ), then the calling thread is suspended until the timestamp given as argument expires, whatever a received packet fits the query or not.

Important note: it is clear that the application cannot know the timestamp of the first packet of the incoming stream, because it can be random. The timestamp given to the function is used relatively to first timestamp of the stream. In simple words, 0 is a good value to start calling this function.

This function internally calls rtp_session_recvm_with_ts() to get a rtp packet. The content of this packet is then copied into the user supplied buffer in an intelligent manner: the function takes care of the size of the supplied buffer and the timestamp given in argument. Using this function it is possible to read continous audio data (e.g. pcma,pcmu...) with for example a standart buffer of size of 160 with timestamp incrementing by 160 while the incoming stream has a different packet size.

Returns: if a packet was availlable with the corresponding timestamp supplied in argument then the number of bytes written in the user supplied buffer is returned. If no packets are availlable, either because the sender has not started to send the stream, or either because silence packet are not transmitted, or either because the packet was lost during network transport, then the function returns zero.

Parameters:
session a rtp session.
buffer a user supplied buffer to write the data.
len the length in bytes of the user supplied buffer.
ts the timestamp wanted.
have_more the address of an integer to indicate if more data is availlable for the given timestamp.

mblk_t* rtp_session_recvm_with_ts ( RtpSession session,
uint32_t  user_ts 
)

Try to get a rtp packet presented as a mblk_t structure from the rtp session. The parameter is relative to the first timestamp of the incoming stream. In other words, the application does not have to know the first timestamp of the stream, it can simply call for the first time this function with =0, and then incrementing it as it want. The RtpSession takes care of synchronisation between the stream timestamp and the user timestamp given here.

Parameters:
session a rtp session.
user_ts a timestamp.
Returns:
a rtp packet presented as a mblk_t.

void rtp_session_register_event_queue ( RtpSession session,
OrtpEvQueue *  q 
)

Register an event queue. An application can use an event queue to get informed about various RTP events.

void rtp_session_release_sockets ( RtpSession session  ) 

Closes the rtp and rtcp sockets.

void rtp_session_reset ( RtpSession session  ) 

Reset the session: local and remote addresses are kept. It resets timestamp, sequence number, and calls rtp_session_resync().

Parameters:
session a rtp session.

void rtp_session_resync ( RtpSession session  ) 

Resynchronize to the incoming RTP streams. This can be useful to handle discoutinuous timestamps. For example, call this function from the timestamp_jump signal handler.

Parameters:
session the rtp session

int rtp_session_send_with_ts ( RtpSession session,
const uint8_t *  buffer,
int  len,
uint32_t  userts 
)

Send a rtp datagram to the destination set by rtp_session_set_remote_addr() containing the data from with timestamp . This is a high level function that uses rtp_session_create_packet() and rtp_session_sendm_with_ts() to send the data.

Parameters:
session a rtp session.
buffer a buffer containing the data to be sent in a rtp packet.
len the length of the data buffer, in bytes.
userts the timestamp of the data to be sent. Refer to the rfc to know what it is.
return the number of bytes sent over the network.

int rtp_session_sendm_with_ts ( RtpSession session,
mblk_t *  mp,
uint32_t  timestamp 
)

Send the rtp datagram to the destination set by rtp_session_set_remote_addr() with timestamp . For audio data, the timestamp is the number of the first sample resulting of the data transmitted. See rfc1889 for details. The packet () is freed once it is sended.

Parameters:
session a rtp session.
mp a rtp packet presented as a mblk_t.
timestamp the timestamp of the data to be sent.
Returns:
the number of bytes sent over the network.

void rtp_session_set_blocking_mode ( RtpSession session,
int  yesno 
)

This function implicitely enables the scheduling mode if yesno is TRUE. rtp_session_set_blocking_mode() defines the behaviour of the rtp_session_recv_with_ts() and rtp_session_send_with_ts() functions. If is TRUE, rtp_session_recv_with_ts() will block until it is time for the packet to be received, according to the timestamp passed to the function. After this time, the function returns. For rtp_session_send_with_ts(), it will block until it is time for the packet to be sent. If is FALSE, then the two functions will return immediately.

Parameters:
session a rtp session
yesno a boolean

void rtp_session_set_connected_mode ( RtpSession session,
bool_t  yesno 
)

If yesno is TRUE, thus a connect() syscall is done on the socket to the destination address set by rtp_session_set_remote_addr(), or if the session does symmetric rtp (see rtp_session_set_symmetric_rtp()) a the connect() is done to the source address of the first packet received. Connecting a socket has effect of rejecting all incoming packets that don't come from the address specified in connect(). It also makes ICMP errors (such as connection refused) available to the application.

Parameters:
session a rtp session
yesno a boolean to enable or disable the feature

void rtp_session_set_data ( RtpSession session,
void *  data 
)

Stores some application specific data into the session, so that it is easy to retrieve it from the signal callbacks using rtp_session_get_data().

Parameters:
session a rtp session
data an opaque pointer to be stored in the session

int rtp_session_set_dscp ( RtpSession session,
int  dscp 
)

rtp_session_set_dscp: : a rtp session : desired DSCP PHB value

Sets the DSCP (Differentiated Services Code Point) for outgoing RTP packets.

Returns: 0 on success.

void rtp_session_set_jitter_compensation ( RtpSession session,
int  milisec 
)

rtp_session_set_jitter_compensation: : a RtpSession : the time interval in milisec to be jitter compensed.

Sets the time interval for which packet are buffered instead of being delivered to the application.

int rtp_session_set_local_addr ( RtpSession session,
const char *  addr,
int  port 
)

rtp_session_set_local_addr: : a rtp session freshly created. : a local IP address in the xxx.xxx.xxx.xxx form. : a local port or -1 to let oRTP choose the port randomly

Specify the local addr to be use to listen for rtp packets or to send rtp packet from. In case where the rtp session is send-only, then it is not required to call this function: when calling rtp_session_set_remote_addr(), if no local address has been set, then the default INADRR_ANY (0.0.0.0) IP address with a random port will be used. Calling rtp_sesession_set_local_addr() is mandatory when the session is recv-only or duplex.

Returns: 0 on success.

int rtp_session_set_multicast_loopback ( RtpSession session,
int  yesno 
)

rtp_session_set_multicast_loopback: : a rtp session : desired Multicast Time-To-Live

Sets the TTL (Time-To-Live) for outgoing multicast packets.

Returns: 0 on success.

int rtp_session_set_multicast_ttl ( RtpSession session,
int  ttl 
)

rtp_session_set_multicast_ttl: : a rtp session : desired Multicast Time-To-Live

Sets the TTL (Time-To-Live) for outgoing multicast packets.

Returns: 0 on success.

int rtp_session_set_payload_type ( RtpSession session,
int  pt 
)

Sets the expected payload type for incoming packets and payload type to be used for outgoing packets. If the actual payload type in incoming packets is different that this expected payload type, thus the "payload_type_changed" signal is emitted.

Parameters:
session a rtp session
paytype the payload type number
Returns:
0 on success, -1 if the payload is not defined.

void rtp_session_set_profile ( RtpSession session,
RtpProfile profile 
)

Set the RTP profile to be used for the session. By default, all session are created by rtp_session_new() are initialized with the AV profile, as defined in RFC 3551. The application can set any other profile instead using that function.

Parameters:
session a rtp session
profile a rtp profile

void rtp_session_set_recv_buf_size ( RtpSession session,
int  bufsize 
)

The default value is 65535 bytes, a big value which is working for everyone. However if your application can make assumption on the MTU, it can be interesting to set it to a lower value in order to save memory.

Parameters:
session a rtp session
bufsize max size in bytes for receiving packets

int rtp_session_set_recv_payload_type ( RtpSession session,
int  paytype 
)

Sets the expected payload type for incoming packets. If the actual payload type in incoming packets is different that this expected payload type, thus the "payload_type_changed" signal is emitted.

Parameters:
session a rtp session
paytype the payload type number
Returns:
0 on success, -1 if the payload is not defined.

void rtp_session_set_recv_profile ( RtpSession session,
RtpProfile profile 
)

Set the RTP profile to be used for the receiveing by this session. By default, all session are created by rtp_session_new() are initialized with the AV profile, as defined in RFC 3551. The application can set any other profile instead using that function.

Parameters:
session a rtp session
profile a rtp profile

int rtp_session_set_remote_addr ( RtpSession session,
const char *  addr,
int  port 
)

rtp_session_set_remote_addr: : a rtp session freshly created. : a local IP address in the xxx.xxx.xxx.xxx form. : a local port.

Sets the remote address of the rtp session, ie the destination address where rtp packet are sent. If the session is recv-only or duplex, it also sets the origin of incoming RTP packets. Rtp packets that don't come from addr:port are discarded.

Returns: 0 on success.

int rtp_session_set_remote_addr_and_port ( RtpSession session,
const char *  addr,
int  rtp_port,
int  rtcp_port 
)

rtp_session_set_remote_addr_and_port: : a rtp session freshly created. : a local IP address in the xxx.xxx.xxx.xxx form. : a local rtp port. : a local rtcp port.

Sets the remote address of the rtp session, ie the destination address where rtp packet are sent. If the session is recv-only or duplex, it also sets the origin of incoming RTP packets. Rtp packets that don't come from addr:port are discarded.

Returns: 0 on success.

void rtp_session_set_scheduling_mode ( RtpSession session,
int  yesno 
)

Sets the scheduling mode of the rtp session. If is TRUE, the rtp session is in the scheduled mode, that means that you can use session_set_select() to block until it's time to receive or send on this session according to the timestamp passed to the respective functions. You can also use blocking mode (see rtp_session_set_blocking_mode() ), to simply block within the receive and send functions. If is FALSE, the ortp scheduler will not manage those sessions, meaning that blocking mode and the use of session_set_select() for this session are disabled.

Parameters:
session a rtp session.
yesno a boolean to indicate the scheduling mode.

int rtp_session_set_send_payload_type ( RtpSession session,
int  paytype 
)

Sets the payload type of the rtp session. It decides of the payload types written in the of the rtp header for the outgoing stream, if the session is SENDRECV or SENDONLY. For payload type in incoming packets, the application can be informed by registering for the "payload_type_changed" signal, so that it can make the necessary changes on the downstream decoder that deals with the payload of the packets.

Parameters:
session a rtp session
paytype the payload type number
Returns:
0 on success, -1 if the payload is not defined.

void rtp_session_set_send_profile ( RtpSession session,
RtpProfile profile 
)

Set the RTP profile to be used for the sending by this session. By default, all session are created by rtp_session_new() are initialized with the AV profile, as defined in RFC 3551. The application can set any other profile instead using that function.

Parameters:
session a rtp session
profile a rtp profile

void rtp_session_set_seq_number ( RtpSession session,
uint16_t  seq 
)

sets the initial sequence number of a sending session.

Parameters:
session a rtp session freshly created.
addr a 16 bit unsigned number.

void rtp_session_set_source_description ( RtpSession session,
const char *  cname,
const char *  name,
const char *  email,
const char *  phone,
const char *  loc,
const char *  tool,
const char *  note 
)

Set session's SDES item for automatic sending of RTCP compound packets. If some items are not specified, use NULL.

void rtp_session_set_ssrc ( RtpSession session,
uint32_t  ssrc 
)

Sets the SSRC for the outgoing stream. If not done, a random ssrc is used.

Parameters:
session a rtp session.
ssrc an unsigned 32bit integer representing the synchronisation source identifier (SSRC).

void rtp_session_set_symmetric_rtp ( RtpSession session,
bool_t  yesno 
)

Enable or disable the "rtp symmetric" hack which consists of the following: after the first packet is received, the source address of the packet is set to be the destination address for all next packets. This is useful to pass-through firewalls.

Parameters:
session a rtp session
yesno a boolean to enable or disable the feature

void rtp_session_set_time_jump_limit ( RtpSession session,
int  milisecs 
)

oRTP has the possibility to inform the application through a callback registered with rtp_session_signal_connect about crazy incoming RTP stream that jumps from a timestamp N to N+some_crazy_value. This lets the opportunity for the application to reset the session in order to resynchronize, or any other action like stopping the call and reporting an error.

Parameters:
session the rtp session
ts_step a time interval in miliseconds

int rtp_session_signal_connect ( RtpSession session,
const char *  signal_name,
RtpCallback  cb,
unsigned long  user_data 
)

This function provides the way for an application to be informed of various events that may occur during a rtp session. is a string identifying the event, and is a user supplied function in charge of processing it. The application can register several callbacks for the same signal, in the limit of RTP_CALLBACK_TABLE_MAX_ENTRIES. Here are name and meaning of supported signals types:

"ssrc_changed" : the SSRC of the incoming stream has changed.

"payload_type_changed" : the payload type of the incoming stream has changed.

"telephone-event_packet" : a telephone-event rtp packet (RFC2833) is received.

"telephone-event" : a telephone event has occured. This is a high-level shortcut for "telephone-event_packet".

"network_error" : a network error happened on a socket. Arguments of the callback functions are a const char * explaining the error, an int errno error code and the user_data as usual.

"timestamp_jump" : we have received a packet with timestamp in far future compared to last timestamp received. The farness of far future is set by rtp_sesssion_set_time_jump_limit() "rtcp_bye": we have received a RTCP bye packet. Arguments of the callback functions are a const char * containing the leaving reason and the user_data.

Returns: 0 on success, -EOPNOTSUPP if the signal does not exists, -1 if no more callbacks can be assigned to the signal type.

Parameters:
session a rtp session
signal_name the name of a signal
cb a RtpCallback
user_data a pointer to any data to be passed when invoking the callback.

int rtp_session_signal_disconnect_by_callback ( RtpSession session,
const char *  signal_name,
RtpCallback  cb 
)

Removes callback function to the list of callbacks for signal .

Parameters:
session a rtp session
signal_name a signal name
cb a callback function.
Returns:
: 0 on success, a negative value if the callback was not found.


Generated on Tue Feb 5 21:35:36 2008 for oRTP by  doxygen 1.5.4