rtpsession.h

Go to the documentation of this file.

/*
The oRTP library is an RTP (Realtime Transport Protocol - rfc3550) stack.
Copyright (C) 2001  Simon MORLAT simon.morlat@linphone.org
 
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
 
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
 
#ifndef RTPSESSION_H
#define RTPSESSION_H
 
#include <ortp/port.h>
#include <ortp/rtp.h>
#include <ortp/payloadtype.h>
#include <ortp/rtcp.h>
#include <ortp/str_utils.h>
#include <ortp/rtpsignaltable.h>
#include <ortp/event.h>
#include <ortp/rtptransport.h>
#include <ortp/stun.h>
#include <ortp/turn.h>
 
typedef enum { RTP_SESSION_RECVONLY, RTP_SESSION_SENDONLY, RTP_SESSION_SENDRECV } RtpSessionMode;
 
typedef enum { RTP_SESSION_SETUP_PASSIVE, RTP_SESSION_SETUP_ACTIVE, RTP_SESSION_SETUP_ACTPASS, RTP_SESSION_SETUP_HOLDCONN } RtpSessionSetup;
 
typedef struct JitterStatistics {
  uint32_t num_entries;
  uint16_t period;
  uint16_t interval;
  float *min_skews;
  float *max_skews;
  struct timeval *times;
  uint32_t index_last;
  float total_skews;
  uint32_t min_skew_index;
  uint32_t max_skew_index;
} JitterStatistics;
 
typedef struct _JBParameters {
  int min_size; 
  int nom_size; 
  int max_size; 
  bool_t adaptive;
  bool_t pad[3];
  int max_packets; 
} JBParameters;
 
typedef struct _JitterControl {
  int count;
  int jitt_comp;    /* the user jitt_comp in miliseconds*/
  int jitt_comp_ts; /* the jitt_comp converted in rtp time (same unit as timestamp) */
  int adapt_jitt_comp_ts;
  int32_t slide;
  int32_t prev_slide;
  float jitter;
  float max_jitter;
 
  JitterStatistics jitter_long_stats;
  JitterStatistics jitter_stats;
 
  int cum_late_packet;
  float cur_max_late_packet;
  int32_t olddiff;
  float inter_jitter; /* interarrival jitter as defined in the RFC */
  int corrective_step;
  int corrective_slide;
  bool_t adaptive;
  bool_t enabled;
  int burst_factor;
  int clock_rate;
  uint64_t average_buffer_size;
  int average_buffer_size_count;
 
  uint32_t prev_packet_ts;
  uint32_t prev_app_ts;
} JitterControl;
 
typedef struct BandwidthStatistics {
  uint32_t final_bytes;
  uint32_t final_overhead_bytes;
 
  uint32_t current_total_bitrate;
  uint32_t current_overhead_bitrate;
  uint32_t num_entries;
  uint16_t period;
  uint32_t *bytes; /* updated to contains more than 65535 bytes */
  uint16_t *overhead_bytes;
  struct timeval *times;
  uint32_t index_last;
  uint32_t total_bytes;
  uint32_t total_overhead_bytes;
} BandwidthStatistics;
 
struct ccmtmmbr_bitrate_table {          /* used for ccm tmmbr */
  uint32_t recv_overhead_realtime_bytes; /* average per packet overhead */
  uint32_t bitrates_table[20];           /* average per packet overhead */
  float bitrates_tables_loss[20];
  uint32_t previous_tmmbr_value;
  uint32_t max_bitrate;
};
 
