src/switch

Bug Summary

File:	src/switch_rtp.c
Warning:	line 8506, column 19 Dereference of null pointer (loaded from variable 'flags')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name switch_rtp.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -menable-no-infs -menable-no-nans -menable-unsafe-fp-math -fno-signed-zeros -mreassociate -freciprocal-math -fno-trapping-math -ffp-contract=fast -ffast-math -ffinite-math-only -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -resource-dir /usr/lib/llvm-7/lib/clang/7.0.1 -D HAVE_CONFIG_H -I . -I ./src/include -I ./libs/esl/src/include -I ./libs/xmlrpc-c -I /drone/src/libs/libvpx -I /drone/src/src/include -I /drone/src/src/include -I /drone/src/libs/libteletone/src -D SWITCH_API_VISIBILITY=1 -D CJSON_API_VISIBILITY=1 -D HAVE_VISIBILITY=1 -D _REENTRANT -D _GNU_SOURCE -I /drone/src/libs/apr/include -I /drone/src/libs/apr-util/include -I /drone/src/libs/apr-util/xml/expat/lib -I /drone/src/libs/srtp/include -I /drone/src/libs/libyuv/include -D SWITCH_HAVE_YUV -I /drone/src/libs/srtp/crypto/include -I libs/srtp/crypto/include -D SWITCH_HAVE_VPX -D ENABLE_SRTP -D SWITCH_HAVE_ODBC -I /usr/include -D SWITCH_HAVE_PNG -I /usr/include/libpng16 -D SWITCH_HAVE_FREETYPE -I /usr/include/freetype2 -I /usr/include/libpng16 -I /usr/include/x86_64-linux-gnu -I /usr/include/editline -D HAVE_OPENSSL -I /usr/include/sofia-sip-1.13 -I /usr/include/uuid -I /drone/src/src/include -I /drone/src/src/include -I /drone/src/libs/libteletone/src -D SWITCH_API_VISIBILITY=1 -D CJSON_API_VISIBILITY=1 -D HAVE_VISIBILITY=1 -D HAVE_OPENSSL -D PIC -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.1/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-result -Wno-misleading-indentation -std=c99 -fdebug-compilation-dir /drone/src -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -o /drone/src/scan-build/2021-10-18-155719-401-1 -x c src/switch_rtp.c -faddrsig
1/*
* FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
* Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
*
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
*
* The Initial Developer of the Original Code is
* Anthony Minessale II <anthm@freeswitch.org>
* Portions created by the Initial Developer are Copyright (C)
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Anthony Minessale II <anthm@freeswitch.org>
* Marcel Barbulescu <marcelbarbulescu@gmail.com>
* Seven Du <dujinfang@gmail.com>
* Noah Mehl - Open Telecom Foundation <https://opentelecom.foundation>
*
* switch_rtp.c -- RTP
*
*/
34#include <switch.h>
35#ifndef _MSC_VER
36#include <switch_private.h>
37#endif
38#include <switch_stun.h>
39#include <apr_network_io.h>
40#undef PACKAGE_NAME"srtp"
41#undef PACKAGE_STRING"srtp 2.4.0"
42#undef PACKAGE_TARNAME"srtp"
43#undef PACKAGE_VERSION"2.4.0"
44#undef PACKAGE_BUGREPORT"mcgrew@cisco.com"
45#undef VERSION"2.4.0"
46#undef PACKAGE"srtp"
47#undef inlineinline
48#include <srtp.h>
49#include <srtp_priv.h>
50#include <switch_ssl.h>
51#include <switch_jitterbuffer.h>

53//#define DEBUG_TS_ROLLOVER
54#ifdef DEBUG_TS_ROLLOVER
55#define TS_ROLLOVER_START 4294951295
56#endif

58//#define DEBUG_2833
59//#define RTP_DEBUG_WRITE_DELTA
60//#define DEBUG_MISSED_SEQ
61//#define DEBUG_EXTRA
62//#define DEBUG_RTCP
63#define DEBUG_ESTIMATORS_


66#define JITTER_LEAD_FRAMES10 10
67#define READ_INC(rtp_session)switch_mutex_lock(rtp_session->read_mutex); rtp_session->
reading++ switch_mutex_lock(rtp_session->read_mutex); rtp_session->reading++
68#define READ_DEC(rtp_session)rtp_session->reading--; switch_mutex_unlock(rtp_session->
read_mutex) rtp_session->reading--; switch_mutex_unlock(rtp_session->read_mutex)
69#define WRITE_INC(rtp_session)switch_mutex_lock(rtp_session->write_mutex); rtp_session->
writing++ switch_mutex_lock(rtp_session->write_mutex); rtp_session->writing++
70#define WRITE_DEC(rtp_session)rtp_session->writing--; switch_mutex_unlock(rtp_session->
write_mutex) rtp_session->writing--; switch_mutex_unlock(rtp_session->write_mutex)

72#define RTP_STUN_FREQ1000000 1000000
73#define rtp_header_len12 12
74#define RTP_START_PORT16384 16384
75#define RTP_END_PORT32768 32768
76#define MASTER_KEY_LEN30   30
77#define RTP_MAGIC_NUMBER42 42
78#define WARN_SRTP_ERRS10 10
79#define MAX_SRTP_ERRS100 100
80#define NTP_TIME_OFFSET2208988800UL 2208988800UL
81#define ZRTP_MAGIC_COOKIE0x5a525450 0x5a525450
82static const switch_payload_t INVALID_PT = 255;

84#define DTMF_SANITY(rtp_session->one_second * 30) (rtp_session->one_second * 30)

86#define rtp_session_name(_rtp_session)_rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(_rtp_session->session)) : "-" _rtp_session->session ? switch_core_session_get_name(_rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(_rtp_session
->session)) : "-"

88#define STUN_USERNAME_MAX_SIZE513 513 /* From RFC5389:  "It MUST contain a UTF-8 [RFC3629] encoded sequence of less than 513 bytes" */
89#define SDP_UFRAG_MAX_SIZE256 256 	/* From draft-ietf-mmusic-ice-sip-sdp-24: "the ice-ufrag attribute MUST NOT be longer than 32
						 * characters when sending, but an implementation MUST accept up to 256
						 * characters when receiving." */

93static switch_port_t START_PORT = RTP_START_PORT16384;
94static switch_port_t END_PORT = RTP_END_PORT32768;
95static switch_mutex_t *port_lock = NULL((void*)0);
96static switch_size_t do_flush(switch_rtp_t *rtp_session, int force, switch_size_t bytes_in);

98typedef srtp_hdr_t rtp_hdr_t;

100#ifdef ENABLE_ZRTP
101#include "zrtp.h"
102static zrtp_global_t *zrtp_global;
103#ifndef WIN32
104static zrtp_zid_t zid = { "FreeSWITCH01" };
105#else
106static zrtp_zid_t zid = { "FreeSWITCH0" };
107#endif
108static int zrtp_on = 0;
109#define ZRTP_MITM_TRIES 100
110#endif

112#ifdef _MSC_VER
113#pragma pack(4)
114#endif

116#ifdef _MSC_VER
117#pragma pack()
118#define ENABLE_SRTP1
119#endif

121static switch_hash_t *alloc_hash = NULL((void*)0);

123typedef struct {
srtp_hdr_t header;
char body[SWITCH_RTP_MAX_BUF_LEN16384+4+sizeof(char *)];
switch_rtp_hdr_ext_t *ext;
char *ebody;
128} rtp_msg_t;

130#define RTP_BODY(_s)(char *) (_s->recv_msg.ebody ? _s->recv_msg.ebody : _s->
recv_msg.body) (char *) (_s->recv_msg.ebody ? _s->recv_msg.ebody : _s->recv_msg.body)

132typedef struct {
uint32_t ssrc;
uint8_t seq;
uint8_t r1;
uint8_t r2;
uint8_t r3;
138} rtcp_fir_t;

140#ifdef _MSC_VER
141#pragma pack(push, r1, 1)
142#endif

144typedef struct switch_rtcp_sdes_unit_s {
unsigned char type;
unsigned char length;
char value[];
148} switch_rtcp_sdes_unit_t;

150typedef struct {
uint32_t ssrc;
uint8_t parts[4];
153} rtcp_tmmbx_t;

155#if SWITCH_BYTE_ORDER1234 == __BIG_ENDIAN4321

157typedef struct {
unsigned version:2;
unsigned p:1;
unsigned fmt:5;
unsigned pt:8;
unsigned length:16;
uint32_t send_ssrc;
uint32_t recv_ssrc;
165} switch_rtcp_ext_hdr_t;

167#else /*  BIG_ENDIAN */

169typedef struct {
unsigned fmt:5;
unsigned p:1;
unsigned version:2;
unsigned pt:8;
unsigned length:16;
uint32_t send_ssrc;
uint32_t recv_ssrc;
177} switch_rtcp_ext_hdr_t;

179#endif

181#ifdef _MSC_VER
182#pragma pack(pop, r1)
183#endif

185#define KALMAN_SYSTEM_MODELS3 3 /*loss, jitter, rtt*/
186#define EST_LOSS0 0
187#define EST_JITTER1 1
188#define EST_RTT2 2

190typedef struct {
switch_rtcp_ext_hdr_t header;
char body[SWITCH_RTCP_MAX_BUF_LEN16384];
193} rtcp_ext_msg_t;

195typedef struct {
switch_rtcp_hdr_t header;
char body[SWITCH_RTCP_MAX_BUF_LEN16384];
198} rtcp_msg_t;


201typedef enum {
VAD_FIRE_TALK = (1 << 0),
VAD_FIRE_NOT_TALK = (1 << 1)
204} vad_talk_mask_t;

206struct switch_rtp_vad_data {
switch_core_session_t *session;
switch_codec_t vad_codec;
switch_codec_t *read_codec;
uint32_t bg_level;
uint32_t bg_count;
uint32_t bg_len;
uint32_t diff_level;
uint8_t hangunder;
uint8_t hangunder_hits;
uint8_t hangover;
uint8_t hangover_hits;
uint8_t cng_freq;
uint8_t cng_count;
switch_vad_flag_t flags;
uint32_t ts;
uint8_t start;
uint8_t start_count;
uint8_t scan_freq;
time_t next_scan;
switch_time_t start_talking;
switch_time_t stop_talking;
switch_time_t total_talk_time;
int fire_events;
230};

232struct switch_rtp_rfc2833_data {
switch_queue_t *dtmf_queue;
char out_digit;
unsigned char out_digit_packet[4];
unsigned int out_digit_sofar;
unsigned int out_digit_sub_sofar;
unsigned int out_digit_dur;
uint16_t in_digit_seq;
uint32_t in_digit_ts;
uint32_t last_in_digit_ts;
uint32_t in_digit_sanity;
uint32_t in_interleaved;
uint32_t timestamp_dtmf;
uint16_t last_duration;
uint32_t flip;
char first_digit;
char last_digit;
switch_queue_t *dtmf_inqueue;
switch_mutex_t *dtmf_mutex;
uint8_t in_digit_queued;
252};

254typedef struct {
char *ice_user;
char *user_ice;
char *luser_ice;
char *pass;
char *rpass;
switch_sockaddr_t *addr;
uint32_t funny_stun;
switch_time_t next_run;
switch_core_media_ice_type_t type;
ice_t *ice_params;
ice_proto_t proto;
uint8_t sending;
uint8_t ready;
uint8_t rready;
int missed_count;
char last_sent_id[13];
switch_time_t last_ok;
272} switch_rtp_ice_t;

274struct switch_rtp;

276static void switch_rtp_dtls_init();
277static void switch_rtp_dtls_destroy();

279#define MAX_DTLS_MTU4096 4096

281typedef struct switch_dtls_s {
/* DTLS */
SSL_CTX *ssl_ctx;
SSL *ssl;
BIO *read_bio;
BIO *write_bio;
BIO *filter_bio;
dtls_fingerprint_t *local_fp;
dtls_fingerprint_t *remote_fp;
dtls_state_t state;
dtls_state_t last_state;
uint8_t new_state;
dtls_type_t type;
switch_size_t bytes;
void *data;
switch_socket_t *sock_output;
switch_sockaddr_t *remote_addr;
char *rsa;
char *pvt;
char *ca;
char *pem;
struct switch_rtp *rtp_session;
int mtu;
304} switch_dtls_t;

306typedef int (*dtls_state_handler_t)(switch_rtp_t *, switch_dtls_t *);


309static int dtls_state_handshake(switch_rtp_t *rtp_session, switch_dtls_t *dtls);
310static int dtls_state_ready(switch_rtp_t *rtp_session, switch_dtls_t *dtls);
311static int dtls_state_setup(switch_rtp_t *rtp_session, switch_dtls_t *dtls);
312static int dtls_state_fail(switch_rtp_t *rtp_session, switch_dtls_t *dtls);

314dtls_state_handler_t dtls_states[DS_INVALID] = {NULL((void*)0), dtls_state_handshake, dtls_state_setup, dtls_state_ready, dtls_state_fail};

316typedef struct ts_normalize_s {
uint32_t last_ssrc;
uint32_t last_frame;
uint32_t ts;
uint32_t delta;
uint32_t delta_ttl;
int last_external;
323} ts_normalize_t;

325struct switch_rtp {
/*
* Two sockets are needed because we might be transcoding protocol families
* (e.g. receive over IPv4 and send over IPv6). In case the protocol
* families are equal, sock_input == sock_output and only one socket is
* used.
*/
switch_socket_t *sock_input, *sock_output, *rtcp_sock_input, *rtcp_sock_output;
switch_pollfd_t *read_pollfd, *rtcp_read_pollfd;
switch_pollfd_t *jb_pollfd;

switch_sockaddr_t *local_addr, *rtcp_local_addr;
rtp_msg_t send_msg;
rtcp_msg_t rtcp_send_msg;
switch_rtcp_frame_t rtcp_frame;

uint8_t send_rr;
uint8_t fir_seq;
uint16_t fir_count;
uint16_t pli_count;
uint32_t cur_tmmbr;
uint32_t tmmbr;
uint32_t tmmbn;

ts_normalize_t ts_norm;
switch_sockaddr_t *remote_addr, *rtcp_remote_addr;
rtp_msg_t recv_msg;
rtcp_msg_t rtcp_recv_msg;
rtcp_msg_t *rtcp_recv_msg_p;

uint32_t autoadj_window;
uint32_t autoadj_threshold;
uint32_t autoadj_tally;

uint32_t rtcp_autoadj_window;
uint32_t rtcp_autoadj_threshold;
uint32_t rtcp_autoadj_tally;

srtp_ctx_t *send_ctx[2];
srtp_ctx_t *recv_ctx[2];

srtp_policy_t send_policy[2];
srtp_policy_t recv_policy[2];

uint32_t srtp_errs[2];
uint32_t srctp_errs[2];


int srtp_idx_rtp;
int srtp_idx_rtcp;

switch_dtls_t *dtls;
switch_dtls_t *rtcp_dtls;

rtp_hdr_t last_rtp_hdr;

uint16_t seq;
uint32_t ssrc;
uint32_t remote_ssrc;
uint32_t last_jb_read_ssrc;
int8_t sending_dtmf;
uint8_t need_mark;
switch_payload_t payload;
switch_rtp_invalid_handler_t invalid_handler;
void *private_data;
uint32_t ts;
//uint32_t last_clock_ts;
uint32_t last_write_ts;
uint32_t last_read_ts;
uint32_t prev_read_ts;
uint32_t last_cng_ts;
uint32_t last_write_samplecount;
uint32_t delay_samples;
uint32_t next_write_samplecount;
uint32_t max_next_write_samplecount;
uint32_t queue_delay;
switch_time_t last_write_timestamp;
uint32_t flags[SWITCH_RTP_FLAG_INVALID];
switch_memory_pool_t *pool;
switch_sockaddr_t *from_addr, *rtp_from_addr, *rtcp_from_addr, *bundle_internal_addr, *bundle_external_addr;
char *rx_host;
switch_port_t rx_port;
switch_rtp_ice_t ice;
switch_rtp_ice_t rtcp_ice;
char *timer_name;
char *local_host_str;
char *remote_host_str;
char *eff_remote_host_str;
switch_time_t first_stun;
switch_time_t last_stun;
uint32_t wrong_addrs;
uint32_t samples_per_interval;
uint32_t samples_per_second;
uint32_t conf_samples_per_interval;
switch_time_t rtcp_last_sent;
uint32_t rsamples_per_interval;
uint32_t ms_per_packet;
uint32_t one_second;
uint32_t consecutive_flaws;
uint32_t jitter_lead;
double old_mean;
switch_time_t next_stat_check_time;
switch_port_t local_port;
switch_port_t remote_port;
switch_port_t eff_remote_port;
switch_port_t remote_rtcp_port;

struct switch_rtp_vad_data vad_data;
struct switch_rtp_rfc2833_data dtmf_data;
switch_payload_t te;
switch_payload_t recv_te;
switch_payload_t cng_pt;
switch_mutex_t *flag_mutex;
switch_mutex_t *read_mutex;
switch_mutex_t *write_mutex;
switch_mutex_t *ice_mutex;
switch_timer_t timer;
switch_timer_t write_timer;
uint8_t ready;
uint8_t cn;
switch_jb_t *jb;
switch_jb_t *vb;
switch_jb_t *vbw;
uint32_t max_missed_packets;
uint32_t missed_count;
switch_time_t last_media;
uint32_t media_timeout;
rtp_msg_t write_msg;
switch_rtp_crypto_key_t *crypto_keys[SWITCH_RTP_CRYPTO_MAX];
int reading;
int writing;
char *stun_ip;
switch_port_t stun_port;
int from_auto;
uint32_t cng_count;
switch_rtp_bug_flag_t rtp_bugs;
switch_rtp_stats_t stats;
switch_rtcp_video_stats_t rtcp_vstats;
uint32_t clean_stream;
uint32_t bad_stream;
uint32_t recovering_stream;

uint32_t hot_hits;
uint32_t sync_packets;
int rtcp_interval;
int rtcp_sent_packets;
switch_bool_t rtcp_fresh_frame;

switch_time_t send_time;
switch_byte_t auto_adj_used;
switch_byte_t rtcp_auto_adj_used;
uint8_t pause_jb;
uint16_t last_seq;
uint16_t last_write_seq;
uint8_t video_delta_mode;
switch_time_t last_read_time;
switch_size_t last_flush_packet_count;
uint32_t interdigit_delay;
switch_core_session_t *session;
payload_map_t **pmaps;
payload_map_t *pmap_tail;
kalman_estimator_t *estimators[KALMAN_SYSTEM_MODELS3];
cusum_kalman_detector_t *detectors[KALMAN_SYSTEM_MODELS3];
int ice_adj;
uint8_t has_rtp;
uint8_t has_rtcp;
uint8_t has_ice;
uint8_t punts;
uint8_t clean;
uint32_t last_max_vb_frames;
int skip_timer;
uint32_t prev_nacks_inflight;
497#ifdef ENABLE_ZRTP
zrtp_session_t *zrtp_session;
zrtp_profile_t *zrtp_profile;
zrtp_stream_t *zrtp_stream;
int zrtp_mitm_tries;
int zinit;
503#endif

505};

507struct switch_rtcp_report_block {
uint32_t ssrc; /* The SSRC identifier of the source to which the information in this reception report block pertains. */
unsigned int fraction :8; /* The fraction of RTP data packets from source SSRC_n lost since the previous SR or RR packet was sent */
int lost :24; /* The total number of RTP data packets from source SSRC_n that have been lost since the beginning of reception */
uint32_t highest_sequence_number_received;
uint32_t jitter; /* An estimate of the statistical variance of the RTP data packet interarrival time, measured in timestamp units and expressed as an unsigned integer. */
uint32_t lsr; /* The middle 32 bits out of 64 in the NTP timestamp */
uint32_t dlsr; /* The delay, expressed in units of 1/65536 seconds, between receiving the last SR packet from source SSRC_n and sending this reception report block */
515};

517struct switch_rtcp_sr_head {
uint32_t ssrc;
uint32_t ntp_msw;
uint32_t ntp_lsw;
uint32_t ts;
uint32_t pc;
uint32_t oc;
524};

526struct switch_rtcp_sender_info {
uint32_t ntp_msw;
uint32_t ntp_lsw;
uint32_t ts;
uint32_t pc;
uint32_t oc;
532};

534struct switch_rtcp_sender_report {
uint32_t ssrc;
struct switch_rtcp_sender_info sender_info;
struct switch_rtcp_report_block report_block;
538};

540struct switch_rtcp_receiver_report {
uint32_t ssrc;
struct switch_rtcp_report_block report_block;
543};

545typedef enum {
RESULT_CONTINUE,
RESULT_GOTO_END,
RESULT_GOTO_RECVFROM,
RESULT_GOTO_TIMERCHECK
550} handle_rfc2833_result_t;

552static void do_2833(switch_rtp_t *rtp_session);


555#define rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio") rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ?  "text" : (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio")


558static void switch_rtp_change_ice_dest(switch_rtp_t *rtp_session, switch_rtp_ice_t *ice, const char *host, switch_port_t port)
559{
int is_rtcp = ice == &rtp_session->rtcp_ice;
const char *err = "";

ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_addr = switch_core_strdup(rtp_session->pool, host)switch_core_perform_strdup(rtp_session->pool, host, "src/switch_rtp.c"
, (const char *)__func__, 563);
ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_port = port;
ice->missed_count = 0;

if (is_rtcp) {
ice->addr = rtp_session->rtcp_remote_addr;
} else {
switch_rtp_set_remote_address(rtp_session, host, port, 0, SWITCH_FALSE, &err);

if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
	ice->addr = rtp_session->remote_addr;
}
}

577}



581static handle_rfc2833_result_t handle_rfc2833(switch_rtp_t *rtp_session, switch_size_t bytes, int *do_cng)
582{

if (rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON]) {
rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON]++;

if (rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] > DTMF_SANITY(rtp_session->one_second * 30)) {
	rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] = 0;
} else {
	rtp_session->stats.inbound.last_processed_seq = 0;
}
}


595#ifdef DEBUG_2833
if (rtp_session->dtmf_data.in_digit_sanity && !(rtp_session->dtmf_data.in_digit_sanity % 100)) {
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 597, ((void*)0), SWITCH_LOG_ERROR, "sanity %d %ld\n", rtp_session->dtmf_data.in_digit_sanity, bytes);
}
599#endif

if (rtp_session->dtmf_data.in_digit_sanity && !--rtp_session->dtmf_data.in_digit_sanity) {

rtp_session->dtmf_data.last_digit = 0;
rtp_session->dtmf_data.in_digit_ts = 0;
rtp_session->dtmf_data.in_digit_queued = 0;
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 606, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Failed DTMF sanity check.\n");
}

if (!bytes) return RESULT_CONTINUE;


/* RFC2833 ... like all RFC RE: VoIP, guaranteed to drive you to insanity!
  We know the real rules here, but if we enforce them, it's an interop nightmare so,
  we put up with as much as we can so we don't have to deal with being punished for
  doing it right. Nice guys finish last!
*/

if (bytes > rtp_header_len12 && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] &&
rtp_session->last_rtp_hdr.pt == rtp_session->recv_te) {
switch_size_t len = bytes - rtp_header_len12;
unsigned char *packet = (unsigned char *) RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body);
int end;
uint16_t duration;
char key;
uint16_t in_digit_seq;
uint32_t ts;

rtp_session->stats.inbound.last_processed_seq = 0;

if (!(packet[0] || packet[1] || packet[2] || packet[3]) && len >= 8) {
	packet += 4;
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 632, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "DTMF payload offset by 4 bytes.\n");
}

if (!(packet[0] || packet[1] || packet[2] || packet[3]) && rtp_session->dtmf_data.in_digit_ts) {
	switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 637, (const char*)(session), SWITCH_LOG_ERROR, "Failed DTMF payload check.\n");
	rtp_session->dtmf_data.last_digit = 0;
	rtp_session->dtmf_data.in_digit_ts = 0;
	rtp_session->dtmf_data.in_digit_sanity = 0;
	rtp_session->dtmf_data.in_digit_queued = 0;
}

end = packet[1] & 0x80 ? 1 : 0;
duration = (packet[2] << 8) + packet[3];
key = switch_rfc2833_to_char(packet[0]);
in_digit_seq = ntohs((uint16_t) rtp_session->last_rtp_hdr.seq)__bswap_16 ((uint16_t) rtp_session->last_rtp_hdr.seq);
ts = htonl(rtp_session->last_rtp_hdr.ts)__bswap_32 (rtp_session->last_rtp_hdr.ts);

if (rtp_session->flags[SWITCH_RTP_FLAG_PASS_RFC2833]) {

	if (end) {
		rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] = DTMF_SANITY(rtp_session->one_second * 30) - 3;
	} else if (!rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON]) {
		rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] = 1;
	}

	return RESULT_CONTINUE;
}

if (in_digit_seq < rtp_session->dtmf_data.in_digit_seq) {
	if (rtp_session->dtmf_data.in_digit_seq - in_digit_seq > 100) {
		rtp_session->dtmf_data.in_digit_seq = 0;
	}
}
666#ifdef DEBUG_2833
if (!(packet[0] || packet[1] || packet[2] || packet[3]) && len >= 8) {
	len -= 4;
}
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 670, ((void*)0), SWITCH_LOG_ERROR, "packet[%d]: %02x %02x %02x %02x\n", (int) len, (unsigned char) packet[0], (unsigned char) packet[1], (unsigned char) packet[2], (unsigned char) packet[3]);
671#endif

if (in_digit_seq > rtp_session->dtmf_data.in_digit_seq) {

	rtp_session->dtmf_data.in_digit_seq = in_digit_seq;
676#ifdef DEBUG_2833

	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 678, ((void*)0), SWITCH_LOG_ERROR, "read: %c %u %u %u %u %d %d %s\n",
					  key, in_digit_seq, rtp_session->dtmf_data.in_digit_seq,
		   ts, duration, rtp_session->last_rtp_hdr.m, end, end && !rtp_session->dtmf_data.in_digit_ts ? "ignored" : "");
681#endif


	if (rtp_session->dtmf_data.in_digit_ts && rtp_session->dtmf_data.in_digit_ts != ts) {
		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 685, ((void*)0), SWITCH_LOG_DEBUG, "TS changed from last packet, resetting....\n");
		rtp_session->dtmf_data.last_digit = 0;
		rtp_session->dtmf_data.in_digit_ts = 0;
		rtp_session->dtmf_data.in_digit_sanity = 0;
		rtp_session->dtmf_data.in_digit_queued = 0;
	}


	if (!rtp_session->dtmf_data.in_digit_queued && rtp_session->dtmf_data.in_digit_ts) {
		if ((rtp_session->rtp_bugs & RTP_BUG_IGNORE_DTMF_DURATION)) {
			switch_dtmf_t dtmf = { key, switch_core_min_dtmf_duration(0), 0, SWITCH_DTMF_RTP };
696#ifdef DEBUG_2833
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 697, ((void*)0), SWITCH_LOG_ERROR, "Early Queuing digit %c:%d\n", dtmf.digit, dtmf.duration / 8);
698#endif
			switch_rtp_queue_rfc2833_in(rtp_session, &dtmf);
			rtp_session->dtmf_data.in_digit_queued = 1;
		}

		if (rtp_session->jb && (rtp_session->rtp_bugs & RTP_BUG_FLUSH_JB_ON_DTMF)) {
			switch_jb_reset(rtp_session->jb);
		}

	}

	/* only set sanity if we do NOT ignore the packet */
	if (rtp_session->dtmf_data.in_digit_ts) {
		rtp_session->dtmf_data.in_digit_sanity = 2000;
	}

	if (rtp_session->dtmf_data.last_duration > duration &&
		rtp_session->dtmf_data.last_duration > 0xFC17 && ts == rtp_session->dtmf_data.in_digit_ts) {
		rtp_session->dtmf_data.flip++;
	}

	if (end) {
		if (!rtp_session->dtmf_data.in_digit_ts && rtp_session->dtmf_data.last_in_digit_ts != ts) {
721#ifdef DEBUG_2833
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 722, ((void*)0), SWITCH_LOG_ERROR, "start with end packet %d\n", ts);
723#endif
			rtp_session->dtmf_data.last_in_digit_ts = ts;
			rtp_session->dtmf_data.in_digit_ts = ts;
			rtp_session->dtmf_data.first_digit = key;
			rtp_session->dtmf_data.in_digit_sanity = 2000;
		}
		if (rtp_session->dtmf_data.in_digit_ts) {
			switch_dtmf_t dtmf = { key, duration, 0, SWITCH_DTMF_RTP };

			if (ts > rtp_session->dtmf_data.in_digit_ts) {
				dtmf.duration += (ts - rtp_session->dtmf_data.in_digit_ts);
			}
			if (rtp_session->dtmf_data.flip) {
				dtmf.duration += rtp_session->dtmf_data.flip * 0xFFFF;
				rtp_session->dtmf_data.flip = 0;
738#ifdef DEBUG_2833
				switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 739, ((void*)0), SWITCH_LOG_ERROR, "you're welcome!\n");
740#endif
			}
742#ifdef DEBUG_2833
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 743, ((void*)0), SWITCH_LOG_ERROR, "done digit=%c ts=%u start_ts=%u dur=%u ddur=%u\n",
				   dtmf.digit, ts, rtp_session->dtmf_data.in_digit_ts, duration, dtmf.duration);
745#endif

			if (!(rtp_session->rtp_bugs & RTP_BUG_IGNORE_DTMF_DURATION) && !rtp_session->dtmf_data.in_digit_queued) {
748#ifdef DEBUG_2833
				switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 749, ((void*)0), SWITCH_LOG_ERROR, "Queuing digit %c:%d\n", dtmf.digit, dtmf.duration / 8);
750#endif
				switch_rtp_queue_rfc2833_in(rtp_session, &dtmf);
			}

			rtp_session->dtmf_data.last_digit = rtp_session->dtmf_data.first_digit;

			rtp_session->dtmf_data.in_digit_ts = 0;
			rtp_session->dtmf_data.in_digit_sanity = 0;
			rtp_session->dtmf_data.in_digit_queued = 0;
			*do_cng = 1;
		} else {
			if (!switch_rtp_ready(rtp_session)) {
				return RESULT_GOTO_END;
			}
			switch_cond_next();
			return RESULT_GOTO_RECVFROM;
		}

	} else if (!rtp_session->dtmf_data.in_digit_ts) {
769#ifdef DEBUG_2833
		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 770, ((void*)0), SWITCH_LOG_ERROR, "start %d [%c]\n", ts, key);
771#endif
		rtp_session->dtmf_data.in_digit_ts = ts;
		rtp_session->dtmf_data.last_in_digit_ts = ts;
		rtp_session->dtmf_data.first_digit = key;
		rtp_session->dtmf_data.in_digit_sanity = 2000;
	}

	rtp_session->dtmf_data.last_duration = duration;
} else {
780#ifdef DEBUG_2833
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 781, ((void*)0), SWITCH_LOG_ERROR, "drop: %c %u %u %u %u %d %d\n",
		   key, in_digit_seq, rtp_session->dtmf_data.in_digit_seq, ts, duration, rtp_session->last_rtp_hdr.m, end);
783#endif
	switch_cond_next();
	return RESULT_GOTO_RECVFROM;
}
}

if (rtp_session->dtmf_data.in_digit_ts) {
if (!switch_rtp_ready(rtp_session)) {
	return RESULT_GOTO_END;
}

if (!rtp_session->dtmf_data.in_interleaved && rtp_session->last_rtp_hdr.pt != rtp_session->recv_te) {
	/* Drat, they are sending audio still as well as DTMF ok fine..... *sigh* */
	rtp_session->dtmf_data.in_interleaved = 1;
}

if (rtp_session->dtmf_data.in_interleaved || (rtp_session->rtp_bugs & RTP_BUG_IGNORE_DTMF_DURATION)) {
	if (rtp_session->last_rtp_hdr.pt == rtp_session->recv_te) {
		return RESULT_GOTO_RECVFROM;
	}
} else {
	*do_cng = 1;
	return RESULT_GOTO_TIMERCHECK;
}
}

return RESULT_CONTINUE;
810}

812static int rtp_write_ready(switch_rtp_t *rtp_session, uint32_t bytes, int line);
813static int global_init = 0;
814static int rtp_common_write(switch_rtp_t *rtp_session,
					rtp_msg_t *send_msg, void *data, uint32_t datalen, switch_payload_t payload, uint32_t timestamp, switch_frame_flag_t *flags);


818static switch_status_t ice_out(switch_rtp_t *rtp_session, switch_rtp_ice_t *ice)
819{
uint8_t buf[256] = { 0 };
switch_stun_packet_t *packet;
unsigned int elapsed;
switch_size_t bytes;
switch_status_t status = SWITCH_STATUS_SUCCESS;
//switch_sockaddr_t *remote_addr = rtp_session->remote_addr;
switch_socket_t *sock_output = rtp_session->sock_output;
switch_time_t now = switch_micro_time_now();

if (ice->type & ICE_LITE) {
// no connectivity checks for ICE-Lite
return SWITCH_STATUS_BREAK;
}

if (ice->next_run && ice->next_run > now) {
return SWITCH_STATUS_BREAK;
}

ice->next_run = now + RTP_STUN_FREQ1000000;

if (ice == &rtp_session->rtcp_ice && rtp_session->rtcp_sock_output) {
sock_output = rtp_session->rtcp_sock_output;
}

if (!sock_output) {
return SWITCH_STATUS_FALSE;
}

switch_assert(rtp_session != NULL)((rtp_session != ((void*)0)) ? (void) (0) : __assert_fail ("rtp_session != ((void*)0)"
, "src/switch_rtp.c", 848, __extension__ __PRETTY_FUNCTION__)
);
switch_assert(ice->ice_user != NULL)((ice->ice_user != ((void*)0)) ? (void) (0) : __assert_fail
 ("ice->ice_user != ((void*)0)", "src/switch_rtp.c", 849, __extension__
 __PRETTY_FUNCTION__));

READ_INC(rtp_session)switch_mutex_lock(rtp_session->read_mutex); rtp_session->
reading++;

if (rtp_session->last_stun) {
elapsed = (unsigned int) ((switch_micro_time_now() - rtp_session->last_stun) / 1000);

if (elapsed > 30000) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 857, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "No %s stun for a long time!\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
	rtp_session->last_stun = switch_micro_time_now();
	//status = SWITCH_STATUS_GENERR;
	//goto end;
}
}

packet = switch_stun_packet_build_header(SWITCH_STUN_BINDING_REQUEST, NULL((void*)0), buf);
switch_stun_packet_attribute_add_username(packet, ice->ice_user, (uint16_t)strlen(ice->ice_user));

memcpy(ice->last_sent_id, packet->header.id, 12);

//if (ice->pass && ice->type == ICE_GOOGLE_JINGLE) {
//	switch_stun_packet_attribute_add_password(packet, ice->pass, (uint16_t)strlen(ice->pass));
//}

if ((ice->type & ICE_VANILLA)) {
char sw[128] = "";

switch_stun_packet_attribute_add_priority(packet, ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].priority);

switch_snprintf(sw, sizeof(sw), "FreeSWITCH (%s)", switch_version_revision_human());
switch_stun_packet_attribute_add_software(packet, sw, (uint16_t)strlen(sw));

if ((ice->type & ICE_CONTROLLED)) {
	switch_stun_packet_attribute_add_controlled(packet);
} else {
	switch_stun_packet_attribute_add_controlling(packet);
	switch_stun_packet_attribute_add_use_candidate(packet);
}

switch_stun_packet_attribute_add_integrity(packet, ice->rpass);
switch_stun_packet_attribute_add_fingerprint(packet);
}


bytes = switch_stun_packet_length(packet)__bswap_16 (packet->header.length) + (sizeof(switch_stun_packet_header_t
));

895#ifdef DEBUG_EXTRA
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 896, (const char*)(rtp_session->session), SWITCH_LOG_CRIT, "%s send %s stun\n", rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
897#endif
switch_socket_sendto(sock_output, ice->addr, 0, (void *) packet, &bytes);

ice->sending = 3;

// end:
READ_DEC(rtp_session)rtp_session->reading--; switch_mutex_unlock(rtp_session->
read_mutex);

return status;
906}

908int icecmp(const char *them, switch_rtp_ice_t *ice)
909{
if (strchr(them, ':')) {
return strcmp(them, ice->user_ice);
}

return strcmp(them, ice->luser_ice);
915}

917static void handle_ice(switch_rtp_t *rtp_session, switch_rtp_ice_t *ice, void *data, switch_size_t len)
918{
switch_stun_packet_t *packet;
switch_stun_packet_attribute_t *attr;
void *end_buf;
char username[STUN_USERNAME_MAX_SIZE513] = { 0 };
unsigned char buf[1500] = { 0 };
switch_size_t cpylen = len;
int xlen = 0;
int ok = 1;
uint32_t *pri = NULL((void*)0);
int is_rtcp = ice == &rtp_session->rtcp_ice;
uint32_t elapsed;
switch_time_t ref_point;

//if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
//	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "WTF OK %s CALL\n", rtp_type(rtp_session));
//}

if (!switch_rtp_ready(rtp_session) || zstr(ice->user_ice)_zstr(ice->user_ice) || zstr(ice->ice_user)_zstr(ice->ice_user)) {
return;
}

READ_INC(rtp_session)switch_mutex_lock(rtp_session->read_mutex); rtp_session->
reading++;
WRITE_INC(rtp_session)switch_mutex_lock(rtp_session->write_mutex); rtp_session->
writing++;

switch_mutex_lock(rtp_session->ice_mutex);

if (!switch_rtp_ready(rtp_session)) {
goto end;
}

if (cpylen > sizeof(buf)) {
cpylen = sizeof(buf);
}


memcpy(buf, data, cpylen);
packet = switch_stun_packet_parse(buf, (uint32_t)cpylen);
if (!packet) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 957, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Invalid STUN/ICE packet received %ld bytes\n", (long)cpylen);
goto end;

}

rtp_session->last_stun = switch_micro_time_now();

if (!rtp_session->first_stun) {
rtp_session->first_stun = rtp_session->last_stun;
}

if (ice->last_ok) {
ref_point = ice->last_ok;
} else {
ref_point = rtp_session->first_stun;
}

elapsed = (unsigned int) ((switch_micro_time_now() - ref_point) / 1000);


end_buf = buf + ((sizeof(buf) > packet->header.length) ? packet->header.length : sizeof(buf));

switch_stun_packet_first_attribute(packet, attr)attr = (switch_stun_packet_attribute_t *)(&packet->first_attribute
);;
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 980, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG8, "%s STUN PACKET TYPE: %s\n",
			  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), switch_stun_value_to_name(SWITCH_STUN_TYPE_PACKET_TYPE, packet->header.type));
do {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 983, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG8, "|---: %s STUN ATTR %d %x %s\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), attr->type, attr->type,
				  switch_stun_value_to_name(SWITCH_STUN_TYPE_ATTRIBUTE, attr->type));

switch (attr->type) {
case SWITCH_STUN_ATTR_USE_CAND:
	{
		ice->rready = 1;
	}
	break;
case SWITCH_STUN_ATTR_ERROR_CODE:
	{
		switch_stun_error_code_t *err = (switch_stun_error_code_t *) attr->value;
		uint32_t code = (err->code * 100) + err->number;

		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 997, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "%s got %s stun binding response %u\n",
						  rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-",
						  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"),
						  code
						  );

		if ((ice->type & ICE_VANILLA) && code == 487) {
			if ((ice->type & ICE_CONTROLLED)) {
				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1005, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "%s STUN Changing role to CONTROLLING\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
				ice->type &= ~ICE_CONTROLLED;
			} else {
				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1008, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "%s STUN Changing role to CONTROLLED\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
				ice->type |= ICE_CONTROLLED;
			}
			packet->header.type = SWITCH_STUN_BINDING_RESPONSE;
		}

	}
	break;
case SWITCH_STUN_ATTR_MAPPED_ADDRESS:
	{
		char ip[50];
		uint16_t port;
		switch_stun_packet_attribute_get_mapped_address(attr, ip, sizeof(ip), &port);
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1021, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG8, "|------: %s:%d\n", ip, port);
	}
	break;
case SWITCH_STUN_ATTR_XOR_MAPPED_ADDRESS:
	{
		char ip[50];
		uint16_t port;
		switch_stun_packet_attribute_get_xor_mapped_address(attr, &packet->header, ip, sizeof(ip), &port);
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1029, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG8, "|------: %s:%d\n", ip, port);
	}
	break;
case SWITCH_STUN_ATTR_USERNAME:
	{
		switch_stun_packet_attribute_get_username(attr, username, sizeof(username));
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1035, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG8, "|------: %s\n", username);
	}
	break;

case SWITCH_STUN_ATTR_PRIORITY:
	{
		uint32_t priority = 0;
		pri = (uint32_t *) attr->value;
		priority = ntohl(*pri)__bswap_32 (*pri);
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1044, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG8, "|------: %u\n", priority);
		ok = priority == ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].priority;
	}
	break;
}

if (!switch_stun_packet_next_attribute(attr, end_buf)(attr && (attr = (switch_stun_packet_attribute_t *) (
attr->value + (int16_t)((attr->length & 0x3) ? 0x4 +
 (attr->length & ~0x3) : attr->length))) &&
 ((void *)attr < end_buf) && attr->type &&
 (((switch_byte_t *)attr + (int16_t)((attr->length & 0x3
) ? 0x4 + (attr->length & ~0x3) : attr->length)) <
 (switch_byte_t *)end_buf))) {
	break;
}

xlen += 4 + switch_stun_attribute_padded_length(attr)(int16_t)((attr->length & 0x3) ? 0x4 + (attr->length
 & ~0x3) : attr->length);
} while (xlen <= packet->header.length);

if ((ice->type & ICE_GOOGLE_JINGLE) && ok) {
ok = !strcmp(ice->user_ice, username);
}

if (packet->header.type != SWITCH_STUN_BINDING_REQUEST && packet->header.type != SWITCH_STUN_BINDING_RESPONSE) {
goto end;
}

if ((ice->type & ICE_VANILLA)) {
if (!ok) ok = !memcmp(packet->header.id, ice->last_sent_id, 12);

if (packet->header.type == SWITCH_STUN_BINDING_RESPONSE) {
	ok = 1;
	if (!ice->rready) {
		if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
			rtp_session->ice.rready = 1;
			rtp_session->rtcp_ice.rready = 1;
		} else {
			ice->rready = 1;
		}

		if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
			switch_core_session_video_reinit(rtp_session->session);
		}
	}
}

if (!ok && ice == &rtp_session->ice && rtp_session->rtcp_ice.ice_params && pri &&
	*pri == rtp_session->rtcp_ice.ice_params->cands[rtp_session->rtcp_ice.ice_params->chosen[1]][1].priority) {
	ice = &rtp_session->rtcp_ice;
	ok = 1;
}

if (!zstr(username)_zstr(username)) {
	if (!icecmp(username, ice)) {
		ok = 1;
	} else if(!zstr(rtp_session->rtcp_ice.user_ice)_zstr(rtp_session->rtcp_ice.user_ice) && !icecmp(username, &rtp_session->rtcp_ice)) {
		ice = &rtp_session->rtcp_ice;
		ok = 1;
	}
}

if (ok) {
	ice->missed_count = 0;
} else {
	switch_rtp_ice_t *icep[2] = { &rtp_session->ice, &rtp_session->rtcp_ice };
	switch_port_t port = 0;
	char *host = NULL((void*)0);

	if (elapsed > 20000 && pri) {
		int i, j;
		uint32_t old;
		//const char *tx_host;
		const char *old_host, *err = NULL((void*)0);
		//char bufa[50];
		char bufb[50];
		char adj_port[6];
		switch_channel_t *channel = NULL((void*)0);


		ice->missed_count++;
		//switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "missed %d\n", ice->missed_count);


		if (rtp_session->session) {
			channel = switch_core_session_get_channel(rtp_session->session);
		}

		//ice->ice_params->cands[ice->ice_params->chosen][ice->proto].priority;
		for (j = 0; j < 2; j++) {
			if (!icep[j] || !icep[j]->ice_params) {
				continue;
			}
			for (i = 0; i < icep[j]->ice_params->cand_idx[icep[j]->proto]; i++) {
				if (icep[j]->ice_params &&  icep[j]->ice_params->cands[i][icep[j]->proto].priority == *pri) {
					if (j == IPR_RTP) {
						icep[j]->ice_params->chosen[j] = i;
						switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1134, (const char*)(rtp_session->session), SWITCH_LOG_INFO, "Change candidate index to %d\n", i);
					}

					ice = icep[j];
					ok = 1;

					if (j != IPR_RTP) {
						break;
					}

					old = rtp_session->remote_port;

					//tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->from_addr);
					old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);

					host = ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_addr;
					port = ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_port;

					if (!host || !port) {
						switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1153, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error setting remote host!\n");
						switch_mutex_unlock(rtp_session->ice_mutex);
						return;
					}

					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1158, (const char*)(rtp_session->session), SWITCH_LOG_INFO,
									  "%s ICE Auto Changing port from %s:%u to %s:%u\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), old_host, old, host, port);


					if (channel) {
						switch_channel_set_variable(channel, "remote_media_ip_reported", switch_channel_get_variable(channel, "remote_media_ip"))switch_channel_set_variable_var_check(channel, "remote_media_ip_reported"
, switch_channel_get_variable_dup(channel, "remote_media_ip",
 SWITCH_TRUE, -1), SWITCH_TRUE);
						switch_channel_set_variable(channel, "remote_media_ip", host)switch_channel_set_variable_var_check(channel, "remote_media_ip"
, host, SWITCH_TRUE);
						switch_channel_set_variable(channel, "rtp_auto_adjust_ip", host)switch_channel_set_variable_var_check(channel, "rtp_auto_adjust_ip"
, host, SWITCH_TRUE);
						switch_snprintf(adj_port, sizeof(adj_port), "%u", port);
						switch_channel_set_variable(channel, "remote_media_port_reported", switch_channel_get_variable(channel, "remote_media_port"))switch_channel_set_variable_var_check(channel, "remote_media_port_reported"
, switch_channel_get_variable_dup(channel, "remote_media_port"
, SWITCH_TRUE, -1), SWITCH_TRUE);
						switch_channel_set_variable(channel, "remote_media_port", adj_port)switch_channel_set_variable_var_check(channel, "remote_media_port"
, adj_port, SWITCH_TRUE);
						switch_channel_set_variable(channel, "rtp_auto_adjust_port", adj_port)switch_channel_set_variable_var_check(channel, "rtp_auto_adjust_port"
, adj_port, SWITCH_TRUE);
						switch_channel_set_variable(channel, "rtp_auto_candidate_adjust", "true")switch_channel_set_variable_var_check(channel, "rtp_auto_candidate_adjust"
, "true", SWITCH_TRUE);
					}
					rtp_session->auto_adj_used = 1;


					switch_rtp_set_remote_address(rtp_session, host, port, 0, SWITCH_FALSE, &err);
					if (switch_sockaddr_info_get(&ice->addr, host, SWITCH_UNSPEC0, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS ||
						!ice->addr) {
						switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1178, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error setting remote host!\n");
						switch_mutex_unlock(rtp_session->ice_mutex);
						return;
					}

					if ((rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST)) {
						switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
					} else {
						switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
					}

				}
			}
		}
	}
}
}

if (ice->missed_count > 5 && !(ice->type & ICE_GOOGLE_JINGLE)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1197, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "missed too many: %d, looking for new ICE dest.\n",
				  ice->missed_count);
ice->rready = 0;
ok = 1;
}


//if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] || 1) {
//	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "WTF OK %s %d\n", rtp_type(rtp_session), ok);
//}

if (ok) {
const char *host = NULL((void*)0), *host2 = NULL((void*)0);
switch_port_t port = 0, port2 = 0;
char buf[80] = "";
char buf2[80] = "";

if (packet->header.type == SWITCH_STUN_BINDING_REQUEST) {
	uint8_t stunbuf[512];
	switch_stun_packet_t *rpacket;
	const char *remote_ip;
	switch_size_t bytes;
	char ipbuf[50];
	switch_sockaddr_t *from_addr = rtp_session->from_addr;
	switch_socket_t *sock_output = rtp_session->sock_output;
	uint8_t do_adj = 0;
	switch_time_t now = switch_micro_time_now();
	int cmp = 0;
	int cur_idx = -1;//, is_relay = 0;
	int i;
	
	if (is_rtcp) {
		from_addr = rtp_session->rtcp_from_addr;
		sock_output = rtp_session->rtcp_sock_output;
	}

	if (!ice->ready) {
		ice->ready = 1;
	}

	memset(stunbuf, 0, sizeof(stunbuf));
	rpacket = switch_stun_packet_build_header(SWITCH_STUN_BINDING_RESPONSE, packet->header.id, stunbuf);

	if ((ice->type & ICE_GOOGLE_JINGLE)) {
		switch_stun_packet_attribute_add_username(rpacket, username, (uint16_t)strlen(username));
	}

	remote_ip = switch_get_addr(ipbuf, sizeof(ipbuf), from_addr);

	switch_stun_packet_attribute_add_xor_binded_address(rpacket, (char *) remote_ip, switch_sockaddr_get_port(from_addr), from_addr->family);

	if ((ice->type & ICE_VANILLA)) {
		switch_stun_packet_attribute_add_integrity(rpacket, ice->pass);
		switch_stun_packet_attribute_add_fingerprint(rpacket);
	}

	bytes = switch_stun_packet_length(rpacket)__bswap_16 (rpacket->header.length) + (sizeof(switch_stun_packet_header_t
));

	host = switch_get_addr(buf, sizeof(buf), from_addr);
	port = switch_sockaddr_get_port(from_addr);
	host2 = switch_get_addr(buf2, sizeof(buf2), ice->addr);
	port2 = switch_sockaddr_get_port(ice->addr);
	cmp = switch_cmp_addr(from_addr, ice->addr);

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1261, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG4,
					  "STUN from %s:%d %s\n", host, port, cmp ? "EXPECTED" : "IGNORED");

	if (cmp) {
		ice->last_ok = now;
		rtp_session->wrong_addrs = 0;
	} else {
		if (((rtp_session->dtls && rtp_session->dtls->state != DS_READY) || !ice->ready || !ice->rready) &&
			rtp_session->wrong_addrs > 2 && rtp_session->ice_adj == 0) {
			do_adj++;
			rtp_session->ice_adj = 1;
			rtp_session->wrong_addrs = 0;
		} else if (rtp_session->wrong_addrs > 10 || elapsed >= 10000) {
			do_adj++;
		}

		if (!do_adj) {
			rtp_session->wrong_addrs++;
		}

		for (i = 0; i < ice->ice_params->cand_idx[ice->proto]; i++) {
			if (!strcmp(ice->ice_params->cands[i][ice->proto].con_addr, host)) {
				cur_idx = i;
				//if (!strcasecmp(ice->ice_params->cands[i][ice->proto].cand_type, "relay")) {
				//	is_relay = 1;
				//}
			}
		}
		
		
		if (ice->ice_params && ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].cand_type &&
			!strcasecmp(ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].cand_type, "relay")) {
			do_adj++;
		}
	}
	
	if ((ice->type & ICE_VANILLA) && ice->ice_params && do_adj) {
		ice->missed_count = 0;
		ice->rready = 1;

		if (cur_idx > -1) {
			ice->ice_params->chosen[ice->proto] = cur_idx;
		}
		
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1305, (const char*)(rtp_session->session), SWITCH_LOG_NOTICE,
						  "Auto Changing %s stun/%s/dtls port from %s:%u to %s:%u idx:%d\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), is_rtcp ? "rtcp" : "rtp",
						  host2, port2,
						  host, port, cur_idx);

		switch_rtp_change_ice_dest(rtp_session, ice, host, port);
		ice->last_ok = now;
		rtp_session->wrong_addrs = 0;
	}
	//if (cmp) {
	switch_socket_sendto(sock_output, from_addr, 0, (void *) rpacket, &bytes);
	//}
}
} else if (packet->header.type == SWITCH_STUN_BINDING_ERROR_RESPONSE) {

if (rtp_session->session) {
	switch_core_session_message_t msg = { 0 };
	msg.from = __FILE__"src/switch_rtp.c";
	msg.numeric_arg = packet->header.type;
	msg.pointer_arg = packet;
	msg.message_id = SWITCH_MESSAGE_INDICATE_STUN_ERROR;
	switch_core_session_receive_message(rtp_session->session, &msg)switch_core_session_perform_receive_message(rtp_session->session
, &msg, "src/switch_rtp.c", (const char *)__func__, 1326);
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1327, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG,
					  "STUN/ICE binding error received on %s channel\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
}

}




end:
switch_mutex_unlock(rtp_session->ice_mutex);
WRITE_DEC(rtp_session)rtp_session->writing--; switch_mutex_unlock(rtp_session->
write_mutex);
READ_DEC(rtp_session)rtp_session->reading--; switch_mutex_unlock(rtp_session->
read_mutex);
1340}

1342#ifdef ENABLE_ZRTP
1343SWITCH_STANDARD_SCHED_FUNC(zrtp_cache_save_callback)static void zrtp_cache_save_callback (switch_scheduler_task_t
 *task)
1344{
zrtp_status_t status = zrtp_status_ok;

status = zrtp_def_cache_store(zrtp_global);
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 1348, ((void*)0), SWITCH_LOG_DEBUG, "Saving ZRTP cache: %s\n", zrtp_status_ok == status ? "OK" : "FAIL");
task->runtime = switch_epoch_time_now(NULL((void*)0)) + 900;
1350}

1352static int zrtp_send_rtp_callback(const zrtp_stream_t *stream, char *rtp_packet, unsigned int rtp_packet_length)
1353{
switch_rtp_t *rtp_session = zrtp_stream_get_userdata(stream);
switch_size_t len = rtp_packet_length;
zrtp_status_t status = zrtp_status_ok;

if (!rtp_session->sock_output) {
return status;
}

switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, rtp_packet, &len);
return status;
1364}

1366static void zrtp_event_callback(zrtp_stream_t *stream, unsigned event)
1367{
switch_rtp_t *rtp_session = zrtp_stream_get_userdata(stream);
zrtp_session_info_t zrtp_session_info;

switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
switch_event_t *fsevent = NULL((void*)0);
const char *type;

type = rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio");

switch (event) {
case ZRTP_EVENT_IS_SECURE:
{
	rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_SEND] = 1;
	rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_RECV] = 1;
	if (!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
		rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 1;
		rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 1;
	}
	if (zrtp_status_ok == zrtp_session_get(stream->session, &zrtp_session_info)) {
		if (zrtp_session_info.sas_is_ready) {

			switch_channel_set_variable_name_printf(channel, "true", "zrtp_secure_media_confirmed_%s", type);
			switch_channel_set_variable_name_printf(channel, stream->session->sas1.buffer, "zrtp_sas1_string_%s", type);
			switch_channel_set_variable_name_printf(channel, stream->session->sas2.buffer, "zrtp_sas2_string", type);
			zrtp_verified_set(zrtp_global, &stream->session->zid, &stream->session->peer_zid, (uint8_t)1);
		}
	}

	if (!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {


		if (rtp_session->session) {
			switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
			switch_rtp_t *video_rtp_session = switch_channel_get_private(channel, "__zrtp_video_rtp_session");

			if (!video_rtp_session) {
				video_rtp_session = switch_channel_get_private_partner(channel, "__zrtp_video_rtp_session");
			}

			if (video_rtp_session) {
				if (zrtp_status_ok != zrtp_stream_attach(stream->session, &video_rtp_session->zrtp_stream)) {
					abort();
				}
				zrtp_stream_set_userdata(video_rtp_session->zrtp_stream, video_rtp_session);
				if (switch_true(switch_channel_get_variable(channel, "zrtp_enrollment")switch_channel_get_variable_dup(channel, "zrtp_enrollment", SWITCH_TRUE
, -1))) {
					zrtp_stream_registration_start(video_rtp_session->zrtp_stream, video_rtp_session->ssrc);
				} else {
					zrtp_stream_start(video_rtp_session->zrtp_stream, video_rtp_session->ssrc);
				}
			}
		}
	}

	if (switch_event_create(&fsevent, SWITCH_EVENT_CALL_SECURE)switch_event_create_subclass_detailed("src/switch_rtp.c", (const
 char * )(const char *)__func__, 1421, &fsevent, SWITCH_EVENT_CALL_SECURE
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
		switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_media_type", "%s", type);
		switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_type", "zrtp:%s:%s", stream->session->sas1.buffer,
								stream->session->sas2.buffer);
		switch_event_add_header_string(fsevent, SWITCH_STACK_BOTTOM, "caller-unique-id", switch_channel_get_uuid(channel));
		switch_event_fire(&fsevent)switch_event_fire_detailed("src/switch_rtp.c", (const char * )
(const char *)__func__, 1426, &fsevent, ((void*)0));
	}
}
break;
1430#if 0
case ZRTP_EVENT_NO_ZRTP_QUICK:
{
	if (stream != NULL((void*)0)) {
		zrtp_stream_stop(stream);
	}
}
break;
1438#endif
case ZRTP_EVENT_IS_CLIENT_ENROLLMENT:
{
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1441, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "Enrolled complete!\n");
	switch_channel_set_variable_name_printf(channel, "true", "zrtp_enroll_complete_%s", type);
}
break;

case ZRTP_EVENT_USER_ALREADY_ENROLLED:
{
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1448, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "User already enrolled!\n");
	switch_channel_set_variable_name_printf(channel, "true", "zrtp_already_enrolled_%s", type);
}
break;

case ZRTP_EVENT_NEW_USER_ENROLLED:
{
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1455, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "New user enrolled!\n");
	switch_channel_set_variable_name_printf(channel, "true", "zrtp_new_user_enrolled_%s", type);
}
break;

case ZRTP_EVENT_USER_UNENROLLED:
{
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1462, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "User unenrolled!\n");
	switch_channel_set_variable_name_printf(channel, "true", "zrtp_user_unenrolled_%s", type);
}
break;

case ZRTP_EVENT_IS_PENDINGCLEAR:
{
	switch_channel_set_variable_name_printf(channel, "false", "zrtp_secure_media_confirmed_%s", type);
	rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_SEND] = 0;
	rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_RECV] = 0;
	rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
	rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
	rtp_session->zrtp_mitm_tries = 0;
}
break;

case ZRTP_EVENT_NO_ZRTP:
{
	switch_channel_set_variable_name_printf(channel, "false", "zrtp_secure_media_confirmed_%s", type);
}
break;

default:
break;
}
1487}

1489static void zrtp_logger(int level, const char *data, int len, int offset)
1490{
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 1491, ((void*)0), SWITCH_LOG_DEBUG, "%s", data);
1492}
1493#endif

1495SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_init(switch_memory_pool_t *pool)
1496{
1497#ifdef ENABLE_ZRTP
const char *zid_string = switch_core_get_variable_pdup("switch_serial", pool);
const char *zrtp_enabled = switch_core_get_variable_pdup("zrtp_enabled", pool);
zrtp_config_t zrtp_config;
char zrtp_cache_path[256] = "";
zrtp_on = zrtp_enabled ? switch_true(zrtp_enabled) : 0;
1503#endif
if (global_init) {
return;
}
switch_core_hash_init(&alloc_hash)switch_core_hash_init_case(&alloc_hash, SWITCH_TRUE);
1508#ifdef ENABLE_ZRTP
if (zrtp_on) {
uint32_t cache_len;
zrtp_config_defaults(&zrtp_config);
strcpy(zrtp_config.client_id, "FreeSWITCH");
zrtp_config.is_mitm = 1;
zrtp_config.lic_mode = ZRTP_LICENSE_MODE_ACTIVE;
switch_snprintf(zrtp_cache_path, sizeof(zrtp_cache_path), "%s%szrtp.dat", SWITCH_GLOBAL_dirs.db_dir, SWITCH_PATH_SEPARATOR"/");
cache_len=(uint32_t)strlen(zrtp_cache_path);
ZSTR_SET_EMPTY(zrtp_config.def_cache_path);
zrtp_config.def_cache_path.length = cache_len > zrtp_config.def_cache_path.max_length ? zrtp_config.def_cache_path.max_length : (uint16_t)cache_len;
strncpy(zrtp_config.def_cache_path.buffer, zrtp_cache_path, zrtp_config.def_cache_path.max_length);
zrtp_config.cb.event_cb.on_zrtp_protocol_event = (void (*)(zrtp_stream_t*,zrtp_protocol_event_t))zrtp_event_callback;
zrtp_config.cb.misc_cb.on_send_packet = zrtp_send_rtp_callback;
zrtp_config.cb.event_cb.on_zrtp_security_event = (void (*)(zrtp_stream_t*,zrtp_security_event_t))zrtp_event_callback;
zrtp_log_set_log_engine((zrtp_log_engine *) zrtp_logger);
zrtp_log_set_level(4);
if (zrtp_status_ok == zrtp_init(&zrtp_config, &zrtp_global)) {
	memcpy(zid, zid_string, 12);
	switch_scheduler_add_task(switch_epoch_time_now(NULL((void*)0)) + 900, zrtp_cache_save_callback, "zrtp_cache_save", "core", 0, NULL((void*)0),
							  SSHF_NONE | SSHF_NO_DEL);
} else {
	switch_core_set_variable("zrtp_enabled", NULL((void*)0));
	zrtp_on = 0;
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 1532, ((void*)0), SWITCH_LOG_CRIT, "ZRTP init failed!\n");
}
}
1535#endif
1536#ifdef ENABLE_SRTP1
{
srtp_err_status_t stat = srtp_init();
if (stat == srtp_err_status_ok) { 
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 1540, ((void*)0), SWITCH_LOG_DEBUG, "SRTP (%s) initialized.\n", srtp_get_version_string());
} else {
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 1542, ((void*)0), SWITCH_LOG_ERROR, "Error initializing SRTP (%d).\n", stat);
}
}
1545#endif
switch_mutex_init(&port_lock, SWITCH_MUTEX_NESTED0x1, pool);
switch_rtp_dtls_init();
global_init = 1;
1549}

1551static uint8_t get_next_write_ts(switch_rtp_t *rtp_session, uint32_t timestamp)
1552{
uint8_t m = 0, changed = 0;

if (!(rtp_session->rtp_bugs & RTP_BUG_SEND_LINEAR_TIMESTAMPS)) {
if (timestamp) {
	rtp_session->ts = (uint32_t) timestamp;
	changed++;
} else if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER)) {
	switch_core_timer_next(&rtp_session->write_timer);
	rtp_session->ts = rtp_session->write_timer.samplecount;
	changed++;
}
}

if (!changed) {
rtp_session->ts = rtp_session->last_write_ts + rtp_session->samples_per_interval;
} else {
/* Send marker bit if timestamp is lower/same as before (resetted/new timer) */
if (abs((int32_t)(rtp_session->ts - rtp_session->last_write_ts)) > rtp_session->samples_per_interval 
	&& !(rtp_session->rtp_bugs & RTP_BUG_NEVER_SEND_MARKER)) {
	m++;
}
}

return m;
1577}

1579static void do_mos(switch_rtp_t *rtp_session) {
int R;

if ((switch_size_t)rtp_session->stats.inbound.recved < rtp_session->stats.inbound.flaws) {
rtp_session->stats.inbound.flaws = 0;
}

if (rtp_session->stats.inbound.recved > 0 &&
rtp_session->stats.inbound.flaws && (rtp_session->stats.inbound.last_flaw != rtp_session->stats.inbound.flaws)) {

if (rtp_session->consecutive_flaws++) {
	int penalty = rtp_session->consecutive_flaws;

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1592, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, "%s %s %d consecutive flaws, adding %d flaw penalty\n",
					  rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"),
					  rtp_session->consecutive_flaws, penalty);
	rtp_session->bad_stream++;
	rtp_session->stats.inbound.flaws += penalty;
	rtp_session->stats.inbound.last_flaw = rtp_session->stats.inbound.flaws;
	
	if (rtp_session->stats.inbound.error_log) {
		rtp_session->stats.inbound.error_log->flaws += penalty;
		rtp_session->stats.inbound.error_log->consecutive_flaws++;
	}
}
} else {
rtp_session->consecutive_flaws = 0;
}

R = (int)((double)((double)(rtp_session->stats.inbound.recved - rtp_session->stats.inbound.flaws) / (double)rtp_session->stats.inbound.recved) * 100.0);

if (R < 0 || R > 100) R = 100;

rtp_session->stats.inbound.R = R;
rtp_session->stats.inbound.mos = 1 + (0.035) * R + (.000007) * R * (R-60) * (100-R);

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1615, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "%s %s stat %0.2f %ld/%d flaws: %ld mos: %0.2f v: %0.2f %0.2f/%0.2f\n",
			  rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-",
			  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"),
			  rtp_session->stats.inbound.R,
			  (long int)(rtp_session->stats.inbound.recved - rtp_session->stats.inbound.flaws), rtp_session->stats.inbound.recved,
			  (long int)rtp_session->stats.inbound.flaws,
			  rtp_session->stats.inbound.mos,
			  rtp_session->stats.inbound.variance,
			  rtp_session->stats.inbound.min_variance,
			  rtp_session->stats.inbound.max_variance
			  );

1627}

1629void burstr_calculate ( int loss[], int received, double *burstr, double *lossr )
1630{
int lost = 0;
int bursts = 0;
int i;

for ( i = 0; i < LOST_BURST_ANALYZE500; i++ ) {
lost += i * loss[i];
bursts += loss[i];
}
if (received > 0 && bursts > 0) {
*burstr = (double)((double)lost / (double)bursts) / (double)(1.0 / ( 1.0 - (double)lost / (double)received ));
if (*burstr < 0) {
	*burstr = - *burstr;
}
} else {
*burstr = 0;
}
if (received > 0) {
*lossr = (double)((double)lost / (double)received);
} else {
*lossr = 0;
}
1652}

1654static void reset_jitter_seq(switch_rtp_t *rtp_session)
1655{
rtp_session->stats.inbound.last_proc_time = 0;
rtp_session->stats.inbound.last_processed_seq = 0;
rtp_session->jitter_lead = 0;
rtp_session->consecutive_flaws = 0;
rtp_session->stats.inbound.last_flaw = 0;
1661}

1663static void check_jitter(switch_rtp_t *rtp_session)
1664{
switch_time_t current_time;
int64_t diff_time = 0, cur_diff = 0;
int seq;

current_time = switch_micro_time_now() / 1000;

if (rtp_session->flags[SWITCH_RTP_FLAG_PAUSE] || rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] || rtp_session->dtmf_data.in_digit_ts) {
reset_jitter_seq(rtp_session);
return;
}

if (++rtp_session->jitter_lead < JITTER_LEAD_FRAMES10 || !rtp_session->stats.inbound.last_proc_time) {
rtp_session->stats.inbound.last_proc_time = current_time;
return;
}

diff_time = (current_time - rtp_session->stats.inbound.last_proc_time);
seq = (int)(uint16_t) ntohs((uint16_t) rtp_session->last_rtp_hdr.seq)__bswap_16 ((uint16_t) rtp_session->last_rtp_hdr.seq);

/* Burst and Packet Loss */
rtp_session->stats.inbound.recved++;

if (rtp_session->stats.inbound.last_processed_seq > 0 && seq > (int)(rtp_session->stats.inbound.last_processed_seq + 1)) {
int lost = (seq - rtp_session->stats.inbound.last_processed_seq - 1);

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1690, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, "%s Got: %s seq %d but expected: %d lost: %d\n",
				  rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-",
				  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"),
				  seq,
				  (rtp_session->stats.inbound.last_processed_seq + 1), lost);
rtp_session->stats.inbound.last_loss++;

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
	switch_core_session_request_video_refresh(rtp_session->session)_switch_core_session_request_video_refresh(rtp_session->session
, 0, "src/switch_rtp.c", (const char *)__func__, 1698);
}

if (rtp_session->stats.inbound.last_loss > 0 && rtp_session->stats.inbound.last_loss < LOST_BURST_CAPTURE1024) {
	rtp_session->stats.inbound.loss[rtp_session->stats.inbound.last_loss] += lost;
}

rtp_session->bad_stream++;
rtp_session->stats.inbound.flaws += lost;

if (rtp_session->stats.inbound.error_log) {
	rtp_session->stats.inbound.error_log->flaws += lost;
}

} else {
rtp_session->stats.inbound.last_loss = 0;
}

rtp_session->stats.inbound.last_processed_seq = seq;

/* Burst and Packet Loss */

if (current_time > rtp_session->next_stat_check_time) {
rtp_session->next_stat_check_time = current_time + 5000;
burstr_calculate(rtp_session->stats.inbound.loss, rtp_session->stats.inbound.recved,
				 &(rtp_session->stats.inbound.burstrate), &(rtp_session->stats.inbound.lossrate));
do_mos(rtp_session);
} else {
do_mos(rtp_session);
}

if (rtp_session->stats.inbound.last_loss || rtp_session->bad_stream) {
if (rtp_session->session && (!rtp_session->stats.inbound.error_log || rtp_session->stats.inbound.error_log->stop)) {
	struct error_period *error = switch_core_session_alloc(rtp_session->session, sizeof(*error))switch_core_perform_session_alloc(rtp_session->session, sizeof
(*error), "src/switch_rtp.c", (const char *)__func__, 1731);
	error->start = switch_micro_time_now();
	error->next = rtp_session->stats.inbound.error_log;
	rtp_session->stats.inbound.error_log = error;
}

if (!rtp_session->stats.inbound.last_loss) {
	if (++rtp_session->recovering_stream > (rtp_session->one_second * 3)) {
		if (rtp_session->session && rtp_session->stats.inbound.error_log) {
			rtp_session->stats.inbound.error_log->stop = switch_micro_time_now();
		}

		rtp_session->bad_stream = 0;
	}
} else {
	rtp_session->recovering_stream = 0;
	rtp_session->bad_stream++;
}
} else {
rtp_session->recovering_stream = 0;
rtp_session->clean_stream++;
}


if ( diff_time < 0 ) {
diff_time = -diff_time;
}

rtp_session->stats.inbound.jitter_n++;
rtp_session->stats.inbound.jitter_add += diff_time;

if (rtp_session->stats.inbound.mean_interval) {
cur_diff = (int64_t)(diff_time - rtp_session->stats.inbound.mean_interval);
} else {
cur_diff = 0;
}

rtp_session->stats.inbound.jitter_addsq += (cur_diff * cur_diff);
rtp_session->stats.inbound.last_proc_time = current_time;

if (rtp_session->stats.inbound.jitter_n > 0) {
double ipdv;

rtp_session->stats.inbound.mean_interval = (double)rtp_session->stats.inbound.jitter_add / (double)rtp_session->stats.inbound.jitter_n;

if (!rtp_session->old_mean) {
	rtp_session->old_mean = rtp_session->stats.inbound.mean_interval;
}

rtp_session->stats.inbound.variance = (double)rtp_session->stats.inbound.jitter_addsq / (double)rtp_session->stats.inbound.jitter_n;

//printf("CHECK %d +%ld +%ld %f %f\n", rtp_session->write_timer.samplecount, diff_time, (diff_time * diff_time), rtp_session->stats.inbound.mean_interval, rtp_session->stats.inbound.variance);

ipdv = rtp_session->old_mean - rtp_session->stats.inbound.mean_interval;

if ( ipdv > IPDV_THRESHOLD1.0 ) { /* It shows Increasing Delays */
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 1787, ((void*)0), SWITCH_LOG_DEBUG3, "Calculated Instantaneous Packet Delay Variation: %s packet %lf\n",
					  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ipdv);
}

if ( rtp_session->stats.inbound.variance < rtp_session->stats.inbound.min_variance || rtp_session->stats.inbound.min_variance == 0 ) {
	rtp_session->stats.inbound.min_variance = rtp_session->stats.inbound.variance;
}

if ( rtp_session->stats.inbound.variance > rtp_session->stats.inbound.max_variance ) {
	rtp_session->stats.inbound.max_variance = rtp_session->stats.inbound.variance;
}

rtp_session->old_mean = rtp_session->stats.inbound.mean_interval;
}
1801}

1803static void rtcp_generate_sender_info(switch_rtp_t *rtp_session, struct switch_rtcp_sender_info *sr){
switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
switch_time_t now;
uint32_t sec, ntp_sec, ntp_usec;
switch_time_exp_t now_hr;
now = switch_micro_time_now();
sec = (uint32_t)(now/1000000);        /* convert to seconds     */
ntp_sec = sec+NTP_TIME_OFFSET2208988800UL;  /* convert to NTP seconds */
sr->ntp_msw = htonl(ntp_sec)__bswap_32 (ntp_sec);   /* store result in "most significant word" */
ntp_usec = (uint32_t)(now - (sec*1000000)); /* remove seconds to keep only the microseconds */
sr->ntp_lsw = htonl((u_long)(ntp_usec*(double)(((uint64_t)1)<<32)*1.0e-6))__bswap_32 ((u_long)(ntp_usec*(double)(((uint64_t)1)<<32
)*1.0e-6)); /* convert microseconds to fraction of 32bits and store result in "least significatn word" */

sr->ts = htonl(rtp_session->last_write_ts)__bswap_32 (rtp_session->last_write_ts);
sr->pc = htonl(rtp_session->stats.outbound.packet_count)__bswap_32 (rtp_session->stats.outbound.packet_count);
sr->oc = htonl(rtp_session->stats.outbound.raw_bytes - rtp_session->stats.outbound.packet_count * sizeof(srtp_hdr_t))__bswap_32 (rtp_session->stats.outbound.raw_bytes - rtp_session
->stats.outbound.packet_count * sizeof(srtp_hdr_t));

switch_time_exp_gmt(&now_hr,now);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1820, (const char*)(session), SWITCH_LOG_DEBUG10,"Sending an RTCP packet[%04d-%02d-%02d %02d:%02d:%02d.%d] lsr[%u] msw[%u] lsw[%u] stats_ssrc[%u] packet_count[%u] OC[%u]\n",
	1900 + now_hr.tm_year,  now_hr.tm_mday, now_hr.tm_mon, now_hr.tm_hour, now_hr.tm_min, now_hr.tm_sec, now_hr.tm_usec,
	(ntohl(sr->ntp_lsw)__bswap_32 (sr->ntp_lsw)&0xffff0000)>>16 | (ntohl(sr->ntp_msw)__bswap_32 (sr->ntp_msw)&0x0000ffff)<<16,
	ntohl(sr->ntp_msw)__bswap_32 (sr->ntp_msw),ntohl(sr->ntp_lsw)__bswap_32 (sr->ntp_lsw), rtp_session->stats.rtcp.ssrc, ntohl(sr->pc)__bswap_32 (sr->pc), ntohl(sr->oc)__bswap_32 (sr->oc)
	);
1825}

1827static inlineinline uint32_t calc_local_lsr_now() 
1828{
switch_time_t now;
uint32_t ntp_sec, ntp_usec, lsr_now, sec;
now = switch_micro_time_now();
sec = (uint32_t)(now/1000000);        /* convert to seconds     */
ntp_sec = sec+NTP_TIME_OFFSET2208988800UL;  /* convert to NTP seconds */
ntp_usec = (uint32_t)(now - ((switch_time_t) sec*1000000)); /* remove seconds to keep only the microseconds */

lsr_now = (uint32_t)(ntp_usec*0.065536) | (ntp_sec&0x0000ffff)<<16; /* 0.065536 is used for convertion from useconds to fraction of 65536 (x65536/1000000) */

return lsr_now;
1839}

1841//#define DEBUG_RTCP
1842/* extra param is for duplicates (received NACKed packets) */ 
1843static void rtcp_generate_report_block(switch_rtp_t *rtp_session, struct switch_rtcp_report_block *rtcp_report_block, 
int16_t extra_expected)
1845{
1846#ifdef DEBUG_RTCP
switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
1848#endif
switch_rtcp_numbers_t * stats=&rtp_session->stats.rtcp;
uint32_t expected_pkt, dlsr = 0;
int32_t pkt_lost;

/* Packet loss */
if (stats->rtcp_rtp_count == 0) {
expected_pkt = stats->high_ext_seq_recv - stats->base_seq + 1;
} else {
expected_pkt = stats->high_ext_seq_recv - stats->last_rpt_ext_seq + extra_expected;
}

pkt_lost = expected_pkt - stats->period_pkt_count;
if (pkt_lost < 0) pkt_lost = 0;

stats->cum_lost=stats->cum_lost+pkt_lost;
if (expected_pkt > 0 && pkt_lost > 0) {
rtcp_report_block->fraction = (pkt_lost == expected_pkt ? 255 : (uint8_t) (pkt_lost * 256 / expected_pkt));             /* if X packets were expected and X was lost, we want 0xff to be reported, not 0 */
} else {
rtcp_report_block->fraction = 0;
}
1869#if SWITCH_BYTE_ORDER1234 == __BIG_ENDIAN4321
rtcp_report_block->lost = stats->cum_lost;
1871#else
/* Reversing byte order for 24bits */
rtcp_report_block->lost = htonl(stats->cum_lost)__bswap_32 (stats->cum_lost) >> 8;
1874#endif

1876#ifdef DEBUG_RTCP
	if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO])
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1878, (const char*)(session), SWITCH_LOG_CRIT, "rtcp_generate_sr: stats_ssrc[%u]\nreceived[%d]\nexpected[%d]\ncum[%d]\nlost[%d|%d/256]pkt\nlast_seq[%d]\ncyc[%d]\nlast_rpt_seq[%d]\ncyc[%d]\nssrc[%d]\n",
				rtp_session->remote_ssrc, stats->period_pkt_count, expected_pkt,
				stats->cum_lost, pkt_lost, rtcp_report_block->fraction, stats->high_ext_seq_recv&0x0000ffff,
				stats->cycle, stats->last_rpt_ext_seq&0x0000ffff, stats->last_rpt_cycle, rtp_session->stats.rtcp.peer_ssrc
				);
1883#endif
rtcp_report_block->highest_sequence_number_received = htonl(stats->high_ext_seq_recv)__bswap_32 (stats->high_ext_seq_recv);

/* Jitter */
rtcp_report_block->jitter = htonl((uint32_t)stats->inter_jitter)__bswap_32 ((uint32_t)stats->inter_jitter);

/* Delay since Last Sender Report (DLSR) : 32bits, 1/65536 seconds */
if (stats->last_recv_lsr_local) {
uint32_t lsr_now = calc_local_lsr_now();
/* check lsr_now: what we just read from clock may be in the past (race cond), don't send huge dlsr due to uint wrap around */
if (lsr_now > stats->last_recv_lsr_local) {
	dlsr = lsr_now - stats->last_recv_lsr_local;
}
}
rtcp_report_block->lsr = stats->last_recv_lsr_peer;
rtcp_report_block->dlsr = htonl(dlsr)__bswap_32 (dlsr);
if (rtp_session->stats.rtcp.peer_ssrc) {
rtcp_report_block->ssrc = htonl(rtp_session->stats.rtcp.peer_ssrc)__bswap_32 (rtp_session->stats.rtcp.peer_ssrc);
} else {
/* if remote is not sending rtcp reports, take ssrc as assigned from rtp */
rtcp_report_block->ssrc = htonl(rtp_session->remote_ssrc)__bswap_32 (rtp_session->remote_ssrc);
}

stats->rtcp_rtp_count++;
1907}

1909static void rtcp_stats_init(switch_rtp_t *rtp_session)
1910{
switch_rtcp_numbers_t * stats = &rtp_session->stats.rtcp;
srtp_hdr_t * hdr = &rtp_session->last_rtp_hdr;
switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
stats->ssrc = ntohl(hdr->ssrc)__bswap_32 (hdr->ssrc);
stats->last_rpt_ts = rtp_session->write_timer.samplecount;
stats->init = 1;
stats->last_rpt_ext_seq = 0;
stats->last_rpt_cycle = 0;
stats->last_pkt_tsdiff = 0;
stats->inter_jitter = 0;
stats->cycle = 0;
stats->high_ext_seq_recv = ntohs((uint16_t)hdr->seq)__bswap_16 ((uint16_t)hdr->seq);
stats->base_seq = ntohs((uint16_t)hdr->seq)__bswap_16 ((uint16_t)hdr->seq);
stats->bad_seq = (1<<16) + 1; /* Make sure we wont missmatch 2 consecutive packets, so seq == bad_seq is false */
stats->cum_lost = 0;
stats->period_pkt_count = 0;
stats->sent_pkt_count = 0;
stats->pkt_count = 0;
stats->rtcp_rtp_count = 0;

if (!rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1932, (const char*)(session), SWITCH_LOG_DEBUG, "rtcp_stats_init: %s rtcp disabled\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
} else if (!rtp_session->rtcp_sock_output) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1934, (const char*)(session), SWITCH_LOG_WARNING, "rtcp_stats_init: %s no rtcp socket\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
} else if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU]) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1936, (const char*)(session), SWITCH_LOG_DEBUG, "rtcp_stats_init: %s rtcp passthru\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
} else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1938, (const char*)(session), SWITCH_LOG_DEBUG, "rtcp_stats_init: %s ssrc[%u] base_seq[%u]\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), stats->ssrc, stats->base_seq);
}

if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] && (switch_core_media_codec_get_cap(rtp_session->session,
													SWITCH_MEDIA_TYPE_AUDIO, SWITCH_CODEC_FLAG_HAS_ADJ_BITRATE))) {
	kalman_estimator_t *estimators[KALMAN_SYSTEM_MODELS3];
	cusum_kalman_detector_t *detectors[KALMAN_SYSTEM_MODELS3];

	rtp_session->flags[SWITCH_RTP_FLAG_ADJ_BITRATE_CAP] = 1;
	rtp_session->flags[SWITCH_RTP_FLAG_ESTIMATORS] = 1;

	rtp_session->estimators[EST_LOSS0] = switch_core_alloc(rtp_session->pool, sizeof(*estimators[0]))switch_core_perform_alloc(rtp_session->pool, sizeof(*estimators
[0]), "src/switch_rtp.c", (const char *)__func__, 1949);
	switch_kalman_init(rtp_session->estimators[EST_LOSS0],0.1,0.1);
	rtp_session->estimators[EST_RTT2] = switch_core_alloc(rtp_session->pool, sizeof(*estimators[0]))switch_core_perform_alloc(rtp_session->pool, sizeof(*estimators
[0]), "src/switch_rtp.c", (const char *)__func__, 1951);
	switch_kalman_init(rtp_session->estimators[EST_RTT2],0.03,1);
	rtp_session->detectors[EST_RTT2] = switch_core_alloc(rtp_session->pool, sizeof(*detectors[0]))switch_core_perform_alloc(rtp_session->pool, sizeof(*detectors
[0]), "src/switch_rtp.c", (const char *)__func__, 1953);
	switch_kalman_cusum_init(rtp_session->detectors[EST_RTT2],0.005,0.5);
	rtp_session->detectors[EST_LOSS0] = switch_core_alloc(rtp_session->pool, sizeof(*detectors[0]))switch_core_perform_alloc(rtp_session->pool, sizeof(*detectors
[0]), "src/switch_rtp.c", (const char *)__func__, 1955);
	switch_kalman_cusum_init(rtp_session->detectors[EST_LOSS0],0.005,0.5);
}
1958}

1960static int rtcp_stats(switch_rtp_t *rtp_session)
1961{
switch_core_session_t *session = switch_core_memory_pool_get_data(rtp_session->pool, "__session");
srtp_hdr_t * hdr = &rtp_session->last_rtp_hdr;
switch_rtcp_numbers_t * stats = &rtp_session->stats.rtcp;
uint32_t packet_spacing_diff = 0, pkt_tsdiff, pkt_extended_seq;
uint16_t pkt_seq, seq_diff, max_seq;
const int MAX_DROPOUT = 3000;
const int MAX_MISORDER = 100;
const int RTP_SEQ_MOD = (1<<16);

if(!rtp_session->rtcp_sock_output || !rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] || rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU] || !rtp_session->rtcp_interval)
return 0; /* do not process RTCP in current state */

pkt_seq = (uint16_t) ntohs((uint16_t) rtp_session->last_rtp_hdr.seq)__bswap_16 ((uint16_t) rtp_session->last_rtp_hdr.seq);

/* Detect sequence number cycle change */
max_seq = stats->high_ext_seq_recv&0x0000ffff;
seq_diff = pkt_seq - max_seq;

if (seq_diff < MAX_DROPOUT) {  /* in order, with permissible gap */
if (pkt_seq < max_seq) {
	stats->cycle++;
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 1983, (const char*)(session), SWITCH_LOG_DEBUG, "rtcp_stats:[cycle change] pkt_seq[%d] cycle[%d] max_seq[%d] stats_ssrc[%u] local_ts[%u]\n",
			pkt_seq, stats->cycle, max_seq, stats->ssrc, rtp_session->timer.samplecount);
}
pkt_extended_seq = stats->cycle << 16 | pkt_seq; /* getting the extended packet extended sequence ID */
if (pkt_extended_seq > stats->high_ext_seq_recv) {
	stats->high_ext_seq_recv = pkt_extended_seq;
}
}
else if (seq_diff <= (RTP_SEQ_MOD - MAX_MISORDER)) {   /* the sequence number made a very large jump */
if (pkt_seq == stats->bad_seq) {
	rtcp_stats_init(rtp_session);
} else {
	stats->bad_seq = (pkt_seq + 1) & (RTP_SEQ_MOD-1);
}
return 0; /* no stats, packet is out of sync and will be accounted as lost */
} else {
/* duplicate or reordered packet */
}

/* Verify that we are on the same stream source (we do not support multiple sources) */
if (ntohl(hdr->ssrc)__bswap_32 (hdr->ssrc) != stats->ssrc || !stats->init) {
rtcp_stats_init(rtp_session);
}

stats->period_pkt_count++;
stats->pkt_count++;
2009#ifdef DEBUG_RTCP
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2010, (const char*)(session), SWITCH_LOG_DEBUG10, "rtcp_stats: period_pkt_count[%d]last_seq[%d]cycle[%d]stats_ssrc[%u]local_ts[%u]\n",
	stats->period_pkt_count, pkt_seq, stats->cycle, stats->ssrc, rtp_session->write_timer.samplecount);
2012#endif
/* Interarrival jitter calculation */
pkt_tsdiff = abs((int32_t)(rtp_session->timer.samplecount - ntohl(hdr->ts)__bswap_32 (hdr->ts)));  /* relative transit times for this packet */
if (stats->pkt_count < 2) { /* Can not compute Jitter with only one packet */
stats->last_pkt_tsdiff = pkt_tsdiff;
} else {
/* Jitter : difference of relative transit times for the two packets */
packet_spacing_diff = abs((int32_t)(pkt_tsdiff - stats->last_pkt_tsdiff));
stats->last_pkt_tsdiff = pkt_tsdiff;
/* Interarrival jitter estimation, "J(i) = J(i-1) + ( |D(i-1,i)| - J(i-1) )/16" */
stats->inter_jitter = (stats->inter_jitter + (((double)packet_spacing_diff - stats->inter_jitter) /16.));
}

2025#ifdef DEBUG_RTCP
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2026, (const char*)(session), SWITCH_LOG_DEBUG10, "rtcp_stats: pkt_ts[%d]local_ts[%d]diff[%d]pkt_spacing[%d]inter_jitter[%f]seq[%d]stats_ssrc[%d]",
	ntohl(hdr->ts)__bswap_32 (hdr->ts), rtp_session->timer.samplecount, pkt_tsdiff, packet_spacing_diff, stats->inter_jitter, ntohs(hdr->seq)__bswap_16 (hdr->seq), stats->ssrc);
2028#endif
return 1;
2030}

2032static void calc_bw_exp(uint32_t bps, uint8_t bits, rtcp_tmmbx_t *tmmbx)
2033{
uint32_t mantissa_max, i = 0;
uint8_t exp = 0;
uint32_t mantissa = 0;
uint16_t overhead = 60;

switch_assert(bits<=32)((bits<=32) ? (void) (0) : __assert_fail ("bits<=32", "src/switch_rtp.c"
, 2039, __extension__ __PRETTY_FUNCTION__));

mantissa_max = (1 << bits) - 1;

for (i = 0; i < 32; ++i) {
if (bps <= (mantissa_max << i)) {
	exp = i;
	break;
}
}

mantissa = (bps >> exp);

tmmbx->parts[0] = (uint8_t) ((exp << 2) + ((mantissa >> 15) & 0x03));
tmmbx->parts[1] = (uint8_t) (mantissa >> 7);
tmmbx->parts[2] = (uint8_t) ((mantissa >> 1) + ((overhead >> 8) & 0x01));
tmmbx->parts[3] = (uint8_t) (overhead);
2056}

2058static int using_ice(switch_rtp_t *rtp_session)
2059{
if (rtp_session->ice.ice_user || rtp_session->rtcp_ice.ice_user) {
return 1;
}

return 0;
2065}

2067static void switch_send_rtcp_event(switch_rtp_t *rtp_session ,struct switch_rtcp_sender_report *sr,struct switch_rtcp_report_block *rtcp_report_block)
2068{
if (sr && rtcp_report_block) {
switch_event_t *event;

if (switch_event_create(&event, SWITCH_EVENT_SEND_RTCP_MESSAGE)switch_event_create_subclass_detailed("src/switch_rtp.c", (const
 char * )(const char *)__func__, 2072, &event, SWITCH_EVENT_SEND_RTCP_MESSAGE
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
		char value[30];
		char header[50];
		uint32_t tmpLost;
		char *uuid = switch_core_session_get_uuid(rtp_session->session);
		if (uuid) {
				switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Unique-ID", switch_core_session_get_uuid(rtp_session->session));
		}

		snprintf(value, sizeof(value), "%.8x", rtp_session->stats.rtcp.ssrc);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "SSRC", value);

		snprintf(value, sizeof(value), "%u", ntohl(sr->sender_info.ntp_msw)__bswap_32 (sr->sender_info.ntp_msw));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "NTP-Most-Significant-Word", value);

		snprintf(value, sizeof(value), "%u", ntohl(sr->sender_info.ntp_lsw)__bswap_32 (sr->sender_info.ntp_lsw));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "NTP-Least-Significant-Word", value);

		snprintf(value, sizeof(value), "%u", ntohl(sr->sender_info.ts)__bswap_32 (sr->sender_info.ts));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "RTP-Timestamp", value);

		snprintf(value, sizeof(value), "%u", ntohl(sr->sender_info.pc)__bswap_32 (sr->sender_info.pc));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Sender-Packet-Count", value);

		snprintf(value, sizeof(value), "%u", ntohl(sr->sender_info.oc)__bswap_32 (sr->sender_info.oc));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Octect-Packet-Count", value);

		snprintf(value, sizeof(value), "%u", ntohl(sr->sender_info.ts)__bswap_32 (sr->sender_info.ts));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Last-RTP-Timestamp", value);

		snprintf(value, sizeof(value), "%" SWITCH_TIME_T_FMT"ld", switch_time_now());
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Capture-Time", value);

		/* Add sources info */
		snprintf(header, sizeof(header), "Source-SSRC");
		snprintf(value, sizeof(value), "%.8x", rtp_session->stats.rtcp.peer_ssrc);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
		snprintf(header, sizeof(header), "Source-Fraction");
		snprintf(value, sizeof(value), "%u", (uint8_t)rtcp_report_block->fraction);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
		snprintf(header, sizeof(header), "Source-Lost");
2113#if SWITCH_BYTE_ORDER1234 == __BIG_ENDIAN4321
		tmpLost = report->lost; /* signed 24bit will extended signess to int32_t automatically */
2115#else
		tmpLost = ntohl(rtcp_report_block->lost)__bswap_32 (rtcp_report_block->lost)>>8;
		tmpLost = tmpLost | ((tmpLost & 0x00800000) ? 0xff000000 : 0x00000000); /* ...and signess compensation */
2118#endif
		snprintf(value, sizeof(value), "%u", tmpLost);
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
		snprintf(header, sizeof(header), "Source-Highest-Sequence-Number-Received");
		snprintf(value, sizeof(value), "%u", ntohl(rtcp_report_block->highest_sequence_number_received)__bswap_32 (rtcp_report_block->highest_sequence_number_received
));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
		snprintf(header, sizeof(header), "Source-Jitter");
		snprintf(value, sizeof(value), "%u", ntohl(rtcp_report_block->jitter)__bswap_32 (rtcp_report_block->jitter));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
		snprintf(header, sizeof(header), "Source-LSR");
		snprintf(value, sizeof(value), "%u", ntohl(rtcp_report_block->lsr)__bswap_32 (rtcp_report_block->lsr));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
		snprintf(header, sizeof(header), "Source-DLSR");
		snprintf(value, sizeof(value), "%u", ntohl(rtcp_report_block->dlsr)__bswap_32 (rtcp_report_block->dlsr));
		switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);

		switch_event_fire(&event)switch_event_fire_detailed("src/switch_rtp.c", (const char * )
(const char *)__func__, 2134, &event, ((void*)0));
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2135, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG10, "Dispatched RTCP SEND event\n");
}
}
2138}

2140#define MAX_NACK10 10
2141static int check_rtcp_and_ice(switch_rtp_t *rtp_session)
2142{
int ret = 0;
int rtcp_ok = 0, rtcp_cyclic = 0, rtcp_fb = 0, force_send_rr = 0;
switch_time_t now = switch_micro_time_now();
int rate = 0, nack_ttl = 0, nack_dup = 0; 
uint32_t cur_nack[MAX_NACK10] = { 0 };
uint16_t seq = 0;

if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
rtp_session->flags[SWITCH_RTP_FLAG_AUTO_CNG] &&
rtp_session->send_msg.header.ts &&
rtp_session->cng_pt != INVALID_PT &&
(rtp_session->write_timer.samplecount - rtp_session->last_write_samplecount >= rtp_session->samples_per_interval * 60)) {
uint8_t data[10] = { 0 };
switch_frame_flag_t frame_flags = SFF_NONE;
data[0] = 65;
rtp_session->cn++;

get_next_write_ts(rtp_session, 0);
rtp_session->send_msg.header.ts = htonl(rtp_session->ts)__bswap_32 (rtp_session->ts);

switch_rtp_write_manual(rtp_session, (void *) data, 2, 0, rtp_session->cng_pt, ntohl(rtp_session->send_msg.header.ts)__bswap_32 (rtp_session->send_msg.header.ts), &frame_flags);

if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER)) {
	rtp_session->last_write_samplecount = rtp_session->write_timer.samplecount;
}
}

rate = rtp_session->rtcp_interval;

if (rtp_session->flags[SWITCH_RTP_FLAG_NACK] && rtp_session->vb) {
int n;
for (n = 0; n < MAX_NACK10; n++) {
	uint32_t nack = switch_jb_pop_nack(rtp_session->vb);

	if (!nack) break;

	seq = ntohs(nack & 0xFFFF)__bswap_16 (nack & 0xFFFF);

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2181, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, "%s Got NACK [%u][0x%x] for seq %u\n",
			switch_core_session_get_name(rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(rtp_session
->session)), nack, nack, seq);

	cur_nack[nack_ttl++] = nack;
}
if (nack_ttl) {
	rtcp_ok = 1;
	rtcp_fb = 1;
}
}



if (rtp_session->rtcp_sent_packets < 4) {
rate = 4000;
} else  {
if (rtp_session->pli_count || rtp_session->fir_count || rtp_session->tmmbr || rtp_session->tmmbn) {
	//switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "MARK BW/FIR ETC %d %d\n", rtp_session->pli_count, rtp_session->fir_count);
	rtcp_ok = 1;
	rtcp_fb = 1;
}
}

if (rtp_session->send_rr) {
rtp_session->send_rr = 0;
rtcp_ok = 1;
force_send_rr = 1;
}

//switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "TIME CHECK %d > %d\n", (int)((now - rtp_session->rtcp_last_sent) / 1000), rate);

if (!rtcp_ok && (!rtp_session->rtcp_last_sent || (int)((now - rtp_session->rtcp_last_sent) / 1000) > rate)) {
//switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "TIME UP\n");
rtcp_cyclic = 1;
rtcp_ok = 1;
}

if (rtcp_ok && using_ice(rtp_session)) {
if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
	if (!rtp_session->ice.rready) {
		rtcp_ok = 0;
	}
} else {
	if (!rtp_session->rtcp_ice.rready) {
		rtcp_ok = 0;
	}
}
}

//switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_ERROR, "WTF %d %d %d %d\n", rate, rtp_session->rtcp_sent_packets, rtcp_ok, nack_ttl);

if (rtp_session->rtcp_sock_output && rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] && !rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU] && rtcp_ok) {
switch_rtcp_numbers_t * stats = &rtp_session->stats.rtcp;
struct switch_rtcp_receiver_report *rr;
struct switch_rtcp_sender_report *sr;
struct switch_rtcp_report_block *rtcp_report_block = NULL((void*)0);
switch_size_t rtcp_bytes = sizeof(struct switch_rtcp_hdr_s)+sizeof(uint32_t); /* add size of the packet header and the ssrc */
switch_rtcp_hdr_t *sdes;
uint8_t *p;
switch_size_t sdes_bytes = sizeof(struct switch_rtcp_hdr_s);
uint32_t *ssrc;
switch_rtcp_sdes_unit_t *unit;
switch_bool_t is_only_receiver = FALSE0;

if (!rtcp_fb) {
	rtp_session->rtcp_last_sent = now;
	rtp_session->rtcp_sent_packets++;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && 
		rtp_session->vb && rtcp_cyclic) {
		nack_dup = rtp_session->prev_nacks_inflight;
		rtp_session->prev_nacks_inflight = 0;
}

rtp_session->rtcp_send_msg.header.version = 2;
rtp_session->rtcp_send_msg.header.p = 0;

if ((switch_core_session_media_flow(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO) == SWITCH_MEDIA_FLOW_RECVONLY) ||
		switch_core_session_media_flow(rtp_session->session, SWITCH_MEDIA_TYPE_VIDEO) == SWITCH_MEDIA_FLOW_RECVONLY) {
	is_only_receiver = TRUE(!0);
}
if (!rtp_session->stats.rtcp.sent_pkt_count || is_only_receiver || force_send_rr) {
	rtp_session->rtcp_send_msg.header.type = _RTCP_PT_RR; /* Receiver report */
	rr=(struct switch_rtcp_receiver_report*) rtp_session->rtcp_send_msg.body;
	rr->ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
	rtcp_report_block = &rr->report_block;
	rtcp_bytes += sizeof(struct switch_rtcp_report_block);
	rtcp_generate_report_block(rtp_session, rtcp_report_block, nack_dup);
	rtp_session->rtcp_send_msg.header.count = 1; /* reception report block count */
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2271, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, "Sending RTCP RR (ssrc=%u)\n", rtp_session->ssrc);
} else {
	struct switch_rtcp_sender_info *rtcp_sender_info;
	rtp_session->rtcp_send_msg.header.type = _RTCP_PT_SR; /* Sender report */
	sr = (struct switch_rtcp_sender_report*) rtp_session->rtcp_send_msg.body;
	sr->ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
	rtcp_sender_info = &sr->sender_info;
	rtcp_generate_sender_info(rtp_session, rtcp_sender_info);
	rtcp_bytes += sizeof(struct switch_rtcp_sender_info);
	if (!rtcp_cyclic && rtcp_fb) {
		 /* rtcp-fb only, don't send receive report block */
		rtp_session->rtcp_send_msg.header.count = 0;
	} else {
		rtcp_report_block = &sr->report_block;
		rtcp_bytes += sizeof(struct switch_rtcp_report_block);
		rtcp_generate_report_block(rtp_session, rtcp_report_block, nack_dup);
		rtp_session->rtcp_send_msg.header.count = 1; /* reception report block count */
		stats->sent_pkt_count = 0;
		if ((!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->flags[SWITCH_RTP_FLAG_AUDIO_FIRE_SEND_RTCP_EVENT]) ||
			(rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->flags[SWITCH_RTP_FLAG_VIDEO_FIRE_SEND_RTCP_EVENT])) {
				switch_send_rtcp_event(rtp_session, sr, rtcp_report_block);
		}
	}
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2294, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, "Sending RTCP SR (ssrc=%u)\n", rtp_session->ssrc);
}

rtp_session->rtcp_send_msg.header.length = htons((uint16_t)(rtcp_bytes / 4) - 1)__bswap_16 ((uint16_t)(rtcp_bytes / 4) - 1);

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
	if (rtp_session->pli_count) {
		switch_rtcp_ext_hdr_t *ext_hdr;

		p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
		ext_hdr = (switch_rtcp_ext_hdr_t *) p;

		ext_hdr->version = 2;
		ext_hdr->p = 0;
		ext_hdr->fmt = _RTCP_PSFB_PLI;
		ext_hdr->pt = _RTCP_PT_PSFB;

		ext_hdr->send_ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
		ext_hdr->recv_ssrc = htonl(rtp_session->remote_ssrc)__bswap_32 (rtp_session->remote_ssrc);
		rtp_session->rtcp_vstats.video_in.pli_count++;
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2314, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, "Sending RTCP PLI %u %u [%u]\n",
						  rtp_session->ssrc, rtp_session->remote_ssrc, rtp_session->rtcp_vstats.video_in.pli_count);

		ext_hdr->length = htons((uint8_t)(sizeof(switch_rtcp_ext_hdr_t) / 4) - 1)__bswap_16 ((uint8_t)(sizeof(switch_rtcp_ext_hdr_t) / 4) - 1);
		rtcp_bytes += sizeof(switch_rtcp_ext_hdr_t);
		rtp_session->pli_count = 0;
	}

	if (rtp_session->flags[SWITCH_RTP_FLAG_NACK] && nack_ttl > 0) {
		int n = 0;

		rtp_session->rtcp_vstats.video_in.nack_count++;
		for (n = 0; n < nack_ttl; n++) {
			switch_rtcp_ext_hdr_t *ext_hdr;
			uint32_t *nack;
			p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
			ext_hdr = (switch_rtcp_ext_hdr_t *) p;

			ext_hdr->version = 2;
			ext_hdr->p = 0;
			ext_hdr->fmt = _RTCP_RTPFB_NACK;
			ext_hdr->pt = _RTCP_PT_RTPFB;
			ext_hdr->send_ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
			ext_hdr->recv_ssrc = htonl(rtp_session->remote_ssrc)__bswap_32 (rtp_session->remote_ssrc);
			ext_hdr->length = htons(3)__bswap_16 (3);
			p += sizeof(switch_rtcp_ext_hdr_t);
			nack = (uint32_t *) p;
			*nack = cur_nack[n];

			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2343, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "Sending RTCP NACK %u [%d]\n",
							  ntohs(*nack & 0xFFFF)__bswap_16 (*nack & 0xFFFF), rtp_session->rtcp_vstats.video_in.nack_count);

			rtcp_bytes += sizeof(switch_rtcp_ext_hdr_t) + sizeof(cur_nack[n]);
			cur_nack[n] = 0;
		}
		rtp_session->prev_nacks_inflight = n;
	}

	if (rtp_session->fir_count) {
		switch_rtcp_ext_hdr_t *ext_hdr;
		rtcp_fir_t *fir;

		if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_OLD_FIR)) {
			p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
			ext_hdr = (switch_rtcp_ext_hdr_t *) p;

			ext_hdr->version = 2;
			ext_hdr->pt = _RTCP_PT_FIR;
			rtcp_bytes += sizeof(switch_rtcp_ext_hdr_t);
		}


		p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
		ext_hdr = (switch_rtcp_ext_hdr_t *) p;

		p += sizeof(switch_rtcp_ext_hdr_t);
		fir = (rtcp_fir_t *) p;

		ext_hdr->version = 2;
		ext_hdr->p = 0;
		ext_hdr->fmt = _RTCP_PSFB_FIR;
		ext_hdr->pt = _RTCP_PT_PSFB;

		ext_hdr->send_ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
		ext_hdr->recv_ssrc = htonl(rtp_session->remote_ssrc)__bswap_32 (rtp_session->remote_ssrc);

		fir->ssrc = htonl(rtp_session->remote_ssrc)__bswap_32 (rtp_session->remote_ssrc);
		fir->seq = rtp_session->fir_seq;
		fir->r1 = fir->r2 = fir->r3 = 0;

		rtp_session->rtcp_vstats.video_in.fir_count++;
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2385, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "Sending RTCP FIR SEQ %d [%u]\n", rtp_session->fir_seq, rtp_session->rtcp_vstats.video_in.fir_count);

		rtp_session->fir_seq++;

		ext_hdr->length = htons((uint8_t)((sizeof(switch_rtcp_ext_hdr_t) + sizeof(rtcp_fir_t)) / 4) - 1)__bswap_16 ((uint8_t)((sizeof(switch_rtcp_ext_hdr_t) + sizeof
(rtcp_fir_t)) / 4) - 1);
		rtcp_bytes += sizeof(switch_rtcp_ext_hdr_t) + sizeof(rtcp_fir_t);
		rtp_session->fir_count = 0;
	}

	//if (!rtp_session->tmmbr && rtp_session->cur_tmmbr) {
	//	rtp_session->tmmbr = rtp_session->cur_tmmbr;
	//}

	while (rtp_session->tmmbr || rtp_session->tmmbn) {
		switch_rtcp_ext_hdr_t *ext_hdr;
		rtcp_tmmbx_t *tmmbx;
		uint32_t bps = 0;
		p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
		ext_hdr = (switch_rtcp_ext_hdr_t *) p;

		p += sizeof(switch_rtcp_ext_hdr_t);
		tmmbx = (rtcp_tmmbx_t *) p;

		ext_hdr->version = 2;
		ext_hdr->p = 0;
		ext_hdr->pt = _RTCP_PT_RTPFB;
		ext_hdr->send_ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
		ext_hdr->recv_ssrc = 0;

		if (rtp_session->tmmbr) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2415, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "Sending RTCP TMMBR %u\n", rtp_session->tmmbr);
			ext_hdr->fmt = _RTCP_RTPFB_TMMBR;
			bps = rtp_session->tmmbr;
			rtp_session->tmmbr = 0;
		} else {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2420, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "Sending RTCP TMMBN %u\n", rtp_session->tmmbr);
			ext_hdr->fmt = _RTCP_RTPFB_TMMBN;
			bps = rtp_session->tmmbn;
			rtp_session->tmmbn = 0;
		}

		tmmbx->ssrc = htonl(rtp_session->remote_ssrc)__bswap_32 (rtp_session->remote_ssrc);
		calc_bw_exp(bps, 17, tmmbx);

		ext_hdr->length = htons((uint8_t)((sizeof(switch_rtcp_ext_hdr_t) + sizeof(rtcp_tmmbx_t)) / 4) - 1)__bswap_16 ((uint8_t)((sizeof(switch_rtcp_ext_hdr_t) + sizeof
(rtcp_tmmbx_t)) / 4) - 1);
		rtcp_bytes += sizeof(switch_rtcp_ext_hdr_t) + sizeof(rtcp_tmmbx_t);
	}

}

//SDES + CNAME
p = (uint8_t *) (&rtp_session->rtcp_send_msg) + rtcp_bytes;
sdes = (switch_rtcp_hdr_t *) p;
sdes->version = 2;
sdes->type = _RTCP_PT_SDES;
sdes->count = 1;
sdes->p = 0;
p = (uint8_t *) (sdes) + sdes_bytes;
ssrc = (uint32_t *) p;
*ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
sdes_bytes += sizeof(uint32_t);


p = (uint8_t *) (sdes) + sdes_bytes;
unit = (switch_rtcp_sdes_unit_t *) p;
unit->type = _RTCP_SDES_CNAME;
snprintf((char *)unit->value, 80, "%x", rtp_session->ssrc);
unit->length = strlen((char *)unit->value);
sdes_bytes += sizeof(switch_rtcp_sdes_unit_t) + unit->length;


p += sizeof(switch_rtcp_sdes_unit_t) + unit->length;
unit = (switch_rtcp_sdes_unit_t *) p;
unit->type = _RTCP_SDES_NOTE;
snprintf((char *)unit->value, 80, "FreeSWITCH.org -- Come to ClueCon.com");
unit->length = strlen((char *)unit->value);
sdes_bytes += sizeof(switch_rtcp_sdes_unit_t) + unit->length;

sdes_bytes ++;//END

sdes_bytes += 4 - (sdes_bytes % 4);

sdes->length = htons((uint16_t)(sdes_bytes / 4) - 1)__bswap_16 ((uint16_t)(sdes_bytes / 4) - 1);
rtcp_bytes += sdes_bytes;

/* Prepare next report */
if (rtp_session->rtcp_send_msg.header.count) {
	stats->last_rpt_cycle = stats->cycle;
	stats->last_rpt_ext_seq = stats->high_ext_seq_recv;
	stats->last_rpt_ts = rtp_session->write_timer.samplecount;
	stats->period_pkt_count = 0;
}



2480#ifdef ENABLE_SRTP1
switch_mutex_lock(rtp_session->ice_mutex);
if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {
	int stat = 0;
	int sbytes = (int) rtcp_bytes;

	if (!rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_MKI]) {
		stat = srtp_protect_rtcp(rtp_session->send_ctx[rtp_session->srtp_idx_rtcp], &rtp_session->rtcp_send_msg.header, &sbytes);
	} else {
		stat = srtp_protect_rtcp_mki(rtp_session->send_ctx[rtp_session->srtp_idx_rtcp], &rtp_session->rtcp_send_msg.header, &sbytes, 1, SWITCH_CRYPTO_MKI_INDEX0);
	}

	if (stat) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2493, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error: SRTP RTCP protection failed with code %d\n", stat);
		switch_mutex_unlock(rtp_session->ice_mutex);
		goto end;
	} else {
		rtcp_bytes = sbytes;
	}
}
switch_mutex_unlock(rtp_session->ice_mutex);
2501#endif

2503#ifdef ENABLE_ZRTP
/* ZRTP Send */
if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
	unsigned int sbytes = (int) rtcp_bytes;
	zrtp_status_t stat = zrtp_status_fail;

	stat = zrtp_process_rtcp(rtp_session->zrtp_stream, (void *) &rtp_session->rtcp_send_msg, &sbytes);

	switch (stat) {
	case zrtp_status_ok:
		break;
	case zrtp_status_drop:
		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 2515, ((void*)0), SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
		ret = (int)rtcp_bytes;
		goto end;
		break;
	case zrtp_status_fail:
		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 2520, ((void*)0), SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
		break;
	default:
		break;
	}

	rtcp_bytes = sbytes;
}
2528#endif
//#define DEBUG_EXTRA
2530#ifdef DEBUG_EXTRA
{
	const char *old_host;
	char bufb[50];
	old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->rtcp_remote_addr);
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2535, (const char*)(rtp_session->session), SWITCH_LOG_CRIT, "%s SEND %s RTCP %s:%d %ld\n",
					  rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-",
					  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"),
					  old_host,
					  switch_sockaddr_get_port(rtp_session->rtcp_remote_addr),
					  rtcp_bytes);
}
2542#endif
if (switch_socket_sendto(rtp_session->rtcp_sock_output, rtp_session->rtcp_remote_addr, 0, (void *)&rtp_session->rtcp_send_msg, &rtcp_bytes ) != SWITCH_STATUS_SUCCESS) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2544, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG,"RTCP packet not written\n");
} else {
	rtp_session->stats.inbound.period_packet_count = 0;
}
}

if (rtp_session->ice.ice_user) {
if (ice_out(rtp_session, &rtp_session->ice) == SWITCH_STATUS_GENERR) {
	ret = -1;
	goto end;
}
}

if (!rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
if (rtp_session->rtcp_ice.ice_user) {
	if (ice_out(rtp_session, &rtp_session->rtcp_ice) == SWITCH_STATUS_GENERR) {
		ret = -1;
		goto end;
	}
}
}

end:

return ret;
2569}

2571SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_ping(switch_rtp_t *rtp_session)
2572{
check_rtcp_and_ice(rtp_session);
2574}

2576SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_get_random(void *buf, uint32_t len)
2577{
2578#ifdef HAVE_OPENSSL1
RAND_bytes(buf, len);
2580#else
switch_stun_random_string(buf, len, NULL((void*)0));
2582#endif
2583}


2586SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_shutdown(void)
2587{
switch_core_port_allocator_t *alloc = NULL((void*)0);
switch_hash_index_t *hi;
const void *var;
void *val;

if (!global_init) {
return;
}

switch_mutex_lock(port_lock);

for (hi = switch_core_hash_first(alloc_hash)switch_core_hash_first_iter(alloc_hash, ((void*)0)); hi; hi = switch_core_hash_next(&hi)) {
switch_core_hash_this(hi, &var, NULL((void*)0), &val);
if ((alloc = (switch_core_port_allocator_t *) val)) {
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 2602, ((void*)0), SWITCH_LOG_DEBUG, "Destroy port allocator for %s\n", (char *) var);
	switch_core_port_allocator_destroy(&alloc);
}
}

switch_core_hash_destroy(&alloc_hash);
switch_mutex_unlock(port_lock);

2610#ifdef ENABLE_ZRTP
if (zrtp_on) {
zrtp_status_t status = zrtp_status_ok;

status = zrtp_def_cache_store(zrtp_global);
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 2615, ((void*)0), SWITCH_LOG_DEBUG, "Saving ZRTP cache: %s\n", zrtp_status_ok == status ? "OK" : "FAIL");
zrtp_down(zrtp_global);
}
2618#endif
2619#ifdef ENABLE_SRTP1
srtp_crypto_kernel_shutdown();
2621#endif
switch_rtp_dtls_destroy();
2623}

2625SWITCH_DECLARE(switch_port_t)__attribute__((visibility("default"))) switch_port_t switch_rtp_set_start_port(switch_port_t port)
2626{
if (port) {
if (port_lock) {
	switch_mutex_lock(port_lock);
}
START_PORT = port;
if (port_lock) {
	switch_mutex_unlock(port_lock);
}
}
return START_PORT;
2637}

2639SWITCH_DECLARE(switch_port_t)__attribute__((visibility("default"))) switch_port_t switch_rtp_set_end_port(switch_port_t port)
2640{
if (port) {
if (port_lock) {
	switch_mutex_lock(port_lock);
}
END_PORT = port;
if (port_lock) {
	switch_mutex_unlock(port_lock);
}
}
return END_PORT;
2651}

2653SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_release_port(const char *ip, switch_port_t port)
2654{
switch_core_port_allocator_t *alloc = NULL((void*)0);

if (!ip || !port) {
return;
}

switch_mutex_lock(port_lock);
if ((alloc = switch_core_hash_find(alloc_hash, ip))) {
switch_core_port_allocator_free_port(alloc, port);
}
switch_mutex_unlock(port_lock);

2667}

2669SWITCH_DECLARE(switch_port_t)__attribute__((visibility("default"))) switch_port_t switch_rtp_request_port(const char *ip)
2670{
switch_port_t port = 0;
switch_core_port_allocator_t *alloc = NULL((void*)0);

switch_mutex_lock(port_lock);
alloc = switch_core_hash_find(alloc_hash, ip);
if (!alloc) {
if (switch_core_port_allocator_new(ip, START_PORT, END_PORT, SPF_EVEN, &alloc) != SWITCH_STATUS_SUCCESS) {
	abort();
}

switch_core_hash_insert(alloc_hash, ip, alloc)switch_core_hash_insert_destructor(alloc_hash, ip, alloc, ((void
*)0));
}

if (switch_core_port_allocator_request_port(alloc, &port) != SWITCH_STATUS_SUCCESS) {
port = 0;
}

switch_mutex_unlock(port_lock);
return port;
2690}

2692SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_set_payload_map(switch_rtp_t *rtp_session, payload_map_t **pmap)
2693{

if (rtp_session) {
switch_mutex_lock(rtp_session->flag_mutex);
rtp_session->pmaps = pmap;
switch_mutex_unlock(rtp_session->flag_mutex);
return SWITCH_STATUS_SUCCESS;
}

return SWITCH_STATUS_FALSE;
2703}

2705SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_intentional_bugs(switch_rtp_t *rtp_session, switch_rtp_bug_flag_t bugs)
2706{
rtp_session->rtp_bugs = bugs;

if ((rtp_session->rtp_bugs & RTP_BUG_START_SEQ_AT_ZERO)) {
rtp_session->seq = 0;
}

2713}


2716static switch_status_t enable_remote_rtcp_socket(switch_rtp_t *rtp_session, const char **err) {

switch_status_t status = SWITCH_STATUS_SUCCESS;

if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {

if (switch_sockaddr_info_get(&rtp_session->rtcp_remote_addr, rtp_session->eff_remote_host_str, SWITCH_UNSPEC0,
							 rtp_session->remote_rtcp_port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !rtp_session->rtcp_remote_addr) {
	*err = "RTCP Remote Address Error!";
	return SWITCH_STATUS_FALSE;
} else {
	const char *host;
	char bufa[50];

	host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtcp_remote_addr);

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2732, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG,
					  "Setting RTCP remote addr to %s:%d %d\n", host, rtp_session->remote_rtcp_port, rtp_session->rtcp_remote_addr->family);
}

if (rtp_session->rtcp_sock_input && switch_sockaddr_get_family(rtp_session->rtcp_remote_addr) ==
	switch_sockaddr_get_family(rtp_session->rtcp_local_addr)) {
	rtp_session->rtcp_sock_output = rtp_session->rtcp_sock_input;
} else {

	if (rtp_session->rtcp_sock_output && rtp_session->rtcp_sock_output != rtp_session->rtcp_sock_input) {
		switch_socket_close(rtp_session->rtcp_sock_output);
	}

	if ((status = switch_socket_create(&rtp_session->rtcp_sock_output,
									   switch_sockaddr_get_family(rtp_session->rtcp_remote_addr),
									   SOCK_DGRAMSOCK_DGRAM, 0, rtp_session->pool)) != SWITCH_STATUS_SUCCESS) {
		*err = "RTCP Socket Error!";
	}
}

} else {
*err = "RTCP NOT ACTIVE!";
}

return status;

2758}

2760static switch_status_t enable_local_rtcp_socket(switch_rtp_t *rtp_session, const char **err) {

const char *host = rtp_session->local_host_str;
switch_port_t port = rtp_session->local_port;
switch_socket_t *rtcp_new_sock = NULL((void*)0), *rtcp_old_sock = NULL((void*)0);
switch_status_t status = SWITCH_STATUS_SUCCESS;
char bufa[50];

if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
if (switch_sockaddr_info_get(&rtp_session->rtcp_local_addr, host, SWITCH_UNSPEC0, port+1, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
	*err = "RTCP Local Address Error!";
	goto done;
}

if (switch_socket_create(&rtcp_new_sock, switch_sockaddr_get_family(rtp_session->rtcp_local_addr), SOCK_DGRAMSOCK_DGRAM, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
	*err = "RTCP Socket Error!";
	goto done;
}

if (switch_socket_opt_set(rtcp_new_sock, SWITCH_SO_REUSEADDR16, 1) != SWITCH_STATUS_SUCCESS) {
	*err = "RTCP Socket Error!";
	goto done;
}

if (switch_socket_bind(rtcp_new_sock, rtp_session->rtcp_local_addr) != SWITCH_STATUS_SUCCESS) {
	*err = "RTCP Bind Error!";
	goto done;
}

if (switch_sockaddr_info_get(&rtp_session->rtcp_from_addr, switch_get_addr(bufa, sizeof(bufa), rtp_session->from_addr),
									 SWITCH_UNSPEC0, switch_sockaddr_get_port(rtp_session->from_addr) + 1, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
	*err = "RTCP From Address Error!";
	goto done;
}

rtcp_old_sock = rtp_session->rtcp_sock_input;
rtp_session->rtcp_sock_input = rtcp_new_sock;
rtcp_new_sock = NULL((void*)0);

switch_socket_create_pollset(&rtp_session->rtcp_read_pollfd, rtp_session->rtcp_sock_input, SWITCH_POLLIN0x001 | SWITCH_POLLERR0x010, rtp_session->pool);

done:

if (*err) {

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2805, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error allocating rtcp [%s]\n", *err);
	status = SWITCH_STATUS_FALSE;
}

if (rtcp_new_sock) {
	switch_socket_close(rtcp_new_sock);
}

if (rtcp_old_sock) {
	switch_socket_close(rtcp_old_sock);
}
} else {
status = SWITCH_STATUS_FALSE;
}

return status;
2821}

2823SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_set_local_address(switch_rtp_t *rtp_session, const char *host, switch_port_t port, const char **err)
2824{
switch_socket_t *new_sock = NULL((void*)0), *old_sock = NULL((void*)0);
switch_status_t status = SWITCH_STATUS_FALSE;
int j = 0;
2828#ifndef WIN32
char o[5] = "TEST", i[5] = "";
switch_size_t len, ilen = 0;
int x;
2832#endif

if (rtp_session->ready != 1) {
if (!switch_rtp_ready(rtp_session)) {
	return SWITCH_STATUS_FALSE;
}

READ_INC(rtp_session)switch_mutex_lock(rtp_session->read_mutex); rtp_session->
reading++;
WRITE_INC(rtp_session)switch_mutex_lock(rtp_session->write_mutex); rtp_session->
writing++;

if (!switch_rtp_ready(rtp_session)) {
	goto done;
}
}


*err = NULL((void*)0);

if (zstr(host)_zstr(host) || !port) {
*err = "Address Error";
goto done;
}


rtp_session->local_host_str = switch_core_strdup(rtp_session->pool, host)switch_core_perform_strdup(rtp_session->pool, host, "src/switch_rtp.c"
, (const char *)__func__, 2856);
rtp_session->local_port = port;


if (switch_sockaddr_info_get(&rtp_session->local_addr, host, SWITCH_UNSPEC0, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
*err = "Local Address Error!";
goto done;
}


if (rtp_session->sock_input) {
switch_rtp_kill_socket(rtp_session);
}

if (switch_socket_create(&new_sock, switch_sockaddr_get_family(rtp_session->local_addr), SOCK_DGRAMSOCK_DGRAM, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS) {
*err = "Socket Error!";
goto done;
}

if (switch_socket_opt_set(new_sock, SWITCH_SO_REUSEADDR16, 1) != SWITCH_STATUS_SUCCESS) {
*err = "Socket Error!";
goto done;
}

//if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
//	switch_socket_opt_set(new_sock, SWITCH_SO_RCVBUF, 1572864);
//	switch_socket_opt_set(new_sock, SWITCH_SO_SNDBUF, 1572864);
//}

if (switch_socket_bind(new_sock, rtp_session->local_addr) != SWITCH_STATUS_SUCCESS) {
char *em = switch_core_sprintf(rtp_session->pool, "Bind Error! %s:%d", host, port);
*err = em;
goto done;
}


if ((j = atoi(host)) && j > 223 && j < 240) { /* mcast */
if (switch_mcast_interface(new_sock, rtp_session->local_addr) != SWITCH_STATUS_SUCCESS) {
	*err = "Multicast Socket interface Error";
	goto done;
}

if (switch_mcast_join(new_sock, rtp_session->local_addr, NULL((void*)0), NULL((void*)0)) != SWITCH_STATUS_SUCCESS) {
	*err = "Multicast Error";
	goto done;
}

if (rtp_session->session) {
	switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
	const char *var;

	if ((var = switch_channel_get_variable(channel, "multicast_ttl")switch_channel_get_variable_dup(channel, "multicast_ttl", SWITCH_TRUE
, -1))) {
		int ttl = atoi(var);

		if (ttl > 0 && ttl < 256) {
			if (switch_mcast_hops(new_sock, (uint8_t) ttl) != SWITCH_STATUS_SUCCESS) {
				*err = "Mutlicast TTL set failed";
				goto done;
			}

		}
	}

}

}



2925#ifndef WIN32
len = sizeof(i);
switch_socket_opt_set(new_sock, SWITCH_SO_NONBLOCK8, TRUE(!0));

switch_socket_sendto(new_sock, rtp_session->local_addr, 0, (void *) o, &len);

x = 0;
while (!ilen) {
switch_status_t status;
ilen = len;
status = switch_socket_recvfrom(rtp_session->from_addr, new_sock, 0, (void *) i, &ilen);

if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
	break;
}

if (++x > 1000) {
	break;
}
switch_cond_next();
}
switch_socket_opt_set(new_sock, SWITCH_SO_NONBLOCK8, FALSE0);

2948#endif

old_sock = rtp_session->sock_input;
rtp_session->sock_input = new_sock;
new_sock = NULL((void*)0);

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] || rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK] || rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK8, TRUE(!0));
switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
}

switch_socket_create_pollset(&rtp_session->read_pollfd, rtp_session->sock_input, SWITCH_POLLIN0x001 | SWITCH_POLLERR0x010, rtp_session->pool);

if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
if ((status = enable_local_rtcp_socket(rtp_session, err)) == SWITCH_STATUS_SUCCESS) {
	*err = "Success";
}
} else {
status = SWITCH_STATUS_SUCCESS;
*err = "Success";
}

switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_IO);

done:

if (new_sock) {
switch_socket_close(new_sock);
}

if (old_sock) {
switch_socket_close(old_sock);
}


if (rtp_session->ready != 1) {
WRITE_DEC(rtp_session)rtp_session->writing--; switch_mutex_unlock(rtp_session->
write_mutex);
READ_DEC(rtp_session)rtp_session->reading--; switch_mutex_unlock(rtp_session->
read_mutex);
}

return status;
2989}

2991SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_media_timeout(switch_rtp_t *rtp_session, uint32_t ms)
2992{
if (!switch_rtp_ready(rtp_session) || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
return;
}

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 2997, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1,
			  "%s MEDIA TIMEOUT %s set to %u", switch_core_session_get_name(rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(rtp_session
->session)), rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ms);
rtp_session->media_timeout = ms;
switch_rtp_reset_media_timer(rtp_session);
3001}

3003SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_max_missed_packets(switch_rtp_t *rtp_session, uint32_t max)
3004{
if (!switch_rtp_ready(rtp_session) || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
return;
}

if (rtp_session->missed_count > max) {

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3011, (const char*)(rtp_session->session), SWITCH_LOG_WARNING,
				  "new max missed packets(%d->%d) greater than current missed packets(%d). RTP will timeout.\n",
				  rtp_session->max_missed_packets, max, rtp_session->missed_count);
}

rtp_session->max_missed_packets = max;
3017}

3019SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_reset_jb(switch_rtp_t *rtp_session)
3020{
if (switch_rtp_ready(rtp_session)) {
if (rtp_session->jb) {
	switch_jb_reset(rtp_session->jb);
}
}
3026}

3028SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_reset_vb(switch_rtp_t *rtp_session)
3029{

if (rtp_session->vb) {
switch_jb_reset(rtp_session->vb);
}

if (rtp_session->vbw) {
switch_jb_reset(rtp_session->vbw);
}
3038}

3040SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_reset(switch_rtp_t *rtp_session)
3041{
if (!rtp_session) {
return;
}

rtp_session->seq = (uint16_t) rand();
rtp_session->ts = 0;
memset(&rtp_session->ts_norm, 0, sizeof(rtp_session->ts_norm));

rtp_session->last_stun = rtp_session->first_stun = 0;
rtp_session->wrong_addrs = 0;
rtp_session->rtcp_sent_packets = 0;
rtp_session->rtcp_last_sent = 0;
rtp_session->ice_adj = 0;

//switch_rtp_del_dtls(rtp_session, DTLS_TYPE_RTP|DTLS_TYPE_RTCP);
switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_PAUSE);
switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_MUTE);
rtcp_stats_init(rtp_session);

if (rtp_session->ice.ready) {
switch_rtp_reset_vb(rtp_session);
rtp_session->ice.ready = rtp_session->ice.rready = 0;
}

3066}

3068SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_reset_media_timer(switch_rtp_t *rtp_session)
3069{
rtp_session->missed_count = 0;
rtp_session->last_media = switch_micro_time_now();
3072}

3074SWITCH_DECLARE(char *)__attribute__((visibility("default"))) char * switch_rtp_get_remote_host(switch_rtp_t *rtp_session)
3075{
return zstr(rtp_session->remote_host_str)_zstr(rtp_session->remote_host_str) ? "0.0.0.0" : rtp_session->remote_host_str;
3077}

3079SWITCH_DECLARE(switch_port_t)__attribute__((visibility("default"))) switch_port_t switch_rtp_get_remote_port(switch_rtp_t *rtp_session)
3080{
return rtp_session->remote_port;
3082}

3084static void ping_socket(switch_rtp_t *rtp_session)
3085{
uint32_t o = UINT_MAX(2147483647 *2U +1U);
switch_size_t len = sizeof(o);
switch_socket_sendto(rtp_session->sock_input, rtp_session->local_addr, 0, (void *) &o, &len);

if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] && rtp_session->rtcp_sock_input && rtp_session->rtcp_sock_input != rtp_session->sock_input) {
switch_socket_sendto(rtp_session->rtcp_sock_input, rtp_session->rtcp_local_addr, 0, (void *) &o, &len);
}
3093}

3095SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_udptl_mode(switch_rtp_t *rtp_session)
3096{
switch_socket_t *sock;

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA)) {
ping_socket(rtp_session);
}

READ_INC(rtp_session)switch_mutex_lock(rtp_session->read_mutex); rtp_session->
reading++;
WRITE_INC(rtp_session)switch_mutex_lock(rtp_session->write_mutex); rtp_session->
writing++;

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] || rtp_session->timer.timer_interface) {
switch_core_timer_destroy(&rtp_session->timer);
memset(&rtp_session->timer, 0, sizeof(rtp_session->timer));
switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
}

rtp_session->missed_count = 0;
rtp_session->max_missed_packets = 0;

rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] = 0;

if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
rtp_session->rtcp_sock_input = NULL((void*)0);
rtp_session->rtcp_sock_output = NULL((void*)0);
} else {
if (rtp_session->rtcp_sock_input && rtp_session->rtcp_sock_input != rtp_session->sock_input) {
	ping_socket(rtp_session);
	switch_socket_shutdown(rtp_session->rtcp_sock_input, SWITCH_SHUTDOWN_READWRITE);
}

if (rtp_session->rtcp_sock_output && rtp_session->rtcp_sock_output != rtp_session->rtcp_sock_input &&
	rtp_session->rtcp_sock_output != rtp_session->sock_input) {
	switch_socket_shutdown(rtp_session->rtcp_sock_output, SWITCH_SHUTDOWN_READWRITE);
}

if ((sock = rtp_session->rtcp_sock_input)) {
	rtp_session->rtcp_sock_input = NULL((void*)0);
	switch_socket_close(sock);

	if (rtp_session->rtcp_sock_output && rtp_session->rtcp_sock_output != sock) {
		sock = rtp_session->rtcp_sock_output;
		rtp_session->rtcp_sock_output = NULL((void*)0);
		switch_socket_close(sock);
	}
}
}

switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_UDPTL);
switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA);
switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK8, FALSE0);
switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);

WRITE_DEC(rtp_session)rtp_session->writing--; switch_mutex_unlock(rtp_session->
write_mutex);
READ_DEC(rtp_session)rtp_session->reading--; switch_mutex_unlock(rtp_session->
read_mutex);

switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH);
switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);

switch_rtp_break(rtp_session);

return SWITCH_STATUS_SUCCESS;

3162}


3165SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_set_remote_address(switch_rtp_t *rtp_session, const char *host, switch_port_t port, switch_port_t remote_rtcp_port,
													  switch_bool_t change_adv_addr, const char **err)
3167{
switch_sockaddr_t *remote_addr;
switch_status_t status = SWITCH_STATUS_SUCCESS;
*err = "Success";

if (switch_sockaddr_info_get(&remote_addr, host, SWITCH_UNSPEC0, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !remote_addr) {
*err = "Remote Address Error!";
return SWITCH_STATUS_FALSE;
}


switch_mutex_lock(rtp_session->write_mutex);

rtp_session->remote_addr = remote_addr;

if (change_adv_addr) {
rtp_session->remote_host_str = switch_core_strdup(rtp_session->pool, host)switch_core_perform_strdup(rtp_session->pool, host, "src/switch_rtp.c"
, (const char *)__func__, 3183);
rtp_session->remote_port = port;
}

rtp_session->eff_remote_host_str = switch_core_strdup(rtp_session->pool, host)switch_core_perform_strdup(rtp_session->pool, host, "src/switch_rtp.c"
, (const char *)__func__, 3187);
rtp_session->eff_remote_port = port;

if (rtp_session->sock_input && switch_sockaddr_get_family(rtp_session->remote_addr) == switch_sockaddr_get_family(rtp_session->local_addr)) {
rtp_session->sock_output = rtp_session->sock_input;
} else {
if (rtp_session->sock_output && rtp_session->sock_output != rtp_session->sock_input) {
	switch_socket_close(rtp_session->sock_output);
}
if ((status = switch_socket_create(&rtp_session->sock_output,
								   switch_sockaddr_get_family(rtp_session->remote_addr),
								   SOCK_DGRAMSOCK_DGRAM, 0, rtp_session->pool)) != SWITCH_STATUS_SUCCESS) {

	*err = "Socket Error!";
}
}

if (rtp_session->dtls) {
rtp_session->dtls->sock_output = rtp_session->sock_output;

if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
	switch_sockaddr_info_get(&rtp_session->dtls->remote_addr, host, SWITCH_UNSPEC0, port, 0, rtp_session->pool);
}
}


if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
	rtp_session->rtcp_remote_addr = rtp_session->remote_addr;
	rtp_session->rtcp_sock_output = rtp_session->sock_output;
}/* else {
	if (remote_rtcp_port) {
		rtp_session->remote_rtcp_port = remote_rtcp_port;
	} else {
		rtp_session->remote_rtcp_port = rtp_session->eff_remote_port + 1;
	}
	status = enable_remote_rtcp_socket(rtp_session, err);

	if (rtp_session->rtcp_dtls) {
		//switch_sockaddr_info_get(&rtp_session->rtcp_dtls->remote_addr, host, SWITCH_UNSPEC, port, 0, rtp_session->pool);
		rtp_session->rtcp_dtls->remote_addr = rtp_session->rtcp_remote_addr;
		rtp_session->rtcp_dtls->sock_output = rtp_session->rtcp_sock_output;
	}
	}*/
}

switch_mutex_unlock(rtp_session->write_mutex);

return status;
3236}


3239static const char *dtls_state_names_t[] = {"OFF", "HANDSHAKE", "SETUP", "READY", "FAIL", "INVALID"};
3240static const char *dtls_state_names(dtls_state_t s)
3241{
if (s > DS_INVALID) {
s = DS_INVALID;
}

return dtls_state_names_t[s];
3247}

3249#define dtls_set_state(_dtls, _state)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 3249, (const char*)(rtp_session->
session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n"
, rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), dtls_state_names
(_dtls->state), dtls_state_names(_state)); _dtls->new_state
 = 1; _dtls->last_state = _dtls->state; _dtls->state
 = _state switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3249, (const char*)(rtp_session->session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), dtls_state_names(_dtls->state), dtls_state_names(_state)); _dtls->new_state = 1; _dtls->last_state = _dtls->state; _dtls->state = _state

3251#define cr_keylen16 16
3252#define cr_saltlen14 14
3253#define cr_kslen30 30

3255static int dtls_state_setup(switch_rtp_t *rtp_session, switch_dtls_t *dtls)
3256{
X509 *cert;
switch_secure_settings_t	ssec;	/* Used just to wrap over params in a call to switch_rtp_add_crypto_key. */
int r = 0;

uint8_t raw_key_data[cr_kslen30 * 2];
unsigned char local_key_buf[cr_kslen30];
unsigned char remote_key_buf[cr_kslen30];

memset(&ssec, 0, sizeof(ssec));
memset(&raw_key_data, 0, cr_kslen30 * 2 * sizeof(uint8_t));
memset(&local_key_buf, 0, cr_kslen30 * sizeof(unsigned char));
memset(&remote_key_buf, 0, cr_kslen30 * sizeof(unsigned char));

if ((dtls->type & DTLS_TYPE_SERVER)) {
r = 1;
} else if ((cert = SSL_get_peer_certificate(dtls->ssl))) {
switch_core_cert_extract_fingerprint(cert, dtls->remote_fp);
r = switch_core_cert_verify(dtls->remote_fp);
X509_free(cert);
}

if (!r) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3279, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s Fingerprint Verification Failed!\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
dtls_set_state(dtls, DS_FAIL)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 3280, (const char*)(rtp_session->
session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n"
, rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), dtls_state_names
(dtls->state), dtls_state_names(DS_FAIL)); dtls->new_state
 = 1; dtls->last_state = dtls->state; dtls->state = DS_FAIL;
return -1;
} else {
unsigned char *local_key, *remote_key, *local_salt, *remote_salt;

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3285, (const char*)(rtp_session->session), SWITCH_LOG_INFO, "%s Fingerprint Verified.\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));

3287#ifdef HAVE_OPENSSL_DTLS_SRTP1
if (!SSL_export_keying_material(dtls->ssl, raw_key_data, sizeof(raw_key_data), "EXTRACTOR-dtls_srtp", 19, NULL((void*)0), 0, 0)) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3289, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s Key material export failure\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
	dtls_set_state(dtls, DS_FAIL)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 3290, (const char*)(rtp_session->
session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n"
, rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), dtls_state_names
(dtls->state), dtls_state_names(DS_FAIL)); dtls->new_state
 = 1; dtls->last_state = dtls->state; dtls->state = DS_FAIL;
	return -1;
}
3293#else
return -1;
3295#endif

if ((dtls->type & DTLS_TYPE_CLIENT)) {
	local_key = raw_key_data;
	remote_key = local_key + cr_keylen16;
	local_salt = remote_key + cr_keylen16;
	remote_salt = local_salt + cr_saltlen14;

} else {
	remote_key = raw_key_data;
	local_key = remote_key + cr_keylen16;
	remote_salt = local_key + cr_keylen16;
	local_salt = remote_salt + cr_saltlen14;
}

memcpy(ssec.local_raw_key, local_key, cr_keylen16);
memcpy(ssec.local_raw_key + cr_keylen16, local_salt, cr_saltlen14);

memcpy(ssec.remote_raw_key, remote_key, cr_keylen16);
memcpy(ssec.remote_raw_key + cr_keylen16, remote_salt, cr_saltlen14);

ssec.crypto_type = AES_CM_128_HMAC_SHA1_80;

if (dtls == rtp_session->rtcp_dtls && rtp_session->rtcp_dtls != rtp_session->dtls) {
	switch_rtp_add_crypto_key(rtp_session, SWITCH_RTP_CRYPTO_SEND_RTCP, 0, &ssec);
	switch_rtp_add_crypto_key(rtp_session, SWITCH_RTP_CRYPTO_RECV_RTCP, 0, &ssec);
} else {
	switch_rtp_add_crypto_key(rtp_session, SWITCH_RTP_CRYPTO_SEND, 0, &ssec);
	switch_rtp_add_crypto_key(rtp_session, SWITCH_RTP_CRYPTO_RECV, 0, &ssec);
}
}

dtls_set_state(dtls, DS_READY)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 3327, (const char*)(rtp_session->
session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n"
, rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), dtls_state_names
(dtls->state), dtls_state_names(DS_READY)); dtls->new_state
 = 1; dtls->last_state = dtls->state; dtls->state = DS_READY;

return 0;
3330}

3332static int dtls_state_ready(switch_rtp_t *rtp_session, switch_dtls_t *dtls)
3333{

if (dtls->new_state) {
if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
	switch_core_session_t *other_session;

	if (rtp_session->session && switch_core_session_get_partner(rtp_session->session, &other_session)switch_core_session_perform_get_partner(rtp_session->session
, &other_session, "src/switch_rtp.c", (const char *)__func__
, 3339) == SWITCH_STATUS_SUCCESS) {
		switch_core_session_request_video_refresh(other_session)_switch_core_session_request_video_refresh(other_session, 0, "src/switch_rtp.c"
, (const char *)__func__, 3340);
		switch_core_session_rwunlock(other_session);
	}
}
dtls->new_state = 0;
}
return 0;
3347}

3349static int dtls_state_fail(switch_rtp_t *rtp_session, switch_dtls_t *dtls)
3350{
if (rtp_session->session) {
switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER)switch_channel_perform_hangup(channel, "src/switch_rtp.c", (const
 char *)__func__, 3353, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER
);
}

return -1;
3357}


3360static int dtls_state_handshake(switch_rtp_t *rtp_session, switch_dtls_t *dtls)
3361{
int ret;

if ((ret = SSL_do_handshake(dtls->ssl)) != 1){
switch((ret = SSL_get_error(dtls->ssl, ret))){
case SSL_ERROR_WANT_READ2:
case SSL_ERROR_WANT_WRITE3:
case SSL_ERROR_NONE0:
	break;
default:
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3371, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "%s Handshake failure %d. This may happen when you use legacy DTLS v1.0 (legacyDTLS channel var is set) but endpoint requires DTLS v1.2.\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ret);
	dtls_set_state(dtls, DS_FAIL)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 3372, (const char*)(rtp_session->
session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n"
, rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), dtls_state_names
(dtls->state), dtls_state_names(DS_FAIL)); dtls->new_state
 = 1; dtls->last_state = dtls->state; dtls->state = DS_FAIL;
	return -1;
}
}

if (SSL_is_init_finished(dtls->ssl)) {
dtls_set_state(dtls, DS_SETUP)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 3378, (const char*)(rtp_session->
session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n"
, rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), dtls_state_names
(dtls->state), dtls_state_names(DS_SETUP)); dtls->new_state
 = 1; dtls->last_state = dtls->state; dtls->state = DS_SETUP;
}

return 0;
3382}

3384static void free_dtls(switch_dtls_t **dtlsp)
3385{
switch_dtls_t *dtls;

if (!dtlsp) {
return;
}

dtls = *dtlsp;
*dtlsp = NULL((void*)0);

if (dtls->ssl) {
SSL_free(dtls->ssl);
}

if (dtls->ssl_ctx) {
SSL_CTX_free(dtls->ssl_ctx);
}
3402}

3404static int do_dtls(switch_rtp_t *rtp_session, switch_dtls_t *dtls)
3405{
int r = 0, ret = 0, len;
switch_size_t bytes;
unsigned char buf[MAX_DTLS_MTU4096] = "";
int ready = rtp_session->ice.ice_user ? (rtp_session->ice.rready && rtp_session->ice.ready) : 1;
int pending;

if (!dtls->bytes && !ready) {
return 0;
}

if (dtls->bytes > 0 && dtls->data) {
ret = BIO_write(dtls->read_bio, dtls->data, (int)dtls->bytes);
if (ret <= 0) {
	ret = SSL_get_error(dtls->ssl, ret);
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3420, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS packet decode err: SSL err %d\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ret);
} else if (ret != (int)dtls->bytes) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3422, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS packet decode err: read %d bytes instead of %d\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ret, (int)dtls->bytes);
}
}

if (dtls_states[dtls->state]) {
r = dtls_states[dtls->state](rtp_session, dtls);
}

while ((pending = BIO_ctrl_pending(dtls->filter_bio)) > 0) {
switch_assert(pending <= sizeof(buf))((pending <= sizeof(buf)) ? (void) (0) : __assert_fail ("pending <= sizeof(buf)"
, "src/switch_rtp.c", 3431, __extension__ __PRETTY_FUNCTION__
));

len = BIO_read(dtls->write_bio, buf, pending);
if (len > 0) {
	bytes = len;
	ret = switch_socket_sendto(dtls->sock_output, dtls->remote_addr, 0, (void *)buf, &bytes);

	if (ret != SWITCH_STATUS_SUCCESS) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3439, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS packet not written to socket: %d\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ret);
	} else if (bytes != len) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3441, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS packet write err: written %d bytes instead of %d\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), (int)bytes, len);
	}
} else {
	ret = SSL_get_error(dtls->ssl, len);
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3445, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS packet encode err: SSL err %d\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ret);
}
}

return r;
3450}

3452#if VERIFY
3453static int cb_verify_peer(int preverify_ok, X509_STORE_CTX *ctx)
3454{
SSL *ssl = NULL((void*)0);
switch_dtls_t *dtls;
X509 *cert;
int r = 0;

ssl = X509_STORE_CTX_get_app_data(ctx)X509_STORE_CTX_get_ex_data(ctx,0);
dtls = (switch_dtls_t *) SSL_get_app_data(ssl)(SSL_get_ex_data(ssl,0));

if (!(ssl && dtls)) {
return 0;
}

if ((cert = SSL_get_peer_certificate(dtls->ssl))) {
switch_core_cert_extract_fingerprint(cert, dtls->remote_fp);

r = switch_core_cert_verify(dtls->remote_fp);

X509_free(cert);
} else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(dtls->rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3474, (const char*)(dtls->rtp_session->session
), SWITCH_LOG_ERROR, "%s CERT ERR!\n", rtp_type(dtls->rtp_session)dtls->rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text"
 : (dtls->rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] ? "video"
 : "audio"));
}

return r;
3478}
3479#endif


3482////////////

3484#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
3485static BIO_METHOD dtls_bio_filter_methods;
3486#else
3487static BIO_METHOD *dtls_bio_filter_methods;
3488#endif

3490BIO_METHOD *BIO_dtls_filter(void) {
3491#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L	
return(&dtls_bio_filter_methods);
3493#else
return(dtls_bio_filter_methods);
3495#endif
3496}

3498typedef struct packet_list_s {
//void *packet;
int size;
struct packet_list_s *next;
3502} packet_list_t;

3504/* Helper struct to keep the filter state */
3505typedef struct dtls_bio_filter {
packet_list_t *packets;
packet_list_t *unused;
packet_list_t *tail;
switch_mutex_t *mutex;
switch_memory_pool_t *pool;
long mtu;
3512} dtls_bio_filter;


3515static int dtls_bio_filter_new(BIO *bio) {
/* Create a filter state struct */
dtls_bio_filter *filter;
switch_memory_pool_t *pool;

switch_core_new_memory_pool(&pool)switch_core_perform_new_memory_pool(&pool, "src/switch_rtp.c"
, (const char *)__func__, 3520);
filter = switch_core_alloc(pool, sizeof(*filter))switch_core_perform_alloc(pool, sizeof(*filter), "src/switch_rtp.c"
, (const char *)__func__, 3521);
filter->pool = pool;

filter->packets = NULL((void*)0);
switch_mutex_init(&filter->mutex, SWITCH_MUTEX_NESTED0x1, filter->pool);

/* Set the BIO as initialized */
3528#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
bio->init = 1;
bio->ptr = filter;
bio->flags = 0;
3532#else
BIO_set_init(bio, 1);
BIO_set_data(bio, filter);
BIO_clear_flags(bio, ~0);
3536#endif

return 1;
3539}

3541static int dtls_bio_filter_free(BIO *bio) {
dtls_bio_filter *filter;

if (bio == NULL((void*)0)) {
return 0;
}

/* Get rid of the filter state */
3549#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
filter = (dtls_bio_filter *)bio->ptr;
3551#else
filter = (dtls_bio_filter *)BIO_get_data(bio);
3553#endif

if (filter != NULL((void*)0)) {
switch_memory_pool_t *pool = filter->pool;
switch_core_destroy_memory_pool(&pool)switch_core_perform_destroy_memory_pool(&pool, "src/switch_rtp.c"
, (const char *)__func__, 3557);
pool = NULL((void*)0);
filter = NULL((void*)0);
}

3562#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
bio->ptr = NULL((void*)0);
bio->init = 0;
bio->flags = 0;
3566#else
BIO_set_init(bio, 0);
BIO_set_data(bio, NULL((void*)0));
BIO_clear_flags(bio, ~0);
3570#endif
return 1;
3572}

3574static int dtls_bio_filter_write(BIO *bio, const char *in, int inl) {
long ret;
dtls_bio_filter *filter;

switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 3578, ((void*)0), SWITCH_LOG_DEBUG1, "dtls_bio_filter_write: %p, %d\n", (void *)in, inl);
/* Forward data to the write BIO */
3580#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
ret = BIO_write(bio->next_bio, in, inl);
3582#else
ret = BIO_write(BIO_next(bio), in, inl);
3584#endif

switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 3586, ((void*)0), SWITCH_LOG_DEBUG1, "  -- %ld\n", ret);

/* Keep track of the packet, as we'll advertize them one by one after a pending check */
3589#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
filter = (dtls_bio_filter *)bio->ptr;
3591#else
filter = (dtls_bio_filter *)BIO_get_data(bio);
3593#endif

if (filter != NULL((void*)0)) {
packet_list_t *node;

switch_mutex_lock(filter->mutex);
if (filter->unused) {
	node = filter->unused;
	node->next = NULL((void*)0);
	filter->unused = filter->unused->next;
} else {
	node = switch_core_alloc(filter->pool, sizeof(*node))switch_core_perform_alloc(filter->pool, sizeof(*node), "src/switch_rtp.c"
, (const char *)__func__, 3604);
}

node->size = ret;

if (filter->tail) {
	filter->tail->next = node;
} else {
	filter->packets = node;
}

filter->tail = node;

switch_mutex_unlock(filter->mutex);
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "New list length: %d\n", g_list_length(filter->packets));
}
return ret;
3621}

3623static long dtls_bio_filter_ctrl(BIO *bio, int cmd, long num, void *ptr) {
3624#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
dtls_bio_filter *filter = (dtls_bio_filter *)bio->ptr;
3626#else
dtls_bio_filter *filter = (dtls_bio_filter *)BIO_get_data(bio);
3628#endif

switch(cmd) {
case BIO_CTRL_DGRAM_GET_FALLBACK_MTU47:
return 1200;
case BIO_CTRL_DGRAM_SET_MTU42:
filter->mtu = num;
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 3635, ((void*)0), SWITCH_LOG_DEBUG1, "Setting MTU: %ld\n", filter->mtu);
return num;
case BIO_CTRL_FLUSH11:
return 1;
case BIO_CTRL_DGRAM_QUERY_MTU40:
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 3640, ((void*)0), SWITCH_LOG_DEBUG1, "Advertizing MTU: %ld\n", filter->mtu);
return filter->mtu;
case BIO_CTRL_WPENDING13:
return 0L;
case BIO_CTRL_PENDING10: {
int pending = 0;
packet_list_t *top;

if (filter == NULL((void*)0)) {
	return 0;
}

switch_mutex_lock(filter->mutex);
if ((top = filter->packets)) {
	filter->packets = filter->packets->next;
	
	if (top == filter->tail || !filter->packets) {
		filter->tail = NULL((void*)0);
	}
	
	pending = top->size;
	top->next = filter->unused;
	filter->unused = top;
}
switch_mutex_unlock(filter->mutex);

return pending;
}
default:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "dtls_bio_filter_ctrl: %d\n", cmd);
break;
}
return 0;
3673}

3675#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
3676static BIO_METHOD dtls_bio_filter_methods = {
BIO_TYPE_FILTER0x0200,
"DTLS filter",
dtls_bio_filter_write,
NULL((void*)0),
NULL((void*)0),
NULL((void*)0),
dtls_bio_filter_ctrl,
dtls_bio_filter_new,
dtls_bio_filter_free,
NULL((void*)0)
3687};
3688#else
3689static BIO_METHOD *dtls_bio_filter_methods = NULL((void*)0);
3690#endif

3692static void switch_rtp_dtls_init() {
3693#if OPENSSL_VERSION_NUMBER0x1010104fL >= 0x10100000L
dtls_bio_filter_methods = BIO_meth_new(BIO_TYPE_FILTER0x0200 | BIO_get_new_index(), "DTLS filter");
BIO_meth_set_write(dtls_bio_filter_methods, dtls_bio_filter_write);
BIO_meth_set_ctrl(dtls_bio_filter_methods, dtls_bio_filter_ctrl);
BIO_meth_set_create(dtls_bio_filter_methods, dtls_bio_filter_new);
BIO_meth_set_destroy(dtls_bio_filter_methods, dtls_bio_filter_free);
3699#endif
3700}

3702static void switch_rtp_dtls_destroy() {
3703#if OPENSSL_VERSION_NUMBER0x1010104fL >= 0x10100000L
if (dtls_bio_filter_methods) {
BIO_meth_free(dtls_bio_filter_methods);
dtls_bio_filter_methods = NULL((void*)0);
}
3708#endif
3709}

3711///////////



3715SWITCH_DECLARE(int)__attribute__((visibility("default"))) int switch_rtp_has_dtls(void) {
3716#ifdef HAVE_OPENSSL_DTLS_SRTP1
return 1;
3718#else
return 0;
3720#endif
3721}

3723SWITCH_DECLARE(dtls_state_t)__attribute__((visibility("default"))) dtls_state_t switch_rtp_dtls_state(switch_rtp_t *rtp_session, dtls_type_t type)
3724{
dtls_state_t s = DS_OFF;

switch_mutex_lock(rtp_session->ice_mutex);

if (!rtp_session || (!rtp_session->dtls && !rtp_session->rtcp_dtls)) {
s = DS_OFF;
goto done;
}

if ((type == DTLS_TYPE_RTP) && rtp_session->dtls) {
s = rtp_session->dtls->state;
goto done;
}

if ((type == DTLS_TYPE_RTCP) && rtp_session->rtcp_dtls) {
s = rtp_session->rtcp_dtls->state;
}

done:

switch_mutex_unlock(rtp_session->ice_mutex);

return s;
3748}

3750SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_del_dtls(switch_rtp_t *rtp_session, dtls_type_t type)
3751{
switch_status_t status = SWITCH_STATUS_SUCCESS;

switch_mutex_lock(rtp_session->ice_mutex);

if (!rtp_session || (!rtp_session->dtls && !rtp_session->rtcp_dtls)) {
switch_goto_status(SWITCH_STATUS_FALSE, done)status = SWITCH_STATUS_FALSE; goto done;
}

if ((type & DTLS_TYPE_RTP)) {
if (rtp_session->dtls && rtp_session->dtls == rtp_session->rtcp_dtls) {
	rtp_session->rtcp_dtls = NULL((void*)0);
}

if (rtp_session->dtls) {
	free_dtls(&rtp_session->dtls);
}

if (rtp_session->jb) {
	switch_jb_reset(rtp_session->jb);
}

if (rtp_session->vb) {
	switch_jb_reset(rtp_session->vb);
}

if (rtp_session->vbw) {
	switch_jb_reset(rtp_session->vbw);
}

}

if ((type & DTLS_TYPE_RTCP) && rtp_session->rtcp_dtls) {
free_dtls(&rtp_session->rtcp_dtls);
}


3788#ifdef ENABLE_SRTP1
if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {
int x;

rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 0;

for(x = 0; x < 2; x++) {
	if (rtp_session->send_ctx[x]) {
		srtp_dealloc(rtp_session->send_ctx[x]);
		rtp_session->send_ctx[x] = NULL((void*)0);
	}
}
}

if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV]) {
int x;

rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 0;

for (x = 0; x < 2; x++) {
	if (rtp_session->recv_ctx[x]) {
		srtp_dealloc(rtp_session->recv_ctx[x]);
		rtp_session->recv_ctx[x] = NULL((void*)0);
	}
}
}
3814#endif

done:

switch_mutex_unlock(rtp_session->ice_mutex);

return status;
3821}

3823SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_add_dtls(switch_rtp_t *rtp_session, dtls_fingerprint_t *local_fp, dtls_fingerprint_t *remote_fp, dtls_type_t type, uint8_t want_DTLSv1_2)
3824{
switch_dtls_t *dtls;
const char *var;
int ret;
const char *kind = "";
unsigned long ssl_method_error = 0;
unsigned long ssl_ctx_error = 0;
const SSL_METHOD *ssl_method;
SSL_CTX *ssl_ctx;
BIO *bio;
DH *dh;
switch_status_t status = SWITCH_STATUS_SUCCESS;
3836#ifndef OPENSSL_NO_EC
3837#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10002000L
EC_KEY* ecdh;
3839#endif
3840#endif

3842#ifndef HAVE_OPENSSL_DTLS_SRTP1
return SWITCH_STATUS_FALSE;
3844#endif

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

switch_mutex_lock(rtp_session->ice_mutex);

if (!((type & DTLS_TYPE_RTP) || (type & DTLS_TYPE_RTCP)) || !((type & DTLS_TYPE_CLIENT) || (type & DTLS_TYPE_SERVER))) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3853, (const char*)(rtp_session->session), SWITCH_LOG_CRIT, "INVALID TYPE!\n");
}

switch_rtp_del_dtls(rtp_session, type);

if ((type & DTLS_TYPE_RTP) && (type & DTLS_TYPE_RTCP)) {
kind = "RTP/RTCP";
} else if ((type & DTLS_TYPE_RTP)) {
kind = "RTP";
} else {
kind = "RTCP";
}

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3866, (const char*)(rtp_session->session), SWITCH_LOG_INFO,
			  "Activate %s %s DTLS %s\n", kind, rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), (type & DTLS_TYPE_SERVER) ? "server" : "client");

if (((type & DTLS_TYPE_RTP) && rtp_session->dtls) || ((type & DTLS_TYPE_RTCP) && rtp_session->rtcp_dtls)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3870, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "DTLS ALREADY INIT\n");
switch_goto_status(SWITCH_STATUS_FALSE, done)status = SWITCH_STATUS_FALSE; goto done;
}

dtls = switch_core_alloc(rtp_session->pool, sizeof(*dtls))switch_core_perform_alloc(rtp_session->pool, sizeof(*dtls)
, "src/switch_rtp.c", (const char *)__func__, 3874);

dtls->pem = switch_core_sprintf(rtp_session->pool, "%s%s%s.pem", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR"/", DTLS_SRTP_FNAME"dtls-srtp");

if (switch_file_exists(dtls->pem, rtp_session->pool) == SWITCH_STATUS_SUCCESS) {
dtls->pvt = dtls->rsa = dtls->pem;
} else {
dtls->pvt = switch_core_sprintf(rtp_session->pool, "%s%s%s.key", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR"/", DTLS_SRTP_FNAME"dtls-srtp");
dtls->rsa = switch_core_sprintf(rtp_session->pool, "%s%s%s.crt", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR"/", DTLS_SRTP_FNAME"dtls-srtp");
}

dtls->ca = switch_core_sprintf(rtp_session->pool, "%s%sca-bundle.crt", SWITCH_GLOBAL_dirs.certs_dir, SWITCH_PATH_SEPARATOR"/");

3887#if OPENSSL_VERSION_NUMBER0x1010104fL >= 0x10100000
ssl_method = (type & DTLS_TYPE_SERVER) ? DTLS_server_method() : DTLS_client_method();
3889#else
  #ifdef HAVE_OPENSSL_DTLSv1_2_method1
ssl_method = (type & DTLS_TYPE_SERVER) ? (want_DTLSv1_2 ? DTLSv1_2_server_method() : DTLSv1_server_method()) : (want_DTLSv1_2 ? DTLSv1_2_client_method() : DTLSv1_client_method());
#else
ssl_method = (type & DTLS_TYPE_SERVER) ? DTLSv1_server_method() : DTLSv1_client_method();
  #endif // HAVE_OPENSSL_DTLSv1_2_method
3895#endif

if (!ssl_method) {
ssl_method_error = ERR_peek_error();
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3899, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s ssl_method is NULL [%lu]\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ssl_method_error);
}

dtls->ssl_ctx = ssl_ctx = SSL_CTX_new(ssl_method);

if (!ssl_ctx) {
ssl_ctx_error = ERR_peek_error();
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3906, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s SSL_CTX_new failed [%lu]\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ssl_ctx_error);
switch_channel_hangup(switch_core_session_get_channel(rtp_session->session), SWITCH_CAUSE_NORMAL_TEMPORARY_FAILURE)switch_channel_perform_hangup(switch_core_session_get_channel
(rtp_session->session), "src/switch_rtp.c", (const char *)
__func__, 3907, SWITCH_CAUSE_NORMAL_TEMPORARY_FAILURE);
switch_goto_status(SWITCH_STATUS_FALSE, done)status = SWITCH_STATUS_FALSE; goto done;
}

switch_assert(dtls->ssl_ctx)((dtls->ssl_ctx) ? (void) (0) : __assert_fail ("dtls->ssl_ctx"
, "src/switch_rtp.c", 3911, __extension__ __PRETTY_FUNCTION__
));

bio = BIO_new_file(dtls->pem, "r");
dh = PEM_read_bio_DHparams(bio, NULL((void*)0), NULL((void*)0), NULL((void*)0));
BIO_free(bio);
if (dh) {
SSL_CTX_set_tmp_dh(dtls->ssl_ctx, dh)SSL_CTX_ctrl(dtls->ssl_ctx,3,0,(char *)(dh));
DH_free(dh);
}

SSL_CTX_set_mode(dtls->ssl_ctx, SSL_MODE_AUTO_RETRY)SSL_CTX_ctrl((dtls->ssl_ctx),33,(0x00000004U),((void*)0));

//SSL_CTX_set_verify(dtls->ssl_ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
SSL_CTX_set_verify(dtls->ssl_ctx, SSL_VERIFY_NONE0x00, NULL((void*)0));

//SSL_CTX_set_cipher_list(dtls->ssl_ctx, "ECDH:!RC4:!SSLv3:RSA_WITH_AES_128_CBC_SHA");
//SSL_CTX_set_cipher_list(dtls->ssl_ctx, "ECDHE-RSA-AES256-GCM-SHA384");
SSL_CTX_set_cipher_list(dtls->ssl_ctx, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
//SSL_CTX_set_cipher_list(dtls->ssl_ctx, "SUITEB128");
SSL_CTX_set_read_ahead(dtls->ssl_ctx, 1)SSL_CTX_ctrl(dtls->ssl_ctx,41,1,((void*)0));
3931#ifdef HAVE_OPENSSL_DTLS_SRTP1
//SSL_CTX_set_tlsext_use_srtp(dtls->ssl_ctx, "SRTP_AES128_CM_SHA1_80:SRTP_AES128_CM_SHA1_32");
SSL_CTX_set_tlsext_use_srtp(dtls->ssl_ctx, "SRTP_AES128_CM_SHA1_80");
3934#endif

dtls->type = type;
dtls->read_bio = BIO_new(BIO_s_mem());
switch_assert(dtls->read_bio)((dtls->read_bio) ? (void) (0) : __assert_fail ("dtls->read_bio"
, "src/switch_rtp.c", 3938, __extension__ __PRETTY_FUNCTION__
));

dtls->write_bio = BIO_new(BIO_s_mem());
switch_assert(dtls->write_bio)((dtls->write_bio) ? (void) (0) : __assert_fail ("dtls->write_bio"
, "src/switch_rtp.c", 3941, __extension__ __PRETTY_FUNCTION__
));

BIO_set_mem_eof_return(dtls->read_bio, -1)BIO_ctrl(dtls->read_bio,130,-1,((void*)0));
BIO_set_mem_eof_return(dtls->write_bio, -1)BIO_ctrl(dtls->write_bio,130,-1,((void*)0));

if ((ret=SSL_CTX_use_certificate_file(dtls->ssl_ctx, dtls->rsa, SSL_FILETYPE_PEM1)) != 1) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3947, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS cert err [%d]\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), SSL_get_error(dtls->ssl, ret));
switch_goto_status(SWITCH_STATUS_FALSE, done)status = SWITCH_STATUS_FALSE; goto done;
}

if ((ret=SSL_CTX_use_PrivateKey_file(dtls->ssl_ctx, dtls->pvt, SSL_FILETYPE_PEM1)) != 1) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3952, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS key err [%d]\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), SSL_get_error(dtls->ssl, ret));
switch_goto_status(SWITCH_STATUS_FALSE, done)status = SWITCH_STATUS_FALSE; goto done;
}

if (SSL_CTX_check_private_key(dtls->ssl_ctx) == 0) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3957, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS check key failed\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
switch_goto_status(SWITCH_STATUS_FALSE, done)status = SWITCH_STATUS_FALSE; goto done;
}

if (!zstr(dtls->ca)_zstr(dtls->ca) && switch_file_exists(dtls->ca, rtp_session->pool) == SWITCH_STATUS_SUCCESS
&& (ret = SSL_CTX_load_verify_locations(dtls->ssl_ctx, dtls->ca, NULL((void*)0))) != 1) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 3963, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "%s DTLS check chain cert failed [%d]\n",
				  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio") ,
				  SSL_get_error(dtls->ssl, ret));
switch_goto_status(SWITCH_STATUS_FALSE, done)status = SWITCH_STATUS_FALSE; goto done;
}

dtls->ssl = SSL_new(dtls->ssl_ctx);

3971#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
dtls->filter_bio = BIO_new(BIO_dtls_filter());
3973#else
switch_assert(dtls_bio_filter_methods)((dtls_bio_filter_methods) ? (void) (0) : __assert_fail ("dtls_bio_filter_methods"
, "src/switch_rtp.c", 3974, __extension__ __PRETTY_FUNCTION__
));
dtls->filter_bio = BIO_new(dtls_bio_filter_methods);
3976#endif

switch_assert(dtls->filter_bio)((dtls->filter_bio) ? (void) (0) : __assert_fail ("dtls->filter_bio"
, "src/switch_rtp.c", 3978, __extension__ __PRETTY_FUNCTION__
));

BIO_push(dtls->filter_bio, dtls->write_bio);

SSL_set_bio(dtls->ssl, dtls->read_bio, dtls->filter_bio);

SSL_set_mode(dtls->ssl, SSL_MODE_AUTO_RETRY)SSL_ctrl((dtls->ssl),33,(0x00000004U),((void*)0));
SSL_set_read_ahead(dtls->ssl, 1);


//SSL_set_verify(dtls->ssl, (SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT), cb_verify_peer);

3990#ifndef OPENSSL_NO_EC
3991#if OPENSSL_VERSION_NUMBER0x1010104fL < 0x10002000L
ecdh = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1415);
if (!ecdh) {
switch_goto_status(SWITCH_STATUS_FALSE, done)status = SWITCH_STATUS_FALSE; goto done;
}
SSL_set_options(dtls->ssl, SSL_OP_SINGLE_ECDH_USE0x0);
SSL_set_tmp_ecdh(dtls->ssl, ecdh)SSL_ctrl(dtls->ssl,4,0,(char *)(ecdh));
EC_KEY_free(ecdh);
3999#elif OPENSSL_VERSION_NUMBER0x1010104fL < 0x10100000L
SSL_set_ecdh_auto(dtls->ssl, 1)((1) != 0);
SSL_set_options(dtls->ssl, SSL_OP_SINGLE_ECDH_USE0x0);
4002#endif
4003#endif

SSL_set_verify(dtls->ssl, SSL_VERIFY_NONE0x00, NULL((void*)0));
SSL_set_app_data(dtls->ssl, dtls)(SSL_set_ex_data(dtls->ssl,0,(char *)(dtls)));

dtls->local_fp = local_fp;
dtls->remote_fp = remote_fp;
dtls->rtp_session = rtp_session;
dtls->mtu = 1200;

if (rtp_session->session) {
switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
if ((var = switch_channel_get_variable(channel, "rtp_dtls_mtu")switch_channel_get_variable_dup(channel, "rtp_dtls_mtu", SWITCH_TRUE
, -1))) {
	int mtu = atoi(var);

	if (mtu > 0 && mtu < MAX_DTLS_MTU4096) {
		dtls->mtu = mtu;
	}

}
}

BIO_ctrl(dtls->filter_bio, BIO_CTRL_DGRAM_SET_MTU42, dtls->mtu, NULL((void*)0));

switch_core_cert_expand_fingerprint(remote_fp, remote_fp->str);

if ((type & DTLS_TYPE_RTP)) {
rtp_session->dtls = dtls;
dtls->sock_output = rtp_session->sock_output;
dtls->remote_addr = rtp_session->remote_addr;
}

if ((type & DTLS_TYPE_RTCP)) {
rtp_session->rtcp_dtls = dtls;
if (!(type & DTLS_TYPE_RTP)) {
	dtls->sock_output = rtp_session->rtcp_sock_output;
	dtls->remote_addr = rtp_session->rtcp_remote_addr;
}
}

if ((type & DTLS_TYPE_SERVER)) {
SSL_set_accept_state(dtls->ssl);
} else {
SSL_set_connect_state(dtls->ssl);
}

dtls_set_state(dtls, DS_HANDSHAKE)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 4049, (const char*)(rtp_session->
session), SWITCH_LOG_INFO, "Changing %s DTLS state from %s to %s\n"
, rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), dtls_state_names
(dtls->state), dtls_state_names(DS_HANDSHAKE)); dtls->new_state
 = 1; dtls->last_state = dtls->state; dtls->state = DS_HANDSHAKE;

rtp_session->flags[SWITCH_RTP_FLAG_VIDEO_BREAK] = 1;
switch_rtp_break(rtp_session);

done:

switch_mutex_unlock(rtp_session->ice_mutex);

return status;

4060}

4062SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_add_crypto_key(switch_rtp_t *rtp_session, switch_rtp_crypto_direction_t direction, uint32_t index, switch_secure_settings_t *ssec)
4063{
4064#ifndef ENABLE_SRTP1
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4065, (const char*)(rtp_session->session), SWITCH_LOG_CRIT, "SRTP NOT SUPPORTED IN THIS BUILD!\n");
return SWITCH_STATUS_FALSE;
4067#else

switch_rtp_crypto_key_t *crypto_key;
srtp_policy_t *policy;
srtp_err_status_t stat;
switch_status_t status = SWITCH_STATUS_SUCCESS;

switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
switch_event_t *fsevent = NULL((void*)0);
int idx = 0;
const char *var;
unsigned char b64_key[512] = "";

unsigned char	*keysalt = NULL((void*)0);
switch_size_t	keysalt_len = 0;

switch_crypto_key_material_t	*key_material = NULL((void*)0);
unsigned long					*key_material_n = NULL((void*)0);
srtp_master_key_t		**mkis = NULL((void*)0);
srtp_master_key_t		*mki = NULL((void*)0);
int mki_idx = 0;

keysalt_len = switch_core_media_crypto_keysalt_len(ssec->crypto_type);

if (direction >= SWITCH_RTP_CRYPTO_MAX || keysalt_len > SWITCH_RTP_MAX_CRYPTO_LEN64) {
return SWITCH_STATUS_FALSE;
}

if (direction == SWITCH_RTP_CRYPTO_RECV_RTCP) {
direction = SWITCH_RTP_CRYPTO_RECV;
rtp_session->srtp_idx_rtcp = idx = 1;
} else if (direction == SWITCH_RTP_CRYPTO_SEND_RTCP) {
direction = SWITCH_RTP_CRYPTO_SEND;
rtp_session->srtp_idx_rtcp = idx = 1;
}

if (direction == SWITCH_RTP_CRYPTO_RECV) {
policy = &rtp_session->recv_policy[idx];
keysalt = ssec->remote_raw_key;
key_material = ssec->remote_key_material_next;
key_material_n = &ssec->remote_key_material_n;
} else {
policy = &rtp_session->send_policy[idx];
keysalt = ssec->local_raw_key;
key_material = ssec->local_key_material_next;
key_material_n = &ssec->local_key_material_n;
}

switch_b64_encode(keysalt, keysalt_len, b64_key, sizeof(b64_key));

if (switch_true(switch_core_get_variable("rtp_retain_crypto_keys"))) {
switch(direction) {
	case SWITCH_RTP_CRYPTO_SEND:
		switch_channel_set_variable(channel, "srtp_local_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtp_local_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	case SWITCH_RTP_CRYPTO_RECV:
		switch_channel_set_variable(channel, "srtp_remote_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtp_remote_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	case SWITCH_RTP_CRYPTO_SEND_RTCP:
		switch_channel_set_variable(channel, "srtcp_local_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtcp_local_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	case SWITCH_RTP_CRYPTO_RECV_RTCP:
		switch_channel_set_variable(channel, "srtcp_remote_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtcp_remote_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	default:
		break;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
	switch(direction) {
	case SWITCH_RTP_CRYPTO_SEND:
		switch_channel_set_variable(channel, "srtp_local_video_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtp_local_video_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	case SWITCH_RTP_CRYPTO_RECV:
		switch_channel_set_variable(channel, "srtp_remote_video_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtp_remote_video_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	case SWITCH_RTP_CRYPTO_SEND_RTCP:
		switch_channel_set_variable(channel, "srtcp_local_video_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtcp_local_video_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	case SWITCH_RTP_CRYPTO_RECV_RTCP:
		switch_channel_set_variable(channel, "srtcp_remote_video_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtcp_remote_video_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	default:
		break;
	}

} else {
	switch(direction) {
	case SWITCH_RTP_CRYPTO_SEND:
		switch_channel_set_variable(channel, "srtp_local_audio_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtp_local_audio_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	case SWITCH_RTP_CRYPTO_RECV:
		switch_channel_set_variable(channel, "srtp_remote_audio_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtp_remote_audio_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	case SWITCH_RTP_CRYPTO_SEND_RTCP:
		switch_channel_set_variable(channel, "srtcp_local_audio_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtcp_local_audio_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	case SWITCH_RTP_CRYPTO_RECV_RTCP:
		switch_channel_set_variable(channel, "srtcp_remote_audio_crypto_key", (const char *)b64_key)switch_channel_set_variable_var_check(channel, "srtcp_remote_audio_crypto_key"
, (const char *)b64_key, SWITCH_TRUE);
		break;
	default:
		break;
	}
}
}

crypto_key = switch_core_alloc(rtp_session->pool, sizeof(*crypto_key))switch_core_perform_alloc(rtp_session->pool, sizeof(*crypto_key
), "src/switch_rtp.c", (const char *)__func__, 4173);

crypto_key->type = ssec->crypto_type;
crypto_key->index = index;
memcpy(crypto_key->keysalt, keysalt, keysalt_len);
crypto_key->next = rtp_session->crypto_keys[direction];
rtp_session->crypto_keys[direction] = crypto_key;

memset(policy, 0, sizeof(*policy));

/* many devices can't handle gaps in SRTP streams */
if (!((var = switch_channel_get_variable(channel, "srtp_allow_idle_gaps")switch_channel_get_variable_dup(channel, "srtp_allow_idle_gaps"
, SWITCH_TRUE, -1))
  && switch_true(var))
&& (!(var = switch_channel_get_variable(channel, "send_silence_when_idle")switch_channel_get_variable_dup(channel, "send_silence_when_idle"
, SWITCH_TRUE, -1))
	|| !(atoi(var)))) {
switch_channel_set_variable(channel, "send_silence_when_idle", "-1")switch_channel_set_variable_var_check(channel, "send_silence_when_idle"
, "-1", SWITCH_TRUE);
}

switch (crypto_key->type) {
case AES_CM_128_HMAC_SHA1_80:
srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy->rtp)srtp_crypto_policy_set_rtp_default(&policy->rtp);
srtp_crypto_policy_set_aes_cm_128_hmac_sha1_80(&policy->rtcp)srtp_crypto_policy_set_rtp_default(&policy->rtcp);

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
	switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_128_HMAC_SHA1_80")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "AES_CM_128_HMAC_SHA1_80", SWITCH_TRUE);
}
break;
case AES_CM_128_HMAC_SHA1_32:
srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy->rtp);
srtp_crypto_policy_set_aes_cm_128_hmac_sha1_32(&policy->rtcp);


if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
	switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_128_HMAC_SHA1_32")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "AES_CM_128_HMAC_SHA1_32", SWITCH_TRUE);
}
break;

case AEAD_AES_256_GCM_8:
srtp_crypto_policy_set_aes_gcm_256_8_auth(&policy->rtp);
srtp_crypto_policy_set_aes_gcm_256_8_auth(&policy->rtcp);

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
	switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_256_GCM_8")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "AEAD_AES_256_GCM_8", SWITCH_TRUE);
}
break;

case AEAD_AES_256_GCM:
srtp_crypto_policy_set_aes_gcm_256_16_auth(&policy->rtp);
srtp_crypto_policy_set_aes_gcm_256_16_auth(&policy->rtcp);

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
	switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_256_GCM")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "AEAD_AES_256_GCM", SWITCH_TRUE);
}
break;

case AEAD_AES_128_GCM_8:
srtp_crypto_policy_set_aes_gcm_128_8_auth(&policy->rtp);
srtp_crypto_policy_set_aes_gcm_128_8_auth(&policy->rtcp);

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
	switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_128_GCM_8")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "AEAD_AES_128_GCM_8", SWITCH_TRUE);
}
break;

case AEAD_AES_128_GCM:
srtp_crypto_policy_set_aes_gcm_128_16_auth(&policy->rtp);
srtp_crypto_policy_set_aes_gcm_128_16_auth(&policy->rtcp);

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
	switch_channel_set_variable(channel, "rtp_has_crypto", "AEAD_AES_128_GCM")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "AEAD_AES_128_GCM", SWITCH_TRUE);
}
break;

case AES_CM_256_HMAC_SHA1_80:
srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80(&policy->rtp);
srtp_crypto_policy_set_aes_cm_256_hmac_sha1_80(&policy->rtcp);
if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
	switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_256_HMAC_SHA1_80")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "AES_CM_256_HMAC_SHA1_80", SWITCH_TRUE);
}
break;
case AES_CM_256_HMAC_SHA1_32:
srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32(&policy->rtp);
srtp_crypto_policy_set_aes_cm_256_hmac_sha1_32(&policy->rtcp);
if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
	switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_256_HMAC_SHA1_32")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "AES_CM_256_HMAC_SHA1_32", SWITCH_TRUE);
}
break;
case AES_CM_128_NULL_AUTH:
srtp_crypto_policy_set_aes_cm_128_null_auth(&policy->rtp);
srtp_crypto_policy_set_aes_cm_128_null_auth(&policy->rtcp);

if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
	switch_channel_set_variable(channel, "rtp_has_crypto", "AES_CM_128_NULL_AUTH")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "AES_CM_128_NULL_AUTH", SWITCH_TRUE);
}
break;
default:
break;
}

/* Setup the policy with MKI if they are used. Number of key materials must be positive to use MKI. */
if (key_material && (*key_material_n > 0)) {

if (direction == SWITCH_RTP_CRYPTO_RECV) {
	rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_MKI] = 1;	/* tell the rest of the environment MKI is used */
} else {
	rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_MKI] = 1;	/* tell the rest of the environment MKI is used */
}

/* key must be NULL for libsrtp to work correctly with MKI. */
policy->key = NULL((void*)0);

/* Allocate array for MKIs. */
mkis = switch_core_alloc(rtp_session->pool, *key_material_n * sizeof(srtp_master_key_t*))switch_core_perform_alloc(rtp_session->pool, *key_material_n
 * sizeof(srtp_master_key_t*), "src/switch_rtp.c", (const char
 *)__func__, 4285);
if (!mkis) {
	return SWITCH_STATUS_FALSE;
}

/* Build array of MKIs. */
mki_idx = 0;

while (key_material && (mki_idx < *key_material_n)) {

	if (key_material->mki_size < 1) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4296, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "MKI bad key size at MKI %d\n", mki_idx);
		return SWITCH_STATUS_FALSE;
	}

	mki = switch_core_alloc(rtp_session->pool, sizeof(srtp_master_key_t))switch_core_perform_alloc(rtp_session->pool, sizeof(srtp_master_key_t
), "src/switch_rtp.c", (const char *)__func__, 4300);
	if (!mki) {
		return SWITCH_STATUS_FALSE;
	}

	/* Setup MKI. */
	mki->mki_id = switch_core_alloc(rtp_session->pool, sizeof(key_material->mki_size))switch_core_perform_alloc(rtp_session->pool, sizeof(key_material
->mki_size), "src/switch_rtp.c", (const char *)__func__, 4306
);
	if (!mki->mki_id) {
		return SWITCH_STATUS_FALSE;
	}

	mki->key = switch_core_alloc(rtp_session->pool, keysalt_len)switch_core_perform_alloc(rtp_session->pool, keysalt_len, "src/switch_rtp.c"
, (const char *)__func__, 4311);
	if (!mki->key) {
		return SWITCH_STATUS_FALSE;
	}

	memcpy(mki->mki_id, &key_material->mki_id, key_material->mki_size);
	mki->mki_size = key_material->mki_size;
	memcpy(mki->key, key_material->raw_key, keysalt_len);

	mkis[mki_idx] = mki;

	key_material = key_material->next;
	++mki_idx;
}

/* And pass the array of MKIs to libsrtp. */
policy->keys = mkis;
policy->num_master_keys = mki_idx;

} else {
policy->key = (uint8_t *) crypto_key->keysalt;
}

policy->next = NULL((void*)0);

policy->window_size = 1024;
policy->allow_repeat_tx = 1;

//policy->rtp.sec_serv = sec_serv_conf_and_auth;
//policy->rtcp.sec_serv = sec_serv_conf_and_auth;

switch (direction) {
case SWITCH_RTP_CRYPTO_RECV:
policy->ssrc.type = ssrc_any_inbound;

if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && idx == 0 && rtp_session->recv_ctx[idx]) {
	rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_RESET] = 1;
} else {
	if ((stat = srtp_create(&rtp_session->recv_ctx[idx], policy)) || !rtp_session->recv_ctx[idx]) {
		status = SWITCH_STATUS_FALSE;
	}

	if (status == SWITCH_STATUS_SUCCESS) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4354, (const char*)(rtp_session->session), SWITCH_LOG_INFO, "Activating %s Secure %s RECV%s\n",
						  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), idx ? "RTCP" : "RTP", rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_MKI] ? " (with MKI)" : "");
		rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 1;
	} else {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4358, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error allocating srtp [%d]\n", stat);
		return status;
	}
}
break;
case SWITCH_RTP_CRYPTO_SEND:
policy->ssrc.type = ssrc_any_outbound;
//policy->ssrc.type = ssrc_specific;
//policy->ssrc.value = rtp_session->ssrc;

if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] && idx == 0 && rtp_session->send_ctx[idx]) {
	rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_RESET] = 1;
} else {
	if ((stat = srtp_create(&rtp_session->send_ctx[idx], policy)) || !rtp_session->send_ctx[idx]) {
		status = SWITCH_STATUS_FALSE;
	}

	if (status == SWITCH_STATUS_SUCCESS) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4376, (const char*)(rtp_session->session), SWITCH_LOG_INFO, "Activating %s Secure %s SEND%s\n",
						  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), idx ? "RTCP" : "RTP", rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_MKI] ? " (with MKI)" : "");
		rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 1;
	} else {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4380, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error allocating SRTP [%d]\n", stat);
		return status;
	}
}

break;
default:
abort();
break;
}

if (switch_event_create(&fsevent, SWITCH_EVENT_CALL_SECURE)switch_event_create_subclass_detailed("src/switch_rtp.c", (const
 char * )(const char *)__func__, 4391, &fsevent, SWITCH_EVENT_CALL_SECURE
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
if (rtp_session->dtls) {
	switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_type", "srtp:dtls:AES_CM_128_HMAC_SHA1_80");
	switch_channel_set_variable(channel, "rtp_has_crypto", "srtp:dtls:AES_CM_128_HMAC_SHA1_80")switch_channel_set_variable_var_check(channel, "rtp_has_crypto"
, "srtp:dtls:AES_CM_128_HMAC_SHA1_80", SWITCH_TRUE);
} else {
	switch_event_add_header(fsevent, SWITCH_STACK_BOTTOM, "secure_type", "srtp:sdes:%s", switch_channel_get_variable(channel, "rtp_has_crypto")switch_channel_get_variable_dup(channel, "rtp_has_crypto", SWITCH_TRUE
, -1));
}
switch_event_add_header_string(fsevent, SWITCH_STACK_BOTTOM, "caller-unique-id", switch_channel_get_uuid(channel));
switch_event_fire(&fsevent)switch_event_fire_detailed("src/switch_rtp.c", (const char * )
(const char *)__func__, 4399, &fsevent, ((void*)0));
}


return SWITCH_STATUS_SUCCESS;
4404#endif
4405}

4407SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_set_interval(switch_rtp_t *rtp_session, uint32_t ms_per_packet, uint32_t samples_per_interval)
4408{
rtp_session->ms_per_packet = ms_per_packet;
rtp_session->samples_per_interval = rtp_session->conf_samples_per_interval = samples_per_interval;
rtp_session->missed_count = 0;
rtp_session->samples_per_second =
(uint32_t) ((double) (1000.0f / (double) (rtp_session->ms_per_packet / 1000)) * (double) rtp_session->samples_per_interval);

rtp_session->one_second = (rtp_session->samples_per_second / rtp_session->samples_per_interval);

return SWITCH_STATUS_SUCCESS;
4418}

4420SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_change_interval(switch_rtp_t *rtp_session, uint32_t ms_per_packet, uint32_t samples_per_interval)
4421{
switch_status_t status = SWITCH_STATUS_SUCCESS;
int change_timer = 0;

if (rtp_session->ms_per_packet != ms_per_packet || rtp_session->samples_per_interval != samples_per_interval) {
change_timer = 1;
}

switch_rtp_set_interval(rtp_session, ms_per_packet, samples_per_interval);

if (change_timer && rtp_session->timer_name) {
READ_INC(rtp_session)switch_mutex_lock(rtp_session->read_mutex); rtp_session->
reading++;
WRITE_INC(rtp_session)switch_mutex_lock(rtp_session->write_mutex); rtp_session->
writing++;

if (rtp_session->timer.timer_interface) {
	switch_core_timer_destroy(&rtp_session->timer);
}

if (rtp_session->write_timer.timer_interface) {
	switch_core_timer_destroy(&rtp_session->write_timer);
}

if ((status = switch_core_timer_init(&rtp_session->timer,
									 rtp_session->timer_name, ms_per_packet / 1000,
									 samples_per_interval, rtp_session->pool)) == SWITCH_STATUS_SUCCESS) {

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4447, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG,
					  "RE-Starting timer [%s] %d bytes per %dms\n", rtp_session->timer_name, samples_per_interval, ms_per_packet / 1000);
	switch_core_timer_init(&rtp_session->write_timer, rtp_session->timer_name, (ms_per_packet / 1000), samples_per_interval, rtp_session->pool);
} else {

	memset(&rtp_session->timer, 0, sizeof(rtp_session->timer));
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4453, (const char*)(rtp_session->session), SWITCH_LOG_ERROR,
					  "Problem RE-Starting timer [%s] %d bytes per %dms\n", rtp_session->timer_name, samples_per_interval, ms_per_packet / 1000);
}

WRITE_DEC(rtp_session)rtp_session->writing--; switch_mutex_unlock(rtp_session->
write_mutex);
READ_DEC(rtp_session)rtp_session->reading--; switch_mutex_unlock(rtp_session->
read_mutex);
}

return status;
4462}

4464SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_set_ssrc(switch_rtp_t *rtp_session, uint32_t ssrc)
4465{
rtp_session->ssrc = ssrc;
rtp_session->send_msg.header.ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);

return SWITCH_STATUS_SUCCESS;
4470}

4472SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_set_remote_ssrc(switch_rtp_t *rtp_session, uint32_t ssrc)
4473{
rtp_session->remote_ssrc = ssrc;
rtp_session->flags[SWITCH_RTP_FLAG_DETECT_SSRC] = 0;
return SWITCH_STATUS_SUCCESS;
4477}

4479SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_create(switch_rtp_t **new_rtp_session,
										  switch_payload_t payload,
										  uint32_t samples_per_interval,
										  uint32_t ms_per_packet,
										  switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID], char *timer_name, const char **err, switch_memory_pool_t *pool)
4484{
switch_rtp_t *rtp_session = NULL((void*)0);
switch_core_session_t *session = switch_core_memory_pool_get_data(pool, "__session");
switch_channel_t *channel = NULL((void*)0);

if (session) channel = switch_core_session_get_channel(session);

*new_rtp_session = NULL((void*)0);

if (samples_per_interval > SWITCH_RTP_MAX_BUF_LEN16384) {
*err = "Packet Size Too Large!";
return SWITCH_STATUS_FALSE;
}

if (!(rtp_session = switch_core_alloc(pool, sizeof(*rtp_session))switch_core_perform_alloc(pool, sizeof(*rtp_session), "src/switch_rtp.c"
, (const char *)__func__, 4498))) {
*err = "Memory Error!";
return SWITCH_STATUS_MEMERR;
}

rtp_session->pool = pool;
rtp_session->te = INVALID_PT;
rtp_session->recv_te = INVALID_PT;
rtp_session->cng_pt = INVALID_PT;
rtp_session->session = session;

switch_mutex_init(&rtp_session->flag_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_mutex_init(&rtp_session->read_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_mutex_init(&rtp_session->write_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_mutex_init(&rtp_session->ice_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_mutex_init(&rtp_session->dtmf_data.dtmf_mutex, SWITCH_MUTEX_NESTED0x1, pool);
switch_queue_create(&rtp_session->dtmf_data.dtmf_queue, 100, rtp_session->pool);
switch_queue_create(&rtp_session->dtmf_data.dtmf_inqueue, 100, rtp_session->pool);

switch_rtp_set_flags(rtp_session, flags);

/* for from address on recvfrom calls */
switch_sockaddr_create(&rtp_session->from_addr, pool);
switch_sockaddr_create(&rtp_session->rtp_from_addr, pool);

if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
switch_sockaddr_create(&rtp_session->rtcp_from_addr, pool);
}
rtp_session->seq = (uint16_t) rand();
rtp_session->ssrc = (uint32_t) ((intptr_t) rtp_session + (uint32_t) switch_epoch_time_now(NULL((void*)0)));
4528#ifdef DEBUG_TS_ROLLOVER
rtp_session->last_write_ts = TS_ROLLOVER_START;
4530#endif
rtp_session->stats.inbound.R = 100.0;
rtp_session->stats.inbound.mos = 4.5;
rtp_session->send_msg.header.ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
rtp_session->send_msg.header.ts = 0;
rtp_session->send_msg.header.m = 0;
rtp_session->send_msg.header.pt = (switch_payload_t) htonl(payload)__bswap_32 (payload);
rtp_session->send_msg.header.version = 2;
rtp_session->send_msg.header.p = 0;
rtp_session->send_msg.header.x = 0;
rtp_session->send_msg.header.cc = 0;

rtp_session->recv_msg.header.ssrc = 0;
rtp_session->recv_msg.header.ts = 0;
rtp_session->recv_msg.header.seq = 0;
rtp_session->recv_msg.header.m = 0;
rtp_session->recv_msg.header.pt = (switch_payload_t) htonl(payload)__bswap_32 (payload);
rtp_session->recv_msg.header.version = 2;
rtp_session->recv_msg.header.p = 0;
rtp_session->recv_msg.header.x = 0;
rtp_session->recv_msg.header.cc = 0;

rtp_session->payload = payload;
rtp_session->rtcp_last_sent = switch_micro_time_now();

switch_rtp_set_interval(rtp_session, ms_per_packet, samples_per_interval);
rtp_session->conf_samples_per_interval = samples_per_interval;

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && zstr(timer_name)_zstr(timer_name)) {
timer_name = "soft";
}

if (!zstr(timer_name)_zstr(timer_name) && !strcasecmp(timer_name, "none")) {
timer_name = NULL((void*)0);
}

if (!zstr(timer_name)_zstr(timer_name)) {
rtp_session->timer_name = switch_core_strdup(pool, timer_name)switch_core_perform_strdup(pool, timer_name, "src/switch_rtp.c"
, (const char *)__func__, 4567);
switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);

if (switch_core_timer_init(&rtp_session->timer, timer_name, ms_per_packet / 1000, samples_per_interval, pool) == SWITCH_STATUS_SUCCESS) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4572, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG,
					  "Starting timer [%s] %d bytes per %dms\n", timer_name, samples_per_interval, ms_per_packet / 1000);
	switch_core_timer_init(&rtp_session->write_timer, timer_name, (ms_per_packet / 1000), samples_per_interval, pool);
4575#ifdef DEBUG_TS_ROLLOVER
	rtp_session->timer.tick = TS_ROLLOVER_START / samples_per_interval;
4577#endif
} else {
	memset(&rtp_session->timer, 0, sizeof(rtp_session->timer));
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4580, (const char*)(rtp_session->session), SWITCH_LOG_ERROR,
					  "Error Starting timer [%s] %d bytes per %dms, async RTP disabled\n", timer_name, samples_per_interval, ms_per_packet / 1000);
	switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
}
} else {
if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
	if (switch_core_timer_init(&rtp_session->timer, "soft", 1, 90, pool) == SWITCH_STATUS_SUCCESS) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4587, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "Starting video timer.\n");
	}

	//switch_jb_create(&rtp_session->vb, 3, 10, rtp_session->pool);
	//switch_jb_debug_level(rtp_session->vb, 10);

} else {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4594, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "Not using a timer\n");
}

switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
}


if (channel) {
switch_channel_set_private(channel, "__rtcp_audio_rtp_session", rtp_session);
}

4606#ifdef ENABLE_ZRTP
if (zrtp_on && session && channel && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
switch_rtp_t *master_rtp_session = NULL((void*)0);

int initiator = 0;
const char *zrtp_enabled = switch_channel_get_variable(channel, "zrtp_secure_media")switch_channel_get_variable_dup(channel, "zrtp_secure_media",
 SWITCH_TRUE, -1);
int srtp_enabled = switch_channel_test_flag(channel, CF_SECURE);

if (srtp_enabled && switch_true(zrtp_enabled)) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4615, (const char*)(rtp_session->session), SWITCH_LOG_WARNING,
					  "You can not have ZRTP and SRTP enabled simultaneously, ZRTP will be disabled for this call!\n");
	switch_channel_set_variable(channel, "zrtp_secure_media", NULL)switch_channel_set_variable_var_check(channel, "zrtp_secure_media"
, ((void*)0), SWITCH_TRUE);
	zrtp_enabled = NULL((void*)0);
}


if (switch_true(zrtp_enabled)) {
	if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
		switch_channel_set_private(channel, "__zrtp_video_rtp_session", rtp_session);
		master_rtp_session = switch_channel_get_private(channel, "__zrtp_audio_rtp_session");
	} else {
		switch_channel_set_private(channel, "__zrtp_audio_rtp_session", rtp_session);
		master_rtp_session = rtp_session;
	}


	if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
		initiator = 1;
	}

	if (rtp_session == master_rtp_session) {
		rtp_session->zrtp_profile = switch_core_alloc(rtp_session->pool, sizeof(*rtp_session->zrtp_profile))switch_core_perform_alloc(rtp_session->pool, sizeof(*rtp_session
->zrtp_profile), "src/switch_rtp.c", (const char *)__func__
, 4637);
		zrtp_profile_defaults(rtp_session->zrtp_profile, zrtp_global);

		rtp_session->zrtp_profile->allowclear = 0;
		rtp_session->zrtp_profile->disclose_bit = 0;
		rtp_session->zrtp_profile->cache_ttl = (uint32_t) -1;

		if (zrtp_status_ok != zrtp_session_init(zrtp_global, rtp_session->zrtp_profile, zid, initiator, &rtp_session->zrtp_session)) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4645, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error! zRTP INIT Failed\n");
			zrtp_session_down(rtp_session->zrtp_session);
			rtp_session->zrtp_session = NULL((void*)0);
			goto end;
		}

		zrtp_session_set_userdata(rtp_session->zrtp_session, session);


		if (zrtp_status_ok != zrtp_stream_attach(master_rtp_session->zrtp_session, &rtp_session->zrtp_stream)) {
			abort();
		}

		zrtp_stream_set_userdata(rtp_session->zrtp_stream, rtp_session);

		if (switch_true(switch_channel_get_variable(channel, "zrtp_enrollment")switch_channel_get_variable_dup(channel, "zrtp_enrollment", SWITCH_TRUE
, -1))) {
			zrtp_stream_registration_start(rtp_session->zrtp_stream, rtp_session->ssrc);
		} else {
			zrtp_stream_start(rtp_session->zrtp_stream, rtp_session->ssrc);
		}
	}

}
}

end:

4672#endif

/* Jitter */
rtp_session->stats.inbound.last_proc_time = switch_micro_time_now() / 1000;
rtp_session->stats.inbound.jitter_n = 0;
rtp_session->stats.inbound.jitter_add = 0;
rtp_session->stats.inbound.jitter_addsq = 0;
rtp_session->stats.inbound.min_variance = 0;
rtp_session->stats.inbound.max_variance = 0;

/* Burst and Packet Loss */
rtp_session->stats.inbound.lossrate = 0;
rtp_session->stats.inbound.burstrate = 0;
memset(rtp_session->stats.inbound.loss, 0, sizeof(rtp_session->stats.inbound.loss));
rtp_session->stats.inbound.last_loss = 0;
rtp_session->stats.inbound.last_processed_seq = -1;

rtp_session->ready = 1;
*new_rtp_session = rtp_session;

return SWITCH_STATUS_SUCCESS;
4693}

4695SWITCH_DECLARE(switch_rtp_t *)__attribute__((visibility("default"))) switch_rtp_t * switch_rtp_new(const char *rx_host,
									  switch_port_t rx_port,
									  const char *tx_host,
									  switch_port_t tx_port,
									  switch_payload_t payload,
									  uint32_t samples_per_interval,
									  uint32_t ms_per_packet,
									  switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID], char *timer_name, const char **err, switch_memory_pool_t *pool,
                                            switch_port_t bundle_internal_port,
                                            switch_port_t bundle_external_port)
4705{
switch_rtp_t *rtp_session = NULL((void*)0);

if (zstr(rx_host)_zstr(rx_host)) {
*err = "Missing local host";
goto end;
}

if (!rx_port) {
*err = "Missing local port";
goto end;
}

if (zstr(tx_host)_zstr(tx_host)) {
*err = "Missing remote host";
goto end;
}

if (!tx_port) {
*err = "Missing remote port";
goto end;
}

if (switch_rtp_create(&rtp_session, payload, samples_per_interval, ms_per_packet, flags, timer_name, err, pool) != SWITCH_STATUS_SUCCESS) {
goto end;
}

switch_mutex_lock(rtp_session->flag_mutex);

if (switch_rtp_set_local_address(rtp_session, rx_host, rx_port, err) != SWITCH_STATUS_SUCCESS) {
switch_mutex_unlock(rtp_session->flag_mutex);
rtp_session = NULL((void*)0);
goto end;
}

if (switch_rtp_set_remote_address(rtp_session, tx_host, tx_port, 0, SWITCH_TRUE, err) != SWITCH_STATUS_SUCCESS) {
switch_mutex_unlock(rtp_session->flag_mutex);
rtp_session = NULL((void*)0);
goto end;
}

end:

if (rtp_session) {
switch_mutex_unlock(rtp_session->flag_mutex);
rtp_session->ready = 2;
rtp_session->rx_host = switch_core_strdup(rtp_session->pool, rx_host)switch_core_perform_strdup(rtp_session->pool, rx_host, "src/switch_rtp.c"
, (const char *)__func__, 4751);
rtp_session->rx_port = rx_port;
switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_DETECT_SSRC);
} else {
switch_rtp_release_port(rx_host, rx_port);
}

return rtp_session;
4760}

4762SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_telephony_event(switch_rtp_t *rtp_session, switch_payload_t te)
4763{
if (te > 95) {
rtp_session->te = te;
}
4767}


4770SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_telephony_recv_event(switch_rtp_t *rtp_session, switch_payload_t te)
4771{
if (te > 95) {
rtp_session->recv_te = te;
}
4775}


4778SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_cng_pt(switch_rtp_t *rtp_session, switch_payload_t pt)
4779{
rtp_session->cng_pt = pt;
rtp_session->flags[SWITCH_RTP_FLAG_AUTO_CNG] = 1;
4782}

4784SWITCH_DECLARE(switch_timer_t *)__attribute__((visibility("default"))) switch_timer_t * switch_rtp_get_media_timer(switch_rtp_t *rtp_session)
4785{

if (rtp_session && rtp_session->timer.timer_interface) {
if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
	switch_core_timer_sync(&rtp_session->timer);
}
return &rtp_session->timer;
}

return NULL((void*)0);
4795}


4798SWITCH_DECLARE(switch_jb_t *)__attribute__((visibility("default"))) switch_jb_t * switch_rtp_get_jitter_buffer(switch_rtp_t *rtp_session)
4799{
if (!switch_rtp_ready(rtp_session)) {
return NULL((void*)0);
}

return rtp_session->jb ? rtp_session->jb : rtp_session->vb;
4805}

4807SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_pause_jitter_buffer(switch_rtp_t *rtp_session, switch_bool_t pause)
4808{
int new_val;

if (rtp_session->pause_jb && !pause) {
if (rtp_session->jb) {
	switch_jb_reset(rtp_session->jb);
}

if (rtp_session->vb) {
	switch_jb_reset(rtp_session->vb);
}
}

new_val = pause ? 1 : -1;

if (rtp_session->pause_jb + new_val > -1) {
rtp_session->pause_jb += new_val;
}

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4827, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1,
			  "Jitterbuffer %s is %s\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), rtp_session->pause_jb ? "paused" : "enabled");

return SWITCH_STATUS_SUCCESS;
4831}

4833SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_deactivate_jitter_buffer(switch_rtp_t *rtp_session)
4834{

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

rtp_session->flags[SWITCH_RTP_FLAG_KILL_JB]++;

return SWITCH_STATUS_SUCCESS;
4843}

4845SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_get_video_buffer_size(switch_rtp_t *rtp_session, uint32_t *min_frame_len, uint32_t *max_frame_len, uint32_t *cur_frame_len, uint32_t *highest_frame_len)
4846{

if (rtp_session->vb) {
return switch_jb_get_frames(rtp_session->vb, min_frame_len, max_frame_len, cur_frame_len, highest_frame_len);
}

return SWITCH_STATUS_FALSE;
4853}

4855SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_set_video_buffer_size(switch_rtp_t *rtp_session, uint32_t frames, uint32_t max_frames)
4856{
if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

if (!max_frames) {
max_frames = rtp_session->last_max_vb_frames;
}

if (!max_frames || frames >= max_frames) {
max_frames = frames * 10;
}

rtp_session->last_max_vb_frames = max_frames;

if (!rtp_session->vb) {
switch_jb_create(&rtp_session->vb, rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? SJB_TEXT : SJB_VIDEO, frames, max_frames, rtp_session->pool);
switch_jb_set_session(rtp_session->vb, rtp_session->session);
} else {
switch_jb_set_frames(rtp_session->vb, frames, max_frames);
}

//switch_rtp_flush(rtp_session);
switch_core_session_request_video_refresh(rtp_session->session)_switch_core_session_request_video_refresh(rtp_session->session
, 0, "src/switch_rtp.c", (const char *)__func__, 4879);

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4881, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, "Setting video buffer %u Frames.\n", frames);

return SWITCH_STATUS_SUCCESS;
4884}

4886SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_debug_jitter_buffer(switch_rtp_t *rtp_session, const char *name)
4887{
int x = 0;

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

if (name) x = atoi(name);
if (x < 0) x = 0;

if (rtp_session->jb) {
switch_jb_debug_level(rtp_session->jb, x);
} else if (rtp_session->vb) {
switch_jb_debug_level(rtp_session->vb, x);
}

return SWITCH_STATUS_SUCCESS;
4904}

4906SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_activate_jitter_buffer(switch_rtp_t *rtp_session,
														  uint32_t queue_frames,
														  uint32_t max_queue_frames,
														  uint32_t samples_per_packet,
														  uint32_t samples_per_second)
4911{
switch_status_t status = SWITCH_STATUS_FALSE;

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

if (queue_frames < 1) {
queue_frames = 3;
}

if (max_queue_frames < queue_frames) {
max_queue_frames = queue_frames * 3;
}



if (rtp_session->jb) {
status = switch_jb_set_frames(rtp_session->jb, queue_frames, max_queue_frames);
} else {
READ_INC(rtp_session)switch_mutex_lock(rtp_session->read_mutex); rtp_session->
reading++;
status = switch_jb_create(&rtp_session->jb, SJB_AUDIO, queue_frames, max_queue_frames, rtp_session->pool);
switch_jb_set_session(rtp_session->jb, rtp_session->session);
if (switch_true(switch_channel_get_variable_dup(switch_core_session_get_channel(rtp_session->session), "jb_use_timestamps", SWITCH_FALSE, -1))) {
	switch_jb_ts_mode(rtp_session->jb, samples_per_packet, samples_per_second);
}
//switch_jb_debug_level(rtp_session->jb, 10);
READ_DEC(rtp_session)rtp_session->reading--; switch_mutex_unlock(rtp_session->
read_mutex);
}



return status;
4944}

4946SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_activate_rtcp(switch_rtp_t *rtp_session, int send_rate, switch_port_t remote_port, switch_bool_t mux)
4947{
const char *err = NULL((void*)0);

if (!rtp_session->ms_per_packet) {
return SWITCH_STATUS_FALSE;
}

rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP] = 1;

if (!(rtp_session->remote_rtcp_port = remote_port)) {
rtp_session->remote_rtcp_port = rtp_session->remote_port + 1;
}

if (mux) {
rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]++;
}


if (send_rate == -1) {

rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU] = 1;
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4968, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "RTCP passthru enabled. Remote Port: %d\n", rtp_session->remote_rtcp_port);
} else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4970, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "RTCP send rate is: %d and packet rate is: %d Remote Port: %d\n", 						  send_rate, rtp_session->ms_per_packet, rtp_session->remote_rtcp_port);

rtp_session->rtcp_interval = send_rate;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {

if (switch_sockaddr_info_get(&rtp_session->rtcp_remote_addr, rtp_session->eff_remote_host_str, SWITCH_UNSPEC0,
							 rtp_session->remote_rtcp_port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !rtp_session->rtcp_remote_addr) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 4979, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "RTCP MUX Remote Address Error!");
	return SWITCH_STATUS_FALSE;
}

rtp_session->rtcp_local_addr = rtp_session->local_addr;
rtp_session->rtcp_from_addr = rtp_session->from_addr;
rtp_session->rtcp_sock_input = rtp_session->sock_input;
rtp_session->rtcp_sock_output = rtp_session->sock_output;

rtp_session->rtcp_recv_msg_p = (rtcp_msg_t *) &rtp_session->recv_msg;

return SWITCH_STATUS_SUCCESS;

//return enable_remote_rtcp_socket(rtp_session, &err);
} else {
rtp_session->rtcp_recv_msg_p = (rtcp_msg_t *) &rtp_session->rtcp_recv_msg;
}

return enable_local_rtcp_socket(rtp_session, &err) || enable_remote_rtcp_socket(rtp_session, &err);

4999}

5001SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_activate_ice(switch_rtp_t *rtp_session, char *login, char *rlogin,
												const char *password, const char *rpassword, ice_proto_t proto,
												switch_core_media_ice_type_t type, ice_t *ice_params)
5004{
char ice_user[STUN_USERNAME_MAX_SIZE513];
char user_ice[STUN_USERNAME_MAX_SIZE513];
char luser_ice[SDP_UFRAG_MAX_SIZE256];
switch_rtp_ice_t *ice;
char *host = NULL((void*)0);
switch_port_t port = 0;
char bufc[50];


switch_mutex_lock(rtp_session->ice_mutex);

if (proto == IPR_RTP) {
ice = &rtp_session->ice;
rtp_session->flags[SWITCH_RTP_FLAG_PAUSE] = 0;
rtp_session->flags[SWITCH_RTP_FLAG_MUTE] = 0;
} else {
ice = &rtp_session->rtcp_ice;
}

ice->proto = proto;

if ((type & ICE_VANILLA)) {
switch_snprintf(ice_user, sizeof(ice_user), "%s:%s", login, rlogin);
switch_snprintf(user_ice, sizeof(user_ice), "%s:%s", rlogin, login);
switch_snprintf(luser_ice, sizeof(user_ice), "%s%s", rlogin, login);
ice->ready = ice->rready = 0;
} else {
switch_snprintf(ice_user, sizeof(ice_user), "%s%s", login, rlogin);
switch_snprintf(user_ice, sizeof(user_ice), "%s%s", rlogin, login);
ice->ready = ice->rready = 1;
}

ice->ice_user = switch_core_strdup(rtp_session->pool, ice_user)switch_core_perform_strdup(rtp_session->pool, ice_user, "src/switch_rtp.c"
, (const char *)__func__, 5037);
ice->user_ice = switch_core_strdup(rtp_session->pool, user_ice)switch_core_perform_strdup(rtp_session->pool, user_ice, "src/switch_rtp.c"
, (const char *)__func__, 5038);
ice->luser_ice = switch_core_strdup(rtp_session->pool, luser_ice)switch_core_perform_strdup(rtp_session->pool, luser_ice, "src/switch_rtp.c"
, (const char *)__func__, 5039);
ice->type = type;
ice->ice_params = ice_params;
ice->pass = "";
ice->rpass = "";
ice->next_run = switch_micro_time_now();

if (password) {
ice->pass = switch_core_strdup(rtp_session->pool, password)switch_core_perform_strdup(rtp_session->pool, password, "src/switch_rtp.c"
, (const char *)__func__, 5047);
}

if (rpassword) {
ice->rpass = switch_core_strdup(rtp_session->pool, rpassword)switch_core_perform_strdup(rtp_session->pool, rpassword, "src/switch_rtp.c"
, (const char *)__func__, 5051);
}

if ((ice->type & ICE_VANILLA) && ice->ice_params) {
host = ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_addr;
port = ice->ice_params->cands[ice->ice_params->chosen[ice->proto]][ice->proto].con_port;

if (!host || !port || switch_sockaddr_info_get(&ice->addr, host, SWITCH_UNSPEC0, port, 0, rtp_session->pool) != SWITCH_STATUS_SUCCESS || !ice->addr) {
	switch_mutex_unlock(rtp_session->ice_mutex);
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 5060, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error setting remote host!\n");
	return SWITCH_STATUS_FALSE;
}
} else {
if (proto == IPR_RTP) {
	ice->addr = rtp_session->remote_addr;
} else {
	ice->addr = rtp_session->rtcp_remote_addr;
}

host = (char *)switch_get_addr(bufc, sizeof(bufc), ice->addr);
port = switch_sockaddr_get_port(ice->addr);
}

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 5074, (const char*)(rtp_session->session), SWITCH_LOG_NOTICE, "Activating %s %s ICE: %s %s:%d\n",
			  proto == IPR_RTP ? "RTP" : "RTCP", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), ice_user, host, port);


rtp_session->rtp_bugs |= RTP_BUG_ACCEPT_ANY_PACKETS;


if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
rtp_session->flags[SWITCH_RTP_FLAG_VIDEO_BREAK] = 1;
switch_rtp_break(rtp_session);
}

switch_mutex_unlock(rtp_session->ice_mutex);

return SWITCH_STATUS_SUCCESS;
5089}


5092SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_flush(switch_rtp_t *rtp_session)
5093{
if (!switch_rtp_ready(rtp_session)) {
return;
}

switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
5099}

5101SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_req_bitrate(switch_rtp_t *rtp_session, uint32_t bps)
5102{
if (!rtp_write_ready(rtp_session, 0, __LINE__5103) || rtp_session->tmmbr) {
return SWITCH_STATUS_FALSE;
}

rtp_session->tmmbr = bps;

return SWITCH_STATUS_SUCCESS;
5110}

5112SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_ack_bitrate(switch_rtp_t *rtp_session, uint32_t bps)
5113{
if (!rtp_write_ready(rtp_session, 0, __LINE__5114) || rtp_session->tmmbn) {
return SWITCH_STATUS_FALSE;
}

rtp_session->tmmbn = bps;

return SWITCH_STATUS_SUCCESS;
5121}

5123SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_video_refresh(switch_rtp_t *rtp_session)
5124{

if (!rtp_write_ready(rtp_session, 0, __LINE__5126)) {
return;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && (rtp_session->ice.ice_user || rtp_session->flags[SWITCH_RTP_FLAG_FIR] || rtp_session->flags[SWITCH_RTP_FLAG_OLD_FIR])) {
rtp_session->fir_count = 1;
}
5133}

5135SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_video_loss(switch_rtp_t *rtp_session)
5136{

if (!rtp_write_ready(rtp_session, 0, __LINE__5138)) {
return;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && (rtp_session->ice.ice_user || rtp_session->flags[SWITCH_RTP_FLAG_PLI])) {
rtp_session->pli_count = 1;
}
5145}

5147SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_break(switch_rtp_t *rtp_session)
5148{
if (!switch_rtp_ready(rtp_session)) {
return;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
int ret = 1;

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO_BREAK]) {
	rtp_session->flags[SWITCH_RTP_FLAG_VIDEO_BREAK] = 0;
	ret = 0;
} else if (rtp_session->session) {
	switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
	if (switch_channel_test_flag(channel, CF_VIDEO_BREAK)) {
		switch_channel_clear_flag(channel, CF_VIDEO_BREAK);
		ret = 0;
	}
}

if (ret) return;

switch_rtp_video_refresh(rtp_session);
}

switch_mutex_lock(rtp_session->flag_mutex);
rtp_session->flags[SWITCH_RTP_FLAG_BREAK] = 1;

if (rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK]) {
switch_mutex_unlock(rtp_session->flag_mutex);
return;
}

if (rtp_session->sock_input) {
ping_socket(rtp_session);
}

switch_mutex_unlock(rtp_session->flag_mutex);
5185}

5187SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_kill_socket(switch_rtp_t *rtp_session)
5188{
switch_assert(rtp_session != NULL)((rtp_session != ((void*)0)) ? (void) (0) : __assert_fail ("rtp_session != ((void*)0)"
, "src/switch_rtp.c", 5189, __extension__ __PRETTY_FUNCTION__
));
switch_mutex_lock(rtp_session->flag_mutex);
if (rtp_session->flags[SWITCH_RTP_FLAG_IO]) {
rtp_session->flags[SWITCH_RTP_FLAG_IO] = 0;
if (rtp_session->sock_input) {
	ping_socket(rtp_session);
	switch_socket_shutdown(rtp_session->sock_input, SWITCH_SHUTDOWN_READWRITE);
}
if (rtp_session->sock_output && rtp_session->sock_output != rtp_session->sock_input) {
	switch_socket_shutdown(rtp_session->sock_output, SWITCH_SHUTDOWN_READWRITE);
}

if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
	if (rtp_session->rtcp_sock_input && rtp_session->rtcp_sock_input != rtp_session->sock_input) {
		ping_socket(rtp_session);
		switch_socket_shutdown(rtp_session->rtcp_sock_input, SWITCH_SHUTDOWN_READWRITE);
	}
	if (rtp_session->rtcp_sock_output && rtp_session->rtcp_sock_output != rtp_session->sock_output && rtp_session->rtcp_sock_output != rtp_session->rtcp_sock_input) {
		switch_socket_shutdown(rtp_session->rtcp_sock_output, SWITCH_SHUTDOWN_READWRITE);
	}
}
}
switch_mutex_unlock(rtp_session->flag_mutex);
5212}

5214SWITCH_DECLARE(uint8_t)__attribute__((visibility("default"))) uint8_t switch_rtp_ready(switch_rtp_t *rtp_session)
5215{
uint8_t ret;

if (!rtp_session || !rtp_session->flag_mutex || rtp_session->flags[SWITCH_RTP_FLAG_SHUTDOWN]) {
return 0;
}

switch_mutex_lock(rtp_session->flag_mutex);
ret = (rtp_session->flags[SWITCH_RTP_FLAG_IO] && rtp_session->sock_input && rtp_session->sock_output && rtp_session->remote_addr
   && rtp_session->ready == 2) ? 1 : 0;
switch_mutex_unlock(rtp_session->flag_mutex);

return ret;
5228}

5230SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_sync_stats(switch_rtp_t *rtp_session)
5231{
if (!rtp_session) {
return SWITCH_STATUS_FALSE;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_VAD]) {
switch_channel_t *channel = switch_core_session_get_channel(rtp_session->vad_data.session);

switch_channel_set_variable_printf(channel, "vad_total_talk_time_ms", "%u", (uint32_t)rtp_session->vad_data.total_talk_time / 1000);
switch_channel_set_variable_printf(channel, "vad_total_talk_time_sec", "%u", (uint32_t)rtp_session->vad_data.total_talk_time / 1000000);
}

do_mos(rtp_session);

if (rtp_session->stats.inbound.error_log && !rtp_session->stats.inbound.error_log->stop) {
rtp_session->stats.inbound.error_log->stop = switch_micro_time_now();
}

return SWITCH_STATUS_SUCCESS;
5250}


5253SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_destroy(switch_rtp_t **rtp_session)
5254{
void *pop;
switch_socket_t *sock;
5257#ifdef ENABLE_SRTP1
int x;
5259#endif

if (!rtp_session || !*rtp_session || !(*rtp_session)->ready) {
return;
}

if ((*rtp_session)->vb) {
/* retrieve counter for ALL received NACKed packets */
uint32_t nack_jb_ok = switch_jb_get_nack_success((*rtp_session)->vb);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG((*rtp_session)->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 5268, (const char*)((*rtp_session)->session), SWITCH_LOG_DEBUG, 
		"NACK: Added to JB: [%u]\n", nack_jb_ok);
}

(*rtp_session)->flags[SWITCH_RTP_FLAG_SHUTDOWN] = 1;

READ_INC((*rtp_session))switch_mutex_lock((*rtp_session)->read_mutex); (*rtp_session
)->reading++;
WRITE_INC((*rtp_session))switch_mutex_lock((*rtp_session)->write_mutex); (*rtp_session
)->writing++;

(*rtp_session)->ready = 0;

WRITE_DEC((*rtp_session))(*rtp_session)->writing--; switch_mutex_unlock((*rtp_session
)->write_mutex);
READ_DEC((*rtp_session))(*rtp_session)->reading--; switch_mutex_unlock((*rtp_session
)->read_mutex);

if ((*rtp_session)->flags[SWITCH_RTP_FLAG_VAD]) {
switch_rtp_disable_vad(*rtp_session);
}

switch_mutex_lock((*rtp_session)->flag_mutex);

switch_rtp_kill_socket(*rtp_session);

while (switch_queue_trypop((*rtp_session)->dtmf_data.dtmf_inqueue, &pop) == SWITCH_STATUS_SUCCESS) {
switch_safe_free(pop)if (pop) {free(pop);pop=((void*)0);};
}

while (switch_queue_trypop((*rtp_session)->dtmf_data.dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
switch_safe_free(pop)if (pop) {free(pop);pop=((void*)0);};
}

if ((*rtp_session)->jb) {
switch_jb_destroy(&(*rtp_session)->jb);
}

if ((*rtp_session)->vb) {
switch_jb_destroy(&(*rtp_session)->vb);
}

if ((*rtp_session)->vbw) {
switch_jb_destroy(&(*rtp_session)->vbw);
}

if ((*rtp_session)->dtls && (*rtp_session)->dtls == (*rtp_session)->rtcp_dtls) {
(*rtp_session)->rtcp_dtls = NULL((void*)0);
}

if ((*rtp_session)->dtls) {
free_dtls(&(*rtp_session)->dtls);
}

if ((*rtp_session)->rtcp_dtls) {
free_dtls(&(*rtp_session)->rtcp_dtls);
}

if ((*rtp_session)->rtcp_sock_input == (*rtp_session)->sock_input) {
(*rtp_session)->rtcp_sock_input = NULL((void*)0);
}

if ((*rtp_session)->rtcp_sock_output == (*rtp_session)->sock_output) {
(*rtp_session)->rtcp_sock_output = NULL((void*)0);
}

sock = (*rtp_session)->sock_input;
(*rtp_session)->sock_input = NULL((void*)0);
switch_socket_close(sock);

if ((*rtp_session)->sock_output != sock) {
sock = (*rtp_session)->sock_output;
(*rtp_session)->sock_output = NULL((void*)0);
switch_socket_close(sock);
}

if ((sock = (*rtp_session)->rtcp_sock_input)) {
(*rtp_session)->rtcp_sock_input = NULL((void*)0);
switch_socket_close(sock);
}

if ((*rtp_session)->rtcp_sock_output && (*rtp_session)->rtcp_sock_output != sock) {
sock = (*rtp_session)->rtcp_sock_output;
(*rtp_session)->rtcp_sock_output = NULL((void*)0);
switch_socket_close(sock);
}

5351#ifdef ENABLE_SRTP1
if ((*rtp_session)->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {
for(x = 0; x < 2; x++) {
	if ((*rtp_session)->send_ctx[x]) {
		srtp_dealloc((*rtp_session)->send_ctx[x]);
		(*rtp_session)->send_ctx[x] = NULL((void*)0);
	}
}
(*rtp_session)->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 0;
}

if ((*rtp_session)->flags[SWITCH_RTP_FLAG_SECURE_RECV]) {
for (x = 0; x < 2; x++) {
	if ((*rtp_session)->recv_ctx[x]) {
		srtp_dealloc((*rtp_session)->recv_ctx[x]);
		(*rtp_session)->recv_ctx[x] = NULL((void*)0);
	}
}
(*rtp_session)->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 0;
}
5371#endif

5373#ifdef ENABLE_ZRTP
/* ZRTP */
if (zrtp_on && !(*rtp_session)->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {

if ((*rtp_session)->zrtp_stream != NULL((void*)0)) {
	zrtp_stream_stop((*rtp_session)->zrtp_stream);
}

if ((*rtp_session)->flags[SWITCH_ZRTP_FLAG_SECURE_SEND]) {
	(*rtp_session)->flags[SWITCH_ZRTP_FLAG_SECURE_SEND] = 0;
}

if ((*rtp_session)->flags[SWITCH_ZRTP_FLAG_SECURE_RECV]) {
	(*rtp_session)->flags[SWITCH_ZRTP_FLAG_SECURE_RECV] = 0;
}

if ((*rtp_session)->zrtp_session) {
	zrtp_session_down((*rtp_session)->zrtp_session);
	(*rtp_session)->zrtp_session = NULL((void*)0);
}
}
5394#endif
if ((*rtp_session)->timer.timer_interface) {
switch_core_timer_destroy(&(*rtp_session)->timer);
}

if ((*rtp_session)->write_timer.timer_interface) {
switch_core_timer_destroy(&(*rtp_session)->write_timer);
}

switch_rtp_release_port((*rtp_session)->rx_host, (*rtp_session)->rx_port);
switch_mutex_unlock((*rtp_session)->flag_mutex);

return;
5407}

5409SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_interdigit_delay(switch_rtp_t *rtp_session, uint32_t delay)
5410{
rtp_session->interdigit_delay = delay;
5412}

5414SWITCH_DECLARE(switch_socket_t *)__attribute__((visibility("default"))) switch_socket_t * switch_rtp_get_rtp_socket(switch_rtp_t *rtp_session)
5415{
return rtp_session->sock_input;
5417}

5419SWITCH_DECLARE(uint32_t)__attribute__((visibility("default"))) uint32_t switch_rtp_get_default_samples_per_interval(switch_rtp_t *rtp_session)
5420{
return rtp_session->samples_per_interval;
5422}

5424SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_default_payload(switch_rtp_t *rtp_session, switch_payload_t payload)
5425{
rtp_session->payload = payload;
5427}

5429SWITCH_DECLARE(uint32_t)__attribute__((visibility("default"))) uint32_t switch_rtp_get_default_payload(switch_rtp_t *rtp_session)
5430{
return rtp_session->payload;
5432}

5434SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_invalid_handler(switch_rtp_t *rtp_session, switch_rtp_invalid_handler_t on_invalid)
5435{
rtp_session->invalid_handler = on_invalid;
5437}

5439SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_flags(switch_rtp_t *rtp_session, switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID])
5440{
int i;

for(i = 0; i < SWITCH_RTP_FLAG_INVALID; i++) {
if (flags[i]) {
	switch_rtp_set_flag(rtp_session, i);
}
}
5448}

5450SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_clear_flags(switch_rtp_t *rtp_session, switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID])
5451{
int i;

for(i = 0; i < SWITCH_RTP_FLAG_INVALID; i++) {
if (flags[i]) {
	switch_rtp_clear_flag(rtp_session, i);
}
}
5459}

5461SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_flag(switch_rtp_t *rtp_session, switch_rtp_flag_t flag)
5462{
int old_flag = rtp_session->flags[flag];

switch_mutex_lock(rtp_session->flag_mutex);
rtp_session->flags[flag] = 1;
switch_mutex_unlock(rtp_session->flag_mutex);

if (flag == SWITCH_RTP_FLAG_PASSTHRU) {
if (!old_flag) {
	switch_rtp_pause_jitter_buffer(rtp_session, SWITCH_TRUE);
}
} else if (flag == SWITCH_RTP_FLAG_DTMF_ON) {
rtp_session->stats.inbound.last_processed_seq = 0;
} else if (flag == SWITCH_RTP_FLAG_FLUSH) {
reset_jitter_seq(rtp_session);
} else if (flag == SWITCH_RTP_FLAG_AUTOADJ) {
rtp_session->autoadj_window = 20;
rtp_session->autoadj_threshold = 10;
rtp_session->autoadj_tally = 0;

switch_mutex_lock(rtp_session->flag_mutex);
rtp_session->flags[SWITCH_RTP_FLAG_RTCP_AUTOADJ] = 1;
switch_mutex_unlock(rtp_session->flag_mutex);

rtp_session->rtcp_autoadj_window = 20;
rtp_session->rtcp_autoadj_threshold = 1;
rtp_session->rtcp_autoadj_tally = 0;

if (rtp_session->session) {
	switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
	const char *x = switch_channel_get_variable(channel, "rtp_auto_adjust_threshold")switch_channel_get_variable_dup(channel, "rtp_auto_adjust_threshold"
, SWITCH_TRUE, -1);
	if (x && *x) {
		int xn = atoi(x);
		if (xn > 0 && xn <= 65535) {
			rtp_session->autoadj_window = xn*2;
			rtp_session->autoadj_threshold = xn;
		}
	}
}


rtp_flush_read_buffer(rtp_session, SWITCH_RTP_FLUSH_ONCE);


if (rtp_session->jb) {
	switch_jb_reset(rtp_session->jb);
}
} else if (flag == SWITCH_RTP_FLAG_NOBLOCK && rtp_session->sock_input) {
switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK8, TRUE(!0));
}

5513}

5515SWITCH_DECLARE(uint32_t)__attribute__((visibility("default"))) uint32_t switch_rtp_test_flag(switch_rtp_t *rtp_session, switch_rtp_flag_t flags)
5516{
return (uint32_t) rtp_session->flags[flags];
5518}

5520SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_clear_flag(switch_rtp_t *rtp_session, switch_rtp_flag_t flag)
5521{
int old_flag = rtp_session->flags[flag];

switch_mutex_lock(rtp_session->flag_mutex);
rtp_session->flags[flag] = 0;
switch_mutex_unlock(rtp_session->flag_mutex);

if (flag == SWITCH_RTP_FLAG_PASSTHRU) {
if (old_flag) {
	switch_rtp_pause_jitter_buffer(rtp_session, SWITCH_FALSE);
}
} else if (flag == SWITCH_RTP_FLAG_DTMF_ON) {
rtp_session->stats.inbound.last_processed_seq = 0;
} else if (flag == SWITCH_RTP_FLAG_PAUSE) {
reset_jitter_seq(rtp_session);
} else if (flag == SWITCH_RTP_FLAG_NOBLOCK && rtp_session->sock_input) {
switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK8, FALSE0);
}
5539}

5541static void set_dtmf_delay(switch_rtp_t *rtp_session, uint32_t ms, uint32_t max_ms)
5542{
int upsamp, max_upsamp;


if (!max_ms) max_ms = ms;

upsamp = ms * (rtp_session->samples_per_second / 1000);
max_upsamp = max_ms * (rtp_session->samples_per_second / 1000);

rtp_session->sending_dtmf = 0;
rtp_session->queue_delay = upsamp;

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
rtp_session->max_next_write_samplecount = rtp_session->timer.samplecount + max_upsamp;
rtp_session->next_write_samplecount = rtp_session->timer.samplecount + upsamp;
rtp_session->last_write_ts += upsamp;
}

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 5560, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "Queue digit delay of %dms\n", ms);
5561}

5563static void do_2833(switch_rtp_t *rtp_session)
5564{
switch_frame_flag_t flags = 0;
uint32_t samples = rtp_session->samples_per_interval;

if (rtp_session->dtmf_data.out_digit_dur > 0) {
int x, loops = 1;

if (!rtp_session->last_write_ts) {
	if (rtp_session->timer.timer_interface) {
		//switch_core_timer_sync(&rtp_session->write_timer);
		rtp_session->last_write_ts = rtp_session->write_timer.samplecount;
	} else {
		rtp_session->last_write_ts = rtp_session->samples_per_interval;
	}
}

rtp_session->dtmf_data.out_digit_sofar += samples;
rtp_session->dtmf_data.out_digit_sub_sofar += samples;

if (rtp_session->dtmf_data.out_digit_sub_sofar > 0xFFFF) {
	rtp_session->dtmf_data.out_digit_sub_sofar = samples;
	rtp_session->dtmf_data.timestamp_dtmf += 0xFFFF;
}

if (rtp_session->dtmf_data.out_digit_sofar >= rtp_session->dtmf_data.out_digit_dur) {
	rtp_session->dtmf_data.out_digit_packet[1] |= 0x80;
	loops = 3;
}

rtp_session->dtmf_data.out_digit_packet[2] = (unsigned char) (rtp_session->dtmf_data.out_digit_sub_sofar >> 8);
rtp_session->dtmf_data.out_digit_packet[3] = (unsigned char) rtp_session->dtmf_data.out_digit_sub_sofar;

for (x = 0; x < loops; x++) {
	switch_size_t wrote = switch_rtp_write_manual(rtp_session,
												  rtp_session->dtmf_data.out_digit_packet, 4, 0,
												  rtp_session->te, rtp_session->dtmf_data.timestamp_dtmf, &flags);

	rtp_session->stats.outbound.raw_bytes += wrote;
	rtp_session->stats.outbound.dtmf_packet_count++;

	if (loops == 1) {
		rtp_session->last_write_ts += samples;

		if (rtp_session->rtp_bugs & RTP_BUG_SONUS_SEND_INVALID_TIMESTAMP_2833) {
			rtp_session->dtmf_data.timestamp_dtmf = rtp_session->last_write_ts;
		}
	}

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 5612, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "Send %s packet for [%c] ts=%u dur=%d/%d/%d seq=%d lw=%u\n",
					  loops == 1 ? "middle" : "end", rtp_session->dtmf_data.out_digit,
					  rtp_session->dtmf_data.timestamp_dtmf,
					  rtp_session->dtmf_data.out_digit_sofar,
					  rtp_session->dtmf_data.out_digit_sub_sofar, rtp_session->dtmf_data.out_digit_dur, rtp_session->seq, rtp_session->last_write_ts);
}

if (loops != 1) {
	rtp_session->sending_dtmf = 0;
	rtp_session->need_mark = 1;

	if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
		//switch_core_timer_sync(&rtp_session->write_timer);
		rtp_session->last_write_samplecount = rtp_session->write_timer.samplecount;
	}

	rtp_session->dtmf_data.out_digit_dur = 0;

	if (rtp_session->interdigit_delay) {
		set_dtmf_delay(rtp_session, rtp_session->interdigit_delay, rtp_session->interdigit_delay * 10);
	}

	return;
}
}

if (!rtp_session->dtmf_data.out_digit_dur && rtp_session->dtmf_data.dtmf_queue && switch_queue_size(rtp_session->dtmf_data.dtmf_queue)) {
void *pop;

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
	//switch_core_timer_sync(&rtp_session->write_timer);
	if (rtp_session->timer.samplecount < rtp_session->next_write_samplecount) {
		return;
	}

	if (rtp_session->timer.samplecount >= rtp_session->max_next_write_samplecount) {
		rtp_session->queue_delay = 0;
	}

} else if (rtp_session->queue_delay) {
	if (rtp_session->delay_samples >= rtp_session->samples_per_interval) {
		rtp_session->delay_samples -= rtp_session->samples_per_interval;
	} else {
		rtp_session->delay_samples = 0;
	}

	if (!rtp_session->delay_samples) {
		rtp_session->queue_delay = 0;
	}
}

if (rtp_session->queue_delay) {
	return;
}


if (!rtp_session->sending_dtmf) {
	rtp_session->sending_dtmf = 1;
}

if (switch_queue_trypop(rtp_session->dtmf_data.dtmf_queue, &pop) == SWITCH_STATUS_SUCCESS) {
	switch_dtmf_t *rdigit = pop;
	switch_size_t wrote;

	if (rdigit->digit == 'w') {
		set_dtmf_delay(rtp_session, 500, 0);
		free(rdigit);
		return;
	}

	if (rdigit->digit == 'W') {
		set_dtmf_delay(rtp_session, 1000, 0);
		free(rdigit);
		return;
	}

	memset(rtp_session->dtmf_data.out_digit_packet, 0, 4);
	rtp_session->dtmf_data.out_digit_sofar = samples;
	rtp_session->dtmf_data.out_digit_sub_sofar = samples;
	rtp_session->dtmf_data.out_digit_dur = rdigit->duration;
	rtp_session->dtmf_data.out_digit = rdigit->digit;
	rtp_session->dtmf_data.out_digit_packet[0] = (unsigned char) switch_char_to_rfc2833(rdigit->digit);
	rtp_session->dtmf_data.out_digit_packet[1] = 13;
	rtp_session->dtmf_data.out_digit_packet[2] = (unsigned char) (rtp_session->dtmf_data.out_digit_sub_sofar >> 8);
	rtp_session->dtmf_data.out_digit_packet[3] = (unsigned char) rtp_session->dtmf_data.out_digit_sub_sofar;


	rtp_session->dtmf_data.timestamp_dtmf = rtp_session->last_write_ts + samples;
	rtp_session->last_write_ts = rtp_session->dtmf_data.timestamp_dtmf;
	rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 0;

	wrote = switch_rtp_write_manual(rtp_session,
									rtp_session->dtmf_data.out_digit_packet,
									4,
									rtp_session->rtp_bugs & RTP_BUG_CISCO_SKIP_MARK_BIT_2833 ? 0 : 1,
									rtp_session->te, rtp_session->dtmf_data.timestamp_dtmf, &flags);


	rtp_session->stats.outbound.raw_bytes += wrote;
	rtp_session->stats.outbound.dtmf_packet_count++;

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 5713, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "Send start packet for [%c] ts=%u dur=%d/%d/%d seq=%d lw=%u\n",
					  rtp_session->dtmf_data.out_digit,
					  rtp_session->dtmf_data.timestamp_dtmf,
					  rtp_session->dtmf_data.out_digit_sofar,
					  rtp_session->dtmf_data.out_digit_sub_sofar, rtp_session->dtmf_data.out_digit_dur, rtp_session->seq, rtp_session->last_write_ts);

	free(rdigit);
}
}
5722}

5724SWITCH_DECLARE(void)__attribute__((visibility("default"))) void rtp_flush_read_buffer(switch_rtp_t *rtp_session, switch_rtp_flush_t flush)
5725{

if (rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] ||
rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
return;
}


if (switch_rtp_ready(rtp_session)) {
rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 1;
rtp_session->flags[SWITCH_RTP_FLAG_FLUSH] = 1;
reset_jitter_seq(rtp_session);

switch (flush) {
case SWITCH_RTP_FLUSH_STICK:
	switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH);
	break;
case SWITCH_RTP_FLUSH_UNSTICK:
	switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_STICKY_FLUSH);
	break;
default:
		break;
}
}
5749}

5751static int jb_valid(switch_rtp_t *rtp_session)
5752{
if (rtp_session->ice.ice_user) {
if (!rtp_session->ice.ready && rtp_session->ice.rready) {
	return 0;
}
}

if (rtp_session->dtls && rtp_session->dtls->state != DS_READY) {
return 0;
}

return 1;
5764}


5767static switch_size_t do_flush(switch_rtp_t *rtp_session, int force, switch_size_t bytes_in)
5768{
int was_blocking = 0;
switch_size_t bytes;
uint32_t flushed = 0;
switch_size_t bytes_out = 0;

if (!switch_rtp_ready(rtp_session)) {
return 0;
}

reset_jitter_seq(rtp_session);

if (!force) {
if ((rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) ||
	rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] ||
	rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] ||
	rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON]
	) {
	return bytes_in;
}
}

READ_INC(rtp_session)switch_mutex_lock(rtp_session->read_mutex); rtp_session->
reading++;

if (switch_rtp_ready(rtp_session) ) {

if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
	//switch_jb_reset(rtp_session->jb);
	bytes_out = bytes_in;
	goto end;
}

if (rtp_session->vbw) {
	switch_jb_reset(rtp_session->vbw);
}

if (rtp_session->vb) {
	//switch_jb_reset(rtp_session->vb);
	bytes_out = bytes_in;
	goto end;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_READ]) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 5811, (const char*)(rtp_session->session),
					  SWITCH_LOG_CONSOLE, "%s FLUSH\n",
					  rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName"
					  );
}

if (!rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK]) {
	was_blocking = 1;
	switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
	switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK8, TRUE(!0));
}

// before processing/flushing packets, if current packet is rfc2833, handle it (else it would be lost)
if (bytes_in > rtp_header_len12 && rtp_session->last_rtp_hdr.version == 2 && rtp_session->last_rtp_hdr.pt == rtp_session->recv_te) {
    int do_cng = 0;
5826#ifdef DEBUG_2833
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 5827, ((void*)0), SWITCH_LOG_ERROR, "*** Handling current RTP packet before flushing. seq=%u ***\n", ntohs(rtp_session->last_rtp_hdr.seq)__bswap_16 (rtp_session->last_rtp_hdr.seq));
5828#endif
    handle_rfc2833(rtp_session, bytes_in, &do_cng);
}

do {
	if (switch_rtp_ready(rtp_session)) {
		bytes = sizeof(rtp_msg_t);
		switch_socket_recvfrom(rtp_session->from_addr, rtp_session->sock_input, 0, (void *) &rtp_session->recv_msg, &bytes);

		if (bytes) {
			int do_cng = 0;

			if (rtp_session->media_timeout) {
				rtp_session->last_media = switch_micro_time_now();
			}

			/* Make sure to handle RFC2833 packets, even if we're flushing the packets */
			if (bytes > rtp_header_len12 && rtp_session->recv_msg.header.version == 2 && rtp_session->recv_msg.header.pt == rtp_session->recv_te) {
				rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;
				handle_rfc2833(rtp_session, bytes, &do_cng);
5848#ifdef DEBUG_2833
				switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 5849, ((void*)0), SWITCH_LOG_ERROR, "*** RTP packet handled in flush loop %d ***\n", do_cng);
5850#endif
			}

			flushed++;

			rtp_session->stats.inbound.raw_bytes += bytes;
			rtp_session->stats.inbound.flush_packet_count++;
			rtp_session->stats.inbound.packet_count++;
		}
	} else {
		break;
	}
} while (bytes > 0);

5864#ifdef DEBUG_2833
      if (flushed) {
          switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 5866, ((void*)0), SWITCH_LOG_ERROR, "*** do_flush: total flushed packets: %ld ***\n",(long)flushed);
      }
5868#endif


if (was_blocking && switch_rtp_ready(rtp_session)) {
	switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
	switch_socket_opt_set(rtp_session->sock_input, SWITCH_SO_NONBLOCK8, FALSE0);
}


if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->session) {
	//int type = 1; // sum flags: 1 encoder; 2; decoder
	//switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_IO_READ, SCC_VIDEO_RESET, SCCT_INT, (void *)&type, NULL, NULL);
	switch_core_session_request_video_refresh(rtp_session->session)_switch_core_session_request_video_refresh(rtp_session->session
, 0, "src/switch_rtp.c", (const char *)__func__, 5880);
}
}

end:

READ_DEC(rtp_session)rtp_session->reading--; switch_mutex_unlock(rtp_session->
read_mutex);

return bytes_out;
5889}

5891static int check_recv_payload(switch_rtp_t *rtp_session)
5892{
int ok = 1;

if (!(rtp_session->rtp_bugs & RTP_BUG_ACCEPT_ANY_PAYLOAD) && rtp_session->pmaps && *rtp_session->pmaps) {
payload_map_t *pmap;
ok = 0;

switch_mutex_lock(rtp_session->flag_mutex);

for (pmap = *rtp_session->pmaps; pmap && pmap->allocated; pmap = pmap->next) {
	if (!pmap->negotiated) {
		continue;
	}

	if (rtp_session->last_rtp_hdr.pt == pmap->pt) {
		ok = 1;
	}
}
switch_mutex_unlock(rtp_session->flag_mutex);
}

return ok;
5914}

5916static int get_recv_payload(switch_rtp_t *rtp_session)
5917{
int r = -1;

if (rtp_session->pmaps && *rtp_session->pmaps) {
payload_map_t *pmap;

switch_mutex_lock(rtp_session->flag_mutex);

for (pmap = *rtp_session->pmaps; pmap && pmap->allocated; pmap = pmap->next) {
	if (pmap->negotiated) {
		r = pmap->pt;
		break;
	}
}
switch_mutex_unlock(rtp_session->flag_mutex);
}

return r;
5935}

5937#define return_cng_frame()do_cng = 1; goto timer_check do_cng = 1; goto timer_check

5939static switch_status_t read_rtp_packet(switch_rtp_t *rtp_session, switch_size_t *bytes, switch_frame_flag_t *flags,
							   payload_map_t **pmapP, switch_status_t poll_status, switch_bool_t return_jb_packet)
5941{
switch_status_t status = SWITCH_STATUS_FALSE;
uint32_t ts = 0;
unsigned char *b = NULL((void*)0);
int sync = 0;
switch_time_t now;
switch_size_t xcheck_jitter = 0;
int tries = 0;
int block = 0;

switch_assert(bytes)((bytes) ? (void) (0) : __assert_fail ("bytes", "src/switch_rtp.c"
, 5951, __extension__ __PRETTY_FUNCTION__));
more:

tries++;

if (tries > 20) {
if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
	switch_jb_reset(rtp_session->jb);
}
rtp_session->punts++;
rtp_session->clean = 0;
*bytes = 0;
return SWITCH_STATUS_BREAK;
}

if (block) {
int to = 20000;
int fdr = 0;

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
	to = 100000;
} else {
	if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->timer.interval) {
		to = rtp_session->timer.interval * 1000;
	}
}

poll_status = switch_poll(rtp_session->read_pollfd, 1, &fdr, to);

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->timer.interval) {
	switch_core_timer_sync(&rtp_session->timer);
}

if (rtp_session->session) {
	switch_ivr_parse_all_messages(rtp_session->session);
}

block = 0;
}

*bytes = sizeof(rtp_msg_t);
sync = 0;

rtp_session->has_rtp = 0;
rtp_session->has_ice = 0;
rtp_session->has_rtcp = 0;
if (rtp_session->dtls) {
rtp_session->dtls->bytes = 0;
rtp_session->dtls->data = NULL((void*)0);
}
memset(&rtp_session->last_rtp_hdr, 0, sizeof(rtp_session->last_rtp_hdr));

if (poll_status == SWITCH_STATUS_SUCCESS) {
status = switch_socket_recvfrom(rtp_session->from_addr, rtp_session->sock_input, 0, (void *) &rtp_session->recv_msg, bytes);
} else {
*bytes = 0;
}

if (*bytes) {
b = (unsigned char *) &rtp_session->recv_msg;

/* version 2 probably rtp, zrtp cookie present means zrtp */
rtp_session->has_rtp = (rtp_session->recv_msg.header.version == 2 || ntohl(*(int *)(b+4))__bswap_32 (*(int *)(b+4)) == ZRTP_MAGIC_COOKIE0x5a525450);

if (rtp_session->media_timeout) {
	rtp_session->last_media = switch_micro_time_now();
}

if ((*b >= 20) && (*b <= 64)) {
	if (rtp_session->dtls) {
		rtp_session->dtls->bytes = *bytes;
		rtp_session->dtls->data = (void *) &rtp_session->recv_msg;
	}
	rtp_session->has_ice = 0;
	rtp_session->has_rtp = 0;
	rtp_session->has_rtcp = 0;
} else if (*b == 0 || *b == 1) {
	rtp_session->has_ice = 1;
	rtp_session->has_rtp = 0;
	rtp_session->has_rtcp = 0;
} else {
	if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
		switch(rtp_session->recv_msg.header.pt) {
		case 64:        //  192 Full INTRA-frame request.
		case 72:        //  200 Sender report.
		case 73:        //  201 Receiver report.
		case 74:        //  202 Source description.
		case 75:        //  203 Goodbye.
		case 76:        //  204 Application-defined.
		case 77:        //  205 Transport layer FB message.
		case 78:        //  206 Payload-specific FB message.
		case 79:        //  207 Extended report.
			rtp_session->has_rtcp = 1;
			rtp_session->has_rtp = 0;
			rtp_session->has_ice = 0;
			break;
		default:
			if (rtp_session->rtcp_recv_msg_p->header.version == 2 &&
				rtp_session->rtcp_recv_msg_p->header.type > 199 && rtp_session->rtcp_recv_msg_p->header.type < 208) {
				rtp_session->has_rtcp = 1;
				rtp_session->has_rtp = 0;
				rtp_session->has_ice = 0;
			}
			break;
		}
	}
}

if (rtp_session->has_rtp || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
	rtp_session->missed_count = 0;
	switch_cp_addr(rtp_session->rtp_from_addr, rtp_session->from_addr);
}

if (rtp_session->has_rtp) {
	rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;


	if (bytes && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
		rtp_session->last_rtp_hdr.pt != 13 &&
		rtp_session->last_rtp_hdr.pt != rtp_session->recv_te &&
		rtp_session->last_rtp_hdr.pt != rtp_session->cng_pt) {
		int accept_packet = 1;


		if (!(rtp_session->rtp_bugs & RTP_BUG_ACCEPT_ANY_PAYLOAD) && 
			!(rtp_session->rtp_bugs & RTP_BUG_ACCEPT_ANY_PACKETS) && rtp_session->pmaps && *rtp_session->pmaps) {
			payload_map_t *pmap;
			accept_packet = 0;

			switch_mutex_lock(rtp_session->flag_mutex);
			for (pmap = *rtp_session->pmaps; pmap && pmap->allocated; pmap = pmap->next) {

				if (ntohl(*(int *)(b+4))__bswap_32 (*(int *)(b+4)) == ZRTP_MAGIC_COOKIE0x5a525450) {
					accept_packet = 1;
					break;
				}

				if (!pmap->negotiated) {
					continue;
				}

				if (rtp_session->last_rtp_hdr.pt == pmap->pt) {
					accept_packet = 1;
					if (pmapP) {
						*pmapP = pmap;
					}
					break;
				}
			}
			switch_mutex_unlock(rtp_session->flag_mutex);
		}

		if (!accept_packet) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6104, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1,
							  "Invalid Packet SEQ: %d TS: %d PT:%d ignored\n",
							  ntohs(rtp_session->recv_msg.header.seq)__bswap_16 (rtp_session->recv_msg.header.seq), ntohl(rtp_session->last_rtp_hdr.ts)__bswap_32 (rtp_session->last_rtp_hdr.ts), rtp_session->last_rtp_hdr.pt);
			*bytes = 0;
		}
	}

	if (rtp_session->flags[SWITCH_RTP_FLAG_DETECT_SSRC]) {
		//if (rtp_session->remote_ssrc != rtp_session->stats.rtcp.peer_ssrc && rtp_session->stats.rtcp.peer_ssrc) {
		//	rtp_session->remote_ssrc = rtp_session->stats.rtcp.peer_ssrc;
		//}

		if (rtp_session->remote_ssrc != rtp_session->last_rtp_hdr.ssrc && rtp_session->last_rtp_hdr.ssrc) {
			rtp_session->remote_ssrc = ntohl(rtp_session->last_rtp_hdr.ssrc)__bswap_32 (rtp_session->last_rtp_hdr.ssrc);
		}
	}
}
}

if (!rtp_session->vb && (!rtp_session->jb || rtp_session->pause_jb || !jb_valid(rtp_session))) {
if (*bytes > rtp_header_len12 && (rtp_session->has_rtp && check_recv_payload(rtp_session))) {
	xcheck_jitter = *bytes;
	check_jitter(rtp_session);
}
}

if (check_rtcp_and_ice(rtp_session) == -1) {
//if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
//switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "WTF CHECK FAIL\n");
//}
return SWITCH_STATUS_GENERR;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
goto udptl;
}


if (*bytes) {
*flags &= ~SFF_PROXY_PACKET;

//if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
//	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_WARNING, "WTF BYTES %ld b=%d\n", *bytes, *b);
//}


if (rtp_session->has_ice) {
	if (rtp_session->ice.ice_user) {
		handle_ice(rtp_session, &rtp_session->ice, (void *) &rtp_session->recv_msg, *bytes);
	}
	*bytes = 0;
	sync = 1;
}
}

switch_mutex_lock(rtp_session->ice_mutex);

if (rtp_session->dtls) {

if (rtp_session->rtcp_dtls && rtp_session->rtcp_dtls != rtp_session->dtls) {
	rtp_session->rtcp_dtls->bytes = 0;
	rtp_session->rtcp_dtls->data = NULL((void*)0);
	do_dtls(rtp_session, rtp_session->rtcp_dtls);
}

do_dtls(rtp_session, rtp_session->dtls);

if (rtp_session->dtls && rtp_session->dtls->bytes) {
	*bytes = 0;
	sync = 1;
}
}



if (status == SWITCH_STATUS_SUCCESS && *bytes) {
if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
	*flags &= ~SFF_RTCP;
	if (rtp_session->has_rtcp) {
		*flags |= SFF_RTCP;

6185#ifdef ENABLE_SRTP1
		if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV]) {
			int sbytes = (int) *bytes;
			srtp_err_status_t stat = 0;

			if (!rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_MKI]) {
				stat = srtp_unprotect_rtcp(rtp_session->recv_ctx[rtp_session->srtp_idx_rtcp], &rtp_session->rtcp_recv_msg_p->header, &sbytes);
			} else {
				stat = srtp_unprotect_rtcp_mki(rtp_session->recv_ctx[rtp_session->srtp_idx_rtcp], &rtp_session->rtcp_recv_msg_p->header, &sbytes, 1);
			}

			if (stat) {
				//++rtp_session->srtp_errs[rtp_session->srtp_idx_rtp]++;
				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6198, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "RTCP UNPROTECT ERR\n");
			} else {
				//rtp_session->srtp_errs[rtp_session->srtp_idx_rtp] = 0;
			}

			*bytes = sbytes;
		}
6205#endif
		switch_mutex_unlock(rtp_session->ice_mutex);
		return SWITCH_STATUS_SUCCESS;
	}
}
}

switch_mutex_unlock(rtp_session->ice_mutex);

if ((*bytes && (!rtp_write_ready(rtp_session, *bytes, __LINE__6214) || !rtp_session->has_rtp || rtp_session->has_rtcp)) || sync) {
rtp_session->hot_hits = 0;
block = 1;
*bytes = 0;
goto more;
}

if (*bytes && rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_READ]) {
const char *tx_host;
const char *old_host;
const char *my_host;

char bufa[50], bufb[50], bufc[50];


tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtp_from_addr);
old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
my_host = switch_get_addr(bufc, sizeof(bufc), rtp_session->local_addr);

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session)SWITCH_CHANNEL_ID_LOG_CLEAN, "src/switch_rtp.c", (const char *
)__func__, 6233, switch_core_session_get_uuid((rtp_session->
session)), SWITCH_LOG_CONSOLE,
				  "R %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
				  rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "No-Name",
				  (long) *bytes,
				  my_host, switch_sockaddr_get_port(rtp_session->local_addr),
				  old_host, rtp_session->remote_port,
				  tx_host, switch_sockaddr_get_port(rtp_session->rtp_from_addr),
				  rtp_session->last_rtp_hdr.pt, ntohl(rtp_session->last_rtp_hdr.ts)__bswap_32 (rtp_session->last_rtp_hdr.ts), ntohs(rtp_session->last_rtp_hdr.seq)__bswap_16 (rtp_session->last_rtp_hdr.seq),
				  rtp_session->last_rtp_hdr.m);

}

6245#ifdef RTP_READ_PLOSS
{
int r = (rand() % 10000) + 1;
if (r <= 200) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6249, (const char*)(rtp_session->session), SWITCH_LOG_ALERT,
					  "Simulate dropped packet ......... ts: %u seq: %u\n", ntohl(rtp_session->last_rtp_hdr.ts)__bswap_32 (rtp_session->last_rtp_hdr.ts), ntohs(rtp_session->last_rtp_hdr.seq)__bswap_16 (rtp_session->last_rtp_hdr.seq));
	*bytes = 0;
}
}
6254#endif



udptl:

ts = 0;
rtp_session->recv_msg.ebody = NULL((void*)0);
now = switch_micro_time_now();

if (*bytes) {
uint16_t seq = ntohs((uint16_t) rtp_session->last_rtp_hdr.seq)__bswap_16 ((uint16_t) rtp_session->last_rtp_hdr.seq);
ts = ntohl(rtp_session->last_rtp_hdr.ts)__bswap_32 (rtp_session->last_rtp_hdr.ts);

6268#ifdef DEBUG_MISSED_SEQ
if (rtp_session->last_seq && rtp_session->last_seq+1 != seq) {
	//2012-11-28 18:33:11.799070 [ERR] switch_rtp.c:2883 Missed -65536 RTP frames from sequence [65536] to [-1] (missed). Time since last read [20021]
	switch_size_t flushed_packets_diff = rtp_session->stats.inbound.flush_packet_count - rtp_session->last_flush_packet_count;
	switch_size_t num_missed = (switch_size_t)seq - (rtp_session->last_seq+1);

	if (num_missed == 1) { /* We missed one packet */
		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 6275, ((void*)0), SWITCH_LOG_ERROR, "Missed one RTP frame with sequence [%d]%s. Time since last read [%ld]\n",
						  rtp_session->last_seq+1, (flushed_packets_diff == 1) ? " (flushed by FS)" : " (missed)",
						  rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
	} else { /* We missed multiple packets */
		if (flushed_packets_diff == 0) {
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 6280, ((void*)0), SWITCH_LOG_ERROR,
							  "Missed %ld RTP frames from sequence [%d] to [%d] (missed). Time since last read [%ld]\n",
							  num_missed, rtp_session->last_seq+1, seq-1,
							  rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
		} else if (flushed_packets_diff == num_missed) {
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 6285, ((void*)0), SWITCH_LOG_ERROR,
							  "Missed %ld RTP frames from sequence [%d] to [%d] (flushed by FS). Time since last read [%ld]\n",
							  num_missed, rtp_session->last_seq+1, seq-1,
							  rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
		} else if (num_missed > flushed_packets_diff) {
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 6290, ((void*)0), SWITCH_LOG_ERROR,
							  "Missed %ld RTP frames from sequence [%d] to [%d] (%ld packets flushed by FS, %ld packets missed)."
							  " Time since last read [%ld]\n",
							  num_missed, rtp_session->last_seq+1, seq-1,
							  flushed_packets_diff, num_missed-flushed_packets_diff,
							  rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
		} else {
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 6297, ((void*)0), SWITCH_LOG_ERROR,
							  "Missed %ld RTP frames from sequence [%d] to [%d] (%ld packets flushed by FS). Time since last read [%ld]\n",
							  num_missed, rtp_session->last_seq+1, seq-1,
							  flushed_packets_diff, rtp_session->last_read_time ? now-rtp_session->last_read_time : 0);
		}
	}

}
6305#endif
rtp_session->last_seq = seq;


rtp_session->last_flush_packet_count = rtp_session->stats.inbound.flush_packet_count;


if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && now - rtp_session->last_read_time > 5000000) {
	switch_rtp_video_refresh(rtp_session);
}

rtp_session->last_read_time = now;
}

if (*bytes && rtp_session->has_rtp && rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]){
rtcp_stats(rtp_session);
}


if (!rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] && !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] &&
*bytes && rtp_session->last_rtp_hdr.pt != rtp_session->recv_te &&
ts && !rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session) && ts == rtp_session->last_cng_ts) {
/* we already sent this frame..... */
*bytes = 0;
return SWITCH_STATUS_SUCCESS;
}

if (*bytes) {
if (!rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
6334#ifdef ENABLE_ZRTP
	/* ZRTP Recv */
	if (zrtp_on) {

		unsigned int sbytes = (int) *bytes;
		zrtp_status_t stat = 0;

		stat = zrtp_process_srtp(rtp_session->zrtp_stream, (void *) &rtp_session->recv_msg, &sbytes);

		switch (stat) {
		case zrtp_status_ok:
			*bytes = sbytes;
			break;
		case zrtp_status_drop:
			/* switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Error: zRTP protection drop with code %d\n", stat); */
			*bytes = 0;
			return SWITCH_STATUS_SUCCESS;
		case zrtp_status_fail:
			switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 6352, ((void*)0), SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
			return SWITCH_STATUS_FALSE;
		default:
			break;
		}
	}
6358#endif

6360#ifdef ENABLE_SRTP1
	switch_mutex_lock(rtp_session->ice_mutex);
	if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && rtp_session->has_rtp &&
		(check_recv_payload(rtp_session) ||
		 rtp_session->last_rtp_hdr.pt == rtp_session->recv_te ||
		 rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt)) {
		//if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && (!rtp_session->ice.ice_user || rtp_session->has_rtp)) {
		int sbytes = (int) *bytes;
		srtp_err_status_t stat = 0;

		if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_RESET] || !rtp_session->recv_ctx[rtp_session->srtp_idx_rtp]) {
			switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_RECV_RESET);
			srtp_dealloc(rtp_session->recv_ctx[rtp_session->srtp_idx_rtp]);
			rtp_session->recv_ctx[rtp_session->srtp_idx_rtp] = NULL((void*)0);
			if ((stat = srtp_create(&rtp_session->recv_ctx[rtp_session->srtp_idx_rtp],
									&rtp_session->recv_policy[rtp_session->srtp_idx_rtp])) || !rtp_session->recv_ctx[rtp_session->srtp_idx_rtp]) {

				rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 0;
				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6378, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error! RE-Activating Secure RTP RECV\n");
				rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] = 0;
				switch_mutex_unlock(rtp_session->ice_mutex);
				return SWITCH_STATUS_FALSE;
			} else {

				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6384, (const char*)(rtp_session->session), SWITCH_LOG_INFO, "RE-Activating Secure RTP RECV\n");
				rtp_session->srtp_errs[rtp_session->srtp_idx_rtp] = 0;
			}
		}

		if (!(*flags & SFF_PLC) && rtp_session->recv_ctx[rtp_session->srtp_idx_rtp]) {
			if (!rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_MKI]) {
				stat = srtp_unprotect(rtp_session->recv_ctx[rtp_session->srtp_idx_rtp], &rtp_session->recv_msg.header, &sbytes);
			} else {
				stat = srtp_unprotect_mki(rtp_session->recv_ctx[rtp_session->srtp_idx_rtp], &rtp_session->recv_msg.header, &sbytes, 1);
			}

			if (rtp_session->flags[SWITCH_RTP_FLAG_NACK] && stat == srtp_err_status_replay_fail) {
				/* false alarm nack */
				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6398, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, "REPLAY ERR, FALSE NACK\n");
				sbytes = 0;
				*bytes = 0;
				if (rtp_session->stats.rtcp.pkt_count) {
					rtp_session->stats.rtcp.period_pkt_count--;
					rtp_session->stats.rtcp.pkt_count--;
				}
				switch_mutex_unlock(rtp_session->ice_mutex);
				goto more;
			}
		}

		if (stat && rtp_session->recv_msg.header.pt != rtp_session->recv_te && rtp_session->recv_msg.header.pt != rtp_session->cng_pt) {
			int errs = ++rtp_session->srtp_errs[rtp_session->srtp_idx_rtp];
			if (stat != 10) {
				char *msg;
				if (stat == srtp_err_status_replay_fail) msg="replay check failed";
				else if (stat == srtp_err_status_auth_fail) msg="auth check failed";
				else msg="";
				if (errs >= MAX_SRTP_ERRS100) {
					switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6419, (const char*)(rtp_session->session), SWITCH_LOG_WARNING,
									  "SRTP %s unprotect failed with code %d (%s) %ld bytes %d errors\n",
									  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), stat, msg, (long)*bytes, errs);
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6422, (const char*)(rtp_session->session), SWITCH_LOG_WARNING,
									  "Ending call due to SRTP error\n");
					switch_channel_hangup(channel, SWITCH_CAUSE_SRTP_READ_ERROR)switch_channel_perform_hangup(channel, "src/switch_rtp.c", (const
 char *)__func__, 6424, SWITCH_CAUSE_SRTP_READ_ERROR);
				} else if (errs >= WARN_SRTP_ERRS10 && !(errs % WARN_SRTP_ERRS10)) {
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6426, (const char*)(rtp_session->session), SWITCH_LOG_WARNING,
									  "SRTP %s unprotect failed with code %d (%s) %ld bytes %d errors\n",
									  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), stat, msg, (long)*bytes, errs);
				}
			}
			sbytes = 0;
		} else {
			rtp_session->srtp_errs[rtp_session->srtp_idx_rtp] = 0;
		}

		*bytes = sbytes;
	}
	switch_mutex_unlock(rtp_session->ice_mutex);
6439#endif
}


if (rtp_session->has_rtp) {
	if (rtp_session->recv_msg.header.cc > 0) { /* Contributing Source Identifiers (4 bytes = sizeof CSRC header)*/
		rtp_session->recv_msg.ebody = RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + (rtp_session->recv_msg.header.cc * 4);
	}

	/* recalculate body length in case rtp extension used */
	if (!rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && !rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
		rtp_session->recv_msg.header.x) { /* header extensions */
		uint16_t length;

		rtp_session->recv_msg.ext = (switch_rtp_hdr_ext_t *) RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body);
		length = ntohs((uint16_t)rtp_session->recv_msg.ext->length)__bswap_16 ((uint16_t)rtp_session->recv_msg.ext->length
);

		if (length < SWITCH_RTP_MAX_BUF_LEN_WORDS4094) {
			rtp_session->recv_msg.ebody = (char *)rtp_session->recv_msg.ext + (length * 4) + 4;
			if (*bytes > (length * 4 + 4)) {
				*bytes -= (length * 4 + 4);
			} else {
				*bytes = 0;
			}
		}
	}


6467#ifdef DEBUG_CHROME

	if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->has_rtp) {

		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 6471, ((void*)0), SWITCH_LOG_INFO,
						  "VIDEO: seq: %d ts: %u len: %ld %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x mark: %d\n",
						  ntohs(rtp_session->last_rtp_hdr.seq)__bswap_16 (rtp_session->last_rtp_hdr.seq), ntohl(rtp_session->last_rtp_hdr.ts)__bswap_32 (rtp_session->last_rtp_hdr.ts), *bytes,
						  *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body)), *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 1),
						  *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 2), *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 3),
						  *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 4), *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 5),
						  *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 6), *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 7),
						  *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 8), *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 9),
						  *((uint8_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body) + 10), rtp_session->last_rtp_hdr.m);

	}
6482#endif



}


rtp_session->stats.inbound.raw_bytes += *bytes;

if (rtp_session->last_rtp_hdr.pt == rtp_session->recv_te) {
	rtp_session->stats.inbound.dtmf_packet_count++;
} else if (rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt || rtp_session->last_rtp_hdr.pt == 13) {
	rtp_session->stats.inbound.cng_packet_count++;
} else {
	rtp_session->stats.inbound.media_packet_count++;
	rtp_session->stats.inbound.media_bytes += *bytes;
}

rtp_session->stats.inbound.packet_count++;
}

if (!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] &&
((rtp_session->recv_te && rtp_session->last_rtp_hdr.pt == rtp_session->recv_te) ||
 (*bytes < rtp_header_len12 && *bytes > 0 && !(rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL])))) {
return SWITCH_STATUS_BREAK;
}

if (ts) {
rtp_session->prev_read_ts = rtp_session->last_read_ts;
rtp_session->last_read_ts = ts;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_BYTESWAP] && check_recv_payload(rtp_session)) {
switch_swap_linear((int16_t *)RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body), (int) *bytes - rtp_header_len12);
}

if (rtp_session->flags[SWITCH_RTP_FLAG_KILL_JB]) {
rtp_session->flags[SWITCH_RTP_FLAG_KILL_JB] = 0;

if (rtp_session->jb) {
	switch_jb_destroy(&rtp_session->jb);
}

if (rtp_session->vb) {
	switch_jb_destroy(&rtp_session->vb);
}

if (rtp_session->vbw) {
	switch_jb_destroy(&rtp_session->vbw);
}

}

if (rtp_session->has_rtp && *bytes) {
uint32_t read_ssrc = ntohl(rtp_session->last_rtp_hdr.ssrc)__bswap_32 (rtp_session->last_rtp_hdr.ssrc);

if (rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
	return SWITCH_STATUS_SUCCESS;
}

if (rtp_session->vb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
	status = switch_jb_put_packet(rtp_session->vb, (switch_rtp_packet_t *) &rtp_session->recv_msg, *bytes);

	if (status == SWITCH_STATUS_TOO_LATE) {
		goto more;
	}

	status = SWITCH_STATUS_FALSE;
	*bytes = 0;

	if (!return_jb_packet) {
		return status;
	}
}

if (rtp_session->jb && jb_valid(rtp_session)) {
	if (rtp_session->last_jb_read_ssrc && rtp_session->last_jb_read_ssrc != read_ssrc) {
		switch_jb_reset(rtp_session->jb);
	}

	rtp_session->last_jb_read_ssrc = read_ssrc;
}

if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {

	if (!rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->timer.interval) {
		switch_core_timer_sync(&rtp_session->timer);
		reset_jitter_seq(rtp_session);
	}

	status = switch_jb_put_packet(rtp_session->jb, (switch_rtp_packet_t *) &rtp_session->recv_msg, *bytes);
	if (status == SWITCH_STATUS_TOO_LATE) {
		goto more;
	}


	status = SWITCH_STATUS_FALSE;
	*bytes = 0;

	if (!return_jb_packet) {
		return status;
	}
} else {
	if (rtp_session->last_rtp_hdr.m && rtp_session->last_rtp_hdr.pt != rtp_session->recv_te &&
		!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && !(rtp_session->rtp_bugs & RTP_BUG_IGNORE_MARK_BIT) && 
		rtp_session->last_read_ts - rtp_session->prev_read_ts < rtp_session->samples_per_interval * 3) {  
		switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
	} else if (rtp_session->last_jb_read_ssrc && rtp_session->last_jb_read_ssrc != read_ssrc) {
		switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
	}
}
}

if (!*bytes || rtp_session->has_rtp) {

if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
	switch_status_t jstatus = switch_jb_get_packet(rtp_session->jb, (switch_rtp_packet_t *) &rtp_session->recv_msg, bytes);

	status = jstatus;

	switch(jstatus) {
	case SWITCH_STATUS_MORE_DATA:
		if (rtp_session->punts < 4) {
			block = 1;
			goto more;
		}
		*bytes = 0;
		break;
	case SWITCH_STATUS_NOTFOUND:
		{
			int pt = get_recv_payload(rtp_session);
			(*flags) |= SFF_PLC;
			status = SWITCH_STATUS_SUCCESS;
			*bytes = switch_jb_get_last_read_len(rtp_session->jb);
			rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;
			rtp_session->last_rtp_hdr.pt = pt;
		}
		break;
	case SWITCH_STATUS_BREAK:
		break;
	case SWITCH_STATUS_SUCCESS:
	case SWITCH_STATUS_TIMEOUT:
	default:
		{
			if (status == SWITCH_STATUS_TIMEOUT) {
				rtp_session->skip_timer = 1;
			}
			rtp_session->stats.inbound.jb_packet_count++;
			status = SWITCH_STATUS_SUCCESS;
			rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;
			if (++rtp_session->clean > 200) {
				rtp_session->punts = 0;
			}
			if (!xcheck_jitter) {
				check_jitter(rtp_session);
			}
		}
		break;
	}
}

if (rtp_session->vb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
	switch_status_t vstatus = switch_jb_get_packet(rtp_session->vb, (switch_rtp_packet_t *) &rtp_session->recv_msg, bytes);
	status = vstatus;

	switch(vstatus) {
	case SWITCH_STATUS_RESTART:
		switch_core_session_request_video_refresh(rtp_session->session)_switch_core_session_request_video_refresh(rtp_session->session
, 0, "src/switch_rtp.c", (const char *)__func__, 6649);
		status = SWITCH_STATUS_BREAK;
		break;
	case SWITCH_STATUS_MORE_DATA:
		status = SWITCH_STATUS_BREAK;
		break;
	case SWITCH_STATUS_BREAK:
	default:
		break;
	}

	if (vstatus == SWITCH_STATUS_NOTFOUND && rtp_session->flags[SWITCH_RTP_FLAG_TEXT]) {
		int pt = get_recv_payload(rtp_session);
		(*flags) |= SFF_PLC;
		status = SWITCH_STATUS_SUCCESS;
		*bytes = switch_jb_get_last_read_len(rtp_session->vb);
		rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;
		if (pt > -1) {
			rtp_session->last_rtp_hdr.pt = pt;
		}
	}

	if (vstatus == SWITCH_STATUS_SUCCESS) {
		rtp_session->last_rtp_hdr = rtp_session->recv_msg.header;

		if (!xcheck_jitter) {
			check_jitter(rtp_session);
		}
	}
}
}

return status;
6682}

6684static void handle_nack(switch_rtp_t *rtp_session, uint32_t nack)
6685{
switch_size_t bytes = 0;
rtp_msg_t send_msg[1] = {{{0}}};
uint16_t seq = (uint16_t) (nack & 0xFFFF);
uint16_t blp = (uint16_t) (nack >> 16);
int i;
const char *tx_host = NULL((void*)0);
const char *old_host = NULL((void*)0);
const char *my_host = NULL((void*)0);
char bufa[50], bufb[50], bufc[50];

if (!(rtp_session->flags[SWITCH_RTP_FLAG_NACK] && rtp_session->vbw)) {
return;  /* not enabled */
}

if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtcp_from_addr);
old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
my_host = switch_get_addr(bufc, sizeof(bufc), rtp_session->local_addr);
}

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6706, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "%s Got NACK [%u][0x%x] for seq %u\n", 
			  switch_core_session_get_name(rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(rtp_session
->session)), nack, nack, ntohs(seq)__bswap_16 (seq));

if (switch_jb_get_packet_by_seq(rtp_session->vbw, seq, (switch_rtp_packet_t *) send_msg, &bytes) == SWITCH_STATUS_SUCCESS) {

if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session)SWITCH_CHANNEL_ID_LOG_CLEAN, "src/switch_rtp.c", (const char *
)__func__, 6712, switch_core_session_get_uuid((rtp_session->
session)), SWITCH_LOG_CONSOLE,
					  "X %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
					  rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName",
					  (long) bytes,
					  my_host, switch_sockaddr_get_port(rtp_session->local_addr),
					  old_host, rtp_session->remote_port,
					  tx_host, switch_sockaddr_get_port(rtp_session->rtcp_from_addr),
					  send_msg->header.pt, ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts), ntohs(send_msg->header.seq)__bswap_16 (send_msg->header.seq), send_msg->header.m);

}
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG2, "RE----SEND %u\n", ntohs(send_msg->header.seq));
switch_rtp_write_raw(rtp_session, (void *) send_msg, &bytes, SWITCH_FALSE);
} else {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6725, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "Cannot send NACK for seq %u\n", ntohs(seq)__bswap_16 (seq));
}

blp = ntohs(blp)__bswap_16 (blp);
for (i = 0; i < 16; i++) {
if (blp & (1 << i)) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6731, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "%s Also Got NACK for seq %u\n", 
					  switch_core_session_get_name(rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(rtp_session
->session)), ntohs(seq)__bswap_16 (seq) + i + 1);
	/* If they are missing more than one, may as well gen a key frame for good measure */
	//switch_core_media_gen_key_frame(rtp_session->session);
	if (switch_jb_get_packet_by_seq(rtp_session->vbw, htons(ntohs(seq) + i + 1)__bswap_16 (__bswap_16 (seq) + i + 1), (switch_rtp_packet_t *) &send_msg, &bytes) == SWITCH_STATUS_SUCCESS) {
		if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session)SWITCH_CHANNEL_ID_LOG_CLEAN, "src/switch_rtp.c", (const char *
)__func__, 6737, switch_core_session_get_uuid((rtp_session->
session)), SWITCH_LOG_CONSOLE,
							  "X %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
							  rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName",
							  (long) bytes,
							  my_host, switch_sockaddr_get_port(rtp_session->local_addr),
							  old_host, rtp_session->remote_port,
							  tx_host, switch_sockaddr_get_port(rtp_session->rtcp_from_addr),
							  send_msg->header.pt, ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts), ntohs(send_msg->header.seq)__bswap_16 (send_msg->header.seq), send_msg->header.m);

		}
		//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "RE----SEND %u\n", ntohs(send_msg->header.seq));

		switch_rtp_write_raw(rtp_session, (void *) &send_msg, &bytes, SWITCH_FALSE);
	} else {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6751, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "Cannot send NACK for seq %u\n", ntohs(seq)__bswap_16 (seq) + i);
	}
}
}
6755}

6757static switch_status_t process_rtcp_report(switch_rtp_t *rtp_session, rtcp_msg_t *msg, switch_size_t bytes)
6758{
switch_status_t status = SWITCH_STATUS_FALSE;

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6761, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3,
			  "RTCP packet bytes %" SWITCH_SIZE_T_FMT"ld" " type %d pad %d\n",
			  bytes, msg->header.type, msg->header.p);

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && (msg->header.type == _RTCP_PT_RTPFB || msg->header.type == _RTCP_PT_PSFB || msg->header.type < 200)) {
rtcp_ext_msg_t *extp = (rtcp_ext_msg_t *) msg;

if (extp->header.fmt != 15) { // <---- REMOVE WHEN BRIA STOPS SENDING UNSOLICITED REMB
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6769, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "%s PICKED UP %s XRTCP type: %d fmt: %d\n",
					  switch_core_session_get_name(rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(rtp_session
->session)), rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), msg->header.type, extp->header.fmt);
}

if (msg->header.type == _RTCP_PT_FIR ||
	(msg->header.type == _RTCP_PT_PSFB && (extp->header.fmt == _RTCP_PSFB_FIR || extp->header.fmt == _RTCP_PSFB_PLI))) {
6775#if 0
	if (msg->header.type == _RTCP_PT_FIR) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6777, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "Ancient FIR Received. Hello from 1996!\n");

		if (!switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_OLD_FIR)) {
			switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_OLD_FIR);
			switch_core_session_request_video_refresh(rtp_session->session)_switch_core_session_request_video_refresh(rtp_session->session
, 0, "src/switch_rtp.c", (const char *)__func__, 6781);
		}
	}
6784#endif
	
	if (switch_core_session_media_flow(rtp_session->session, SWITCH_MEDIA_TYPE_VIDEO) == SWITCH_MEDIA_FLOW_RECVONLY) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6787, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "%s Ignoring FIR/PLI from a sendonly stream.\n", 
						  switch_core_session_get_name(rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(rtp_session
->session)));
	} else {
		switch_core_media_gen_key_frame(rtp_session->session)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 6790, (const char*)(rtp_session->
session), SWITCH_LOG_DEBUG1, "%s Send KeyFrame\n", switch_channel_get_name
(switch_core_session_get_channel(rtp_session->session))); switch_core_media_codec_control
(rtp_session->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_IO_WRITE
, SCC_VIDEO_GEN_KEYFRAME, SCCT_NONE, ((void*)0), SCCT_NONE, (
(void*)0), ((void*)0), ((void*)0));
		switch_core_session_request_video_refresh(rtp_session->session)_switch_core_session_request_video_refresh(rtp_session->session
, 0, "src/switch_rtp.c", (const char *)__func__, 6791);
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6792, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "%s Got FIR/PLI\n", 
						  switch_core_session_get_name(rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(rtp_session
->session)));
		switch_channel_set_flag(switch_core_session_get_channel(rtp_session->session), CF_VIDEO_REFRESH_REQ)switch_channel_set_flag_value(switch_core_session_get_channel
(rtp_session->session), CF_VIDEO_REFRESH_REQ, 1);
	}
}

if (msg->header.type == _RTCP_PT_RTPFB && extp->header.fmt == _RTCP_RTPFB_NACK) {
	uint32_t *nack = (uint32_t *) extp->body;
	int i;

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6802, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG2, "%s Got NACK count %d\n", 
					  switch_core_session_get_name(rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(rtp_session
->session)), ntohs(extp->header.length)__bswap_16 (extp->header.length) - 2);


	for (i = 0; i < ntohs(extp->header.length)__bswap_16 (extp->header.length) - 2; i++) {
		handle_nack(rtp_session, nack[i]);
	}

	//switch_core_media_gen_key_frame(rtp_session->session);
}

} else {
struct switch_rtcp_report_block *report;

if (msg->header.type == _RTCP_PT_SR || msg->header.type == _RTCP_PT_RR) {
	int i;
6818#ifdef DEBUG_RTCP
	switch_time_t now = switch_micro_time_now();
6820#endif 
	uint32_t lsr_now;
	uint32_t lsr;
	uint32_t packet_ssrc;
	double rtt_now = 0;
	uint8_t rtt_valid = 0;
	int rtt_increase = 0, packet_loss_increase=0;

	//if (msg->header.type == _RTCP_PT_SR && rtp_session->ice.ice_user) {
	//	rtp_session->send_rr = 1;
	//}

	lsr_now = calc_local_lsr_now();

	if (msg->header.type == _RTCP_PT_SR) { /* Sender report */
		struct switch_rtcp_sender_report* sr = (struct switch_rtcp_sender_report*)msg->body;

		rtp_session->stats.rtcp.packet_count = ntohl(sr->sender_info.pc)__bswap_32 (sr->sender_info.pc);
		rtp_session->stats.rtcp.octet_count = ntohl(sr->sender_info.oc)__bswap_32 (sr->sender_info.oc);
		packet_ssrc = sr->ssrc;
		/* Extracting LSR from NTP timestamp and save it */
		lsr = (ntohl(sr->sender_info.ntp_lsw)__bswap_32 (sr->sender_info.ntp_lsw)&0xffff0000)>>16 | (ntohl(sr->sender_info.ntp_msw)__bswap_32 (sr->sender_info.ntp_msw)&0x0000ffff)<<16; /* The middle 32 bits out of 64 in the NTP timestamp */
		rtp_session->stats.rtcp.last_recv_lsr_peer = htonl(lsr)__bswap_32 (lsr);  /* Save it include it in the next SR */
		rtp_session->stats.rtcp.last_recv_lsr_local = lsr_now;    /* Save it to calculate DLSR when generating next SR */
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6844, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3,"Received a SR with %d report blocks, " \
						  "length in words = %d, " \
						  "SSRC = 0x%X, " \
						  "NTP MSW = %u, " \
						  "NTP LSW = %u, " \
						  "RTP timestamp = %u, " \
						  "Sender Packet Count = %u, " \
						  "Sender Octet Count = %u\n",
						  msg->header.count,
						  ntohs((uint16_t)msg->header.length)__bswap_16 ((uint16_t)msg->header.length),
						  ntohl(sr->ssrc)__bswap_32 (sr->ssrc),
						  ntohl(sr->sender_info.ntp_msw)__bswap_32 (sr->sender_info.ntp_msw),
						  ntohl(sr->sender_info.ntp_lsw)__bswap_32 (sr->sender_info.ntp_lsw),
						  ntohl(sr->sender_info.ts)__bswap_32 (sr->sender_info.ts),
						  ntohl(sr->sender_info.pc)__bswap_32 (sr->sender_info.pc),
						  ntohl(sr->sender_info.oc)__bswap_32 (sr->sender_info.oc));


		rtp_session->rtcp_frame.ssrc = ntohl(sr->ssrc)__bswap_32 (sr->ssrc);
		rtp_session->rtcp_frame.packet_type = (uint16_t)rtp_session->rtcp_recv_msg_p->header.type;
		rtp_session->rtcp_frame.ntp_msw = ntohl(sr->sender_info.ntp_msw)__bswap_32 (sr->sender_info.ntp_msw);
		rtp_session->rtcp_frame.ntp_lsw = ntohl(sr->sender_info.ntp_lsw)__bswap_32 (sr->sender_info.ntp_lsw);
		rtp_session->rtcp_frame.timestamp = ntohl(sr->sender_info.ts)__bswap_32 (sr->sender_info.ts);
		rtp_session->rtcp_frame.packet_count =  ntohl(sr->sender_info.pc)__bswap_32 (sr->sender_info.pc);
		rtp_session->rtcp_frame.octect_count = ntohl(sr->sender_info.oc)__bswap_32 (sr->sender_info.oc);

		report = &sr->report_block;
	} else { /* Receiver report */
		struct switch_rtcp_receiver_report* rr = (struct switch_rtcp_receiver_report*)msg->body;
		packet_ssrc = rr->ssrc;
		//memset(&rtp_session->rtcp_frame, 0, sizeof(rtp_session->rtcp_frame));
		report = &rr->report_block;

		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6877, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3,"Received a RR with %d report blocks, " \
						  "length in words = %d, " \
						  "SSRC = 0x%X, ",
						  msg->header.count,
						  ntohs((uint16_t)msg->header.length)__bswap_16 ((uint16_t)msg->header.length),
						  ntohl(rr->ssrc)__bswap_32 (rr->ssrc));

	}
	

	for (i = 0; i < (int)msg->header.count && i < MAX_REPORT_BLOCKS5 ; i++) {
		uint32_t old_avg = rtp_session->rtcp_frame.reports[i].loss_avg;
		uint8_t percent_fraction = (uint8_t)((uint16_t/* prevent overflow when '* 100' */)(uint8_t)report->fraction * 100 / 255);
		if (!rtp_session->rtcp_frame.reports[i].loss_avg) {
			rtp_session->rtcp_frame.reports[i].loss_avg = percent_fraction;
		} else {
			rtp_session->rtcp_frame.reports[i].loss_avg = (uint32_t)(((float)rtp_session->rtcp_frame.reports[i].loss_avg * .7) +
																	 ((float)percent_fraction * .3));
		}

		rtp_session->rtcp_frame.reports[i].ssrc = ntohl(report->ssrc)__bswap_32 (report->ssrc);
		rtp_session->rtcp_frame.reports[i].fraction = (uint8_t)report->fraction;
6899#if SWITCH_BYTE_ORDER1234 == __BIG_ENDIAN4321
		rtp_session->rtcp_frame.reports[i].lost = report->lost; // signed 24bit will extended signess to int32_t automatically
6901#else
		rtp_session->rtcp_frame.reports[i].lost = ntohl(report->lost)__bswap_32 (report->lost)>>8; // signed 24bit casted to uint32_t need >>8 after ntohl()...
		rtp_session->rtcp_frame.reports[i].lost = rtp_session->rtcp_frame.reports[i].lost | ((rtp_session->rtcp_frame.reports[i].lost & 0x00800000) ? 0xff000000 : 0x00000000); // ...and signess compensation
6904#endif
		rtp_session->rtcp_frame.reports[i].highest_sequence_number_received = ntohl(report->highest_sequence_number_received)__bswap_32 (report->highest_sequence_number_received);
		rtp_session->rtcp_frame.reports[i].jitter = ntohl(report->jitter)__bswap_32 (report->jitter);
		rtp_session->rtcp_frame.reports[i].lsr = ntohl(report->lsr)__bswap_32 (report->lsr);
		rtp_session->rtcp_frame.reports[i].dlsr = ntohl(report->dlsr)__bswap_32 (report->dlsr);
		
		if (rtp_session->rtcp_frame.reports[i].lsr && !rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU]) {

			/* Calculating RTT = A - DLSR - LSR */
			rtt_now = ((double)(((int64_t)lsr_now) - rtp_session->rtcp_frame.reports[i].dlsr - rtp_session->rtcp_frame.reports[i].lsr))/65536;

			/* Only account RTT if it didn't overflow. */
			if (lsr_now > rtp_session->rtcp_frame.reports[i].dlsr + rtp_session->rtcp_frame.reports[i].lsr) {
6917#ifdef DEBUG_RTCP
				switch_time_exp_t now_hr;
				switch_time_exp_gmt(&now_hr,now);
				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6920, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3,
						"Receiving an RTCP packet\n[%04d-%02d-%02d %02d:%02d:%02d.%d] SSRC[0x%x]\n"
						"RTT[%f] = A[%u] - DLSR[%u] - LSR[%u]\n",
						1900 + now_hr.tm_year, now_hr.tm_mday, now_hr.tm_mon, now_hr.tm_hour, now_hr.tm_min, now_hr.tm_sec, now_hr.tm_usec,
						rtp_session->rtcp_frame.reports[i].ssrc, rtt_now,
						lsr_now, rtp_session->rtcp_frame.reports[i].dlsr, rtp_session->rtcp_frame.reports[i].lsr);
6926#endif 
				rtt_valid = 1;
				if (!rtp_session->rtcp_frame.reports[i].rtt_avg) {
					rtp_session->rtcp_frame.reports[i].rtt_avg = rtt_now;
				} else {
					rtp_session->rtcp_frame.reports[i].rtt_avg = (double)((rtp_session->rtcp_frame.reports[i].rtt_avg * .7) + (rtt_now * .3 ));
				}
			} else {
6934#ifdef DEBUG_RTCP
				switch_time_exp_t now_hr;
				switch_time_exp_gmt(&now_hr,now);
				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6937, (const char*)(rtp_session->session), SWITCH_LOG_WARNING,
						"Receiving RTCP packet\n[%04d-%02d-%02d %02d:%02d:%02d.%d] SSRC[0x%x]\n"
						"Ignoring erroneous RTT[%f] = A[%u] - DLSR[%u] - LSR[%u]\n",
						1900 + now_hr.tm_year, now_hr.tm_mday, now_hr.tm_mon, now_hr.tm_hour, now_hr.tm_min, now_hr.tm_sec, now_hr.tm_usec,
						rtp_session->rtcp_frame.reports[i].ssrc, rtt_now,
						lsr_now, rtp_session->rtcp_frame.reports[i].dlsr, rtp_session->rtcp_frame.reports[i].lsr);
6943#endif
				rtt_valid = 0;
				rtt_now = 0;
			}


			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6949, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "RTT average %f\n",
					rtp_session->rtcp_frame.reports[i].rtt_avg);
		}

		if (rtp_session->flags[SWITCH_RTP_FLAG_ADJ_BITRATE_CAP] && rtp_session->flags[SWITCH_RTP_FLAG_ESTIMATORS] && !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {

			/* SWITCH_RTP_FLAG_ADJ_BITRATE_CAP : Can the codec change its bitrate on the fly per API command ? */
6956#ifdef DEBUG_ESTIMATORS_
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6957, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "Current packet loss: [%d %%] Current RTT: [%f ms]\n", percent_fraction, rtt_now);
6958#endif

			if (rtt_valid) {

				switch_kalman_estimate(rtp_session->estimators[EST_RTT2], rtt_now, EST_RTT2);

				if (switch_kalman_cusum_detect_change(rtp_session->detectors[EST_RTT2], rtt_now, rtp_session->estimators[EST_RTT2]->val_estimate_last)) {
					/* sudden change in the mean value of RTT */
6966#ifdef DEBUG_ESTIMATORS_
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6967, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3,"Sudden change in the mean value of RTT !\n");
6968#endif
					rtt_increase = 1;
				}
			}

			switch_kalman_estimate(rtp_session->estimators[EST_LOSS0], percent_fraction, EST_LOSS0);

			if (switch_kalman_cusum_detect_change(rtp_session->detectors[EST_LOSS0], percent_fraction, rtp_session->estimators[EST_LOSS0]->val_estimate_last)){
				/* sudden change in the mean value of packet loss */
6977#ifdef DEBUG_ESTIMATORS_
				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6978, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3,"Sudden change in the mean value of packet loss!\n");
6979#endif
				packet_loss_increase = 1;
			}
6982#ifdef DEBUG_ESTIMATORS_
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6983, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "ESTIMATORS: Packet loss will be: [%f] RTT will be: [%f ms]\n",
							  rtp_session->estimators[EST_LOSS0]->val_estimate_last, rtp_session->estimators[EST_RTT2]->val_estimate_last);
6985#endif

			if (rtp_session->rtcp_frame.reports[i].loss_avg != old_avg) {
				/*getting bad*/
				if (switch_kalman_is_slow_link(rtp_session->estimators[EST_LOSS0],
											   rtp_session->estimators[EST_RTT2])) {
					/* going to minimum bitrate */
6992#ifdef DEBUG_ESTIMATORS_
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 6993, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "Slow link conditions: Loss average: [%d %%], Previous loss: [%d %%]. \
															Going to minimum bitrate!",rtp_session->rtcp_frame.reports[i].loss_avg, old_avg);
6995#endif
					switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
													SWITCH_IO_WRITE, SCC_AUDIO_ADJUST_BITRATE, SCCT_STRING, "minimum", SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));
					/* if after going to minimum bitrate we still have packet loss then we increase ptime. TODO */

				} else if (packet_loss_increase && (rtp_session->estimators[EST_LOSS0]->val_estimate_last >= 5)) {
					/* sudden change in the mean value of packet loss percentage */
					switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
													SWITCH_IO_WRITE, SCC_AUDIO_ADJUST_BITRATE,
													SCCT_STRING, "decrease",
													SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));
7006#ifdef DEBUG_ESTIMATORS_
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7007, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3,"Sudden change in the mean value of packet loss percentage !\n");
7008#endif
					switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
													SWITCH_IO_WRITE, SCC_AUDIO_PACKET_LOSS, SCCT_INT,
													(void *)&rtp_session->rtcp_frame.reports[i].loss_avg,
													SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

				} else if (rtt_valid && !rtt_increase && rtp_session->estimators[EST_LOSS0]->val_estimate_last >= rtp_session->rtcp_frame.reports[i].loss_avg ) {
					/* lossy because of congestion (queues full somewhere -> some packets are dropped , but RTT is good ), packet loss with many small gaps */
7016#ifdef DEBUG_ESTIMATORS_
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7017, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "packet loss, but RTT is not bad\n");
7018#endif
					switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
													SWITCH_IO_WRITE, SCC_AUDIO_PACKET_LOSS, SCCT_INT,
													(void *)&rtp_session->rtcp_frame.reports[i].loss_avg,
													SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

				} else if ((rtp_session->estimators[EST_LOSS0]->val_estimate_last < 1) && packet_loss_increase) {
7025#ifdef DEBUG_ESTIMATORS_
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7026, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "small packet loss average\n");
7027#endif
					/*small loss_avg*/
					switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
													SWITCH_IO_WRITE, SCC_AUDIO_ADJUST_BITRATE,
													SCCT_STRING, "default",
													SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

					switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
													SWITCH_IO_WRITE, SCC_AUDIO_PACKET_LOSS, SCCT_INT,
													(void *)&rtp_session->rtcp_frame.reports[i].loss_avg,
													SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

				} else if ((rtp_session->estimators[EST_LOSS0]->val_estimate_last < 5) &&
						   (rtp_session->rtcp_frame.reports[i].rtt_avg < rtp_session->estimators[EST_RTT2]->val_estimate_last))  {

					/* estimate that packet loss will decrease, we can increase the bitrate */
					switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
													SWITCH_IO_WRITE, SCC_AUDIO_ADJUST_BITRATE,
													SCCT_STRING, "increase",
													SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

					switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
													SWITCH_IO_WRITE, SCC_AUDIO_PACKET_LOSS, SCCT_INT,
													(void *)&rtp_session->rtcp_frame.reports[i].loss_avg,
													SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

				} else {
					/* *do nothing about bitrate, just pass the packet loss to the codec */
7055#ifdef DEBUG_ESTIMATORS_
					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7056, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3,"do nothing about bitrate, just pass the packet loss to the codec\n");
7057#endif
					switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
													SWITCH_IO_WRITE, SCC_AUDIO_PACKET_LOSS, SCCT_INT,
													(void *)&rtp_session->rtcp_frame.reports[i].loss_avg,
													SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));
				}
			}
		} else {
			if (!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->rtcp_frame.reports[i].loss_avg != old_avg) {
				switch_core_media_codec_control(rtp_session->session, SWITCH_MEDIA_TYPE_AUDIO,
												SWITCH_IO_WRITE, SCC_AUDIO_PACKET_LOSS, SCCT_INT,
												(void *)&rtp_session->rtcp_frame.reports[i].loss_avg,
												SCCT_NONE, NULL((void*)0), NULL((void*)0), NULL((void*)0));
			}
		}

		report++;
	}
	rtp_session->rtcp_frame.report_count = (uint16_t)i;
		




	rtp_session->rtcp_fresh_frame = 1;
	rtp_session->stats.rtcp.peer_ssrc = ntohl(packet_ssrc)__bswap_32 (packet_ssrc);
}
}

if (msg->header.type > 194 && msg->header.type < 255) {
status = SWITCH_STATUS_SUCCESS;
}

return status;
7091}


7094static switch_status_t process_rtcp_packet(switch_rtp_t *rtp_session, switch_size_t *bytes)
7095{
switch_size_t len;
switch_size_t remain = *bytes;
switch_status_t status = SWITCH_STATUS_FALSE;
rtcp_msg_t *msg = rtp_session->rtcp_recv_msg_p;

if (remain < sizeof(switch_rtcp_ext_hdr_t) || remain > sizeof(rtcp_msg_t)) {
return status;
}
if (msg->header.version != 2) {
if (msg->header.version == 0) {
	if (rtp_session->ice.ice_user) {
		handle_ice(rtp_session, &rtp_session->rtcp_ice, (void *) msg, *bytes);
	}
	return SWITCH_STATUS_SUCCESS;
} else {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7111, (const char*)(rtp_session->session),
					  SWITCH_LOG_WARNING, "Received an unsupported RTCP packet version %d\n", msg->header.version);
	return SWITCH_STATUS_FALSE;
}
}

do {
len = ((switch_size_t)ntohs(msg->header.length)__bswap_16 (msg->header.length) * 4) + 4;

if (msg->header.version != 2 || !(msg->header.type > 191 && msg->header.type < 210)) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7121, (const char*)(rtp_session->session), SWITCH_LOG_WARNING,
					  "INVALID RTCP PACKET TYPE %d VER %d LEN %" SWITCH_SIZE_T_FMT"ld" "\n", msg->header.type,
					  msg->header.version, len);
	status = SWITCH_STATUS_BREAK;
	break;
}

//switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_CRIT,
//"WTF BYTES %ld REMAIN %ld PACKET TYPE %d LEN %ld\n", *bytes, remain, msg->header.type, len);

if (len > remain) {
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7132, (const char*)(rtp_session->session), SWITCH_LOG_WARNING,
					  "RTCP INVALID LENGTH %" SWITCH_SIZE_T_FMT"ld" "\n", len);
	len = remain;
}

status = process_rtcp_report(rtp_session, msg, len);

if (remain > len) {
	unsigned char *p = (unsigned char *) msg;
	p += len;
	msg = (rtcp_msg_t *) p;
}

remain -= len;

} while (remain >= 4);

return status;
7150}

7152static switch_status_t read_rtcp_packet(switch_rtp_t *rtp_session, switch_size_t *bytes, switch_frame_flag_t *flags)
7153{
switch_status_t status = SWITCH_STATUS_FALSE;

if (!rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
return SWITCH_STATUS_FALSE;
}

switch_assert(bytes)((bytes) ? (void) (0) : __assert_fail ("bytes", "src/switch_rtp.c"
, 7160, __extension__ __PRETTY_FUNCTION__));

*bytes = sizeof(rtcp_msg_t);

if ((status = switch_socket_recvfrom(rtp_session->rtcp_from_addr, rtp_session->rtcp_sock_input, 0, (void *) rtp_session->rtcp_recv_msg_p, bytes))
!= SWITCH_STATUS_SUCCESS) {
*bytes = 0;
}

switch_mutex_lock(rtp_session->ice_mutex);
if (rtp_session->rtcp_dtls) {
char *b = (char *) rtp_session->rtcp_recv_msg_p;

if (*b == 0 || *b == 1) {
	if (rtp_session->rtcp_ice.ice_user) {
		handle_ice(rtp_session, &rtp_session->rtcp_ice, (void *) rtp_session->rtcp_recv_msg_p, *bytes);
	}
	*bytes = 0;
}

if (*bytes && (*b >= 20) && (*b <= 64)) {
	rtp_session->rtcp_dtls->bytes = *bytes;
	rtp_session->rtcp_dtls->data = (void *) rtp_session->rtcp_recv_msg_p;
} else {
	rtp_session->rtcp_dtls->bytes = 0;
	rtp_session->rtcp_dtls->data = NULL((void*)0);
}

do_dtls(rtp_session, rtp_session->rtcp_dtls);


if (rtp_session->rtcp_dtls->bytes) {
	*bytes = 0;
}
}

7196#ifdef ENABLE_SRTP1
if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && rtp_session->rtcp_recv_msg_p->header.version == 2) {
//if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV] && (!rtp_session->ice.ice_user || rtp_session->rtcp_recv_msg_p->header.version == 2)) {
int sbytes = (int) *bytes;
srtp_err_status_t stat = 0;


if (!rtp_session->flags[SWITCH_RTP_FLAG_SECURE_RECV_MKI]) {
	stat = srtp_unprotect_rtcp(rtp_session->recv_ctx[rtp_session->srtp_idx_rtcp], &rtp_session->rtcp_recv_msg_p->header, &sbytes);
} else {
	stat = srtp_unprotect_rtcp_mki(rtp_session->recv_ctx[rtp_session->srtp_idx_rtcp], &rtp_session->rtcp_recv_msg_p->header, &sbytes, 1);
}

if (stat) {
	//++rtp_session->srtp_errs[rtp_session->srtp_idx_rtp]++;
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7211, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "RTCP UNPROTECT ERR\n");
} else {
	//rtp_session->srtp_errs[rtp_session->srtp_idx_rtp] = 0;
}

*bytes = sbytes;

}
7219#endif

switch_mutex_unlock(rtp_session->ice_mutex);

7223#ifdef ENABLE_ZRTP
if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] && rtp_session->rtcp_recv_msg_p->header.version == 2) {
/* ZRTP Recv */
if (bytes) {
	unsigned int sbytes = (int) *bytes;
	zrtp_status_t stat = 0;

	stat = zrtp_process_srtcp(rtp_session->zrtp_stream, (void *) rtp_session->rtcp_recv_msg_p, &sbytes);

	switch (stat) {
	case zrtp_status_ok:
		*bytes = sbytes;
		break;
	case zrtp_status_drop:
		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 7237, ((void*)0), SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
		*bytes = 0;
		break;
	case zrtp_status_fail:
		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 7241, ((void*)0), SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
		*bytes = 0;
		break;
	default:
		break;
	}
}
}
7249#endif

/* RTCP Auto ADJ */
if (*bytes && rtp_session->flags[SWITCH_RTP_FLAG_RTCP_AUTOADJ] &&  switch_sockaddr_get_port(rtp_session->rtcp_from_addr)) {
	if (!switch_cmp_addr(rtp_session->rtcp_from_addr, rtp_session->rtcp_remote_addr)) {
		if (++rtp_session->rtcp_autoadj_tally >= rtp_session->rtcp_autoadj_threshold) {
			const char *err;
			uint32_t old = rtp_session->remote_rtcp_port;
			const char *tx_host;
			const char *old_host;
			char bufa[50], bufb[50];

			tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtcp_from_addr);
			old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->rtcp_remote_addr);

			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7264, (const char*)(rtp_session->session), SWITCH_LOG_INFO,
							  "Auto Changing %s RTCP port from %s:%u to %s:%u\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), old_host, old, tx_host,
							  switch_sockaddr_get_port(rtp_session->rtcp_from_addr));


			rtp_session->eff_remote_host_str = switch_core_strdup(rtp_session->pool, tx_host)switch_core_perform_strdup(rtp_session->pool, tx_host, "src/switch_rtp.c"
, (const char *)__func__, 7269);
			rtp_session->remote_rtcp_port = switch_sockaddr_get_port(rtp_session->rtcp_from_addr);
			status = enable_remote_rtcp_socket(rtp_session, &err);
			rtp_session->rtcp_auto_adj_used = 1;

			if ((rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST)) {
				switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_RTCP_AUTOADJ);
			} else {
				switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_RTCP_AUTOADJ);
			}
		}
	} else {

		if ((rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST)) {
			switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_RTCP_AUTOADJ);
		} else {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7285, (const char*)(rtp_session->session),
							  SWITCH_LOG_DEBUG, "Correct %s RTCP ip/port confirmed.\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
			switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_RTCP_AUTOADJ);
		}
		rtp_session->rtcp_auto_adj_used = 0;

	}
}

if (*bytes) {
return process_rtcp_packet(rtp_session, bytes);
}

return status;
7299}

7301static void check_timeout(switch_rtp_t *rtp_session)
7302{

switch_time_t now = switch_micro_time_now();
uint32_t elapsed = 0;

if (now >= rtp_session->last_media) {
elapsed = (now - rtp_session->last_media) / 1000;
}

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7311, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG10,
			  "%s MEDIA TIMEOUT %s %d/%d", switch_core_session_get_name(rtp_session->session)switch_channel_get_name(switch_core_session_get_channel(rtp_session
->session)), rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"),
			  elapsed, rtp_session->media_timeout);

if (elapsed > rtp_session->media_timeout) {

if (rtp_session->session) {
	switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);

	switch_channel_execute_on(channel, "execute_on_media_timeout");
	switch_channel_hangup(channel, SWITCH_CAUSE_MEDIA_TIMEOUT)switch_channel_perform_hangup(channel, "src/switch_rtp.c", (const
 char *)__func__, 7321, SWITCH_CAUSE_MEDIA_TIMEOUT);
}
}
7324}

7326static int rtp_common_read(switch_rtp_t *rtp_session, switch_payload_t *payload_type,
				   payload_map_t **pmapP, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
7328{

switch_channel_t *channel = NULL((void*)0);
switch_size_t bytes = 0;
switch_size_t rtcp_bytes = 0;
switch_status_t status = SWITCH_STATUS_SUCCESS, poll_status = SWITCH_STATUS_SUCCESS;
switch_status_t rtcp_status = SWITCH_STATUS_SUCCESS, rtcp_poll_status = SWITCH_STATUS_SUCCESS;
int check = 0;
int ret = -1;
int sleep_mss = 1000;
int poll_sec = 5;
int poll_loop = 0;
int fdr = 0;
int rtcp_fdr = 0;
int hot_socket = 0;
int read_loops = 0;
int slept = 0;
switch_bool_t got_jb = SWITCH_FALSE;

if (!switch_rtp_ready(rtp_session)) {
return -1;
}

if (rtp_session->session) {
channel = switch_core_session_get_channel(rtp_session->session);
}

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
sleep_mss = rtp_session->timer.interval * 1000;
}

READ_INC(rtp_session)switch_mutex_lock(rtp_session->read_mutex); rtp_session->
reading++;



while (switch_rtp_ready(rtp_session)) {
int do_cng = 0;
int read_pretriggered = 0;
int has_rtcp = 0;
int got_rtp_poll = 0;

bytes = 0;

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] &&
	!rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] &&
	!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] &&
	!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
	rtp_session->read_pollfd) {

	if (rtp_session->jb && !rtp_session->pause_jb && jb_valid(rtp_session)) {
		while (switch_poll(rtp_session->read_pollfd, 1, &fdr, 0) == SWITCH_STATUS_SUCCESS) {
			status = read_rtp_packet(rtp_session, &bytes, flags, pmapP, SWITCH_STATUS_SUCCESS, SWITCH_FALSE);

			if (status == SWITCH_STATUS_GENERR) {
				ret = -1;
				goto end;
			}

			if ((*flags & SFF_RTCP)) {
				*flags &= ~SFF_RTCP;
				has_rtcp = 1;
				read_pretriggered = 0;
				goto rtcp;
			}

			if (status == SWITCH_STATUS_BREAK) {
				read_pretriggered = 1;
				break;
			}
		}

	} else if ((rtp_session->flags[SWITCH_RTP_FLAG_AUTOFLUSH] || rtp_session->flags[SWITCH_RTP_FLAG_STICKY_FLUSH])) {

		if (switch_poll(rtp_session->read_pollfd, 1, &fdr, 0) == SWITCH_STATUS_SUCCESS) {
			status = read_rtp_packet(rtp_session, &bytes, flags, pmapP, SWITCH_STATUS_SUCCESS, SWITCH_FALSE);
			if (status == SWITCH_STATUS_GENERR) {
				ret = -1;
				goto end;
			}
			if ((*flags & SFF_RTCP)) {
				*flags &= ~SFF_RTCP;
				has_rtcp = 1;
				read_pretriggered = 0;
				goto rtcp;
			}

			/* switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Initial (%i) %d\n", status, bytes); */
			if (status != SWITCH_STATUS_FALSE) {
				read_pretriggered = 1;
			}

			if (bytes) {
				if (switch_poll(rtp_session->read_pollfd, 1, &fdr, 0) == SWITCH_STATUS_SUCCESS) {
					rtp_session->hot_hits++;//+= rtp_session->samples_per_interval;

					switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7423, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG10, "%s Hot Hit %d\n",
									  rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-",
									  rtp_session->hot_hits);
				} else {
					rtp_session->hot_hits = 0;
				}
			}

			if (rtp_session->hot_hits > 1 && !rtp_session->sync_packets) {// >= (rtp_session->samples_per_second * 30)) {
				hot_socket = 1;
			}
		} else {
			rtp_session->hot_hits = 0;
		}
	}

	if (rtp_session->flags[SWITCH_RTP_FLAG_TEXT]) {
		///NOOP
	} else if (hot_socket && (rtp_session->hot_hits % 10) != 0) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7442, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG10, "%s timer while HOT\n", rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-");
		switch_core_timer_next(&rtp_session->timer);
	} else if (hot_socket) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7445, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG10, "%s skip timer once\n", rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-");
		rtp_session->sync_packets++;
		switch_core_timer_sync(&rtp_session->timer);
		reset_jitter_seq(rtp_session);
	} else {

		if (rtp_session->sync_packets) {

			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7453, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG10,
							  "%s Auto-Flush catching up %d packets (%d)ms.\n",
							  rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-",
							  rtp_session->sync_packets, (rtp_session->ms_per_packet * rtp_session->sync_packets) / 1000);
			if (!rtp_session->flags[SWITCH_RTP_FLAG_PAUSE]) {
				switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7458, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "%s syncing %d %s packet(s)\n",
								 rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-",
								  rtp_session->sync_packets, rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));

				rtp_session->bad_stream++;
				rtp_session->stats.inbound.flaws += rtp_session->sync_packets;

				if (rtp_session->stats.inbound.error_log) {
					rtp_session->stats.inbound.error_log->flaws += rtp_session->sync_packets;
				}
			}

			switch_core_timer_sync(&rtp_session->timer);
			reset_jitter_seq(rtp_session);
			rtp_session->hot_hits = 0;
		} else {
			if (slept) {
				switch_cond_next();
			} else {
				if (rtp_session->skip_timer) {
					rtp_session->skip_timer = 0;
					switch_cond_next();
				} else {
					switch_core_timer_next(&rtp_session->timer);
				}
				slept++;
			}

		}

		rtp_session->sync_packets = 0;
	}
}

rtp_session->stats.read_count++;

recvfrom:

if (!read_pretriggered) {
	bytes = 0;
}
read_loops++;
//poll_loop = 0;

if (!switch_rtp_ready(rtp_session)) {
	break;
}

if (!rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->read_pollfd) {
	int pt = poll_sec * 1000000;

	do_2833(rtp_session);

	if (rtp_session->dtmf_data.out_digit_dur > 0 || rtp_session->dtmf_data.in_digit_sanity || rtp_session->sending_dtmf ||
		switch_queue_size(rtp_session->dtmf_data.dtmf_queue) || switch_queue_size(rtp_session->dtmf_data.dtmf_inqueue)) {
		pt = 20000;
	}

	if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
		pt = 100000;
	}

	if (rtp_session->vb && !rtp_session->pause_jb) {
		if (switch_jb_poll(rtp_session->vb)) {
			pt = 1000;
		}
	}

	if ((io_flags & SWITCH_IO_FLAG_NOBLOCK)) {
		pt = 0;
	}

	poll_status = switch_poll(rtp_session->read_pollfd, 1, &fdr, pt);

	if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && poll_status != SWITCH_STATUS_SUCCESS && rtp_session->media_timeout && rtp_session->last_media) {
		check_timeout(rtp_session);
	}

	if (!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->dtmf_data.out_digit_dur > 0) {
		return_cng_frame()do_cng = 1; goto timer_check;
	}

	if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->flags[SWITCH_RTP_FLAG_BREAK]) {
		switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_BREAK);
		bytes = 0;
		reset_jitter_seq(rtp_session);
		return_cng_frame()do_cng = 1; goto timer_check;
	}

}

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
	got_jb = (rtp_session->vb && !rtp_session->pause_jb && switch_jb_poll(rtp_session->vb));
} else {
	got_jb = SWITCH_TRUE;
}

if (poll_status == SWITCH_STATUS_SUCCESS || got_jb) {

	got_rtp_poll = 1;

	if (read_pretriggered) {
		read_pretriggered = 0;
	} else {
		
		
		status = read_rtp_packet(rtp_session, &bytes, flags, pmapP, poll_status, got_jb);

		if (status == SWITCH_STATUS_GENERR) {
			ret = -1;
			goto end;
		}

		if (rtp_session->max_missed_packets && read_loops == 1 && !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] &&
			!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
			if (bytes && status == SWITCH_STATUS_SUCCESS) {
				rtp_session->missed_count = 0;
			} else {
				if (rtp_session->media_timeout && rtp_session->last_media) {
					check_timeout(rtp_session);
				} else {
					if (++rtp_session->missed_count >= rtp_session->max_missed_packets) {
						ret = -2;
						goto end;
					}
				}
			}
		}

		if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
			//switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_CRIT, "Read bytes (%i) %ld\n", status, bytes);

			if (bytes == 0) {
				if (check_rtcp_and_ice(rtp_session) == -1) {
					ret = -1;
					goto end;
				}
				// This is dumb
				//switch_rtp_video_refresh(rtp_session);
				goto  rtcp;
			}
		}

		if ((*flags & SFF_PROXY_PACKET)) {
			ret = (int) bytes;
			goto end;
		}

		if ((*flags & SFF_RTCP)) {
			*flags &= ~SFF_RTCP;
			has_rtcp = 1;
			goto rtcp;
		}


	}
	poll_loop = 0;
} else {

	if (!switch_rtp_ready(rtp_session)) {
		ret = -1;
		goto end;
	}

	if (!SWITCH_STATUS_IS_BREAK(poll_status)(poll_status == SWITCH_STATUS_BREAK || poll_status == 730035 ||
 poll_status == 35 || poll_status == SWITCH_STATUS_INTR) && poll_status != SWITCH_STATUS_TIMEOUT) {
		char tmp[128] = "";
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7624, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Poll failed with error: %d [%s]\n",
						  poll_status, switch_strerror_r(poll_status, tmp, sizeof(tmp)));
		ret = -1;
		goto end;
	}

	if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] && !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
		rtp_session->missed_count += (poll_sec * 1000) / (rtp_session->ms_per_packet ? rtp_session->ms_per_packet / 1000 : 20);
		bytes = 0;

		if (rtp_session->media_timeout && rtp_session->last_media) {
			check_timeout(rtp_session);
		} else if (rtp_session->max_missed_packets) {
			if (rtp_session->missed_count >= rtp_session->max_missed_packets) {
				ret = -2;
				goto end;
			}
		}
	}


	if (check_rtcp_and_ice(rtp_session) == -1) {
		ret = -1;
		goto end;
	}


	if ((!(io_flags & SWITCH_IO_FLAG_NOBLOCK)) &&
		(rtp_session->dtmf_data.out_digit_dur == 0) && !rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
		return_cng_frame()do_cng = 1; goto timer_check;
	}
}

rtcp:

if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
	rtcp_poll_status = SWITCH_STATUS_FALSE;

	if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX] && has_rtcp) {
		if (rtp_session->rtcp_recv_msg_p->header.version == 2) { //rtcp muxed
			rtp_session->rtcp_from_addr = rtp_session->from_addr;
			rtcp_status = rtcp_poll_status = SWITCH_STATUS_SUCCESS;
			rtcp_bytes = bytes;
		}

		has_rtcp = 0;

	} else if (rtp_session->rtcp_read_pollfd) {
		rtcp_poll_status = switch_poll(rtp_session->rtcp_read_pollfd, 1, &rtcp_fdr, 0);
	}

	if (rtcp_poll_status == SWITCH_STATUS_SUCCESS) {

		if (!rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
			rtcp_status = read_rtcp_packet(rtp_session, &rtcp_bytes, flags);
		}

		if (rtcp_status == SWITCH_STATUS_SUCCESS) {
			switch_rtp_reset_media_timer(rtp_session);
			
			if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_PASSTHRU]) {
				switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);
				const char *uuid = switch_channel_get_partner_uuid(channel);

				if (uuid) {
					switch_core_session_t *other_session;
					switch_rtp_t *other_rtp_session = NULL((void*)0);

					if ((other_session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_rtp.c", (
const char *)__func__, 7692))) {
						switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
						if ((other_rtp_session = switch_channel_get_private(other_channel, "__rtcp_audio_rtp_session")) &&
							other_rtp_session->rtcp_sock_output &&
							switch_rtp_test_flag(other_rtp_session, SWITCH_RTP_FLAG_ENABLE_RTCP)) {
							other_rtp_session->rtcp_send_msg = rtp_session->rtcp_recv_msg;

7699#ifdef ENABLE_SRTP1
							switch_mutex_lock(other_rtp_session->ice_mutex);
							if (switch_rtp_test_flag(other_rtp_session, SWITCH_RTP_FLAG_SECURE_SEND)) {
								int stat = 0;
								int sbytes = (int) rtcp_bytes;
								
								if (!other_rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_MKI]) {
									stat = srtp_protect_rtcp(other_rtp_session->send_ctx[rtp_session->srtp_idx_rtcp], &other_rtp_session->rtcp_send_msg.header, &sbytes);
								} else {
									stat = srtp_protect_rtcp_mki(other_rtp_session->send_ctx[other_rtp_session->srtp_idx_rtcp], &other_rtp_session->rtcp_send_msg.header, &sbytes, 1, SWITCH_CRYPTO_MKI_INDEX0);
								}

								if (stat) {
									switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7712, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error: SRTP RTCP protection failed with code %d\n", stat);
								}
								rtcp_bytes = sbytes;
							}
							switch_mutex_unlock(other_rtp_session->ice_mutex);
7717#endif

7719#ifdef ENABLE_ZRTP
							/* ZRTP Send */
							if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
								unsigned int sbytes = (unsigned int) bytes;
								zrtp_status_t stat = zrtp_status_fail;

								stat = zrtp_process_rtcp(other_rtp_session->zrtp_stream, (void *) &other_rtp_session->rtcp_send_msg, &sbytes);

								switch (stat) {
								case zrtp_status_ok:
									break;
								case zrtp_status_drop:
									switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7731, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
									ret = (int) bytes;
									goto end;
									break;
								case zrtp_status_fail:
									switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7736, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
									break;
								default:
									break;
								}

								bytes = sbytes;
							}
7744#endif
							if (switch_socket_sendto(other_rtp_session->rtcp_sock_output, other_rtp_session->rtcp_remote_addr, 0,
													 (const char*)&other_rtp_session->rtcp_send_msg, &rtcp_bytes ) != SWITCH_STATUS_SUCCESS) {
								switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7747, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG,"RTCP packet not written\n");
							}


						}
						switch_core_session_rwunlock(other_session);
					}
				}

			}

			if (rtp_session->flags[SWITCH_RTP_FLAG_RTCP_MUX]) {
				process_rtcp_packet(rtp_session, &rtcp_bytes);
				ret = 1;

				if (!rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && rtp_session->timer.interval && !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
					switch_core_timer_sync(&rtp_session->timer);
					reset_jitter_seq(rtp_session);
				}
				goto recvfrom;
			}
		}
	}
}

if ((!(io_flags & SWITCH_IO_FLAG_NOBLOCK)) &&
	(rtp_session->dtmf_data.out_digit_dur == 0) && !got_rtp_poll) {
	return_cng_frame()do_cng = 1; goto timer_check;
}

if (!bytes && (io_flags & SWITCH_IO_FLAG_NOBLOCK)) {
	rtp_session->missed_count = 0;
	ret = 0;
	goto end;
}

check = !bytes;

if (rtp_session->flags[SWITCH_RTP_FLAG_FLUSH]) {
	bytes = do_flush(rtp_session, SWITCH_FALSE, bytes);
	switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_FLUSH);
}

if ((!bytes && rtp_session->flags[SWITCH_RTP_FLAG_BREAK]) || (bytes && bytes == 4 && *((int *) &rtp_session->recv_msg) == UINT_MAX(2147483647 *2U +1U))) {
	switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_BREAK);

	if (!rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK] || !rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] ||
		rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] ||
		(bytes && bytes < 5) || (!bytes && poll_loop)) {
		bytes = 0;
		reset_jitter_seq(rtp_session);
		return_cng_frame()do_cng = 1; goto timer_check;
	}
}

if (bytes && bytes < 5) {
	continue;
}

if (!bytes && poll_loop) {
	goto recvfrom;
}

if (bytes && rtp_session->last_rtp_hdr.m && rtp_session->last_rtp_hdr.pt != rtp_session->recv_te &&
	!rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] &&
	!rtp_session->flags[SWITCH_RTP_FLAG_TEXT] &&
	!(rtp_session->rtp_bugs & RTP_BUG_IGNORE_MARK_BIT)) {
	rtp_flush_read_buffer(rtp_session, SWITCH_RTP_FLUSH_ONCE);
}

if (rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt || rtp_session->last_rtp_hdr.pt == 13) {
	*flags |= SFF_NOT_AUDIO;
} else {
	*flags &= ~SFF_NOT_AUDIO; /* If this flag was already set, make sure to remove it when we get real audio */
}

/* ignore packets not meant for us unless the auto-adjust window is open (ice mode has its own alternatives to this) */
if (!using_ice(rtp_session) && bytes) {
	if (rtp_session->flags[SWITCH_RTP_FLAG_AUTOADJ]) {
		if (rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt || rtp_session->last_rtp_hdr.pt == 13) {
			goto recvfrom;

		}
	} else if (!(rtp_session->rtp_bugs & RTP_BUG_ACCEPT_ANY_PACKETS) && !switch_cmp_addr(rtp_session->rtp_from_addr, rtp_session->remote_addr)) {
		goto recvfrom;
	}
}

if (bytes && rtp_session->flags[SWITCH_RTP_FLAG_AUTOADJ] && switch_sockaddr_get_port(rtp_session->rtp_from_addr)) {
	if (!switch_cmp_addr(rtp_session->rtp_from_addr, rtp_session->remote_addr)) {
		if (++rtp_session->autoadj_tally >= rtp_session->autoadj_threshold) {
			const char *err;
			uint32_t old = rtp_session->remote_port;
			const char *tx_host;
			const char *old_host;
			char bufa[50], bufb[50];
			char adj_port[6];

			tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtp_from_addr);
			old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);

			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7848, (const char*)(rtp_session->session), SWITCH_LOG_INFO,
							  "Auto Changing %s port from %s:%u to %s:%u\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), old_host, old, tx_host,
							  switch_sockaddr_get_port(rtp_session->rtp_from_addr));

			if (channel) {
				char varname[80] = "";

				switch_snprintf(varname, sizeof(varname), "remote_%s_ip_reported", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
				switch_channel_set_variable(channel, varname, switch_channel_get_variable(channel, "remote_media_ip"))switch_channel_set_variable_var_check(channel, varname, switch_channel_get_variable_dup
(channel, "remote_media_ip", SWITCH_TRUE, -1), SWITCH_TRUE);

				switch_snprintf(varname, sizeof(varname), "remote_%s_ip", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
				switch_channel_set_variable(channel, varname, tx_host)switch_channel_set_variable_var_check(channel, varname, tx_host
, SWITCH_TRUE);

				switch_snprintf(varname, sizeof(varname), "remote_%s_port_reported", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
				switch_snprintf(adj_port, sizeof(adj_port), "%u", switch_sockaddr_get_port(rtp_session->rtp_from_addr));
				switch_channel_set_variable(channel, varname, switch_channel_get_variable(channel, "remote_media_port"))switch_channel_set_variable_var_check(channel, varname, switch_channel_get_variable_dup
(channel, "remote_media_port", SWITCH_TRUE, -1), SWITCH_TRUE);

				switch_snprintf(varname, sizeof(varname), "remote_%s_port", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
				switch_channel_set_variable(channel, varname, adj_port)switch_channel_set_variable_var_check(channel, varname, adj_port
, SWITCH_TRUE);

				switch_snprintf(varname, sizeof(varname), "rtp_auto_adjust_%s", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
				switch_channel_set_variable(channel, varname, "true")switch_channel_set_variable_var_check(channel, varname, "true"
, SWITCH_TRUE);
			}
			rtp_session->auto_adj_used = 1;
			switch_rtp_set_remote_address(rtp_session, tx_host, switch_sockaddr_get_port(rtp_session->rtp_from_addr), 0, SWITCH_FALSE, &err);
			if ((rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST)) {
				switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
				switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_RTCP_AUTOADJ);
			} else {
				switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
			}
			if (rtp_session->ice.ice_user) {
				rtp_session->ice.addr = rtp_session->remote_addr;
			}
		}
	} else {
		if ((rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST)) {
			switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
			switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_RTCP_AUTOADJ);
		} else {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7888, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "Correct %s ip/port confirmed.\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
			switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
		}
		rtp_session->auto_adj_used = 0;
	}
}

if (bytes && !(rtp_session->rtp_bugs & RTP_BUG_ALWAYS_AUTO_ADJUST) && rtp_session->autoadj_window) {
	if (--rtp_session->autoadj_window == 0) {
		switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
	}
}

if (rtp_session->flags[SWITCH_RTP_FLAG_TEXT]) {
	if (!bytes) {
		if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
			switch_core_timer_next(&rtp_session->timer);
		}
		return_cng_frame()do_cng = 1; goto timer_check;
	} else {
		*payload_type = rtp_session->last_rtp_hdr.pt;
		ret = (int) bytes;
		goto end;
	}
}

if (bytes && (rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL])) {
	/* Fast PASS! */
	*flags |= SFF_PROXY_PACKET;

	if (rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
7919#if 0
		if (rtp_session->has_rtp && check_recv_payload(rtp_session)) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7921, (const char*)(rtp_session->session), SWITCH_LOG_WARNING,
							  "Ignoring udptl packet of size of %ld bytes that looks strikingly like a RTP packet.\n", (long)bytes);
			bytes = 0;
			goto do_continue;
		}
7926#endif
		*flags |= SFF_UDPTL_PACKET;
	}

	ret = (int) bytes;
	goto end;
}

if (bytes) {
	rtp_session->missed_count = 0;

	if (bytes < rtp_header_len12) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 7938, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "Ignoring invalid RTP packet size of %ld bytes.\n", (long)bytes);
		bytes = 0;
		goto do_continue;
	}

	if (rtp_session->last_rtp_hdr.pt && (rtp_session->last_rtp_hdr.pt == rtp_session->cng_pt || rtp_session->last_rtp_hdr.pt == 13)) {
		return_cng_frame()do_cng = 1; goto timer_check;
	}
}

if (check || bytes) {
	do_2833(rtp_session);
}

if (bytes && rtp_session->recv_msg.header.version != 2) {
	uint8_t *data = (uint8_t *) RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body);

	//if (rtp_session->recv_msg.header.version == 0) {
	//	if (rtp_session->ice.ice_user) {
	//		handle_ice(rtp_session, &rtp_session->ice, (void *) &rtp_session->recv_msg, bytes);
	//		goto recvfrom;
	//	}
	//}

	if (rtp_session->invalid_handler) {
		rtp_session->invalid_handler(rtp_session, rtp_session->sock_input, (void *) &rtp_session->recv_msg, bytes, rtp_session->rtp_from_addr);
	}

	memset(data, 0, 2);
	data[0] = 65;

	rtp_session->last_rtp_hdr.pt = rtp_session->cng_pt != INVALID_PT ? rtp_session->cng_pt : SWITCH_RTP_CNG_PAYLOAD13;
	*flags |= SFF_CNG;
	*payload_type = (switch_payload_t) rtp_session->last_rtp_hdr.pt;
	ret = 2 + rtp_header_len12;
	goto end;
} else if (bytes) {
	rtp_session->stats.inbound.period_packet_count++;
}


/* Handle incoming RFC2833 packets */
switch (handle_rfc2833(rtp_session, bytes, &do_cng)) {
case RESULT_GOTO_END:
	goto end;
case RESULT_GOTO_RECVFROM:
	goto recvfrom;
case RESULT_GOTO_TIMERCHECK:
	goto timer_check;
case RESULT_CONTINUE:
	status = SWITCH_STATUS_SUCCESS;
	goto result_continue;
}

result_continue:
timer_check:

if (!rtp_session->media_timeout && rtp_session->flags[SWITCH_RTP_FLAG_MUTE]) {
	do_cng++;
}

if (do_cng) {
	uint8_t *data = (uint8_t *) RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body);

	do_2833(rtp_session);

	if (rtp_session->last_cng_ts == rtp_session->last_read_ts + rtp_session->samples_per_interval) {
		rtp_session->last_cng_ts = 0;
	} else {
		rtp_session->last_cng_ts = rtp_session->last_read_ts + rtp_session->samples_per_interval;
	}

	memset(data, 0, 2);
	data[0] = 65;
	rtp_session->last_rtp_hdr.pt = rtp_session->cng_pt != INVALID_PT ? rtp_session->cng_pt : SWITCH_RTP_CNG_PAYLOAD13;
	*flags |= SFF_CNG;
	*payload_type = (switch_payload_t) rtp_session->last_rtp_hdr.pt;
	ret = 2 + rtp_header_len12;
	rtp_session->stats.inbound.skip_packet_count++;
	goto end;
}


if (check || (bytes && !rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER])) {
	if (!bytes && rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {	/* We're late! We're Late! */
		if (!rtp_session->flags[SWITCH_RTP_FLAG_NOBLOCK] && status == SWITCH_STATUS_BREAK) {
			switch_cond_next();
			continue;
		}



		if (!rtp_session->flags[SWITCH_RTP_FLAG_PAUSE] && !rtp_session->flags[SWITCH_RTP_FLAG_DTMF_ON] && !rtp_session->dtmf_data.in_digit_ts
			&& rtp_session->cng_count > (rtp_session->one_second * 2) && rtp_session->jitter_lead > JITTER_LEAD_FRAMES10) {

			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8033, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, "%s %s timeout\n",
							  rtp_session_name(rtp_session)rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel
(rtp_session->session)) : "-", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));

			if (rtp_session->media_timeout && rtp_session->last_media) {
				check_timeout(rtp_session);
			}

			if (rtp_session->stats.inbound.error_log) {
				rtp_session->stats.inbound.error_log->flaws++;
			}
			rtp_session->stats.inbound.flaws++;
			do_mos(rtp_session);
		}

		rtp_session->cng_count++;
		return_cng_frame()do_cng = 1; goto timer_check;
	}
}

rtp_session->cng_count = 0;

if (status == SWITCH_STATUS_BREAK || bytes == 0) {
	if (!(io_flags & SWITCH_IO_FLAG_SINGLE_READ) && rtp_session->flags[SWITCH_RTP_FLAG_DATAWAIT]) {
		goto do_continue;
	}
	return_cng_frame()do_cng = 1; goto timer_check;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_GOOGLEHACK] && rtp_session->last_rtp_hdr.pt == 102) {
	rtp_session->last_rtp_hdr.pt = 97;
}

break;

do_continue:

if (!bytes && !rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] && !switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO)) {

	if (sleep_mss) {
		switch_yield(sleep_mss)switch_sleep(sleep_mss);;
	}
}

}

if (switch_rtp_ready(rtp_session)) {
*payload_type = (switch_payload_t) rtp_session->last_rtp_hdr.pt;

if (*payload_type == SWITCH_RTP_CNG_PAYLOAD13) {
	*flags |= SFF_CNG;
}

ret = (int) bytes;
} else {
ret = -1;
}

end:

READ_DEC(rtp_session)rtp_session->reading--; switch_mutex_unlock(rtp_session->
read_mutex);

return ret;
8095}


8098SWITCH_DECLARE(switch_byte_t)__attribute__((visibility("default"))) switch_byte_t switch_rtp_check_auto_adj(switch_rtp_t *rtp_session)
8099{
return rtp_session->auto_adj_used;
8101}

8103SWITCH_DECLARE(switch_size_t)__attribute__((visibility("default"))) switch_size_t switch_rtp_has_dtmf(switch_rtp_t *rtp_session)
8104{
switch_size_t has = 0;

if (switch_rtp_ready(rtp_session)) {
switch_mutex_lock(rtp_session->dtmf_data.dtmf_mutex);
has = switch_queue_size(rtp_session->dtmf_data.dtmf_inqueue);
switch_mutex_unlock(rtp_session->dtmf_data.dtmf_mutex);
}

return has;
8114}

8116SWITCH_DECLARE(switch_size_t)__attribute__((visibility("default"))) switch_size_t switch_rtp_dequeue_dtmf(switch_rtp_t *rtp_session, switch_dtmf_t *dtmf)
8117{
switch_size_t bytes = 0;
switch_dtmf_t *_dtmf = NULL((void*)0);
void *pop;

if (!switch_rtp_ready(rtp_session)) {
return bytes;
}

switch_mutex_lock(rtp_session->dtmf_data.dtmf_mutex);
if (switch_queue_trypop(rtp_session->dtmf_data.dtmf_inqueue, &pop) == SWITCH_STATUS_SUCCESS) {

_dtmf = (switch_dtmf_t *)pop;
*dtmf = *_dtmf;
/* Only log DTMF buffer if sensitive_dtmf channel variable not set to true */
if (!(switch_channel_var_true(switch_core_session_get_channel(rtp_session->session), SWITCH_SENSITIVE_DTMF_VARIABLE"sensitive_dtmf"))) {			
	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8133, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG,"RTP RECV DTMF %c:%d\n", dtmf->digit, dtmf->duration);
}
bytes++;
free(pop);
}
switch_mutex_unlock(rtp_session->dtmf_data.dtmf_mutex);

return bytes;
8141}

8143SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_queue_rfc2833(switch_rtp_t *rtp_session, const switch_dtmf_t *dtmf)
8144{

switch_dtmf_t *rdigit;

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

if ((rdigit = malloc(sizeof(*rdigit))) != 0) {
*rdigit = *dtmf;
if (rdigit->duration < switch_core_min_dtmf_duration(0)) {
	rdigit->duration = switch_core_min_dtmf_duration(0);
}

if ((switch_queue_trypush(rtp_session->dtmf_data.dtmf_queue, rdigit)) != SWITCH_STATUS_SUCCESS) {
	free(rdigit);
	return SWITCH_STATUS_FALSE;
}
} else {
abort();
}

return SWITCH_STATUS_SUCCESS;
8167}

8169SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_queue_rfc2833_in(switch_rtp_t *rtp_session, const switch_dtmf_t *dtmf)
8170{
switch_dtmf_t *rdigit;

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

if ((rdigit = malloc(sizeof(*rdigit))) != 0) {
*rdigit = *dtmf;
if (rdigit->duration < switch_core_min_dtmf_duration(0)) {
	rdigit->duration = switch_core_min_dtmf_duration(0);
}

if ((switch_queue_trypush(rtp_session->dtmf_data.dtmf_inqueue, rdigit)) != SWITCH_STATUS_SUCCESS) {
	free(rdigit);
	return SWITCH_STATUS_FALSE;
}
} else {
abort();
}

return SWITCH_STATUS_SUCCESS;
8192}

8194SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_read(switch_rtp_t *rtp_session, void *data, uint32_t *datalen,
										switch_payload_t *payload_type, switch_frame_flag_t *flags, switch_io_flag_t io_flags)
8196{
int bytes = 0;

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

bytes = rtp_common_read(rtp_session, payload_type, NULL((void*)0), flags, io_flags);

if (bytes < 0) {
*datalen = 0;
return bytes == -2 ? SWITCH_STATUS_TIMEOUT : SWITCH_STATUS_GENERR;
} else if (bytes == 0) {
*datalen = 0;
return SWITCH_STATUS_BREAK;
} else {
if (bytes > rtp_header_len12) {
	bytes -= rtp_header_len12;
}
}

*datalen = bytes;

memcpy(data, RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body), bytes);

return SWITCH_STATUS_SUCCESS;
8222}

8224SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtcp_zerocopy_read_frame(switch_rtp_t *rtp_session, switch_rtcp_frame_t *frame)
8225{

if (!rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
return SWITCH_STATUS_FALSE;
}

/* A fresh frame has been found! */
if (rtp_session->rtcp_fresh_frame) {
/* turn the flag off! */
rtp_session->rtcp_fresh_frame = 0;

*frame = rtp_session->rtcp_frame;

return SWITCH_STATUS_SUCCESS;
}

return SWITCH_STATUS_TIMEOUT;
8242}

8244SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_zerocopy_read_frame(switch_rtp_t *rtp_session, switch_frame_t *frame, switch_io_flag_t io_flags)
8245{
int bytes = 0;

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

bytes = rtp_common_read(rtp_session, &frame->payload, &frame->pmap, &frame->flags, io_flags);

frame->data = RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body);

if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] && (bytes < rtp_header_len12 || switch_test_flag(frame, SFF_CNG)((frame)->flags & SFF_CNG))) {
frame->packet = NULL((void*)0);
frame->timestamp = 0;
frame->seq = 0;
frame->ssrc = 0;
frame->m = 0;
} else {

frame->packet = &rtp_session->recv_msg;
frame->packetlen = bytes;
frame->source = __FILE__"src/switch_rtp.c";

switch_set_flag(frame, SFF_RAW_RTP)(frame)->flags |= (SFF_RAW_RTP);
switch_set_flag(frame, SFF_EXTERNAL)(frame)->flags |= (SFF_EXTERNAL);
if (frame->payload == rtp_session->recv_te) {
	switch_set_flag(frame, SFF_RFC2833)(frame)->flags |= (SFF_RFC2833);
}
frame->timestamp = ntohl(rtp_session->last_rtp_hdr.ts)__bswap_32 (rtp_session->last_rtp_hdr.ts);
frame->seq = (uint16_t) ntohs((uint16_t) rtp_session->last_rtp_hdr.seq)__bswap_16 ((uint16_t) rtp_session->last_rtp_hdr.seq);
frame->ssrc = ntohl(rtp_session->last_rtp_hdr.ssrc)__bswap_32 (rtp_session->last_rtp_hdr.ssrc);
frame->m = rtp_session->last_rtp_hdr.m ? SWITCH_TRUE : SWITCH_FALSE;
}

8279#ifdef ENABLE_ZRTP
if (zrtp_on && rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV]) {
zrtp_session_info_t zrtp_session_info;

if (rtp_session->zrtp_session && (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info))) {
	if (zrtp_session_info.sas_is_ready) {

		switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);

		const char *uuid = switch_channel_get_partner_uuid(channel);
		if (uuid) {
			switch_core_session_t *other_session;

			if ((other_session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_rtp.c", (
const char *)__func__, 8292))) {
				switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
				switch_rtp_t *other_rtp_session = switch_channel_get_private(other_channel, "__zrtp_audio_rtp_session");

				if (other_rtp_session) {
					if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND) {
						switch_mutex_lock(other_rtp_session->read_mutex);
						if (zrtp_status_ok == zrtp_session_get(other_rtp_session->zrtp_session, &zrtp_session_info)) {
							if (rtp_session->zrtp_mitm_tries > ZRTP_MITM_TRIES) {
								switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
								switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
								rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
								rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
							} else if (zrtp_status_ok == zrtp_resolve_mitm_call(other_rtp_session->zrtp_stream, rtp_session->zrtp_stream)) {
								rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
								rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
								switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
								switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
								rtp_session->zrtp_mitm_tries++;
							}
						}
						switch_mutex_unlock(other_rtp_session->read_mutex);
					}
				}

				switch_core_session_rwunlock(other_session);
			}
		}
	}
} else {
	rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
	rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
}
}
8326#endif

if (bytes < 0) {
frame->datalen = 0;
return bytes == -2 ? SWITCH_STATUS_TIMEOUT : SWITCH_STATUS_GENERR;
} else if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
if (bytes < rtp_header_len12) {
	frame->datalen = 0;
	return SWITCH_STATUS_BREAK;
} else {
	bytes -= rtp_header_len12;
}
}

frame->datalen = bytes;
return SWITCH_STATUS_SUCCESS;
8342}

8344SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_zerocopy_read(switch_rtp_t *rtp_session,
												 void **data, uint32_t *datalen, switch_payload_t *payload_type, switch_frame_flag_t *flags,
												 switch_io_flag_t io_flags)
8347{
int bytes = 0;

if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

bytes = rtp_common_read(rtp_session, payload_type, NULL((void*)0), flags, io_flags);
*data = RTP_BODY(rtp_session)(char *) (rtp_session->recv_msg.ebody ? rtp_session->recv_msg
.ebody : rtp_session->recv_msg.body);

if (bytes < 0) {
*datalen = 0;
return SWITCH_STATUS_GENERR;
} else {
if (bytes > rtp_header_len12) {
	bytes -= rtp_header_len12;
}
}

*datalen = bytes;
return SWITCH_STATUS_SUCCESS;
8368}

8370static int rtp_write_ready(switch_rtp_t *rtp_session, uint32_t bytes, int line)
8371{
if (!rtp_session) return 0;

if (rtp_session->ice.ice_user && !(rtp_session->ice.rready || rtp_session->ice.ready)) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8375, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "Skip sending %s packet %ld bytes (ice not ready @ line %d!)\n",
				  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), (long)bytes, line);
return 0;
}

if (rtp_session->dtls && rtp_session->dtls->state != DS_READY) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8381, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG3, "Skip sending %s packet %ld bytes (dtls not ready @ line %d!)\n",
				  rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), (long)bytes, line);
return 0;
}

return 1;
8387}


8390static int rtp_common_write(switch_rtp_t *rtp_session,
					rtp_msg_t *send_msg, void *data, uint32_t datalen, switch_payload_t payload, uint32_t timestamp, switch_frame_flag_t *flags)
8392{
switch_size_t bytes;
uint8_t send = 1;
uint32_t this_ts = 0;
int ret;
switch_time_t now;
uint8_t m = 0;

if (!switch_rtp_ready(rtp_session)) {
1
Assuming the condition is false→
2
←
Taking false branch→
return -1;
}

if (!rtp_write_ready(rtp_session, datalen, __LINE__8404)) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
return 0;
}

WRITE_INC(rtp_session)switch_mutex_lock(rtp_session->write_mutex); rtp_session->
writing++;

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
5
←
Assuming the condition is false→
6
←
Taking false branch→
//switch_core_timer_sync(&rtp_session->write_timer);
}

if (send_msg) {
7
←
Assuming 'send_msg' is non-null→
8
←
Taking true branch→
bytes = datalen;

m = (uint8_t) send_msg->header.m;
rtp_session->ts = ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts);

if (flags && *flags & SFF_RFC2833) {
9
←
Assuming 'flags' is null→
	if (rtp_session->te == INVALID_PT) {
		ret = 0;
		goto end;
	}
	send_msg->header.pt = rtp_session->te;
}
data = send_msg->body;
if (datalen > rtp_header_len12) {
10
←
Assuming 'datalen' is <= rtp_header_len→
11
←
Taking false branch→
	datalen -= rtp_header_len12;
}
} else {
if (*flags & SFF_RFC2833) {
	if (rtp_session->te == INVALID_PT) {
		ret = 0;
		goto end;
	}
	payload = rtp_session->te;
}

send_msg = &rtp_session->send_msg;
send_msg->header.pt = payload;

m = get_next_write_ts(rtp_session, timestamp);

rtp_session->send_msg.header.ts = htonl(rtp_session->ts)__bswap_32 (rtp_session->ts);

memcpy(send_msg->body, data, datalen);
bytes = datalen + rtp_header_len12;
}

if (!switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO)) {
12
←
Assuming the condition is false→
13
←
Taking false branch→

if ((rtp_session->rtp_bugs & RTP_BUG_NEVER_SEND_MARKER)) {
	m = 0;
} else {
	int delta = rtp_session->ts - rtp_session->last_write_ts;

	if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] &&
		((!rtp_session->flags[SWITCH_RTP_FLAG_RESET] && (abs(delta) > rtp_session->samples_per_interval * 10))
		|| rtp_session->ts == rtp_session->samples_per_interval)) {
		m++;
	}

	if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
		//switch_core_timer_sync(&rtp_session->write_timer);
	}

	if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] &&
		(rtp_session->write_timer.samplecount - rtp_session->last_write_samplecount) > rtp_session->samples_per_interval * 10) {
		m++;
	}

	if (!rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER] &&
		((unsigned) ((switch_micro_time_now() - rtp_session->last_write_timestamp))) > (rtp_session->ms_per_packet * 10)) {
		m++;
	}

	if (rtp_session->cn && payload != rtp_session->cng_pt) {
		rtp_session->cn = 0;
		m++;
	}

	if (rtp_session->need_mark && !rtp_session->sending_dtmf) {
		m++;
		rtp_session->need_mark = 0;
	}
}

if (m) {
	rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 1;
	rtp_session->ts = 0;
}

/* If the marker was set, and the timestamp seems to have started over - set a new SSRC, to indicate this is a new stream */
if (m && !switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND) && (rtp_session->rtp_bugs & RTP_BUG_CHANGE_SSRC_ON_MARKER) &&
	(rtp_session->flags[SWITCH_RTP_FLAG_RESET] || (rtp_session->ts <= rtp_session->last_write_ts && rtp_session->last_write_ts > 0))) {
	switch_rtp_set_ssrc(rtp_session, (uint32_t) ((intptr_t) rtp_session + (uint32_t) switch_epoch_time_now(NULL((void*)0))));
}

if (!switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO) && !switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_UDPTL)) {
	send_msg->header.m = (m && !(rtp_session->rtp_bugs & RTP_BUG_NEVER_SEND_MARKER)) ? 1 : 0;
}
}

if (switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO)) {
14
←
Taking true branch→
int external = (*flags & SFF_EXTERNAL);
15
←
Dereference of null pointer (loaded from variable 'flags')
/* Normalize the timestamps to our own base by generating a made up starting point then adding the measured deltas to that base
   so if the timestamps and ssrc of the source change, it will not break the other end's jitter bufffer / decoder etc *cough* CHROME *cough*
 */

if (!rtp_session->ts_norm.ts) {
	rtp_session->ts_norm.ts = (uint32_t) rand() % 1000000 + 1;
}

if (!rtp_session->ts_norm.last_ssrc || send_msg->header.ssrc != rtp_session->ts_norm.last_ssrc || rtp_session->ts_norm.last_external != external) {
	switch_core_session_t *other_session;
	
	switch_core_session_request_video_refresh(rtp_session->session)_switch_core_session_request_video_refresh(rtp_session->session
, 0, "src/switch_rtp.c", (const char *)__func__, 8518);
	switch_core_media_gen_key_frame(rtp_session->session)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 8519, (const char*)(rtp_session->
session), SWITCH_LOG_DEBUG1, "%s Send KeyFrame\n", switch_channel_get_name
(switch_core_session_get_channel(rtp_session->session))); switch_core_media_codec_control
(rtp_session->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_IO_WRITE
, SCC_VIDEO_GEN_KEYFRAME, SCCT_NONE, ((void*)0), SCCT_NONE, (
(void*)0), ((void*)0), ((void*)0));

	if (switch_core_session_get_partner(rtp_session->session, &other_session)switch_core_session_perform_get_partner(rtp_session->session
, &other_session, "src/switch_rtp.c", (const char *)__func__
, 8521) == SWITCH_STATUS_SUCCESS) {
		switch_core_session_request_video_refresh(other_session)_switch_core_session_request_video_refresh(other_session, 0, "src/switch_rtp.c"
, (const char *)__func__, 8522);
		switch_core_media_gen_key_frame(other_session)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 8523, (const char*)(other_session),
 SWITCH_LOG_DEBUG1, "%s Send KeyFrame\n", switch_channel_get_name
(switch_core_session_get_channel(other_session))); switch_core_media_codec_control
(other_session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_IO_WRITE, SCC_VIDEO_GEN_KEYFRAME
, SCCT_NONE, ((void*)0), SCCT_NONE, ((void*)0), ((void*)0), (
(void*)0));
		switch_core_session_rwunlock(other_session);
	}

	if (rtp_session->ts_norm.last_ssrc) {
		rtp_session->ts_norm.delta_ttl = 0;
		rtp_session->ts_norm.ts++;
	}

	rtp_session->ts_norm.last_ssrc = send_msg->header.ssrc;
	rtp_session->ts_norm.last_frame = ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts);
}

rtp_session->ts_norm.last_external = external;

if (ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts) != rtp_session->ts_norm.last_frame) {
	int32_t delta = ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts) - rtp_session->ts_norm.last_frame;

	if (delta < 0 || delta > 90000) {
		switch_core_media_gen_key_frame(rtp_session->session)switch_log_printf(SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c"
, (const char *)__func__, 8542, (const char*)(rtp_session->
session), SWITCH_LOG_DEBUG1, "%s Send KeyFrame\n", switch_channel_get_name
(switch_core_session_get_channel(rtp_session->session))); switch_core_media_codec_control
(rtp_session->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_IO_WRITE
, SCC_VIDEO_GEN_KEYFRAME, SCCT_NONE, ((void*)0), SCCT_NONE, (
(void*)0), ((void*)0), ((void*)0));
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8543, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG1, 
						  "Timestamp shift detected last: %d this: %d delta: %d stick with prev delta: %d\n", 
						  rtp_session->ts_norm.last_frame, ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts), delta, rtp_session->ts_norm.delta);
	} else {
		rtp_session->ts_norm.delta = delta;
	}

	rtp_session->ts_norm.ts += rtp_session->ts_norm.delta;

}

rtp_session->ts_norm.last_frame = ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts);
send_msg->header.ts = htonl(rtp_session->ts_norm.ts)__bswap_32 (rtp_session->ts_norm.ts);
this_ts = rtp_session->ts_norm.ts;
}

send_msg->header.ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);

if (rtp_session->flags[SWITCH_RTP_FLAG_GOOGLEHACK] && rtp_session->send_msg.header.pt == 97) {
rtp_session->last_rtp_hdr.pt = 102;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_VAD] &&
rtp_session->last_rtp_hdr.pt == rtp_session->vad_data.read_codec->implementation->ianacode) {

int16_t decoded[SWITCH_RECOMMENDED_BUFFER_SIZE8192 / sizeof(int16_t)] = { 0 };
uint32_t rate = 0;
uint32_t codec_flags = 0;
uint32_t len = sizeof(decoded);
time_t now = switch_epoch_time_now(NULL((void*)0));
send = 0;

if (rtp_session->vad_data.scan_freq && rtp_session->vad_data.next_scan <= now) {
	rtp_session->vad_data.bg_count = rtp_session->vad_data.bg_level = 0;
	rtp_session->vad_data.next_scan = now + rtp_session->vad_data.scan_freq;
}

if (switch_core_codec_decode(&rtp_session->vad_data.vad_codec,
							 rtp_session->vad_data.read_codec,
							 data,
							 datalen,
							 rtp_session->vad_data.read_codec->implementation->actual_samples_per_second,
							 decoded, &len, &rate, &codec_flags) == SWITCH_STATUS_SUCCESS) {

	uint32_t energy = 0;
	uint32_t x, y = 0, z = len / sizeof(int16_t);
	uint32_t score = 0;
	int divisor = 0;
	if (z) {

		if (!(divisor = rtp_session->vad_data.read_codec->implementation->actual_samples_per_second / 8000)) {
			divisor = 1;
		}

		for (x = 0; x < z; x++) {
			energy += abs(decoded[y]);
			y += rtp_session->vad_data.read_codec->implementation->number_of_channels;
		}

		if (++rtp_session->vad_data.start_count < rtp_session->vad_data.start) {
			send = 1;
		} else {
			score = (energy / (z / divisor));
			if (score && (rtp_session->vad_data.bg_count < rtp_session->vad_data.bg_len)) {
				rtp_session->vad_data.bg_level += score;
				if (++rtp_session->vad_data.bg_count == rtp_session->vad_data.bg_len) {
					rtp_session->vad_data.bg_level /= rtp_session->vad_data.bg_len;
				}
				send = 1;
			} else {
				if (score > rtp_session->vad_data.bg_level && !switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)((&rtp_session->vad_data)->flags & SWITCH_VAD_FLAG_TALKING
)) {
					uint32_t diff = score - rtp_session->vad_data.bg_level;

					if (rtp_session->vad_data.hangover_hits) {
						rtp_session->vad_data.hangover_hits--;
					}

					if (diff >= rtp_session->vad_data.diff_level || ++rtp_session->vad_data.hangunder_hits >= rtp_session->vad_data.hangunder) {

						switch_set_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)(&rtp_session->vad_data)->flags |= (SWITCH_VAD_FLAG_TALKING
);

						rtp_session->vad_data.start_talking = switch_micro_time_now();

						if (!(rtp_session->rtp_bugs & RTP_BUG_NEVER_SEND_MARKER)) {
							send_msg->header.m = 1;
						}
						rtp_session->vad_data.hangover_hits = rtp_session->vad_data.hangunder_hits = rtp_session->vad_data.cng_count = 0;
						if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_TALK)((&rtp_session->vad_data)->flags & SWITCH_VAD_FLAG_EVENTS_TALK
)) {

							if ((rtp_session->vad_data.fire_events & VAD_FIRE_TALK)) {
								switch_event_t *event;
								if (switch_event_create(&event, SWITCH_EVENT_TALK)switch_event_create_subclass_detailed("src/switch_rtp.c", (const
 char * )(const char *)__func__, 8634, &event, SWITCH_EVENT_TALK
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
									switch_channel_event_set_data(switch_core_session_get_channel(rtp_session->vad_data.session), event);
									switch_event_fire(&event)switch_event_fire_detailed("src/switch_rtp.c", (const char * )
(const char *)__func__, 8636, &event, ((void*)0));
								}
							}
						}
					}
				} else {
					if (rtp_session->vad_data.hangunder_hits) {
						rtp_session->vad_data.hangunder_hits--;
					}
					if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)((&rtp_session->vad_data)->flags & SWITCH_VAD_FLAG_TALKING
)) {
						if (++rtp_session->vad_data.hangover_hits >= rtp_session->vad_data.hangover) {
							rtp_session->vad_data.stop_talking = switch_micro_time_now();
							rtp_session->vad_data.total_talk_time += (rtp_session->vad_data.stop_talking - rtp_session->vad_data.start_talking);

							switch_clear_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)(&rtp_session->vad_data)->flags &= ~(SWITCH_VAD_FLAG_TALKING
);

							rtp_session->vad_data.hangover_hits = rtp_session->vad_data.hangunder_hits = rtp_session->vad_data.cng_count = 0;
							if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_EVENTS_NOTALK)((&rtp_session->vad_data)->flags & SWITCH_VAD_FLAG_EVENTS_NOTALK
)) {

								if ((rtp_session->vad_data.fire_events & VAD_FIRE_NOT_TALK)) {
									switch_event_t *event;
									if (switch_event_create(&event, SWITCH_EVENT_NOTALK)switch_event_create_subclass_detailed("src/switch_rtp.c", (const
 char * )(const char *)__func__, 8657, &event, SWITCH_EVENT_NOTALK
, ((void*)0)) == SWITCH_STATUS_SUCCESS) {
										switch_channel_event_set_data(switch_core_session_get_channel(rtp_session->vad_data.session), event);
										switch_event_fire(&event)switch_event_fire_detailed("src/switch_rtp.c", (const char * )
(const char *)__func__, 8659, &event, ((void*)0));
									}
								}
							}
						}
					}
				}
			}
		}

		if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)((&rtp_session->vad_data)->flags & SWITCH_VAD_FLAG_TALKING
)) {
			send = 1;
		}
	}
} else {
	ret = -1;
	goto end;
}
}

if (!switch_rtp_test_flag(rtp_session, SWITCH_RTP_FLAG_VIDEO)) {
uint32_t ts_delta;

this_ts = ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts);

ts_delta = abs((int32_t)(this_ts - rtp_session->last_write_ts));

if (ts_delta > rtp_session->samples_per_second * 2) {
	rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 1;
}
8689#ifdef DEBUG_TS_ROLLOVER
switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 8690, ((void*)0), SWITCH_LOG_ERROR, "WRITE TS LAST:%u THIS:%u DELTA:%u\n", rtp_session->last_write_ts, this_ts, ts_delta);
8691#endif
if ((!(flags && *flags & SFF_RFC2833) && ts_delta == 0) || !switch_rtp_ready(rtp_session) || rtp_session->sending_dtmf) {
	send = 0;
}
}

if (rtp_session->flags[SWITCH_RTP_FLAG_PAUSE]) {
send = 0;
}

if (send) {
int delta = 1;

if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && (*flags & SFF_EXTERNAL) && 
	rtp_session->stats.outbound.packet_count && rtp_session->flags[SWITCH_RTP_FLAG_PASSTHRU]) {
	int32_t x = rtp_session->last_write_seq;
	int32_t y = ntohs(send_msg->header.seq)__bswap_16 (send_msg->header.seq);

	if (!rtp_session->video_delta_mode) {
		rtp_session->video_delta_mode = 1;
	} else {
		if (x > UINT16_MAX(65535) / 2 && y < UINT16_MAX(65535) / 2) {
			x -= (int32_t)UINT16_MAX(65535)+1;
		}
	
		delta = y-x;
	}
	
	rtp_session->last_write_seq = y;
}

if (!rtp_session->flags[SWITCH_RTP_FLAG_PASSTHRU]) {
	rtp_session->video_delta_mode = 0;
}

rtp_session->seq += delta;

send_msg->header.seq = htons(rtp_session->seq)__bswap_16 (rtp_session->seq);

if (rtp_session->flags[SWITCH_RTP_FLAG_BYTESWAP] && send_msg->header.pt == rtp_session->payload) {
	switch_swap_linear((int16_t *)send_msg->body, (int) datalen);
}

8734#ifdef ENABLE_SRTP1
switch_mutex_lock(rtp_session->ice_mutex);
if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {
	int sbytes = (int) bytes;
	srtp_err_status_t stat;


	if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_RESET] || !rtp_session->send_ctx[rtp_session->srtp_idx_rtp]) {

		switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND_RESET);
		srtp_dealloc(rtp_session->send_ctx[rtp_session->srtp_idx_rtp]);
		rtp_session->send_ctx[rtp_session->srtp_idx_rtp] = NULL((void*)0);
		if ((stat = srtp_create(&rtp_session->send_ctx[rtp_session->srtp_idx_rtp],
								&rtp_session->send_policy[rtp_session->srtp_idx_rtp])) || !rtp_session->send_ctx[rtp_session->srtp_idx_rtp]) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8748, (const char*)(rtp_session->session), SWITCH_LOG_ERROR,
							  "Error! RE-Activating %s Secure RTP SEND\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
			rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 0;
			ret = -1;
			switch_mutex_unlock(rtp_session->ice_mutex);
			goto end;
		} else {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8755, (const char*)(rtp_session->session), SWITCH_LOG_INFO,
							  "RE-Activating %s Secure RTP SEND\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"));
		}
	}

	if (!rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_MKI]) {
		stat = srtp_protect(rtp_session->send_ctx[rtp_session->srtp_idx_rtp], &send_msg->header, &sbytes);
	} else {
		stat = srtp_protect_mki(rtp_session->send_ctx[rtp_session->srtp_idx_rtp], &send_msg->header, &sbytes, 1, SWITCH_CRYPTO_MKI_INDEX0);
	}

	if (stat) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8767, (const char*)(rtp_session->session), SWITCH_LOG_ERROR,
						  "Error: %s SRTP protection failed with code %d\n", rtp_type(rtp_session)rtp_session->flags[SWITCH_RTP_FLAG_TEXT] ? "text" : (rtp_session
->flags[SWITCH_RTP_FLAG_VIDEO] ? "video" : "audio"), stat);
	}

	bytes = sbytes;
}
switch_mutex_unlock(rtp_session->ice_mutex);
8774#endif
8775#ifdef ENABLE_ZRTP
/* ZRTP Send */
if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
	unsigned int sbytes = (int) bytes;
	zrtp_status_t stat = zrtp_status_fail;


	stat = zrtp_process_rtp(rtp_session->zrtp_stream, (void *) send_msg, &sbytes);

	switch (stat) {
	case zrtp_status_ok:
		break;
	case zrtp_status_drop:
		/* switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session), SWITCH_LOG_DEBUG, "Error: zRTP protection drop with code %d\n", stat); */
		ret = (int) bytes;
		goto end;
		break;
	case zrtp_status_fail:
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8793, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
		break;
	default:
		break;
	}

	bytes = sbytes;
}
8801#endif

now = switch_micro_time_now();
8804#ifdef RTP_DEBUG_WRITE_DELTA
{
	int delta = (int) (now - rtp_session->send_time) / 1000;
	switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 8807, ((void*)0), SWITCH_LOG_ERROR, "WRITE %d delta %d\n", (int) bytes, delta);
}
8809#endif
rtp_session->send_time = now;

if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
	const char *tx_host;
	const char *old_host;
	const char *my_host;

	char bufa[50], bufb[50], bufc[50];


	tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtp_from_addr);
	old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
	my_host = switch_get_addr(bufc, sizeof(bufc), rtp_session->local_addr);

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session)SWITCH_CHANNEL_ID_LOG_CLEAN, "src/switch_rtp.c", (const char *
)__func__, 8824, switch_core_session_get_uuid((rtp_session->
session)), SWITCH_LOG_CONSOLE,
					  "W %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
					  rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName",
					  (long) bytes,
					  my_host, switch_sockaddr_get_port(rtp_session->local_addr),
					  old_host, rtp_session->remote_port,
					  tx_host, switch_sockaddr_get_port(rtp_session->rtp_from_addr),
					  send_msg->header.pt, ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts), ntohs(send_msg->header.seq)__bswap_16 (send_msg->header.seq), send_msg->header.m);

}

if (rtp_session->flags[SWITCH_RTP_FLAG_NACK]) {
	switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);

	if (!rtp_session->vbw) {
		int nack_size = 100;
		const char *var;
		
		if ((var = switch_channel_get_variable(channel, "rtp_nack_buffer_size")switch_channel_get_variable_dup(channel, "rtp_nack_buffer_size"
, SWITCH_TRUE, -1))) {
			int tmp = atoi(var);
			
			if (tmp > 0 && tmp < 500) {
				nack_size = tmp;
			}
		}

		switch_jb_create(&rtp_session->vbw, SJB_VIDEO, nack_size, nack_size, rtp_session->pool);

		if (rtp_session->vbw) {
			switch_jb_set_flag(rtp_session->vbw, SJB_QUEUE_ONLY);
			//switch_jb_debug_level(rtp_session->vbw, 10);
		}
	}
	switch_jb_put_packet(rtp_session->vbw, (switch_rtp_packet_t *)send_msg, bytes);
}

8860#ifdef RTP_WRITE_PLOSS
{
	int r = (rand() % 10000) + 1;

	if (r <= 200) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8865, (const char*)(rtp_session->session), SWITCH_LOG_ALERT,
						  "Simulate dropping packet ......... ts: %u seq: %u\n", ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts), ntohs(send_msg->header.seq)__bswap_16 (send_msg->header.seq));
	} else {
		if (switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, (void *) send_msg, &bytes) != SWITCH_STATUS_SUCCESS) {
			rtp_session->seq--;
			ret = -1;
			goto end;
		}
	}
}
8875#else
//if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
//
//	rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_READ]++;
//
//	//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "SEND %u\n", ntohs(send_msg->header.seq));
//}
if (switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, (void *) send_msg, &bytes) != SWITCH_STATUS_SUCCESS) {
	rtp_session->seq -= delta;

	ret = -1;
	goto end;
}
8888#endif
rtp_session->last_write_ts = this_ts;
rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 0;

if (rtp_session->queue_delay) {
	rtp_session->delay_samples = rtp_session->queue_delay;
	rtp_session->queue_delay = 0;
}

rtp_session->stats.outbound.raw_bytes += bytes;
rtp_session->stats.outbound.packet_count++;

if (rtp_session->flags[SWITCH_RTP_FLAG_ENABLE_RTCP]) {
	rtp_session->stats.rtcp.sent_pkt_count++;
}

if (send_msg->header.pt == rtp_session->cng_pt) {
	rtp_session->stats.outbound.cng_packet_count++;
} else {
	rtp_session->stats.outbound.media_packet_count++;
	rtp_session->stats.outbound.media_bytes += bytes;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_USE_TIMER]) {
	//switch_core_timer_sync(&rtp_session->write_timer);
	rtp_session->last_write_samplecount = rtp_session->write_timer.samplecount;
}

rtp_session->last_write_timestamp = switch_micro_time_now();
}

ret = (int) bytes;

end:

WRITE_DEC(rtp_session)rtp_session->writing--; switch_mutex_unlock(rtp_session->
write_mutex);

return ret;
8926}

8928SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_disable_vad(switch_rtp_t *rtp_session)
8929{

if (!rtp_session) {
return SWITCH_STATUS_FALSE;
}

if (!rtp_session->flags[SWITCH_RTP_FLAG_VAD]) {
return SWITCH_STATUS_GENERR;
}
switch_core_codec_destroy(&rtp_session->vad_data.vad_codec);
switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_VAD);
return SWITCH_STATUS_SUCCESS;
8941}

8943SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_enable_vad(switch_rtp_t *rtp_session, switch_core_session_t *session, switch_codec_t *codec,
											  switch_vad_flag_t flags)
8945{
if (!switch_rtp_ready(rtp_session)) {
return SWITCH_STATUS_FALSE;
}

if (rtp_session->flags[SWITCH_RTP_FLAG_VAD]) {
return SWITCH_STATUS_GENERR;
}

memset(&rtp_session->vad_data, 0, sizeof(rtp_session->vad_data));

if (switch_true(switch_channel_get_variable(switch_core_session_get_channel(rtp_session->session), "fire_talk_events")switch_channel_get_variable_dup(switch_core_session_get_channel
(rtp_session->session), "fire_talk_events", SWITCH_TRUE, -
1))) {
rtp_session->vad_data.fire_events |= VAD_FIRE_TALK;
}

if (switch_true(switch_channel_get_variable(switch_core_session_get_channel(rtp_session->session), "fire_not_talk_events")switch_channel_get_variable_dup(switch_core_session_get_channel
(rtp_session->session), "fire_not_talk_events", SWITCH_TRUE
, -1))) {
rtp_session->vad_data.fire_events |= VAD_FIRE_NOT_TALK;
}


if (switch_core_codec_init(&rtp_session->vad_data.vad_codec,switch_core_codec_init_with_bitrate(&rtp_session->vad_data
.vad_codec, codec->implementation->iananame, codec->
implementation->modname, ((void*)0), codec->implementation
->samples_per_second, codec->implementation->microseconds_per_packet
 / 1000, codec->implementation->number_of_channels, 0, SWITCH_CODEC_FLAG_ENCODE
 | SWITCH_CODEC_FLAG_DECODE, ((void*)0), rtp_session->pool
)
					   codec->implementation->iananame,switch_core_codec_init_with_bitrate(&rtp_session->vad_data
.vad_codec, codec->implementation->iananame, codec->
implementation->modname, ((void*)0), codec->implementation
->samples_per_second, codec->implementation->microseconds_per_packet
 / 1000, codec->implementation->number_of_channels, 0, SWITCH_CODEC_FLAG_ENCODE
 | SWITCH_CODEC_FLAG_DECODE, ((void*)0), rtp_session->pool
)
					   codec->implementation->modname,switch_core_codec_init_with_bitrate(&rtp_session->vad_data
.vad_codec, codec->implementation->iananame, codec->
implementation->modname, ((void*)0), codec->implementation
->samples_per_second, codec->implementation->microseconds_per_packet
 / 1000, codec->implementation->number_of_channels, 0, SWITCH_CODEC_FLAG_ENCODE
 | SWITCH_CODEC_FLAG_DECODE, ((void*)0), rtp_session->pool
)
					   NULL,switch_core_codec_init_with_bitrate(&rtp_session->vad_data
.vad_codec, codec->implementation->iananame, codec->
implementation->modname, ((void*)0), codec->implementation
->samples_per_second, codec->implementation->microseconds_per_packet
 / 1000, codec->implementation->number_of_channels, 0, SWITCH_CODEC_FLAG_ENCODE
 | SWITCH_CODEC_FLAG_DECODE, ((void*)0), rtp_session->pool
)
					   codec->implementation->samples_per_second,switch_core_codec_init_with_bitrate(&rtp_session->vad_data
.vad_codec, codec->implementation->iananame, codec->
implementation->modname, ((void*)0), codec->implementation
->samples_per_second, codec->implementation->microseconds_per_packet
 / 1000, codec->implementation->number_of_channels, 0, SWITCH_CODEC_FLAG_ENCODE
 | SWITCH_CODEC_FLAG_DECODE, ((void*)0), rtp_session->pool
)
					   codec->implementation->microseconds_per_packet / 1000,switch_core_codec_init_with_bitrate(&rtp_session->vad_data
.vad_codec, codec->implementation->iananame, codec->
implementation->modname, ((void*)0), codec->implementation
->samples_per_second, codec->implementation->microseconds_per_packet
 / 1000, codec->implementation->number_of_channels, 0, SWITCH_CODEC_FLAG_ENCODE
 | SWITCH_CODEC_FLAG_DECODE, ((void*)0), rtp_session->pool
)
					   codec->implementation->number_of_channels,switch_core_codec_init_with_bitrate(&rtp_session->vad_data
.vad_codec, codec->implementation->iananame, codec->
implementation->modname, ((void*)0), codec->implementation
->samples_per_second, codec->implementation->microseconds_per_packet
 / 1000, codec->implementation->number_of_channels, 0, SWITCH_CODEC_FLAG_ENCODE
 | SWITCH_CODEC_FLAG_DECODE, ((void*)0), rtp_session->pool
)
					   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, rtp_session->pool)switch_core_codec_init_with_bitrate(&rtp_session->vad_data
.vad_codec, codec->implementation->iananame, codec->
implementation->modname, ((void*)0), codec->implementation
->samples_per_second, codec->implementation->microseconds_per_packet
 / 1000, codec->implementation->number_of_channels, 0, SWITCH_CODEC_FLAG_ENCODE
 | SWITCH_CODEC_FLAG_DECODE, ((void*)0), rtp_session->pool
) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8973, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Can't load codec?\n");
return SWITCH_STATUS_FALSE;
}
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 8976, (const char*)(rtp_session->session), SWITCH_LOG_DEBUG, "Activate VAD codec %s %dms\n", codec->implementation->iananame,
			  codec->implementation->microseconds_per_packet / 1000);
rtp_session->vad_data.diff_level = 400;
rtp_session->vad_data.hangunder = 15;
rtp_session->vad_data.hangover = 40;
rtp_session->vad_data.bg_len = 5;
rtp_session->vad_data.bg_count = 5;
rtp_session->vad_data.bg_level = 300;
rtp_session->vad_data.read_codec = codec;
rtp_session->vad_data.session = session;
rtp_session->vad_data.flags = flags;
rtp_session->vad_data.cng_freq = 50;
rtp_session->vad_data.ts = 1;
rtp_session->vad_data.start = 0;
rtp_session->vad_data.next_scan = switch_epoch_time_now(NULL((void*)0));
rtp_session->vad_data.scan_freq = 0;
if (switch_test_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_TALKING)((&rtp_session->vad_data)->flags & SWITCH_VAD_FLAG_TALKING
)) {
rtp_session->vad_data.start_talking = switch_micro_time_now();
}
switch_rtp_set_flag(rtp_session, SWITCH_RTP_FLAG_VAD);
switch_set_flag(&rtp_session->vad_data, SWITCH_VAD_FLAG_CNG)(&rtp_session->vad_data)->flags |= (SWITCH_VAD_FLAG_CNG
);
return SWITCH_STATUS_SUCCESS;
8998}

9000SWITCH_DECLARE(int)__attribute__((visibility("default"))) int switch_rtp_write_frame(switch_rtp_t *rtp_session, switch_frame_t *frame)
9001{
uint8_t fwd = 0;
void *data = NULL((void*)0);
uint32_t len, ts = 0;
switch_payload_t payload = 0;
rtp_msg_t *send_msg = NULL((void*)0);
srtp_hdr_t local_header;
int r = 0;
switch_status_t status;

if (!switch_rtp_ready(rtp_session) || !rtp_session->remote_addr) {
return -1;
}

if (!rtp_write_ready(rtp_session, frame->datalen, __LINE__9015)) {
return 0;
}

//if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
//	rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_READ]++;
//	rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]++;
//}


if (switch_test_flag(frame, SFF_PROXY_PACKET)((frame)->flags & SFF_PROXY_PACKET) || switch_test_flag(frame, SFF_UDPTL_PACKET)((frame)->flags & SFF_UDPTL_PACKET) ||
rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {

//if (rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA] || rtp_session->flags[SWITCH_RTP_FLAG_UDPTL]) {
switch_size_t bytes;
//char bufa[50];

/* Fast PASS! */
if (!switch_test_flag(frame, SFF_PROXY_PACKET)((frame)->flags & SFF_PROXY_PACKET) && !switch_test_flag(frame, SFF_UDPTL_PACKET)((frame)->flags & SFF_UDPTL_PACKET)) {
	return 0;
}
bytes = frame->packetlen;
//tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->remote_addr);

send_msg = frame->packet;

if (!rtp_session->flags[SWITCH_RTP_FLAG_UDPTL] && !switch_test_flag(frame, SFF_UDPTL_PACKET)((frame)->flags & SFF_UDPTL_PACKET)) {

	if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] && rtp_session->payload > 0) {
		send_msg->header.pt = rtp_session->payload;
	}

	send_msg->header.ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
	send_msg->header.seq = htons(++rtp_session->seq)__bswap_16 (++rtp_session->seq);
}

if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
	const char *tx_host;
	const char *old_host;
	const char *my_host;

	char bufa[50], bufb[50], bufc[50];


	tx_host = switch_get_addr(bufa, sizeof(bufa), rtp_session->rtp_from_addr);
	old_host = switch_get_addr(bufb, sizeof(bufb), rtp_session->remote_addr);
	my_host = switch_get_addr(bufc, sizeof(bufc), rtp_session->local_addr);

	switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session)SWITCH_CHANNEL_ID_LOG_CLEAN, "src/switch_rtp.c", (const char *
)__func__, 9063, switch_core_session_get_uuid((rtp_session->
session)), SWITCH_LOG_CONSOLE,
					  "W %s b=%4ld %s:%u %s:%u %s:%u pt=%d ts=%u seq=%u m=%d\n",
					  rtp_session->session ? switch_channel_get_name(switch_core_session_get_channel(rtp_session->session)) : "NoName",
					  (long) bytes,
					  my_host, switch_sockaddr_get_port(rtp_session->local_addr),
					  old_host, rtp_session->remote_port,
					  tx_host, switch_sockaddr_get_port(rtp_session->rtp_from_addr),
					  send_msg->header.pt, ntohl(send_msg->header.ts)__bswap_32 (send_msg->header.ts), ntohs(send_msg->header.seq)__bswap_16 (send_msg->header.seq), send_msg->header.m);

}

if ((status = switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, frame->packet, &bytes)) != SWITCH_STATUS_SUCCESS) {
	if (rtp_session->flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG_CLEAN(rtp_session->session)SWITCH_CHANNEL_ID_LOG_CLEAN, "src/switch_rtp.c", (const char *
)__func__, 9076, switch_core_session_get_uuid((rtp_session->
session)), SWITCH_LOG_ERROR, "bytes: %" SWITCH_SIZE_T_FMT"ld" ", status: %d", bytes, status);
	}

	return -1 * status;
}


rtp_session->stats.outbound.raw_bytes += bytes;
rtp_session->stats.outbound.media_bytes += bytes;
rtp_session->stats.outbound.media_packet_count++;
rtp_session->stats.outbound.packet_count++;
return (int) bytes;
}
9089#ifdef ENABLE_ZRTP
if (zrtp_on && rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND]) {
zrtp_session_info_t zrtp_session_info;

if (zrtp_status_ok == zrtp_session_get(rtp_session->zrtp_session, &zrtp_session_info)) {
	if (zrtp_session_info.sas_is_ready) {

		switch_channel_t *channel = switch_core_session_get_channel(rtp_session->session);

		const char *uuid = switch_channel_get_partner_uuid(channel);
		if (uuid) {
			switch_core_session_t *other_session;

			if ((other_session = switch_core_session_locate(uuid)switch_core_session_perform_locate(uuid, "src/switch_rtp.c", (
const char *)__func__, 9102))) {
				switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
				switch_rtp_t *other_rtp_session = switch_channel_get_private(other_channel, "__zrtp_audio_rtp_session");


				if (other_rtp_session) {
					if (zrtp_status_ok == zrtp_session_get(other_rtp_session->zrtp_session, &zrtp_session_info)) {
						if (rtp_session->zrtp_mitm_tries > ZRTP_MITM_TRIES) {
							rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
							rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
							switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
							switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
						} else if (zrtp_status_ok == zrtp_resolve_mitm_call(other_rtp_session->zrtp_stream, rtp_session->zrtp_stream)) {
							rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_RECV] = 0;
							rtp_session->flags[SWITCH_ZRTP_FLAG_SECURE_MITM_SEND] = 0;
							switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_RECV);
							switch_rtp_clear_flag(other_rtp_session, SWITCH_ZRTP_FLAG_SECURE_MITM_SEND);
							rtp_session->zrtp_mitm_tries++;
						}
						rtp_session->zrtp_mitm_tries++;
					}
				}

				switch_core_session_rwunlock(other_session);
			}
		}
	}
}
}
9131#endif

fwd = (rtp_session->flags[SWITCH_RTP_FLAG_RAW_WRITE] &&
   (switch_test_flag(frame, SFF_RAW_RTP)((frame)->flags & SFF_RAW_RTP) || switch_test_flag(frame, SFF_RAW_RTP_PARSE_FRAME)((frame)->flags & SFF_RAW_RTP_PARSE_FRAME))) ? 1 : 0;

if (!fwd && !rtp_session->sending_dtmf && !rtp_session->queue_delay && !rtp_session->flags[SWITCH_RTP_FLAG_VIDEO] &&
rtp_session->flags[SWITCH_RTP_FLAG_RAW_WRITE] && (rtp_session->rtp_bugs & RTP_BUG_GEN_ONE_GEN_ALL)) {

switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 9139, (const char*)(rtp_session->session), SWITCH_LOG_WARNING, "Generating RTP locally but timestamp passthru is configured, disabling....\n");
rtp_session->flags[SWITCH_RTP_FLAG_RAW_WRITE] = 0;
rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 1;
}

switch_assert(frame != NULL)((frame != ((void*)0)) ? (void) (0) : __assert_fail ("frame != ((void*)0)"
, "src/switch_rtp.c", 9144, __extension__ __PRETTY_FUNCTION__
));

if (switch_test_flag(frame, SFF_CNG)((frame)->flags & SFF_CNG)) {
if (rtp_session->cng_pt != INVALID_PT) {
	payload = rtp_session->cng_pt;
} else {
	return (int) frame->packetlen;
}
} else {
payload = rtp_session->payload;
9154#if 0
if (rtp_session->pmaps && *rtp_session->pmaps) {
	payload_map_t *pmap;
	for (pmap = *rtp_session->pmaps; pmap; pmap = pmap->next) {
		if (pmap->current) {
			payload = pmap->pt;
		}
	}
}
9163#endif
}


if (switch_test_flag(frame, SFF_RTP_HEADER)((frame)->flags & SFF_RTP_HEADER) || rtp_session->flags[SWITCH_RTP_FLAG_TEXT]) {
switch_size_t wrote;

wrote = switch_rtp_write_manual(rtp_session, frame->data, frame->datalen,
								frame->m, frame->payload, (uint32_t) (frame->timestamp), &frame->flags);

rtp_session->stats.outbound.raw_bytes += wrote;
rtp_session->stats.outbound.media_bytes += wrote;
rtp_session->stats.outbound.media_packet_count++;
rtp_session->stats.outbound.packet_count++;

return wrote;
}

if (frame->pmap && rtp_session->pmaps && *rtp_session->pmaps) {
payload_map_t *pmap;

switch_mutex_lock(rtp_session->flag_mutex);
for (pmap = *rtp_session->pmaps; pmap; pmap = pmap->next) {
	if (pmap->negotiated && pmap->hash == frame->pmap->hash) {
		payload = pmap->recv_pt;
		break;
	}
}
switch_mutex_unlock(rtp_session->flag_mutex);
}

if (fwd) {
send_msg = frame->packet;
local_header = send_msg->header;
len = frame->packetlen;
ts = 0;

send_msg->header.pt = payload;

if (switch_test_flag(frame, SFF_RAW_RTP_PARSE_FRAME)((frame)->flags & SFF_RAW_RTP_PARSE_FRAME)) {
	send_msg->header.version = 2;
	send_msg->header.m = frame->m;

	send_msg->header.ts = htonl(frame->timestamp)__bswap_32 (frame->timestamp);
	if (frame->ssrc) {
		send_msg->header.ssrc = htonl(frame->ssrc)__bswap_32 (frame->ssrc);
	} else {
		send_msg->header.ssrc = htonl(rtp_session->ssrc)__bswap_32 (rtp_session->ssrc);
	}
}

} else {
data = frame->data;
len = frame->datalen;
ts = rtp_session->flags[SWITCH_RTP_FLAG_RAW_WRITE] ? (uint32_t) frame->timestamp : 0;
}

/*
 if (rtp_session->flags[SWITCH_RTP_FLAG_VIDEO]) {
 send_msg->header.pt = rtp_session->payload;
 }
*/

r = rtp_common_write(rtp_session, send_msg, data, len, payload, ts, &frame->flags);

if (send_msg) {
send_msg->header = local_header;
}

return r;

9234}

9236SWITCH_DECLARE(switch_rtp_stats_t *)__attribute__((visibility("default"))) switch_rtp_stats_t * switch_rtp_get_stats(switch_rtp_t *rtp_session, switch_memory_pool_t *pool)
9237{
switch_rtp_stats_t *s;

if (!rtp_session) {
return NULL((void*)0);
}

switch_mutex_lock(rtp_session->flag_mutex);
if (pool) {
s = switch_core_alloc(pool, sizeof(*s))switch_core_perform_alloc(pool, sizeof(*s), "src/switch_rtp.c"
, (const char *)__func__, 9246);
*s = rtp_session->stats;
} else {
s = &rtp_session->stats;
}

if (rtp_session->jb) {
switch_jb_get_frames(rtp_session->jb, NULL((void*)0), NULL((void*)0), NULL((void*)0), (uint32_t *)&s->inbound.largest_jb_size);
}

do_mos(rtp_session);

switch_mutex_unlock(rtp_session->flag_mutex);

return s;
9261}

9263SWITCH_DECLARE(int)__attribute__((visibility("default"))) int switch_rtp_write_manual(switch_rtp_t *rtp_session,
									void *data, uint32_t datalen, uint8_t m, switch_payload_t payload, uint32_t ts, switch_frame_flag_t *flags)
9265{
switch_size_t bytes;
int ret = -1;

if (!switch_rtp_ready(rtp_session) || !rtp_session->remote_addr || datalen > SWITCH_RTP_MAX_BUF_LEN16384) {
return -1;
}

if (!rtp_write_ready(rtp_session, datalen, __LINE__9273)) {
return 0;
}

if (payload == INVALID_PT) {
return 0;
}

WRITE_INC(rtp_session)switch_mutex_lock(rtp_session->write_mutex); rtp_session->
writing++;

rtp_session->write_msg = rtp_session->send_msg;
rtp_session->write_msg.header.seq = htons(++rtp_session->seq)__bswap_16 (++rtp_session->seq);
rtp_session->write_msg.header.ts = htonl(ts)__bswap_32 (ts);
rtp_session->write_msg.header.pt = payload;
rtp_session->write_msg.header.m = m;
memcpy(rtp_session->write_msg.body, data, datalen);

bytes = rtp_header_len12 + datalen;

if (switch_rtp_write_raw(rtp_session, (void *) &rtp_session->write_msg, &bytes, SWITCH_TRUE) != SWITCH_STATUS_SUCCESS) {
rtp_session->seq--;
ret = -1;
goto end;
}

if (((*flags) & SFF_RTP_HEADER)) {
rtp_session->last_write_ts = ts;
rtp_session->flags[SWITCH_RTP_FLAG_RESET] = 0;
}

ret = (int) bytes;

end:

WRITE_DEC(rtp_session)rtp_session->writing--; switch_mutex_unlock(rtp_session->
write_mutex);

return ret;
9310}



9314SWITCH_DECLARE(switch_status_t)__attribute__((visibility("default"))) switch_status_t switch_rtp_write_raw(switch_rtp_t *rtp_session, void *data, switch_size_t *bytes, switch_bool_t process_encryption)
9315{
switch_status_t status = SWITCH_STATUS_FALSE;

switch_assert(bytes)((bytes) ? (void) (0) : __assert_fail ("bytes", "src/switch_rtp.c"
, 9318, __extension__ __PRETTY_FUNCTION__));

if (!switch_rtp_ready(rtp_session) || !rtp_session->remote_addr || *bytes > SWITCH_RTP_MAX_BUF_LEN16384) {
return status;
}

if (!rtp_write_ready(rtp_session, *bytes, __LINE__9324)) {
return SWITCH_STATUS_NOT_INITALIZED;
}

WRITE_INC(rtp_session)switch_mutex_lock(rtp_session->write_mutex); rtp_session->
writing++;

if (process_encryption) {
9331#ifdef ENABLE_SRTP1
switch_mutex_lock(rtp_session->ice_mutex);
if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND]) {

	int sbytes = (int) *bytes;
	srtp_err_status_t stat;

	if (rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_RESET]) {
		switch_rtp_clear_flag(rtp_session, SWITCH_RTP_FLAG_SECURE_SEND_RESET);
		srtp_dealloc(rtp_session->send_ctx[rtp_session->srtp_idx_rtp]);
		rtp_session->send_ctx[rtp_session->srtp_idx_rtp] = NULL((void*)0);
		if ((stat = srtp_create(&rtp_session->send_ctx[rtp_session->srtp_idx_rtp],
								&rtp_session->send_policy[rtp_session->srtp_idx_rtp])) || !rtp_session->send_ctx[rtp_session->srtp_idx_rtp]) {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 9344, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error! RE-Activating Secure RTP SEND\n");
			rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND] = 0;
			status = SWITCH_STATUS_FALSE;
			switch_mutex_unlock(rtp_session->ice_mutex);
			goto end;
		} else {
			switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 9350, (const char*)(rtp_session->session), SWITCH_LOG_INFO, "RE-Activating Secure RTP SEND\n");
		}
	}

	if (!rtp_session->flags[SWITCH_RTP_FLAG_SECURE_SEND_MKI]) {
		stat = srtp_protect(rtp_session->send_ctx[rtp_session->srtp_idx_rtp], &rtp_session->write_msg.header, &sbytes);
	} else {
		stat = srtp_protect_mki(rtp_session->send_ctx[rtp_session->srtp_idx_rtp], &rtp_session->write_msg.header, &sbytes, 1, SWITCH_CRYPTO_MKI_INDEX0);
	}

	if (stat) {
		switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(rtp_session->session)SWITCH_CHANNEL_ID_SESSION, "src/switch_rtp.c", (const char *)
__func__, 9361, (const char*)(rtp_session->session), SWITCH_LOG_ERROR, "Error: SRTP protection failed with code %d\n", stat);
	}
	*bytes = sbytes;
}
switch_mutex_unlock(rtp_session->ice_mutex);
9366#endif
9367#ifdef ENABLE_ZRTP
/* ZRTP Send */
if (zrtp_on && !rtp_session->flags[SWITCH_RTP_FLAG_PROXY_MEDIA]) {
	unsigned int sbytes = (int) *bytes;
	zrtp_status_t stat = zrtp_status_fail;

	stat = zrtp_process_rtp(rtp_session->zrtp_stream, (void *) &rtp_session->write_msg, &sbytes);

	switch (stat) {
	case zrtp_status_ok:
		break;
	case zrtp_status_drop:
		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 9379, ((void*)0), SWITCH_LOG_ERROR, "Error: zRTP protection drop with code %d\n", stat);
		status = SWITCH_STATUS_SUCCESS;
		goto end;
		break;
	case zrtp_status_fail:
		switch_log_printf(SWITCH_CHANNEL_LOGSWITCH_CHANNEL_ID_LOG, "src/switch_rtp.c", (const char *)__func__
, 9384, ((void*)0), SWITCH_LOG_ERROR, "Error: zRTP protection fail with code %d\n", stat);
		break;
	default:
		break;
	}

	*bytes = sbytes;
}
9392#endif
}

status = switch_socket_sendto(rtp_session->sock_output, rtp_session->remote_addr, 0, data, bytes);
9396#if defined(ENABLE_SRTP1) || defined(ENABLE_ZRTP)
end:
9398#endif

WRITE_DEC(rtp_session)rtp_session->writing--; switch_mutex_unlock(rtp_session->
write_mutex);

return status;
9403}

9405SWITCH_DECLARE(uint32_t)__attribute__((visibility("default"))) uint32_t switch_rtp_get_ssrc(switch_rtp_t *rtp_session)
9406{
return rtp_session->ssrc;
9408}

9410SWITCH_DECLARE(void)__attribute__((visibility("default"))) void switch_rtp_set_private(switch_rtp_t *rtp_session, void *private_data)
9411{
rtp_session->private_data = private_data;
9413}

9415SWITCH_DECLARE(void *)__attribute__((visibility("default"))) void * switch_rtp_get_private(switch_rtp_t *rtp_session)
9416{
return rtp_session->private_data;
9418}

9420SWITCH_DECLARE(switch_core_session_t*)__attribute__((visibility("default"))) switch_core_session_t* switch_rtp_get_core_session(switch_rtp_t *rtp_session)
9421{
return rtp_session->session;
9423}

9425/* For Emacs:
* Local Variables:
* mode:c
* indent-tabs-mode:t
* tab-width:4
* c-basic-offset:4
* End:
* For VIM:
* vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
*/