typedef struct _RtpStream {
  ortp_socket_t socketv4[10];
  struct _RtpTransport *tr;
  int sockfamily[10];
  int max_rq_size;
  int time_jump;
  uint32_t ts_jump;
  queue_t rq;
  queue_t tev_rq;
  mblk_t *cached_mp;
  int loc_port;
  struct sockaddr_storage rem_addr;
  int rem_addrlen;
  void *QoSHandle;
  unsigned long QoSFlowID;
  JitterControl jittctl;
 
  /* Information about outgoing RTP stream */
  uint16_t snd_seq;     /* send sequence number */
  uint32_t snd_last_ts; /* the last stream timestamp sent */
 
  // uint32_t snd_time_offset;/*the scheduler time when the application send its first timestamp*/
  // uint32_t snd_ts_offset;    /* the first application timestamp sent by the application */
  // uint32_t snd_rand_offset;  /* a random number added to the user offset to make the stream timestamp*/
  // uint32_t rcv_time_offset; /*the scheduler time when the application ask for its first timestamp*/
  // uint32_t rcv_ts_offset;  /* the first stream timestamp */
  // uint32_t rcv_query_ts_offset;      /* the first user timestamp asked by the application */
  // uint32_t rcv_last_ret_ts; /* the timestamp of the last sample returned (only for continuous audio)*/
 
  /* local timestamp Information about incoming RTP stream */
  uint32_t rcv_last_app_ts; /* the last application timestamp asked by the application */
  /* Information about incoming RTP stream */
  uint32_t rcv_last_ts;  /* the last stream timestamp got by the application */
  uint32_t hwrcv_extseq; /* last received on socket extended sequence number */
  uint32_t hwrcv_seq_at_last_SR;
  uint32_t hwrcv_since_last_SR;
  uint32_t last_rcv_SR_ts;         /* NTP timestamp (middle 32 bits) of last received SR */
  struct timeval last_rcv_SR_time; /* time at which last SR was received  */
 
  /* Information for outgoing RTCP packets */
  uint32_t last_rtcp_report_snt_r;   /* the time of the last rtcp report sent, in recv timestamp unit */
  uint32_t last_rtcp_report_snt_s;   /* the time of the last rtcp report sent, in send timestamp unit */
  uint32_t rtcp_report_snt_interval; /* the interval in timestamp unit between rtcp report sent */
  uint32_t last_rtcp_packet_count;   /*the sender's octet count in the last sent RTCP SR*/
 
  uint32_t sent_payload_bytes;                  /*used for RTCP sender reports*/
  unsigned int sent_bytes;                      /* used for bandwidth estimation */
  struct timeval send_bw_start;                 /* used for bandwidth estimation */
  unsigned int recv_bytes;                      /* used for bandwidth estimation */
  struct timeval recv_bw_start;                 /* used for bandwidth estimation */
  BandwidthStatistics sent_total_rtp_bitrate;   /* total sent bandwidth: valid RTP+overhead / overhead is IP_UDP_OVERHEAD(28) */
  BandwidthStatistics sent_total_rtcp_bitrate;  /* total sent bandwidth: RTCP+overhead / overhead is IP_UDP_OVERHEAD(28) */
  BandwidthStatistics sent_total_stun_bitrate;  /* total sent bandwidth: STUN, ...+overhead / overhead is IP_UDP_OVERHEAD(28) */
  BandwidthStatistics sent_total_other_bitrate; /* total sent bandwidth: DTLS, ...+overhead / overhead is IP_UDP_OVERHEAD(28) */
 
  BandwidthStatistics recv_total_rtp_bitrate;        /* total recv bandwidth: valid RTP+overhead / overhead is IP_UDP_OVERHEAD(28) */
  BandwidthStatistics recv_total_rtcp_bitrate;       /* total recv bandwidth: RTCP+overhead / overhead is IP_UDP_OVERHEAD(28) */
  BandwidthStatistics recv_total_stun_bitrate;       /* total recv bandwidth: STUN, ...+overhead / overhead is IP_UDP_OVERHEAD(28) */
  BandwidthStatistics recv_total_other_bitrate;      /* total recv bandwidth: DTLS, ...+overhead / overhead is IP_UDP_OVERHEAD(28) */
  BandwidthStatistics recv_total_bad_bitrate;        /* total recv bandwidth: BAD+overhead (bad format, wrong ssrc...) / overhead is IP_UDP_OVERHEAD(28) */
  BandwidthStatistics recv_total_rtppayload_bitrate; /* used for ccm tmmbr: RTP PAYLOAD DATA+overhead // overhead is rtp header + IP_UDP_OVERHEAD(28) */
  struct ccmtmmbr_bitrate_table cur_bitrate_table;
 
  rtp_stats_t stats;
  rtp_extended_stats_t extended_stats;
  int recv_errno;
  int send_errno;
  int snd_socket_size;
  int rcv_socket_size;
  int ssrc_changed_thres;
} RtpStream;
 
typedef struct _RtcpStream {
  ortp_socket_t socketv4[10];
  int sockfamily[10];
  mblk_t *cached_mp;
  struct sockaddr_storage rem_addr;
  int rem_addrlen;
  bool_t enabled;               /*tells whether we can send RTCP packets */
  unsigned int sent_bytes;      /* used for bandwidth estimation */
  struct timeval send_bw_start; /* used for bandwidth estimation */
  unsigned int recv_bytes;      /* used for bandwidth estimation */
  struct timeval recv_bw_start; /* used for bandwidth estimation */
} RtcpStream;
 
typedef struct _RtpSession RtpSession;
 
struct _tc_qos_ifc;
 
struct _tc_qos {
  struct _tc_qos_ifc *ifc;
  int num_ifc;
};
 
struct _RtcpXrStats {
  uint32_t last_rcvr_rtt_ts;         /* NTP timestamp (middle 32 bits) of last received XR rcvr-rtt */
  struct timeval last_rcvr_rtt_time; /* Time at which last XR rcvr-rtt was received  */
};
 
typedef struct _RtcpXrStats RtcpXrStats;
 
struct _ZigzagParams {
  float rtt_limit;
  float rtt_high;
  float rtt_medium;
  float rtt_low;
 
  uint32_t bitrate_severe_issue;
  uint32_t bitrate_medium_issue;
  uint32_t bitrate_minor_issue;
 
  float loss_severe;
  float loss_high;
  float loss_medium;
  float loss_low;
};
 
typedef struct _ZigzagParams ZigzagParams;
 
 
struct _RtpExtension {
  int rtp_ext;
  int id;
  char uri[128];
};
 
typedef struct _RtpExtension RtpExtension;
 
struct _RtpSession {
  RtpSession *next; /* next RtpSession, when the session are enqueued by the scheduler */
  int mask_pos;     /* the position in the scheduler mask of RtpSession : do not move this field: it is part of the ABI since the session_set macros use it*/
  struct {
    RtpProfile *profile;
    int pt;
    unsigned int ssrc;
    int telephone_events_pt; /* the payload type used for telephony events */
    char sdes_mid[32];
  } snd, rcv;
  unsigned int inc_ssrc_candidate;
  int inc_same_ssrc_count;
  int inc_same_ssrc_new_origin_count;
  int hw_recv_pt; /* recv payload type before jitter buffer */
  int recv_buf_size;
  RtpSignalTable on_ssrc_changed;
  RtpSignalTable on_payload_type_changed;
  RtpSignalTable on_telephone_event_packet;
  RtpSignalTable on_telephone_event;
  RtpSignalTable on_timestamp_jump;
  RtpSignalTable on_network_error;
  RtpSignalTable on_rtcp_bye;
  struct _OList *signal_tables;
  struct _OList *eventqs;
  msgb_allocator_t allocator;
  RtpStream rtp;
  RtcpStream rtcp;
  struct _OList *modules_tables;
  RtpSessionMode mode;
  struct _RtpScheduler *sched;
  uint32_t flags;
  int dscp;
  struct _tc_qos tc_qos;
  int multicast_ttl;
  int multicast_loopback;
  void *user_data;
  /* FIXME: Should be a table for all session participants. */
  struct timeval last_recv_time; /* Time of receiving the RTP/RTCP packet. */
  mblk_t *pending;
  /* telephony events extension */
  mblk_t *current_tev; /* the pending telephony events */
  mblk_t *sd;
  queue_t contributing_sources;
  bool_t symmetric_rtp;
  bool_t permissive; /*use the permissive algorithm*/
  bool_t ssrc_set;
  bool_t rtcp_mux;
  bool_t rtcp_rsize;
  struct IceCheckList *rtp_icechecklist;
  struct IceCheckList *rtcp_icechecklist;
  RtpSessionSetup rfc4145_setup;
  unsigned char remote_fingerprint[64];
  struct _RtpBundle *bundle;     /* if this is set, a bundle thread will be used to read data */
  bool_t use_bundle;             /* BUNDLE is active */
  bool_t rtcpfeedback_pli;       /* rtcp feedback with nack pli mode */
  bool_t rtcpfeedback_nack;      /* rtcp feedback with nack mode */
  bool_t rtcpfeedback_ccm_tmmbr; /* rtcp feedback with tmmbr mode */
  bool_t rtcpfeedback_goog_remb; /* rtcp feedback with goog-remb mode */
  bool_t rtcpxr_voip_metrics;    /* rtcp xr with voip-metrics */
  bool_t rtcpxr_send_one_dlrr;   /* one rtcp dlrr must be sent */
  uint16_t rtcpfeedback_nack_retransmission;
#if 0
  uint16_t rtcpfeedback_nack_retransmission2;
#endif
  RtcpXrStats rtcp_xr_stats;
 
  int FEC_N_interval;
  ZigzagParams zparams;
  queue_t nack_rtpq;
  struct _OList *rtpExtensions;
};
 
typedef struct _RtpMedia {
  RtpSession session;
} RtpMedia;
 
/* the first "media" will be used when bundle is active */
typedef struct _RtpBundle {
  struct _OList *rtpMedias;
  ortp_thread_t thread;
  bool_t run;
  ortp_mutex_t lock;
} RtpBundle;
 
struct ortp_dtls_srtp;
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* public API */
void JitterStatistics_init(JitterStatistics *jt_stats, int period, int interval);
void JitterStatistics_update(JitterStatistics *jt_stats, float skew, struct timeval *now);
void JitterStatistics_destroy(JitterStatistics *jt_stats);
 
void BandwidthStatistics_init(BandwidthStatistics *bw_stats, int period);
void BandwidthStatistics_update(BandwidthStatistics *bw_stats, int nbytes, int nbytes_overhead, struct timeval *now);
void BandwidthStatistics_destroy(BandwidthStatistics *bw_stats);
 
RtpBundle *rtp_bundle_new(void);
void rtp_bundle_destroy(RtpBundle *bundle);
void rtp_bundle_lock(RtpBundle *bundle);
void rtp_bundle_unlock(RtpBundle *bundle);
void rtp_bundle_media_add(RtpBundle *bundle, RtpMedia *_RtpMedia, int pos);
void rtp_bundle_media_remove(RtpBundle *bundle, RtpMedia *_RtpMedia);
void rtp_bundle_start(RtpBundle *bundle);
void rtp_bundle_stop(RtpBundle *bundle);
RtpMedia *rtp_media_new(int session_mode, bool_t use_bundle);
void rtp_media_destroy(RtpMedia *media);
void rtp_session_set_bundle(RtpSession *session, struct _RtpBundle *bundle);
 
RtpSession *rtp_session_new(int mode);
void rtp_session_enable_sendrecv(RtpSession *session);
void rtp_session_disable_sendrecv(RtpSession *session);
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);
RtpProfile *rtp_session_get_profile(RtpSession *session);
RtpProfile *rtp_session_get_send_profile(RtpSession *session);
RtpProfile *rtp_session_get_recv_profile(RtpSession *session);
int rtp_session_signal_connect(RtpSession *session, const char *signal_name, RtpCallback cb, uintptr_t 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_recv_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);
float rtp_session_get_average_buffer_size(RtpSession *session);
 
/*deprecated jitter control functions*/
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, int idx, const char *addr, int port);
int rtp_session_get_local_port(const RtpSession *session);
 
int rtp_session_set_remote_addr_full(RtpSession *session, int idx, const char *addr, int rtp_port, int rtcp_port);
/*same as previous function, old name:*/
int rtp_session_set_remote_addr_and_port(RtpSession *session, int idx, const char *addr, int rtp_port, int rtcp_port);
int rtp_session_set_remote_addr(RtpSession *session, int idx, const char *addr, int port);
void rtp_session_set_transports(RtpSession *session, RtpTransport *rtptr);
void rtp_session_add_module(RtpSession *session, RtpModule *module);
RtpModule *rtp_session_get_module(RtpSession *session, const char *name);
int rtp_session_remove_module(RtpSession *session, const char *name);
void rtp_session_module_remove_all(RtpSession *session);
 
/* QOS / DSCP */
int rtp_session_set_dscp(RtpSession *session, int idx, int dscp);
int rtp_session_get_dscp(const RtpSession *session);
 
/* Multicast methods */
int rtp_session_set_multicast_ttl(RtpSession *session, int idx, int ttl);
int rtp_session_get_multicast_ttl(RtpSession *session);
 
int rtp_session_set_multicast_loopback(RtpSession *session, int idx, 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_rtcp_mux(RtpSession *session, bool_t yesno);
 
void rtp_session_set_rtcp_rsize(RtpSession *session, bool_t yesno);
 
void rtp_session_set_rtcp_fb_nack(RtpSession *session, bool_t yesno);
 
void rtp_session_set_rtcp_fb_pli(RtpSession *session, bool_t yesno);
 
void rtp_session_set_rtcp_fb_ccm_tmmbr(RtpSession *session, bool_t yesno);
 
void rtp_session_set_rtcp_fb_goog_remb(RtpSession *session, bool_t yesno);
 
void rtp_session_set_rtcp_xr_voip_metrics(RtpSession *session, bool_t yesno);
void rtp_session_update_voip_metrics(RtpSession *session, int packet_received, int packet_lost, int packet_discarded);
 
void rtp_session_enable_rtcp(RtpSession *session, bool_t yesno);
 
void rtp_session_set_ssrc_changed_threshold(RtpSession *session, int numpackets);
 
/*low level recv and send functions */
mblk_t *rtp_session_recvm_with_ts(RtpSession *session, uint32_t user_ts);
mblk_t *rtp_session_recvm_with_ts_extended(RtpSession *session, uint32_t user_ts, mblk_t **last_dropped);
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_sendm_with_ts(RtpSession *session, mblk_t *mp, uint32_t packet_ts, uint32_t send_ts); /* usefull for test purpose */
/* high level recv and send functions */
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);
 
/* send data without applying module */
int rtp_session_data_send(RtpSession *session, mblk_t *m, int packettype);
 
/* event API*/
void rtp_session_register_event_queue(RtpSession *session, OrtpEvQueue *q);
void rtp_session_unregister_event_queue(RtpSession *session, OrtpEvQueue *q);
 
/* IP bandwidth usage estimation functions, returning bits/s*/
float rtp_session_get_sent_rtp_bandwidth(RtpSession *session, BandwidthStatistics *val);
float rtp_session_get_recv_rtp_bandwidth(RtpSession *session, BandwidthStatistics *val);
float rtp_session_get_sent_stun_bandwidth(RtpSession *session, BandwidthStatistics *val);
float rtp_session_get_recv_stun_bandwidth(RtpSession *session, BandwidthStatistics *val);
float rtp_session_get_sent_other_bandwidth(RtpSession *session, BandwidthStatistics *val);
float rtp_session_get_recv_other_bandwidth(RtpSession *session, BandwidthStatistics *val);
float rtp_session_get_recv_bad_bandwidth(RtpSession *session, BandwidthStatistics *val);
float rtp_session_get_sent_rtcp_bandwidth(RtpSession *session, BandwidthStatistics *val);
float rtp_session_get_recv_rtcp_bandwidth(RtpSession *session, BandwidthStatistics *val);
float rtp_session_get_recv_rtppayload_bandwidth(RtpSession *session, BandwidthStatistics *val);
 
float rtp_session_compute_send_bandwidth(RtpSession *session);
float rtp_session_compute_recv_bandwidth(RtpSession *session);
float rtp_session_compute_rtcp_recv_bandwidth(RtpSession *session);
float rtp_session_compute_rtcp_send_bandwidth(RtpSession *session);
float rtp_session_compute_average_jitter(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);
const rtp_extended_stats_t *rtp_session_get_extented_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);
void rtp_session_set_rtp_socket_send_buffer_size(RtpSession *session, unsigned int size);
void rtp_session_set_rtp_socket_recv_buffer_size(RtpSession *session, unsigned int size);
 
/* in use with the scheduler to convert a timestamp in scheduler time unit (ms) */
uint32_t rtp_session_ts_to_time(RtpSession *session, uint32_t timestamp);
uint32_t rtp_session_time_to_ts(RtpSession *session, int millisecs);
/* this function aims at simulating senders with "imprecise" clocks, resulting in
rtp packets sent with timestamp uncorrelated with the system clock .
This is only availlable to sessions working with the oRTP scheduler */
void rtp_session_make_time_distorsion(RtpSession *session, int milisec);
 
int rtp_session_set_icechecklist(RtpSession *session, struct IceCheckList *rtp_checklist, struct IceCheckList *rtcp_checklist);
int rtp_session_set_max_recv_bitrate(RtpSession *session, uint32_t max_ccm_bitrate);
 
/*RTCP functions */
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);
mblk_t *rtp_session_create_rtcp_xr_vm_packet(RtpSession *session);
mblk_t *rtp_session_create_rtcp_xr_rr_packet(RtpSession *session);
mblk_t *rtp_session_create_rtcp_xr_dlrr_packet(RtpSession *session);
 
void rtp_session_get_last_recv_time(RtpSession *session, struct timeval *tv);
int rtp_session_bye(RtpSession *session, const char *reason);
 
void rtp_session_send_rtcp_fb_NACK(RtpSession *session, const uint16_t cseq, const uint16_t bits);
void rtp_session_send_rtcp_fb_RPSI(RtpSession *session, const uint8_t *bitstring, int bitstring_len);
void rtp_session_send_rtcp_fb_PLI(RtpSession *session);
void rtp_session_send_rtcp_fb_TMMB(RtpSession *session, const uint8_t subtype, const uint32_t ssrc, const uint32_t bitrate, const uint32_t overhead);
void rtp_session_send_rtcp_fb_GOOGREMB(RtpSession *session, const uint32_t ssrc, const uint32_t bitrate);
 
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);
 
/*private */
void rtp_session_init(RtpSession *session, int mode);
#define rtp_session_set_flag(session, flag) (session)->flags |= (flag)
#define rtp_session_unset_flag(session, flag) (session)->flags &= ~(flag)
void rtp_session_uninit(RtpSession *session);
 
void rtp_session_dispatch_event(RtpSession *session, OrtpEvent *ev);
 
int rtp_session_add_extension(RtpSession *session, char *extmap);
void rtp_session_set_recv_sdes_mid(RtpSession *session, char *sdes_mid);
void rtp_session_set_send_sdes_mid(RtpSession *session, char *sdes_mid);
 
#ifdef __cplusplus
}
#endif
 
#endif