switch_core_media.c

Go to the documentation of this file.

/*
 * FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
 * Copyright (C) 2005-2021, 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>
 * Seven Du <dujinfang@gmail.com>
 *
 * switch_core_media.c -- Core Media
 *
 */

#include <switch.h>
#include <switch_ssl.h>
#include <switch_stun.h>
#include <switch_nat.h>
#include "private/switch_core_pvt.h"
#include "private/switch_apr_pvt.h"
#include <switch_curl.h>
#include <errno.h>
#include <sofia-sip/sdp.h>
#include <sofia-sip/su.h>

#include <stdbool.h>

static switch_t38_options_t * switch_core_media_process_udptl(switch_core_session_t *session, sdp_session_t *sdp, sdp_media_t *m);
static void switch_core_media_set_r_sdp_codec_string(switch_core_session_t *session, const char *codec_string, sdp_session_t *sdp, switch_sdp_type_t sdp_type);
static void gen_ice(switch_core_session_t *session, switch_media_type_t type, const char *ip, switch_port_t port);
//#define GOOGLE_ICE
#define RTCP_MUX
#define MAX_CODEC_CHECK_FRAMES 50//x:mod_sofia.h
#define MAX_MISMATCH_FRAMES 5//x:mod_sofia.h
#define type2str(type) type == SWITCH_MEDIA_TYPE_VIDEO ? "video" : (type == SWITCH_MEDIA_TYPE_AUDIO ? "audio" : "text")
#define VIDEO_REFRESH_FREQ 1000000

#define TEXT_TIMER_MS 100
#define TEXT_TIMER_SAMPLES 10
#define TEXT_PERIOD_TIMEOUT 3000
#define MAX_RED_FRAMES 25
#define RED_PACKET_SIZE 100

typedef enum {
        SMF_INIT = (1 << 0),
        SMF_READY = (1 << 1),
        SMF_JB_PAUSED = (1 << 2),
        SMF_VB_PAUSED = (1 << 3)
} smh_flag_t;

typedef struct core_video_globals_s {
        int cpu_count;
        int cur_cpu;
        switch_memory_pool_t *pool;
        switch_mutex_t *mutex;
        uint32_t fps;
        uint32_t synced;
} core_video_globals_t;

static core_video_globals_t video_globals = { 0 };

struct media_helper {
        switch_core_session_t *session;
        switch_thread_cond_t *cond;
        switch_mutex_t *cond_mutex;
        switch_mutex_t *file_read_mutex;
        switch_mutex_t *file_write_mutex;
        int up;
        int ready;
};

typedef enum {
        CRYPTO_MODE_OPTIONAL,
        CRYPTO_MODE_MANDATORY,
        CRYPTO_MODE_FORBIDDEN
} switch_rtp_crypto_mode_t;

struct switch_rtp_text_factory_s {
        switch_memory_pool_t *pool;
        switch_frame_t text_frame;
        int red_level;
        switch_byte_t *text_write_frame_data;
        switch_frame_t text_write_frame;
        switch_buffer_t *write_buffer;
        int write_empty;
        switch_byte_t *red_buf[MAX_RED_FRAMES];
        int red_bufsize;
        int red_buflen[MAX_RED_FRAMES];
        uint32_t red_ts[MAX_RED_FRAMES];
        int red_pos;
        int red_max;
        switch_timer_t timer;
};


struct switch_rtp_engine_s {
        switch_secure_settings_t ssec[CRYPTO_INVALID+1];
        switch_rtp_crypto_key_type_t crypto_type;

        switch_media_type_t type;

        switch_rtp_t *rtp_session;
        switch_frame_t read_frame;
        switch_codec_t read_codec;
        switch_codec_t write_codec;

        switch_codec_implementation_t read_impl;
        switch_codec_implementation_t write_impl;

        switch_size_t last_ts;
        switch_size_t last_seq;
        uint32_t check_frames;
        uint32_t mismatch_count;
        uint32_t last_codec_ms;
        uint8_t codec_reinvites;
        uint32_t max_missed_packets;
        uint32_t max_missed_hold_packets;
        uint32_t media_timeout;
        uint32_t media_hold_timeout;
        uint32_t ssrc;
        uint32_t remote_ssrc;
        switch_port_t remote_rtcp_port;
        switch_rtp_bug_flag_t rtp_bugs;


        char *local_sdp_ip;
        switch_port_t local_sdp_port;
        char *adv_sdp_ip;
        switch_port_t adv_sdp_port;
        char *proxy_sdp_ip;
        switch_port_t proxy_sdp_port;


        payload_map_t *cur_payload_map;
        payload_map_t *payload_map;
        payload_map_t *pmap_tail;

        uint32_t timestamp_send;

        char *cand_acl[SWITCH_MAX_CAND_ACL];
        int cand_acl_count;

        ice_t ice_in;
        ice_t ice_out;

        int8_t rtcp_mux;

        dtls_fingerprint_t local_dtls_fingerprint;
        dtls_fingerprint_t remote_dtls_fingerprint;

        char *remote_rtp_ice_addr;
        switch_port_t remote_rtp_ice_port;

        char *remote_rtcp_ice_addr;
        switch_port_t remote_rtcp_ice_port;

        struct media_helper mh;
        switch_thread_t *media_thread;


        uint8_t reset_codec;
        uint8_t codec_negotiated;

        uint8_t fir;
        uint8_t pli;
        uint8_t nack;
        uint8_t tmmbr;
        uint8_t no_crypto;
        uint8_t dtls_controller;
        uint8_t pass_codecs;
        switch_codec_settings_t codec_settings;
        switch_media_flow_t rmode;
        switch_media_flow_t smode;
        switch_thread_id_t thread_id;
        switch_thread_id_t thread_write_lock;
        uint8_t new_ice;
        uint8_t new_dtls;
        uint32_t sdp_bw;
        uint32_t orig_bitrate;
        float bw_mult;
        uint8_t reject_avp;
        int t140_pt;
        int red_pt;
        switch_rtp_text_factory_t *tf;

        switch_engine_function_t engine_function;
        void *engine_user_data;
        int8_t engine_function_running;
        switch_frame_buffer_t *write_fb;
};

#define MAX_REJ_STREAMS 10

struct switch_media_handle_s {
        switch_core_session_t *session;
        switch_channel_t *channel;
        switch_core_media_flag_t media_flags[SCMF_MAX];
        smh_flag_t flags;
        switch_rtp_engine_t engines[SWITCH_MEDIA_TYPE_TOTAL];
        switch_msrp_session_t *msrp_session;
        switch_mutex_t *read_mutex[SWITCH_MEDIA_TYPE_TOTAL];
        switch_mutex_t *write_mutex[SWITCH_MEDIA_TYPE_TOTAL];
        char *codec_order[SWITCH_MAX_CODECS];
        int codec_order_last;
        const switch_codec_implementation_t *codecs[SWITCH_MAX_CODECS];
        char fmtp[SWITCH_MAX_CODECS][MAX_FMTP_LEN];
        int payload_space;
        char *origin;

        sdp_media_e rejected_streams[MAX_REJ_STREAMS];
        int rej_idx;

        switch_mutex_t *mutex;
        switch_mutex_t *sdp_mutex;
        switch_mutex_t *control_mutex;

        const switch_codec_implementation_t *negotiated_codecs[SWITCH_MAX_CODECS];
        int num_negotiated_codecs;
        switch_payload_t ianacodes[SWITCH_MAX_CODECS];
        switch_payload_t dtmf_ianacodes[SWITCH_MAX_CODECS];
        switch_payload_t cng_ianacodes[SWITCH_MAX_CODECS];
        char *fmtps[SWITCH_MAX_CODECS];
        int video_count;

        int rates[SWITCH_MAX_CODECS];
        uint32_t num_rates;

        uint32_t owner_id;
        uint32_t session_id;

        switch_core_media_params_t *mparams;

        char *msid;
        char *cname;

        switch_rtp_crypto_mode_t crypto_mode;
        switch_rtp_crypto_key_type_t crypto_suite_order[CRYPTO_INVALID+1];
        switch_time_t video_last_key_time;
        switch_time_t video_init;
        switch_time_t last_codec_refresh;
        switch_time_t last_video_refresh_req;
        switch_timer_t video_timer;


        switch_vid_params_t vid_params;
        switch_file_handle_t *video_read_fh;
        switch_file_handle_t *video_write_fh;

        uint64_t vid_frames;
        time_t vid_started;
        int ready_loops;

        switch_thread_t *video_write_thread;
        int video_write_thread_running;

        switch_time_t last_text_frame;

};

switch_srtp_crypto_suite_t SUITES[CRYPTO_INVALID] = {
        { "AEAD_AES_256_GCM_8", "", AEAD_AES_256_GCM_8, 44, 12},
        { "AEAD_AES_256_GCM", "", AEAD_AES_256_GCM, 44, 12},
        { "AEAD_AES_128_GCM_8", "", AEAD_AES_128_GCM_8, 28, 12},
        { "AEAD_AES_128_GCM", "", AEAD_AES_128_GCM, 28, 12},
        { "AES_256_CM_HMAC_SHA1_80", "AES_CM_256_HMAC_SHA1_80", AES_CM_256_HMAC_SHA1_80, 46, 14},
        { "AES_192_CM_HMAC_SHA1_80", "AES_CM_192_HMAC_SHA1_80", AES_CM_192_HMAC_SHA1_80, 38, 14},
        { "AES_CM_128_HMAC_SHA1_80", "", AES_CM_128_HMAC_SHA1_80, 30, 14},
        { "AES_256_CM_HMAC_SHA1_32", "AES_CM_256_HMAC_SHA1_32", AES_CM_256_HMAC_SHA1_32, 46, 14},
        { "AES_192_CM_HMAC_SHA1_32", "AES_CM_192_HMAC_SHA1_32", AES_CM_192_HMAC_SHA1_32, 38, 14},
        { "AES_CM_128_HMAC_SHA1_32", "", AES_CM_128_HMAC_SHA1_32, 30, 14},
        { "AES_CM_128_NULL_AUTH", "", AES_CM_128_NULL_AUTH, 30, 14}
};

static switch_bool_t ice_resolve_candidate = 0;

SWITCH_DECLARE(void) switch_core_media_set_resolveice(switch_bool_t resolve_ice)
{
        ice_resolve_candidate = resolve_ice;
}

SWITCH_DECLARE(switch_bool_t) switch_core_media_has_resolveice(void)
{
        return ice_resolve_candidate;
}


SWITCH_DECLARE(switch_rtp_crypto_key_type_t) switch_core_media_crypto_str2type(const char *str)
{
        int i;

        for (i = 0; i < CRYPTO_INVALID; i++) {
                if (!strncasecmp(str, SUITES[i].name, strlen(SUITES[i].name)) || (SUITES[i].alias && strlen(SUITES[i].alias) && !strncasecmp(str, SUITES[i].alias, strlen(SUITES[i].alias)))) {
                        return SUITES[i].type;
                }
        }

        return CRYPTO_INVALID;
}


SWITCH_DECLARE(const char *) switch_core_media_crypto_type2str(switch_rtp_crypto_key_type_t type)
{
        switch_assert(type < CRYPTO_INVALID);
        return SUITES[type].name;
}


SWITCH_DECLARE(int) switch_core_media_crypto_keysalt_len(switch_rtp_crypto_key_type_t type)
{
        switch_assert(type < CRYPTO_INVALID);
        return SUITES[type].keysalt_len;
}

SWITCH_DECLARE(int) switch_core_media_crypto_salt_len(switch_rtp_crypto_key_type_t type)
{
        switch_assert(type < CRYPTO_INVALID);
        return SUITES[type].salt_len;
}

static const char* CRYPTO_KEY_PARAM_METHOD[CRYPTO_KEY_PARAM_METHOD_INVALID] = {
        [CRYPTO_KEY_PARAM_METHOD_INLINE] = "inline",
};

static inline switch_media_flow_t sdp_media_flow(unsigned in)
{
        switch(in) {
        case sdp_sendonly:
                return SWITCH_MEDIA_FLOW_SENDONLY;
        case sdp_recvonly:
                return SWITCH_MEDIA_FLOW_RECVONLY;
        case sdp_sendrecv:
                return SWITCH_MEDIA_FLOW_SENDRECV;
        case sdp_inactive:
                return SWITCH_MEDIA_FLOW_INACTIVE;
        }

        return SWITCH_MEDIA_FLOW_SENDRECV;
}

static int get_channels(const char *name, int dft)
{

        if (!zstr(name) && !switch_true(switch_core_get_variable("NDLB_broken_opus_sdp")) && !strcasecmp(name, "opus")) {
                return 2; /* IKR???*/
        }

        return dft ? dft : 1;
}

SWITCH_DECLARE(uint32_t) switch_core_media_get_video_fps(switch_core_session_t *session)
{
        switch_media_handle_t *smh;
        time_t now;
        uint32_t fps, elapsed = 0;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!switch_channel_test_flag(session->channel, CF_VIDEO)) {
                return 0;
        }

        now = switch_epoch_time_now(NULL);

        elapsed = now - smh->vid_started;

        if (!(smh->vid_started && smh->vid_frames && elapsed > 0)) {
                return 0;
        }

        fps = switch_round_to_step(smh->vid_frames / (elapsed), 5);

        if (smh->vid_frames > 1000) {
                smh->vid_started = switch_epoch_time_now(NULL);
                smh->vid_frames = 1;
        }

        if (fps > 0) {
                video_globals.fps = fps;

                if (smh->vid_params.fps != fps) {
                        switch_channel_set_variable_printf(session->channel, "video_fps", "%d", fps);
                        smh->vid_params.fps = fps;
                }
        }

        return fps;
}

static switch_t38_options_t * switch_core_media_process_udptl(switch_core_session_t *session, sdp_session_t *sdp, sdp_media_t *m)
{
        switch_t38_options_t *t38_options = switch_channel_get_private(session->channel, "t38_options");
        sdp_attribute_t *attr;

        switch_assert(sdp);

        if (!t38_options) {
                t38_options = switch_core_session_alloc(session, sizeof(switch_t38_options_t));

                // set some default value
                t38_options->T38FaxVersion = 0;
                t38_options->T38MaxBitRate = 14400;
                t38_options->T38FaxRateManagement = switch_core_session_strdup(session, "transferredTCF");
                t38_options->T38FaxUdpEC = switch_core_session_strdup(session, "t38UDPRedundancy");
                t38_options->T38FaxMaxBuffer = 500;
                t38_options->T38FaxMaxDatagram = 500;
        }

        t38_options->remote_port = (switch_port_t)m->m_port;

        if (sdp->sdp_origin) {
                t38_options->sdp_o_line = switch_core_session_strdup(session, sdp->sdp_origin->o_username);
        } else {
                t38_options->sdp_o_line = "unknown";
        }

        if (m->m_connections && m->m_connections->c_address) {
                t38_options->remote_ip = switch_core_session_strdup(session, m->m_connections->c_address);
        } else if (sdp->sdp_connection && sdp->sdp_connection->c_address) {
                t38_options->remote_ip = switch_core_session_strdup(session, sdp->sdp_connection->c_address);
        }

        for (attr = m->m_attributes; attr; attr = attr->a_next) {
                if (!strcasecmp(attr->a_name, "T38FaxVersion") && attr->a_value) {
                        t38_options->T38FaxVersion = (uint16_t) atoi(attr->a_value);
                } else if (!strcasecmp(attr->a_name, "T38MaxBitRate") && attr->a_value) {
                        t38_options->T38MaxBitRate = (uint32_t) atoi(attr->a_value);
                } else if (!strcasecmp(attr->a_name, "T38FaxFillBitRemoval")) {
                        t38_options->T38FaxFillBitRemoval = switch_safe_atoi(attr->a_value, 1);
                } else if (!strcasecmp(attr->a_name, "T38FaxTranscodingMMR")) {
                        t38_options->T38FaxTranscodingMMR = switch_safe_atoi(attr->a_value, 1);
                } else if (!strcasecmp(attr->a_name, "T38FaxTranscodingJBIG")) {
                        t38_options->T38FaxTranscodingJBIG = switch_safe_atoi(attr->a_value, 1);
                } else if (!strcasecmp(attr->a_name, "T38FaxRateManagement") && attr->a_value) {
                        t38_options->T38FaxRateManagement = switch_core_session_strdup(session, attr->a_value);
                } else if (!strcasecmp(attr->a_name, "T38FaxMaxBuffer") && attr->a_value) {
                        t38_options->T38FaxMaxBuffer = (uint32_t) atoi(attr->a_value);
                } else if (!strcasecmp(attr->a_name, "T38FaxMaxDatagram") && attr->a_value) {
                        t38_options->T38FaxMaxDatagram = (uint32_t) atoi(attr->a_value);
                } else if (!strcasecmp(attr->a_name, "T38FaxUdpEC") && attr->a_value) {
                        t38_options->T38FaxUdpEC = switch_core_session_strdup(session, attr->a_value);
                } else if (!strcasecmp(attr->a_name, "T38VendorInfo") && attr->a_value) {
                        t38_options->T38VendorInfo = switch_core_session_strdup(session, attr->a_value);
                }
        }

        switch_channel_set_variable(session->channel, "has_t38", "true");
        switch_channel_set_private(session->channel, "t38_options", t38_options);
        switch_channel_set_app_flag_key("T38", session->channel, CF_APP_T38);

        switch_channel_execute_on(session->channel, "sip_execute_on_image");
        switch_channel_api_on(session->channel, "sip_api_on_image");

        return t38_options;
}

SWITCH_DECLARE(switch_status_t) switch_core_media_check_autoadj(switch_core_session_t *session)
{
        switch_rtp_engine_t *a_engine;
        switch_rtp_engine_t *v_engine;
        switch_rtp_engine_t *t_engine;
        switch_media_handle_t *smh;
        const char *val;
        int x = 0;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) &&
                !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) &&
                !switch_channel_test_flag(session->channel, CF_AVPF)) {
                /* Reactivate the NAT buster flag. */

                if (a_engine->rtp_session) {
                        switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                        x++;
                }

                if (v_engine->rtp_session) {
                        switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                        x++;
                }

                if (t_engine->rtp_session) {
                        switch_rtp_set_flag(t_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                        x++;
                }
        }

        return x ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
}

SWITCH_DECLARE(switch_status_t) switch_core_media_get_vid_params(switch_core_session_t *session, switch_vid_params_t *vid_params)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        switch_mutex_lock(smh->control_mutex);
        *vid_params = smh->vid_params;
        switch_mutex_unlock(smh->control_mutex);

        return SWITCH_STATUS_SUCCESS;
}

SWITCH_DECLARE(switch_t38_options_t *) switch_core_media_extract_t38_options(switch_core_session_t *session, const char *r_sdp)
{
        sdp_media_t *m;
        sdp_parser_t *parser = NULL;
        sdp_session_t *sdp;
        switch_t38_options_t *t38_options = NULL;

        if (!(parser = sdp_parse(NULL, r_sdp, (int) strlen(r_sdp), 0))) {
                return NULL;
        }

        if (!(sdp = sdp_session(parser))) {
                sdp_parser_free(parser);
                return NULL;
        }

        for (m = sdp->sdp_media; m; m = m->m_next) {
                if (m->m_proto == sdp_proto_udptl && m->m_type == sdp_media_image && m->m_port) {
                        t38_options = switch_core_media_process_udptl(session, sdp, m);
                        break;
                }
        }

        sdp_parser_free(parser);

        return t38_options;

}



//?
SWITCH_DECLARE(switch_status_t) switch_core_media_process_t38_passthru(switch_core_session_t *session,
                                                                                                                                           switch_core_session_t *other_session, switch_t38_options_t *t38_options)
{
        char *remote_host;
        switch_port_t remote_port;
        char tmp[32] = "";
        switch_rtp_engine_t *a_engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];

        remote_host = switch_rtp_get_remote_host(a_engine->rtp_session);
        remote_port = switch_rtp_get_remote_port(a_engine->rtp_session);

        a_engine->cur_payload_map->remote_sdp_ip = switch_core_session_strdup(session, t38_options->remote_ip);
        a_engine->cur_payload_map->remote_sdp_port = t38_options->remote_port;

        if (remote_host && remote_port && !strcmp(remote_host, a_engine->cur_payload_map->remote_sdp_ip) &&
                remote_port == a_engine->cur_payload_map->remote_sdp_port) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                  "Audio params are unchanged for %s.\n",
                                                  switch_channel_get_name(session->channel));
        } else {
                const char *err = NULL;

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                  "Audio params changed for %s from %s:%d to %s:%d\n",
                                                  switch_channel_get_name(session->channel),
                                                  remote_host, remote_port, a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);

                switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->cur_payload_map->remote_sdp_port);
                switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->cur_payload_map->remote_sdp_ip);
                switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE, tmp);
                if (switch_rtp_set_remote_address(a_engine->rtp_session, a_engine->cur_payload_map->remote_sdp_ip,
                                                                                  a_engine->cur_payload_map->remote_sdp_port, 0, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "AUDIO RTP REPORTS ERROR: [%s]\n", err);
                        switch_channel_hangup(session->channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
                }
                switch_channel_execute_on(session->channel, "execute_on_audio_change");
        }

        switch_core_media_copy_t38_options(t38_options, other_session);

        return SWITCH_STATUS_SUCCESS;

}

SWITCH_DECLARE(switch_status_t) switch_core_session_get_payload_code(switch_core_session_t *session,
                                                                                                                                         switch_media_type_t type,
                                                                                                                                         const char *iananame,
                                                                                                                                         uint32_t rate,
                                                                                                                                         const char *fmtp_in,
                                                                                                                                         switch_payload_t *ptP,
                                                                                                                                         switch_payload_t *recv_ptP,
                                                                                                                                         char **fmtpP)
{
        payload_map_t *pmap;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;
        switch_payload_t pt = 0, recv_pt = 0;
        int found = 0;
        char *fmtp = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        engine = &smh->engines[type];

        switch_mutex_lock(smh->sdp_mutex);
        for (pmap = engine->payload_map; pmap ; pmap = pmap->next) {
                char *fmtp_a = pmap->rm_fmtp;

                if (!pmap->allocated) continue;

                if (!fmtp_a) fmtp_a = "";
                if (!fmtp_in) fmtp_in = "";


                if (!strcasecmp(pmap->iananame, iananame) && !strcasecmp(fmtp_a, fmtp_in) && (!rate || (rate == pmap->rate))) {
                        pt = pmap->pt;
                        recv_pt = pmap->recv_pt;
                        fmtp = pmap->rm_fmtp;
                        found++;
                        break;
                }
        }
        switch_mutex_unlock(smh->sdp_mutex);

        if (found) {
                if (ptP) {
                        *ptP = pt;
                }
                if (recv_ptP) {
                        *recv_ptP = recv_pt;
                }

                if (!zstr(fmtp) && fmtpP) {
                        *fmtpP = fmtp;
                }

                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;

}


SWITCH_DECLARE(payload_map_t *) switch_core_media_add_payload_map(switch_core_session_t *session,
                                                                                                                                  switch_media_type_t type,
                                                                                                                                  const char *name,
                                                                                                                                  const char *modname,
                                                                                                                                  const char *fmtp,
                                                                                                                                  switch_sdp_type_t sdp_type,
                                                                                                                                  uint32_t pt,
                                                                                                                                  uint32_t rate,
                                                                                                                                  uint32_t ptime,
                                                                                                                                  uint32_t channels,
                                                                                                                                  uint8_t negotiated)
{
        payload_map_t *pmap;
        int exists = 0;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return NULL;
        }

        engine = &smh->engines[type];

        switch_mutex_lock(smh->sdp_mutex);


        for (pmap = engine->payload_map; pmap && pmap->allocated; pmap = pmap->next) {

                if (sdp_type == SDP_ANSWER) {
                        switch(type) {
                        case SWITCH_MEDIA_TYPE_TEXT:
                                exists = (type == pmap->type && !strcasecmp(name, pmap->iananame));
                                break;
                        case SWITCH_MEDIA_TYPE_AUDIO:
                                exists = (type == pmap->type && !strcasecmp(name, pmap->iananame) && pmap->pt == pt && (!pmap->rate || rate == pmap->rate) && (!pmap->ptime || pmap->ptime == ptime));
                                break;
                        case SWITCH_MEDIA_TYPE_VIDEO:
                                exists = (pmap->sdp_type == SDP_OFFER && type == pmap->type && !strcasecmp(name, pmap->iananame));

                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "CHECK PMAP %s:%s %d %s:%s %d ... %d\n", 
                                                                  name, "RES", pt,
                                                                  pmap->iananame, pmap->sdp_type == SDP_OFFER ? "REQ" : "RES", pmap->pt, exists);
                                                                  

                                break;
                        }

                        if (exists) {

                                if (!zstr(fmtp) && !zstr(pmap->rm_fmtp)) {
                                        if (strcmp(pmap->rm_fmtp, fmtp)) {
                                                exists = 0;
                                                continue;
                                        }
                                }

                                break;
                        }

                } else {
                        if (type == SWITCH_MEDIA_TYPE_TEXT) {
                                exists = (type == pmap->type && !strcasecmp(name, pmap->iananame) && pmap->pt == pt);
                        } else {
                                exists = (type == pmap->type && !strcasecmp(name, pmap->iananame) && pmap->pt == pt && (!pmap->rate || rate == pmap->rate) && (!pmap->ptime || pmap->ptime == ptime));
                        }

                        if (exists) {
                                if (type != SWITCH_MEDIA_TYPE_TEXT && !zstr(fmtp) && !zstr(pmap->rm_fmtp)) {
                                        if (strcmp(pmap->rm_fmtp, fmtp)) {
                                                exists = 0;
                                                continue;
                                        }
                                }

                                break;
                        }
                }
        }

        if (!exists) {
                switch_ssize_t hlen = -1;

                if (engine->payload_map && !engine->payload_map->allocated) {
                        pmap = engine->payload_map;
                } else {
                        pmap = switch_core_alloc(session->pool, sizeof(*pmap));
                }

                pmap->type = type;
                pmap->iananame = switch_core_strdup(session->pool, name);
                pmap->rm_encoding = pmap->iananame;
                pmap->hash = switch_ci_hashfunc_default(pmap->iananame, &hlen);
                pmap->channels = 1;
        }

        if (ptime) {
                pmap->ptime = ptime;
        }

        if (rate) {
                pmap->rate = rate;
        }

        if (channels) {
                pmap->channels = channels;
        }

        if (modname) {
                pmap->modname = switch_core_strdup(session->pool, modname);
        }

        if (!zstr(fmtp)) {
                if (sdp_type == SDP_OFFER || !exists) {
                        pmap->rm_fmtp = switch_core_strdup(session->pool, fmtp);
                }
        }

        pmap->allocated = 1;

        pmap->recv_pt = (switch_payload_t) pt;


        if (sdp_type == SDP_OFFER || !exists) {
                pmap->pt = (switch_payload_t) pt;
        }

        if (negotiated) {
                pmap->negotiated = negotiated;
        }

        if (!exists) {
                pmap->sdp_type = sdp_type;

                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "ADD PMAP %s %s %d\n", sdp_type == SDP_OFFER ? "REQ" : "RES", name, pt);

                if (pmap == engine->payload_map) {
                        engine->pmap_tail = pmap;
                } else if (!engine->payload_map) {
                        engine->payload_map = engine->pmap_tail = pmap;
                } else {
                        engine->pmap_tail->next = pmap;
                        engine->pmap_tail = engine->pmap_tail->next;
                }
        }

        switch_mutex_unlock(smh->sdp_mutex);

        return pmap;
}




SWITCH_DECLARE(const char *)switch_core_media_get_codec_string(switch_core_session_t *session)
{
        const char *preferred = NULL, *fallback = NULL;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                preferred = "PCMU";
                fallback = "PCMU";
        } else {

                if (!(preferred = switch_channel_get_variable(session->channel, "absolute_codec_string"))) {
                        preferred = switch_channel_get_variable(session->channel, "codec_string");
                }

                if (!preferred) {
                        if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                                preferred = smh->mparams->outbound_codec_string;
                                fallback = smh->mparams->inbound_codec_string;

                        } else {
                                preferred = smh->mparams->inbound_codec_string;
                                fallback = smh->mparams->outbound_codec_string;
                        }
                }
        }

        return !zstr(preferred) ? preferred : fallback;
}

SWITCH_DECLARE(void) switch_core_session_clear_crypto(switch_core_session_t *session)
{
        int i;
        switch_media_handle_t *smh;

        const char *vars[] = { "rtp_last_audio_local_crypto_key",
                                                   "srtp_remote_audio_crypto_key",
                                                   "srtp_remote_audio_crypto_tag",
                                                   "srtp_remote_audio_crypto_type",
                                                   "srtp_remote_video_crypto_key",
                                                   "srtp_remote_video_crypto_tag",
                                                   "srtp_remote_video_crypto_type",
                                                   "srtp_remote_text_crypto_key",
                                                   "srtp_remote_text_crypto_tag",
                                                   "srtp_remote_text_crypto_type",
                                                   "rtp_secure_media",
                                                   "rtp_secure_media_inbound",
                                                   "rtp_secure_media_outbound",
                                                   NULL};

        for(i = 0; vars[i] ;i++) {
                switch_channel_set_variable(session->channel, vars[i], NULL);
        }

        if (!(smh = session->media_handle)) {
                return;
        }
        for (i = 0; i < CRYPTO_INVALID; i++) {
                memset(&smh->engines[SWITCH_MEDIA_TYPE_AUDIO].ssec[i], 0, sizeof(smh->engines[SWITCH_MEDIA_TYPE_AUDIO].ssec[i]));
                memset(&smh->engines[SWITCH_MEDIA_TYPE_VIDEO].ssec[i], 0, sizeof(smh->engines[SWITCH_MEDIA_TYPE_VIDEO].ssec[i]));
                memset(&smh->engines[SWITCH_MEDIA_TYPE_TEXT].ssec[i], 0, sizeof(smh->engines[SWITCH_MEDIA_TYPE_TEXT].ssec[i]));
        }

}

SWITCH_DECLARE(const char *) switch_core_session_local_crypto_key(switch_core_session_t *session, switch_media_type_t type)
{
        if (!session->media_handle) {
                return NULL;
        }

        return session->media_handle->engines[type].ssec[session->media_handle->engines[type].crypto_type].local_crypto_key;
}



SWITCH_DECLARE(void) switch_core_media_parse_rtp_bugs(switch_rtp_bug_flag_t *flag_pole, const char *str)
{

        if (switch_stristr("clear", str)) {
                *flag_pole = 0;
        }

        if (switch_stristr("CISCO_SKIP_MARK_BIT_2833", str)) {
                *flag_pole |= RTP_BUG_CISCO_SKIP_MARK_BIT_2833;
        }

        if (switch_stristr("~CISCO_SKIP_MARK_BIT_2833", str)) {
                *flag_pole &= ~RTP_BUG_CISCO_SKIP_MARK_BIT_2833;
        }

        if (switch_stristr("SONUS_SEND_INVALID_TIMESTAMP_2833", str)) {
                *flag_pole |= RTP_BUG_SONUS_SEND_INVALID_TIMESTAMP_2833;
        }

        if (switch_stristr("~SONUS_SEND_INVALID_TIMESTAMP_2833", str)) {
                *flag_pole &= ~RTP_BUG_SONUS_SEND_INVALID_TIMESTAMP_2833;
        }

        if (switch_stristr("IGNORE_MARK_BIT", str)) {
                *flag_pole |= RTP_BUG_IGNORE_MARK_BIT;
        }

        if (switch_stristr("~IGNORE_MARK_BIT", str)) {
                *flag_pole &= ~RTP_BUG_IGNORE_MARK_BIT;
        }

        if (switch_stristr("SEND_LINEAR_TIMESTAMPS", str)) {
                *flag_pole |= RTP_BUG_SEND_LINEAR_TIMESTAMPS;
        }

        if (switch_stristr("~SEND_LINEAR_TIMESTAMPS", str)) {
                *flag_pole &= ~RTP_BUG_SEND_LINEAR_TIMESTAMPS;
        }

        if (switch_stristr("START_SEQ_AT_ZERO", str)) {
                *flag_pole |= RTP_BUG_START_SEQ_AT_ZERO;
        }

        if (switch_stristr("~START_SEQ_AT_ZERO", str)) {
                *flag_pole &= ~RTP_BUG_START_SEQ_AT_ZERO;
        }

        if (switch_stristr("NEVER_SEND_MARKER", str)) {
                *flag_pole |= RTP_BUG_NEVER_SEND_MARKER;
        }

        if (switch_stristr("~NEVER_SEND_MARKER", str)) {
                *flag_pole &= ~RTP_BUG_NEVER_SEND_MARKER;
        }

        if (switch_stristr("IGNORE_DTMF_DURATION", str)) {
                *flag_pole |= RTP_BUG_IGNORE_DTMF_DURATION;
        }

        if (switch_stristr("~IGNORE_DTMF_DURATION", str)) {
                *flag_pole &= ~RTP_BUG_IGNORE_DTMF_DURATION;
        }

        if (switch_stristr("ACCEPT_ANY_PACKETS", str)) {
                *flag_pole |= RTP_BUG_ACCEPT_ANY_PACKETS;
        }

        if (switch_stristr("~ACCEPT_ANY_PACKETS", str)) {
                *flag_pole &= ~RTP_BUG_ACCEPT_ANY_PACKETS;
        }

        if (switch_stristr("ACCEPT_ANY_PAYLOAD", str)) {
                *flag_pole |= RTP_BUG_ACCEPT_ANY_PAYLOAD;
        }

        if (switch_stristr("~ACCEPT_ANY_PAYLOAD", str)) {
                *flag_pole &= ~RTP_BUG_ACCEPT_ANY_PAYLOAD;
        }

        if (switch_stristr("GEN_ONE_GEN_ALL", str)) {
                *flag_pole |= RTP_BUG_GEN_ONE_GEN_ALL;
        }

        if (switch_stristr("~GEN_ONE_GEN_ALL", str)) {
                *flag_pole &= ~RTP_BUG_GEN_ONE_GEN_ALL;
        }

        if (switch_stristr("CHANGE_SSRC_ON_MARKER", str)) {
                *flag_pole |= RTP_BUG_CHANGE_SSRC_ON_MARKER;
        }

        if (switch_stristr("~CHANGE_SSRC_ON_MARKER", str)) {
                *flag_pole &= ~RTP_BUG_CHANGE_SSRC_ON_MARKER;
        }

        if (switch_stristr("FLUSH_JB_ON_DTMF", str)) {
                *flag_pole |= RTP_BUG_FLUSH_JB_ON_DTMF;
        }

        if (switch_stristr("~FLUSH_JB_ON_DTMF", str)) {
                *flag_pole &= ~RTP_BUG_FLUSH_JB_ON_DTMF;
        }

        if (switch_stristr("ALWAYS_AUTO_ADJUST", str)) {
                *flag_pole |= (RTP_BUG_ALWAYS_AUTO_ADJUST | RTP_BUG_ACCEPT_ANY_PACKETS);
        }

        if (switch_stristr("~ALWAYS_AUTO_ADJUST", str)) {
                *flag_pole &= ~(RTP_BUG_ALWAYS_AUTO_ADJUST | RTP_BUG_ACCEPT_ANY_PACKETS);
        }
}

/**
 * If @use_alias != 0 then send crypto with alias name instead of name.
 */ 
static switch_status_t switch_core_media_build_crypto(switch_media_handle_t *smh,
                                                                                                          switch_media_type_t type,
                                                                                                          int index, switch_rtp_crypto_key_type_t ctype, switch_rtp_crypto_direction_t direction, int force, int use_alias)
{
        unsigned char b64_key[512] = "";
        unsigned char *key;
        const char *val;
        switch_channel_t *channel;
        char *p;
        switch_rtp_engine_t *engine;

        switch_assert(smh);
        channel = switch_core_session_get_channel(smh->session);

        engine = &smh->engines[type];

        if (!force && engine->ssec[ctype].local_raw_key[0]) {
                return SWITCH_STATUS_SUCCESS;
        }

//#define SAME_KEY
#ifdef SAME_KEY
        if (switch_channel_test_flag(channel, CF_AVPF) && type == SWITCH_MEDIA_TYPE_VIDEO) {
                if (direction == SWITCH_RTP_CRYPTO_SEND) {
                        memcpy(engine->ssec[ctype].local_raw_key, smh->engines[SWITCH_MEDIA_TYPE_AUDIO].ssec.local_raw_key, SUITES[ctype].keysalt_len);
                        key = engine->ssec[ctype].local_raw_key;
                } else {
                        memcpy(engine->ssec[ctype].remote_raw_key, smh->engines[SWITCH_MEDIA_TYPE_AUDIO].ssec.remote_raw_key, SUITES[ctype].keysalt_len);
                        key = engine->ssec[ctype].remote_raw_key;
                }
        } else {
#endif
                if (direction == SWITCH_RTP_CRYPTO_SEND) {
                        key = engine->ssec[ctype].local_raw_key;
                } else {
                        key = engine->ssec[ctype].remote_raw_key;
                }

                switch_rtp_get_random(key, SUITES[ctype].keysalt_len);
#ifdef SAME_KEY
        }
#endif

        switch_b64_encode(key, SUITES[ctype].keysalt_len, b64_key, sizeof(b64_key));
        if (switch_channel_var_false(channel, "rtp_pad_srtp_keys")) {
                p = strrchr((char *) b64_key, '=');

                while (p && *p && *p == '=') {
                        *p-- = '\0';
                }
        }

        if (index == SWITCH_NO_CRYPTO_TAG) index = ctype + 1;

        if (switch_channel_var_true(channel, "rtp_secure_media_mki")) { 
                engine->ssec[ctype].local_crypto_key = switch_core_session_sprintf(smh->session, "%d %s inline:%s|2^31|1:1", index, (use_alias ? SUITES[ctype].alias : SUITES[ctype].name), b64_key);
        } else {
                engine->ssec[ctype].local_crypto_key = switch_core_session_sprintf(smh->session, "%d %s inline:%s", index, (use_alias ? SUITES[ctype].alias : SUITES[ctype].name), b64_key);
        }

        switch_channel_set_variable_name_printf(smh->session->channel, engine->ssec[ctype].local_crypto_key, "rtp_last_%s_local_crypto_key", type2str(type));
        switch_channel_set_flag(smh->session->channel, CF_SECURE);

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "Set Local %s crypto Key [%s]\n",
                                          type2str(type),
                                          engine->ssec[ctype].local_crypto_key);

        if (!(smh->mparams->ndlb & SM_NDLB_DISABLE_SRTP_AUTH) &&
                !((val = switch_channel_get_variable(channel, "NDLB_support_asterisk_missing_srtp_auth")) && switch_true(val))) {
                engine->ssec[ctype].crypto_type = ctype;
        } else {
                engine->ssec[ctype].crypto_type = AES_CM_128_NULL_AUTH;
        }

        return SWITCH_STATUS_SUCCESS;
}

#define CRYPTO_KEY_MATERIAL_LIFETIME_MKI_ERR    0x0u
#define CRYPTO_KEY_MATERIAL_MKI                                 0x1u
#define CRYPTO_KEY_MATERIAL_LIFETIME                    0x2u

#define RAW_BITS_PER_64_ENCODED_CHAR 6

/* Return uint32_t which contains all the info about the field found:
 * XXXXXXXa | YYYYYYYY | YYYYYYYY | ZZZZZZZZ
 * where:
 * a - CRYPTO_KEY_MATERIAL_LIFETIME if LIFETIME, CRYPTO_KEY_MATERIAL_MKI if MKI
 * YYYYYYYY and ZZZZZZZZ - depend on 'a':
 *                              if a is LIFETIME then YYYYYYYY is decimal Base, ZZZZZZZZ is decimal Exponent
 *                              if a is MKI, then YYYYYYYY is decimal MKI_ID, ZZZZZZZZ is decimal MKI_SIZE
 */
static uint32_t parse_lifetime_mki(const char **p, const char *end)
{
        const char *field_begin;
        const char *field_end;
        const char *sep, *space;
        uint32_t res = 0;

        uint32_t val = 0;
        int i;

        switch_assert(*p != NULL);
        switch_assert(end != NULL);

        field_begin = strchr(*p, '|');

        if (field_begin && (field_begin + 1 < end)) {
                space = strchr(field_begin, ' ');
                field_end = strchr(field_begin + 2, '|');

                if (!field_end) {
                                field_end = end;
                }

                if (space) {
                        if ((field_end == NULL) || (space < field_end)) {
                                field_end = space;
                        }
                }

                if (field_end) {
                        /* Closing '|' found. */
                        sep = strchr(field_begin, ':');         /* The lifetime field never includes a colon, whereas the third field always does. (RFC 4568) */
                        if (sep && (sep + 1 < field_end) && isdigit(*(sep + 1))) {
                                res |= (CRYPTO_KEY_MATERIAL_MKI << 24);

                                for (i = 1, *p = sep - 1; *p != field_begin; --(*p), i *= 10) {
                                        val += ((**p) - '0') * i;
                                }

                                res |= ((val << 8) & 0x00ffff00);                       /* MKI_ID */

                                val = 0;
                                for (i = 1, *p = field_end - 1; *p != sep; --(*p), i *= 10) {
                                        val += ((**p) - '0') * i;
                                }
                                res |= (val & 0x000000ff);                                      /* MKI_SIZE */
                        } else if (isdigit(*(field_begin + 1)) && (*(field_begin + 2) == '^') && isdigit(*(field_begin + 3))) {
                                res |= (CRYPTO_KEY_MATERIAL_LIFETIME << 24);
                                val = ((uint32_t) (*(field_begin + 1) - '0')) << 8;
                                res |= val;                                                                     /* LIFETIME base. */

                                val = 0;
                                for (i = 1, *p = field_end - 1; *p != (field_begin + 2); --(*p), i *= 10) {
                                        val += ((**p) - '0') * i;
                                }

                                res |= (val & 0x000000ff);                                      /* LIFETIME exponent. */
                        }
                }

                *p = field_end;
        }

        return res;
}

static switch_crypto_key_material_t* switch_core_media_crypto_append_key_material(
                switch_core_session_t *session,
                switch_crypto_key_material_t *tail,
                switch_rtp_crypto_key_param_method_type_t method,
                unsigned char raw_key[SWITCH_RTP_MAX_CRYPTO_LEN],
                int raw_key_len,
                const char *key_material,
                int key_material_len,
                uint64_t lifetime,
                unsigned int mki_id,
                unsigned int mki_size)
{
        struct switch_crypto_key_material_s *new_key_material;

        new_key_material = switch_core_session_alloc(session, (sizeof(*new_key_material)));
        if (new_key_material == NULL) {
                return NULL;
        }

        new_key_material->method = method;
        memcpy(new_key_material->raw_key, raw_key, raw_key_len);
        new_key_material->crypto_key = switch_core_session_strdup(session, key_material);
        new_key_material->lifetime = lifetime;
        new_key_material->mki_id = mki_id;
        new_key_material->mki_size = mki_size;

        new_key_material->next = tail;

        return new_key_material;
}

/* 
 * Skip all space and return pointer to the '\0' terminator of the char string candidate to be a key-material
 * or pointer to first ' ' in the candidate string.
 */
static const char* switch_core_media_crypto_find_key_material_candidate_end(const char *p)
{
        const char *end = NULL;

        switch_assert(p != NULL);

        if (p) {
                end = strchr(p, ' ');   /* find the end of the continuous string of characters in the candidate string */
                if (end == NULL)
                        end = p + strlen(p);
        }

        return end;
}

SWITCH_DECLARE(switch_status_t) switch_core_media_add_crypto(switch_core_session_t *session, switch_secure_settings_t *ssec, switch_rtp_crypto_direction_t direction)
{
        unsigned char key[SWITCH_RTP_MAX_CRYPTO_LEN];
        switch_rtp_crypto_key_type_t type;

        const char *p, *delimit;
        const char *key_material_begin;
        const char *key_material_end = NULL; /* begin and end of the current key material candidate */
        int method_len;
        int keysalt_len;

        const char              *opts;
        uint32_t        opt_field;              /* LIFETIME or MKI */
        switch_rtp_crypto_key_param_method_type_t       method = CRYPTO_KEY_PARAM_METHOD_INLINE;
        uint64_t                lifetime = 0;
        uint16_t                lifetime_base = 0;
        uint16_t                lifetime_exp = 0;
        uint16_t                mki_id = 0;
        uint16_t                mki_size = 0;
        switch_crypto_key_material_t *key_material = NULL;
        unsigned long   *key_material_n = NULL;

        bool multiple_keys = false;

        const char *key_param;


        if (direction == SWITCH_RTP_CRYPTO_SEND || direction == SWITCH_RTP_CRYPTO_SEND_RTCP) {
                key_param = ssec->local_crypto_key;
                key_material = ssec->local_key_material_next;
                key_material_n = &ssec->local_key_material_n;
        } else {
                key_param = ssec->remote_crypto_key;
                key_material = ssec->remote_key_material_next;
                key_material_n = &ssec->remote_key_material_n;
        }

        if (zstr(key_param)) {
                goto no_crypto_found;
        }

        *key_material_n = 0;

        p = strchr(key_param, ' ');

        if (!(p && *p && *(p + 1))) {
                goto no_crypto_found;
        }

        p++;

        type = switch_core_media_crypto_str2type(p);

        if (type == CRYPTO_INVALID) {
                goto bad_crypto;
        }

        p = strchr(p, ' '); /* skip the crypto suite description */
        if (p == NULL) {
                goto bad_crypto;
        }

        do {
                if (*key_material_n == SWITCH_CRYPTO_MKI_MAX) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Skipping excess of MKIs due to max number of suppoerted MKIs %d exceeded\n", SWITCH_CRYPTO_MKI_MAX);
                        break;
                }

                p = switch_strip_spaces((char*) p, 0);
                if (!p) {
                        break;
                }

                key_material_begin = p;
                key_material_end = switch_core_media_crypto_find_key_material_candidate_end(p);

                /* Parsing the key material candidate within [begin, end). */

                if ((delimit = strchr(p, ':')) == NULL) {
                        goto bad_error_parsing_near;
                }

                method_len = delimit - p;

                if (strncasecmp(p, CRYPTO_KEY_PARAM_METHOD[CRYPTO_KEY_PARAM_METHOD_INLINE], method_len)) {
                        goto bad_key_param_method;
                }

                method = CRYPTO_KEY_PARAM_METHOD_INLINE;

                /* Valid key-material found. Save as default key in secure_settings_s. */

                p = delimit + 1;                                /* skip ':' */
                if (!(p && *p && *(p + 1))) {
                        goto bad_keysalt;
                }

                /* Check if '|' is present in currently considered key-material. */
                if ((opts = strchr(p, '|')) && (opts < key_material_end)) {
                        keysalt_len = opts - p;
                } else {
                        keysalt_len = key_material_end - p;
                }

                if (keysalt_len > sizeof(key)) {
                        goto bad_keysalt_len;
                }

                switch_b64_decode(p, (char *) key, keysalt_len);

                if (!multiple_keys) { /* First key becomes default (used in case no MKI is found). */
                        if (direction == SWITCH_RTP_CRYPTO_SEND) {
                                memcpy(ssec->local_raw_key, key, SUITES[type].keysalt_len);
                        } else {
                                memcpy(ssec->remote_raw_key, key, SUITES[type].keysalt_len);
                        }
                        multiple_keys = true;
                }

                p += keysalt_len;

                if (!(p < key_material_end)) {
                        continue;
                }

                if (opts) {     /* if opts != NULL then opts points to first '|' in current key-material cadidate, parse it as LIFETIME or MKI */

                        lifetime = 0;
                        mki_id = 0;
                        mki_size = 0;

                        for (int i = 0; i < 2 && (*opts == '|'); ++i) {

                                opt_field = parse_lifetime_mki(&opts, key_material_end);

                                switch ((opt_field  >> 24) & 0x3) {

                                        case CRYPTO_KEY_MATERIAL_LIFETIME:

                                                lifetime_base = ((opt_field & 0x00ffff00) >> 8) & 0xffff;
                                                lifetime_exp = (opt_field & 0x000000ff) & 0xffff;
                                                lifetime = pow(lifetime_base, lifetime_exp);
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "LIFETIME found in %s, base %u exp %u\n", p, lifetime_base, lifetime_exp);
                                                break;

                                        case CRYPTO_KEY_MATERIAL_MKI:

                                                mki_id = ((opt_field & 0x00ffff00) >> 8) & 0xffff;
                                                mki_size = (opt_field & 0x000000ff) & 0xffff;
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "MKI found in %s, id %u size %u\n", p, mki_id, mki_size);
                                                break;

                                        default:
                                                goto bad_key_lifetime_or_mki;
                                }
                        }

                        if (mki_id == 0 && lifetime == 0) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Bad MKI found in %s, (parsed as: id %u size %u lifetime base %u exp %u\n", p, mki_id, mki_size, lifetime_base, lifetime_exp);
                                return SWITCH_STATUS_FALSE;
                        } else if (mki_id == 0 || lifetime == 0) {
                                if (mki_id == 0) {
                                        if (key_material)
                                                goto bad_key_no_mki_index;

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Skipping MKI due to empty index\n");
                                } else {
                                        if (mki_size == 0)
                                                goto bad_key_no_mki_size;

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Skipping MKI due to empty lifetime\n");
                                }
                                continue;
                        }
                }

                if (key_material) {
                        if (mki_id == 0) {
                                goto bad_key_no_mki_index;
                        }

                        if (mki_size != key_material->mki_size) {
                                goto bad_key_mki_size;
                        }
                }

                key_material = switch_core_media_crypto_append_key_material(session, key_material, method, (unsigned char*) key,
                                SUITES[type].keysalt_len, (char*) key_material_begin, key_material_end - key_material_begin, lifetime, mki_id, mki_size);
                *key_material_n = *key_material_n + 1;
        } while ((p = switch_strip_spaces((char*) key_material_end, 0)) && (*p != '\0'));

        if (direction == SWITCH_RTP_CRYPTO_SEND || direction == SWITCH_RTP_CRYPTO_SEND_RTCP) {
                ssec->local_key_material_next = key_material;
        } else {
                ssec->remote_key_material_next = key_material;
        }

        return SWITCH_STATUS_SUCCESS;


no_crypto_found:
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error! No crypto to parse\n");
        return SWITCH_STATUS_FALSE;

bad_error_parsing_near:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! Parsing near %s\n", p);
        return SWITCH_STATUS_FALSE;

bad_crypto:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! SRTP: Invalid format of crypto attribute %s\n", key_param);
        return SWITCH_STATUS_FALSE;

bad_keysalt:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! SRTP: Invalid keysalt in the crypto attribute %s\n", key_param);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! Parsing near %s\n", p);
        return SWITCH_STATUS_FALSE;

bad_keysalt_len:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! SRTP: Invalid keysalt length in the crypto attribute %s\n", key_param);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! Parsing near %s\n", p);
        return SWITCH_STATUS_FALSE;

bad_key_lifetime_or_mki:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! SRTP: Invalid key param MKI or LIFETIME in the crypto attribute %s\n", key_param);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! Parsing near %s\n", p);
        return SWITCH_STATUS_FALSE;

bad_key_no_mki_index:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Crypto invalid: multiple keys in a single crypto MUST all have MKI indices, %s\n", key_param);
        return SWITCH_STATUS_FALSE;

bad_key_no_mki_size:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Crypto invalid: MKI index with no MKI size in %s\n", key_param);
        return SWITCH_STATUS_FALSE;

bad_key_mki_size:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Crypto invalid: MKI sizes differ in %s\n", key_param);
        return SWITCH_STATUS_FALSE;

bad_key_param_method:
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! SRTP: Invalid key param method type in %s\n", key_param);
        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Error! Parsing near %s\n", p);
        return SWITCH_STATUS_FALSE;
}

SWITCH_DECLARE(void) switch_core_media_set_rtp_session(switch_core_session_t *session, switch_media_type_t type, switch_rtp_t *rtp_session)
{
        switch_rtp_engine_t *engine;
        if (!session->media_handle) return;
        engine = &session->media_handle->engines[type];
        engine->rtp_session = rtp_session;
        engine->type = type;
}

SWITCH_DECLARE(switch_rtp_t *) switch_core_media_get_rtp_session(switch_core_session_t *session, switch_media_type_t type)
{
        switch_assert(session);
        if (!session->media_handle) return NULL;
        return session->media_handle->engines[type].rtp_session;
}

static void switch_core_session_get_recovery_crypto_key(switch_core_session_t *session, switch_media_type_t type)
{
        const char *tmp;
        switch_rtp_engine_t *engine;
        char *keyvar, *tagvar, *ctypevar;

        if (!session->media_handle) return;
        engine = &session->media_handle->engines[type];

        if (type == SWITCH_MEDIA_TYPE_AUDIO) {
                keyvar = "srtp_remote_audio_crypto_key";
                tagvar = "srtp_remote_audio_crypto_tag";
                ctypevar = "srtp_remote_audio_crypto_type";
        } else if (type == SWITCH_MEDIA_TYPE_VIDEO) {
                keyvar = "srtp_remote_video_crypto_key";
                tagvar = "srtp_remote_video_crypto_tag";
                ctypevar = "srtp_remote_video_crypto_type";
        } else if (type == SWITCH_MEDIA_TYPE_TEXT) {
                keyvar = "srtp_remote_text_crypto_key";
                tagvar = "srtp_remote_text_crypto_tag";
                ctypevar = "srtp_remote_text_crypto_type";
        } else return;

        if ((tmp = switch_channel_get_variable(session->channel, keyvar))) {
                const char *ct;
                if ((ct = switch_channel_get_variable(session->channel, ctypevar))) {
                        engine->crypto_type = switch_core_media_crypto_str2type(ct);
                }

                engine->ssec[engine->crypto_type].remote_crypto_key = switch_core_session_strdup(session, tmp);

                if ((tmp = switch_channel_get_variable(session->channel, tagvar))) {
                        int tv = atoi(tmp);
                        engine->ssec[engine->crypto_type].crypto_tag = tv;
                } else {
                        engine->ssec[engine->crypto_type].crypto_tag = 1;
                }

                switch_channel_set_flag(session->channel, CF_SECURE);
        }
}


static void switch_core_session_apply_crypto(switch_core_session_t *session, switch_media_type_t type)
{
        switch_rtp_engine_t *engine;
        const char *varname;

        if (type == SWITCH_MEDIA_TYPE_AUDIO) {
                varname = "rtp_secure_audio_confirmed";
        } else if (type == SWITCH_MEDIA_TYPE_VIDEO) {
                varname = "rtp_secure_video_confirmed";
        } else if (type == SWITCH_MEDIA_TYPE_TEXT) {
                varname = "rtp_secure_text_confirmed";
        } else {
                return;
        }

        if (!session->media_handle) return;

        engine = &session->media_handle->engines[type];

        if (switch_channel_test_flag(session->channel, CF_RECOVERING)) {
                return;
        }

        if (engine->ssec[engine->crypto_type].remote_crypto_key && switch_channel_test_flag(session->channel, CF_SECURE)) {
                
                if (switch_channel_var_true(session->channel, "rtp_secure_media_mki"))
                        switch_core_media_add_crypto(session, &engine->ssec[engine->crypto_type], SWITCH_RTP_CRYPTO_SEND);

                switch_core_media_add_crypto(session, &engine->ssec[engine->crypto_type], SWITCH_RTP_CRYPTO_RECV);


                switch_rtp_add_crypto_key(engine->rtp_session, SWITCH_RTP_CRYPTO_SEND, 1, &engine->ssec[engine->crypto_type]);

                switch_rtp_add_crypto_key(engine->rtp_session, SWITCH_RTP_CRYPTO_RECV, engine->ssec[engine->crypto_type].crypto_tag, &engine->ssec[engine->crypto_type]);

                switch_channel_set_variable(session->channel, varname, "true");


                switch_channel_set_variable(session->channel, "rtp_secure_media_negotiated", SUITES[engine->crypto_type].name);

        }

}

static void switch_core_session_parse_crypto_prefs(switch_core_session_t *session)
{
        const char *var = NULL;
        const char *val = NULL;
        char *suites = NULL;
        switch_media_handle_t *smh;
        char *fields[CRYPTO_INVALID+1];
        int argc = 0, i = 0, j = 0, k = 0;

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                return;
        }

        if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                var = "rtp_secure_media_inbound";
        } else {
                var = "rtp_secure_media_outbound";
        }

        if (!(val = switch_channel_get_variable(session->channel, var))) {
                var = "rtp_secure_media";
                val = switch_channel_get_variable(session->channel, var);
        }

        if (!zstr(val) && (suites = strchr(val, ':'))) {
                *suites++ = '\0';
        }

        if (zstr(suites)) {
                suites = (char *) switch_channel_get_variable(session->channel, "rtp_secure_media_suites");
        }

        if (zstr(val)) {
                if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND && !switch_channel_test_flag(session->channel, CF_RECOVERING)) {
                        val = "optional";
                } else {
                        val = "forbidden";
                }
        }

        if (!strcasecmp(val, "optional")) {
                smh->crypto_mode = CRYPTO_MODE_OPTIONAL;
        } else if (switch_true(val) || !strcasecmp(val, "mandatory")) {
                smh->crypto_mode = CRYPTO_MODE_MANDATORY;
        } else {
                smh->crypto_mode = CRYPTO_MODE_FORBIDDEN;
                if (!switch_false(val) && strcasecmp(val, "forbidden")) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "INVALID VALUE FOR %s defaulting to 'forbidden'\n", var);
                }
        }

        if (smh->crypto_mode != CRYPTO_MODE_FORBIDDEN && !zstr(suites)) {
                argc = switch_split((char *)suites, ':', fields);

                for (i = 0; i < argc; i++) {
                        int ok = 0;

                        for (j = 0; j < CRYPTO_INVALID; j++) {
                                if (!strcasecmp(fields[i], SUITES[j].name)) {
                                        smh->crypto_suite_order[k++] = SUITES[j].type;
                                        ok++;
                                        break;
                                }
                        }

                        if (!ok) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "INVALID SUITE SUPPLIED\n");
                        }

                }
        } else {
                for (i = 0; i < CRYPTO_INVALID; i++) {
                        smh->crypto_suite_order[k++] = SUITES[i].type;
                }
        }
}

SWITCH_DECLARE(int) switch_core_session_check_incoming_crypto(switch_core_session_t *session,
                                                                                                                           const char *varname,
                                                                                                                          switch_media_type_t type, const char *crypto, int crypto_tag, switch_sdp_type_t sdp_type)
{
        int got_crypto = 0;
        int i = 0;
        int ctype = 0;
        const char *vval = NULL;
        int use_alias = 0;
        switch_rtp_engine_t *engine;
        switch_media_handle_t *smh;

        if (!(smh = session->media_handle)) {
                return 0;
        }

        if (smh->crypto_mode == CRYPTO_MODE_FORBIDDEN) {
                return -1;
        }

        if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                return 0;
        }

        if (!crypto) {
                return 0;
        }
        engine = &session->media_handle->engines[type];

        for (i = 0; smh->crypto_suite_order[i] != CRYPTO_INVALID; i++) {
                switch_rtp_crypto_key_type_t j = SUITES[smh->crypto_suite_order[i]].type;

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "looking for crypto suite [%s]alias=[%s] in [%s]\n", SUITES[j].name, SUITES[j].alias, crypto);

                if (switch_stristr(SUITES[j].alias, crypto)) {
                        use_alias = 1;
                }
                
                if (use_alias || switch_stristr(SUITES[j].name, crypto)) {
                        ctype = SUITES[j].type;
                        vval = use_alias ? SUITES[j].alias : SUITES[j].name;
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Found suite %s\n", vval);
                        switch_channel_set_variable(session->channel, "rtp_secure_media_negotiated", vval);
                        break;
                }

                use_alias = 0;
        }

        if (engine->ssec[engine->crypto_type].remote_crypto_key && switch_rtp_ready(engine->rtp_session)) {
                /* Compare all the key. The tag may remain the same even if key changed */
                if (engine->crypto_type != CRYPTO_INVALID && !strcmp(crypto, engine->ssec[engine->crypto_type].remote_crypto_key)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Existing key is still valid.\n");
                        got_crypto = 1;
                } else {
                        const char *a = switch_stristr("AE", engine->ssec[engine->crypto_type].remote_crypto_key);
                        const char *b = switch_stristr("AE", crypto);

                        if (sdp_type == SDP_OFFER) {
                                if (!vval) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Unsupported Crypto [%s]\n", crypto);
                                        goto end;
                                }
                                switch_channel_set_variable(session->channel, varname, vval);

                                switch_core_media_build_crypto(session->media_handle, type, crypto_tag, ctype, SWITCH_RTP_CRYPTO_SEND, 1, use_alias);
                                switch_rtp_add_crypto_key(engine->rtp_session, SWITCH_RTP_CRYPTO_SEND, atoi(crypto), &engine->ssec[engine->crypto_type]);
                        }

                        if (a && b && !strncasecmp(a, b, 23)) {
                                engine->crypto_type = ctype;

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Change Remote key to [%s]\n", crypto);
                                engine->ssec[engine->crypto_type].remote_crypto_key = switch_core_session_strdup(session, crypto);

                                if (engine->type == SWITCH_MEDIA_TYPE_AUDIO) {
                                        switch_channel_set_variable(session->channel, "srtp_remote_audio_crypto_key", crypto);
                                        switch_channel_set_variable_printf(session->channel, "srtp_remote_audio_crypto_tag", "%d", crypto_tag);
                                        switch_channel_set_variable_printf(session->channel, "srtp_remote_audio_crypto_type", "%s", switch_core_media_crypto_type2str(ctype));
                                } else if (engine->type == SWITCH_MEDIA_TYPE_VIDEO) {
                                        switch_channel_set_variable(session->channel, "srtp_remote_video_crypto_key", crypto);
                                        switch_channel_set_variable_printf(session->channel, "srtp_remote_video_crypto_tag", "%d", crypto_tag);
                                        switch_channel_set_variable_printf(session->channel, "srtp_remote_video_crypto_type", "%s", switch_core_media_crypto_type2str(ctype));
                                } else if (engine->type == SWITCH_MEDIA_TYPE_TEXT) {
                                        switch_channel_set_variable(session->channel, "srtp_remote_text_crypto_key", crypto);
                                        switch_channel_set_variable_printf(session->channel, "srtp_remote_text_crypto_tag", "%d", crypto_tag);
                                        switch_channel_set_variable_printf(session->channel, "srtp_remote_text_crypto_type", "%s", switch_core_media_crypto_type2str(ctype));
                                }

                                engine->ssec[engine->crypto_type].crypto_tag = crypto_tag;


                                if (switch_rtp_ready(engine->rtp_session) && switch_channel_test_flag(session->channel, CF_SECURE)) {
                                        switch_core_media_add_crypto(session, &engine->ssec[engine->crypto_type], SWITCH_RTP_CRYPTO_RECV);
                                        switch_rtp_add_crypto_key(engine->rtp_session, SWITCH_RTP_CRYPTO_RECV, engine->ssec[engine->crypto_type].crypto_tag, &engine->ssec[engine->crypto_type]);
                                }
                                got_crypto++;

                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Ignoring unacceptable key\n");
                        }
                }
        } else if (!switch_rtp_ready(engine->rtp_session)) {

                if (!vval) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Unsupported Crypto [%s]\n", crypto);
                        goto end;
                }

                engine->crypto_type = ctype;
                engine->ssec[engine->crypto_type].remote_crypto_key = switch_core_session_strdup(session, crypto);
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set Remote Key [%s]\n", engine->ssec[engine->crypto_type].remote_crypto_key);
                if (engine->type == SWITCH_MEDIA_TYPE_AUDIO) {
                        switch_channel_set_variable(session->channel, "srtp_remote_audio_crypto_key", crypto);
                        switch_channel_set_variable_printf(session->channel, "srtp_remote_audio_crypto_type", "%s", switch_core_media_crypto_type2str(ctype));
                } else if (engine->type == SWITCH_MEDIA_TYPE_VIDEO) {
                        switch_channel_set_variable(session->channel, "srtp_remote_video_crypto_key", crypto);
                        switch_channel_set_variable_printf(session->channel, "srtp_remote_video_crypto_type", "%s", switch_core_media_crypto_type2str(ctype));
                } else if (engine->type == SWITCH_MEDIA_TYPE_TEXT) {
                        switch_channel_set_variable(session->channel, "srtp_remote_text_crypto_key", crypto);
                        switch_channel_set_variable_printf(session->channel, "srtp_remote_text_crypto_type", "%s", switch_core_media_crypto_type2str(ctype));
                }

                engine->ssec[engine->crypto_type].crypto_tag = crypto_tag;
                got_crypto++;

                switch_channel_set_variable(session->channel, varname, vval);
                switch_channel_set_flag(smh->session->channel, CF_SECURE);

                if (zstr(engine->ssec[engine->crypto_type].local_crypto_key)) {
                        switch_core_media_build_crypto(session->media_handle, type, crypto_tag, ctype, SWITCH_RTP_CRYPTO_SEND, 1, use_alias);
                }
        }

 end:

        return got_crypto;
}


SWITCH_DECLARE(void) switch_core_session_check_outgoing_crypto(switch_core_session_t *session)
{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_handle_t *smh;
        int i;

        if (switch_core_session_media_handle_ready(session) != SWITCH_STATUS_SUCCESS) {
                return;
        }

        if (!(smh = session->media_handle)) {
                return;
        }

        if (!(smh->crypto_mode == CRYPTO_MODE_OPTIONAL || smh->crypto_mode == CRYPTO_MODE_MANDATORY)) {
                return;
        }

        if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                return;
        }

        switch_channel_set_flag(channel, CF_SECURE);

        for (i = 0; smh->crypto_suite_order[i] != CRYPTO_INVALID; i++) {
                switch_core_media_build_crypto(session->media_handle,
                                                                           SWITCH_MEDIA_TYPE_AUDIO, SWITCH_NO_CRYPTO_TAG, smh->crypto_suite_order[i], SWITCH_RTP_CRYPTO_SEND, 0, 0);

                switch_core_media_build_crypto(session->media_handle,
                                                                           SWITCH_MEDIA_TYPE_VIDEO, SWITCH_NO_CRYPTO_TAG, smh->crypto_suite_order[i], SWITCH_RTP_CRYPTO_SEND, 0, 0);

                switch_core_media_build_crypto(session->media_handle,
                                                                           SWITCH_MEDIA_TYPE_TEXT, SWITCH_NO_CRYPTO_TAG, smh->crypto_suite_order[i], SWITCH_RTP_CRYPTO_SEND, 0, 0);
        }

}

#define add_stat(_i, _s)                                                                                                \
        switch_snprintf(var_name, sizeof(var_name), "rtp_%s_%s", switch_str_nil(prefix), _s) ; \
        switch_snprintf(var_val, sizeof(var_val), "%" SWITCH_SIZE_T_FMT, _i); \
        switch_channel_set_variable(channel, var_name, var_val)

#define add_stat_double(_i, _s)                                                                                         \
        switch_snprintf(var_name, sizeof(var_name), "rtp_%s_%s", switch_str_nil(prefix), _s) ; \
        switch_snprintf(var_val, sizeof(var_val), "%0.2f", _i); \
        switch_channel_set_variable(channel, var_name, var_val)

static void set_stats(switch_core_session_t *session, switch_media_type_t type, const char *prefix)
{
        switch_rtp_stats_t *stats = switch_core_media_get_stats(session, type, NULL);
        switch_channel_t *channel = switch_core_session_get_channel(session);

        char var_name[256] = "", var_val[35] = "";

        if (stats) {
                stats->inbound.std_deviation = sqrt(stats->inbound.variance);

                add_stat(stats->inbound.raw_bytes, "in_raw_bytes");
                add_stat(stats->inbound.media_bytes, "in_media_bytes");
                add_stat(stats->inbound.packet_count, "in_packet_count");
                add_stat(stats->inbound.media_packet_count, "in_media_packet_count");
                add_stat(stats->inbound.skip_packet_count, "in_skip_packet_count");
                add_stat(stats->inbound.jb_packet_count, "in_jitter_packet_count");
                add_stat(stats->inbound.dtmf_packet_count, "in_dtmf_packet_count");
                add_stat(stats->inbound.cng_packet_count, "in_cng_packet_count");
                add_stat(stats->inbound.flush_packet_count, "in_flush_packet_count");
                add_stat(stats->inbound.largest_jb_size, "in_largest_jb_size");
                add_stat_double(stats->inbound.min_variance, "in_jitter_min_variance");
                add_stat_double(stats->inbound.max_variance, "in_jitter_max_variance");
                add_stat_double(stats->inbound.lossrate, "in_jitter_loss_rate");
                add_stat_double(stats->inbound.burstrate, "in_jitter_burst_rate");
                add_stat_double(stats->inbound.mean_interval, "in_mean_interval");
                add_stat(stats->inbound.flaws, "in_flaw_total");
                add_stat_double(stats->inbound.R, "in_quality_percentage");
                add_stat_double(stats->inbound.mos, "in_mos");


                add_stat(stats->outbound.raw_bytes, "out_raw_bytes");
                add_stat(stats->outbound.media_bytes, "out_media_bytes");
                add_stat(stats->outbound.packet_count, "out_packet_count");
                add_stat(stats->outbound.media_packet_count, "out_media_packet_count");
                add_stat(stats->outbound.skip_packet_count, "out_skip_packet_count");
                add_stat(stats->outbound.dtmf_packet_count, "out_dtmf_packet_count");
                add_stat(stats->outbound.cng_packet_count, "out_cng_packet_count");

                add_stat(stats->rtcp.packet_count, "rtcp_packet_count");
                add_stat(stats->rtcp.octet_count, "rtcp_octet_count");

        }
}

SWITCH_DECLARE(void) switch_core_media_sync_stats(switch_core_session_t *session)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (a_engine->rtp_session) {
                switch_rtp_sync_stats(a_engine->rtp_session);
        }

        if (v_engine->rtp_session) {
                switch_rtp_sync_stats(v_engine->rtp_session);
        }

        if (t_engine->rtp_session) {
                switch_rtp_sync_stats(t_engine->rtp_session);
        }

}

SWITCH_DECLARE(void) switch_core_media_set_stats(switch_core_session_t *session)
{

        if (!session->media_handle) {
                return;
        }

        switch_core_media_sync_stats(session);

        set_stats(session, SWITCH_MEDIA_TYPE_AUDIO, "audio");
        set_stats(session, SWITCH_MEDIA_TYPE_VIDEO, "video");
        set_stats(session, SWITCH_MEDIA_TYPE_TEXT, "text");
}



SWITCH_DECLARE(void) switch_media_handle_destroy(switch_core_session_t *session)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine, *v_engine;//, *t_engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        //t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];


        if (smh->video_timer.timer_interface) {
                switch_core_timer_destroy(&smh->video_timer);
        }

        if (switch_core_codec_ready(&a_engine->read_codec)) {
                switch_core_codec_destroy(&a_engine->read_codec);
        }

        if (switch_core_codec_ready(&a_engine->write_codec)) {
                switch_core_codec_destroy(&a_engine->write_codec);
        }

        if (switch_core_codec_ready(&v_engine->read_codec)) {
                switch_core_codec_destroy(&v_engine->read_codec);
        }

        if (switch_core_codec_ready(&v_engine->write_codec)) {
                switch_core_codec_destroy(&v_engine->write_codec);
        }

        switch_core_session_unset_read_codec(session);
        switch_core_session_unset_write_codec(session);
        switch_core_media_deactivate_rtp(session);

        if (a_engine->write_fb) switch_frame_buffer_destroy(&a_engine->write_fb);

        if (smh->msrp_session) switch_msrp_session_destroy(&smh->msrp_session);
}


SWITCH_DECLARE(switch_status_t) switch_media_handle_create(switch_media_handle_t **smhp, switch_core_session_t *session, switch_core_media_params_t *params)
{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_media_handle_t *smh = NULL;
        int i;

        *smhp = NULL;

        if (zstr(params->sdp_username)) {
                params->sdp_username = "FreeSWITCH";
        }


        if ((session->media_handle = switch_core_session_alloc(session, (sizeof(*smh))))) {
                session->media_handle->session = session;


                *smhp = session->media_handle;
                switch_set_flag(session->media_handle, SMF_INIT);
                session->media_handle->media_flags[SCMF_RUNNING] = 1;

                session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].read_frame.buflen = SWITCH_RTP_MAX_BUF_LEN;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].type = SWITCH_MEDIA_TYPE_AUDIO;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].crypto_type = CRYPTO_INVALID;

                for (i = 0; i < CRYPTO_INVALID; i++) {
                        session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].ssec[i].crypto_type = i;
                }



                session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].read_frame.buflen = SWITCH_RTP_MAX_BUF_LEN;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].type = SWITCH_MEDIA_TYPE_TEXT;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].crypto_type = CRYPTO_INVALID;

                for (i = 0; i < CRYPTO_INVALID; i++) {
                        session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].ssec[i].crypto_type = i;
                }



                session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].read_frame.buflen = SWITCH_RTP_MAX_BUF_LEN;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].type = SWITCH_MEDIA_TYPE_VIDEO;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].crypto_type = CRYPTO_INVALID;


                switch_channel_set_variable(session->channel, "video_media_flow", "disabled");
                switch_channel_set_variable(session->channel, "audio_media_flow", "disabled");
                switch_channel_set_variable(session->channel, "text_media_flow", "disabled");

                session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].smode = SWITCH_MEDIA_FLOW_DISABLED;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].smode = SWITCH_MEDIA_FLOW_DISABLED;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].smode = SWITCH_MEDIA_FLOW_DISABLED;

                for (i = 0; i < CRYPTO_INVALID; i++) {
                        session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].ssec[i].crypto_type = i;
                }

                session->media_handle->mparams = params;

                //if (!session->media_handle->mparams->video_key_freq) {
                //      session->media_handle->mparams->video_key_freq = 10000000;
                //}

                if (!session->media_handle->mparams->video_key_first) {
                        session->media_handle->mparams->video_key_first = 1000000;
                }


                for (i = 0; i <= CRYPTO_INVALID; i++) {
                        session->media_handle->crypto_suite_order[i] = CRYPTO_INVALID;
                }

                switch_mutex_init(&session->media_handle->mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
                switch_mutex_init(&session->media_handle->sdp_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
                switch_mutex_init(&session->media_handle->control_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));

                session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].ssrc =
                        (uint32_t) ((intptr_t) &session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO] + (switch_time_t) time(NULL));

                session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].ssrc =
                        (uint32_t) ((intptr_t) &session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO] + (switch_time_t) time(NULL) / 2);

                session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].ssrc =
                        (uint32_t) ((intptr_t) &session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT] + (switch_time_t) time(NULL) / 2);



                session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].payload_map = switch_core_alloc(session->pool, sizeof(payload_map_t));
                session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].cur_payload_map = session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].payload_map;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_AUDIO].cur_payload_map->current = 1;

                session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].payload_map = switch_core_alloc(session->pool, sizeof(payload_map_t));
                session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].cur_payload_map = session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].payload_map;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].cur_payload_map->current = 1;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_VIDEO].codec_settings.video.try_hardware_encoder = 1;


                session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].payload_map = switch_core_alloc(session->pool, sizeof(payload_map_t));
                session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].cur_payload_map = session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].payload_map;
                session->media_handle->engines[SWITCH_MEDIA_TYPE_TEXT].cur_payload_map->current = 1;

                switch_channel_set_flag(session->channel, CF_DTLS_OK);

                status = SWITCH_STATUS_SUCCESS;
        }


        return status;
}

SWITCH_DECLARE(void) switch_media_handle_set_media_flag(switch_media_handle_t *smh, switch_core_media_flag_t flag)
{
        switch_assert(smh);

        smh->media_flags[flag] = 1;

}

SWITCH_DECLARE(void) switch_media_handle_set_media_flags(switch_media_handle_t *smh, switch_core_media_flag_t flags[SCMF_MAX])
{
        int i;
        switch_assert(smh);

        for(i = 0; i < SCMF_MAX; i++) {
                if (flags[i]) {
                        smh->media_flags[i] = flags[i];
                }
        }

}

SWITCH_DECLARE(void) switch_media_handle_clear_media_flag(switch_media_handle_t *smh, switch_core_media_flag_t flag)
{
        switch_assert(smh);

        smh->media_flags[flag] = 0;
}

SWITCH_DECLARE(int32_t) switch_media_handle_test_media_flag(switch_media_handle_t *smh, switch_core_media_flag_t flag)
{
        switch_assert(smh);
        return smh->media_flags[flag];
}

SWITCH_DECLARE(switch_media_flow_t) switch_core_session_media_flow(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_flow_t flow = SWITCH_MEDIA_FLOW_SENDRECV;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                goto end;
        }

        if (!smh->media_flags[SCMF_RUNNING]) {
                goto end;
        }

        engine = &smh->engines[type];
        flow = engine->smode;

 end:

        return flow;
}


SWITCH_DECLARE(switch_media_flow_t) switch_core_session_remote_media_flow(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_flow_t flow = SWITCH_MEDIA_FLOW_SENDRECV;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                goto end;
        }

        if (!smh->media_flags[SCMF_RUNNING]) {
                goto end;
        }
        
        engine = &smh->engines[type];
        flow = engine->rmode;

 end:

        return flow;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_media_handle_ready(switch_core_session_t *session)
{
        if (session->media_handle && switch_test_flag(session->media_handle, SMF_INIT)) {
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}



SWITCH_DECLARE(uint8_t) switch_core_session_get_rtp_pt(switch_core_session_t *session, switch_media_type_t type)
{
        switch_rtp_engine_t *engine = &session->media_handle->engines[type];

        if (!engine) return 0;

        return  engine->cur_payload_map->pt;
}

SWITCH_DECLARE(switch_rtp_t *) switch_core_session_get_rtp_session(switch_core_session_t *session, switch_media_type_t type)
{
        switch_rtp_engine_t *engine = &session->media_handle->engines[type];

        if (!engine) return NULL;

        return engine->rtp_session;
}

SWITCH_DECLARE(switch_media_handle_t *) switch_core_session_get_media_handle(switch_core_session_t *session)
{
        if (switch_core_session_media_handle_ready(session) == SWITCH_STATUS_SUCCESS) {
                return session->media_handle;
        }

        return NULL;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_clear_media_handle(switch_core_session_t *session)
{
        if (!session->media_handle) {
                return SWITCH_STATUS_FALSE;
        }

        return SWITCH_STATUS_SUCCESS;
}

SWITCH_DECLARE(switch_core_media_params_t *) switch_core_media_get_mparams(switch_media_handle_t *smh)
{
        switch_assert(smh);
        return smh->mparams;
}

SWITCH_DECLARE(switch_status_t) switch_core_media_prepare_codecs(switch_core_session_t *session, switch_bool_t force)
{
        const char *abs, *codec_string = NULL;
        const char *ocodec = NULL, *val;
        switch_media_handle_t *smh;
        char *tmp_codec_string;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!force && (switch_channel_test_flag(session->channel, CF_PROXY_MODE) || switch_channel_test_flag(session->channel, CF_PROXY_MEDIA))) {
                return SWITCH_STATUS_FALSE;
        }

        if (force) {
                smh->mparams->num_codecs = 0;
        }

        if (smh->mparams->num_codecs) {
                return SWITCH_STATUS_FALSE;
        }

        ocodec = switch_channel_get_variable(session->channel, SWITCH_ORIGINATOR_CODEC_VARIABLE);

        smh->payload_space = 0;

        switch_assert(smh->session != NULL);

        if ((abs = switch_channel_get_variable(session->channel, "absolute_codec_string"))) {
                codec_string = abs;
                goto ready;
        }

        val = switch_channel_get_variable_dup(session->channel, "media_mix_inbound_outbound_codecs", SWITCH_FALSE, -1);

        if (!switch_channel_test_flag(session->channel, CF_ANSWERED) && (!val || !switch_true(val) || smh->media_flags[SCMF_DISABLE_TRANSCODING]) && ocodec) {
                codec_string = ocodec;
                goto ready;
        }

        if (!(codec_string = switch_channel_get_variable(session->channel, "codec_string"))) {
                codec_string = switch_core_media_get_codec_string(smh->session);
        }

        if (codec_string && *codec_string == '=') {
                codec_string++;
                goto ready;
        }

        if (ocodec) {
                codec_string = switch_core_session_sprintf(smh->session, "%s,%s", ocodec, codec_string);
        }

 ready:

        if (!codec_string) {
                codec_string = "PCMU@20i,PCMA@20i,speex@20i";
        }

        tmp_codec_string = switch_core_session_strdup(smh->session, codec_string);
        switch_channel_set_variable(session->channel, "rtp_use_codec_string", codec_string);
        smh->codec_order_last = switch_separate_string(tmp_codec_string, ',', smh->codec_order, SWITCH_MAX_CODECS);
        smh->mparams->num_codecs = switch_loadable_module_get_codecs_sorted(smh->codecs, smh->fmtp, SWITCH_MAX_CODECS, smh->codec_order, smh->codec_order_last);
        return SWITCH_STATUS_SUCCESS;
}

static void check_jb(switch_core_session_t *session, const char *input, int32_t jb_msec, int32_t maxlen, switch_bool_t silent)
{
        const char *val;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine = NULL, *v_engine = NULL, *t_engine = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];


        if (!zstr(input)) {
                const char *s;
                if (a_engine->rtp_session) {
                        if (!strcasecmp(input, "pause")) {
                                switch_rtp_pause_jitter_buffer(a_engine->rtp_session, SWITCH_TRUE);
                                return;
                        } else if (!strcasecmp(input, "resume")) {
                                switch_rtp_pause_jitter_buffer(a_engine->rtp_session, SWITCH_FALSE);
                                return;
                        } else if (!strcasecmp(input, "stop")) {
                                switch_rtp_deactivate_jitter_buffer(a_engine->rtp_session);
                                return;
                        } else if (!strncasecmp(input, "debug:", 6)) {
                                s = input + 6;
                                if (s && !strcmp(s, "off")) {
                                        s = NULL;
                                }
                                switch_rtp_debug_jitter_buffer(a_engine->rtp_session, s);
                                return;
                        }

                        switch_channel_set_variable(session->channel, "jitterbuffer_msec", input);
                }

                if (v_engine->rtp_session) {
                        if (!strncasecmp(input, "vbsize:", 7)) {
                                int frames = 0, max_frames = 0;
                                s = input + 7;

                                frames = atoi(s);

                                if ((s = strchr(s, ':')) && *(s+1) != '\0') {
                                        max_frames = atoi(s+1);
                                }

                                if (frames > 0) {
                                        switch_rtp_set_video_buffer_size(v_engine->rtp_session, frames, max_frames);
                                } else {
                                        switch_rtp_deactivate_jitter_buffer(v_engine->rtp_session);
                                }
                                return;
                        } else if (!strncasecmp(input, "vdebug:", 7)) {
                                s = input + 7;

                                if (s && !strcmp(s, "off")) {
                                        s = NULL;
                                }
                                switch_rtp_debug_jitter_buffer(v_engine->rtp_session, s);
                                return;
                        }
                }

                if (t_engine->rtp_session) {
                        if (!strncasecmp(input, "tbsize:", 7)) {
                                int frames = 0, max_frames = 0;
                                s = input + 7;

                                frames = atoi(s);

                                if ((s = strchr(s, ':')) && *(s+1) != '\0') {
                                        max_frames = atoi(s+1);
                                }

                                if (frames > 0) {
                                        switch_rtp_set_video_buffer_size(t_engine->rtp_session, frames, max_frames);
                                }
                                return;
                        } else if (!strncasecmp(input, "tdebug:", 7)) {
                                s = input + 7;

                                if (s && !strcmp(s, "off")) {
                                        s = NULL;
                                }
                                switch_rtp_debug_jitter_buffer(t_engine->rtp_session, s);
                                return;
                        }
                }
        }


        if (jb_msec || (val = switch_channel_get_variable(session->channel, "jitterbuffer_msec")) || (val = smh->mparams->jb_msec)) {
                char *p;

                if (!jb_msec) {
                        jb_msec = atoi(val);

                        if (strchr(val, 'p') && jb_msec > 0) {
                                jb_msec *= -1;
                                if (!maxlen) maxlen = jb_msec * 50;
                        }

                        if ((p = strchr(val, ':'))) {
                                p++;
                                maxlen = atoi(p);

                                if (strchr(p, 'p') && maxlen > 0) {
                                        maxlen *= -1;
                                }
                        }
                }

                if (!maxlen) maxlen = jb_msec * 50;
                
                if (jb_msec < 0 && jb_msec > -1000) {
                        jb_msec = (a_engine->read_codec.implementation->microseconds_per_packet / 1000) * abs(jb_msec);
                }

                if (maxlen < 0 && maxlen > -1000) {
                        maxlen = (a_engine->read_codec.implementation->microseconds_per_packet / 1000) * abs(maxlen);
                }
                
                
                if (jb_msec < 10 || jb_msec > 10000) {
                        //switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                        //"Invalid Jitterbuffer spec [%d] must be between 10 and 10000\n", jb_msec);
                        jb_msec = (a_engine->read_codec.implementation->microseconds_per_packet / 1000) * 1;
                        maxlen = jb_msec * 100;
                }

                if (jb_msec && maxlen) {
                        int qlen, maxqlen = 50;

                        qlen = jb_msec / (a_engine->read_impl.microseconds_per_packet / 1000);

                        if (maxlen) {
                                maxqlen = maxlen / (a_engine->read_impl.microseconds_per_packet / 1000);
                        }

                        if (maxqlen < qlen) {
                                maxqlen = qlen * 5;
                        }
                        if (switch_rtp_activate_jitter_buffer(a_engine->rtp_session, qlen, maxqlen,
                                                                                                  a_engine->read_impl.samples_per_packet,
                                                                                                  a_engine->read_impl.samples_per_second) == SWITCH_STATUS_SUCCESS) {
                                if (!silent) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session),
                                                                          SWITCH_LOG_DEBUG, "Setting Jitterbuffer to %dms (%d frames) (%d max frames)\n",
                                                                          jb_msec, qlen, maxqlen);
                                }
                                switch_channel_set_flag(session->channel, CF_JITTERBUFFER);
                                if (!switch_false(switch_channel_get_variable(session->channel, "rtp_jitter_buffer_plc"))) {
                                        switch_channel_set_flag(session->channel, CF_JITTERBUFFER_PLC);
                                }
                        } else if (!silent) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session),
                                                                  SWITCH_LOG_WARNING, "Error Setting Jitterbuffer to %dms (%d frames)\n", jb_msec, qlen);
                        }

                }
        }

}

static void check_jb_sync(switch_core_session_t *session)
{
        int32_t jb_sync_msec = 0;
        uint32_t fps = 0, frames = 0;
        uint32_t min_frames = 0;
        uint32_t max_frames = 0;
        uint32_t cur_frames = 0;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *v_engine = NULL;
        int sync_audio = 0;

        const char *var;

        switch_assert(session);

        if (!switch_channel_test_flag(session->channel, CF_VIDEO)) {
                return;
        }

        if (!(smh = session->media_handle)) {
                return;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        if ((var = switch_channel_get_variable_dup(session->channel, "jb_av_sync_msec", SWITCH_FALSE, -1))) {
                int tmp;
                char *p;

                if (!strcasecmp(var, "disabled")) {
                        return;
                }

                tmp = atol(var);

                if (tmp && tmp > -50 && tmp < 10000) {
                        jb_sync_msec = tmp;
                }

                if ((p = strchr(var, ':'))) {
                        p++;
                        frames = atoi(p);
                }
        }

        switch_rtp_get_video_buffer_size(v_engine->rtp_session, &min_frames, &max_frames, &cur_frames, NULL);

        fps = video_globals.fps;

        if (fps < 15) return;

        sync_audio = 1;

        if (!frames) {
                if (cur_frames && min_frames && cur_frames >= min_frames) {
                        frames = cur_frames;
                } else if (min_frames) {
                        frames = min_frames;
                } else {
                        frames = 0;
                        sync_audio = 0;
                }
        }

        if (!jb_sync_msec && frames) {
                jb_sync_msec = ((double)1000 / fps) * frames;
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session),
                                          SWITCH_LOG_DEBUG1, "%s %s \"%s\" Sync A/V JB to %dms %u VFrames, FPS %u a:%s sync_ms:%d\n",
                                          switch_core_session_get_uuid(session),
                                          switch_channel_get_name(session->channel),
                                          switch_channel_get_variable_dup(session->channel, "caller_id_name", SWITCH_FALSE, -1),
                                          jb_sync_msec, frames, video_globals.fps, sync_audio ? "yes" : "no", jb_sync_msec);

        if (sync_audio) {
                check_jb(session, NULL, jb_sync_msec, jb_sync_msec * 2, SWITCH_TRUE);
        }

        video_globals.synced++;
}


//?
SWITCH_DECLARE(switch_status_t) switch_core_media_read_lock_unlock(switch_core_session_t *session, switch_media_type_t type, switch_bool_t lock)
{
        switch_rtp_engine_t *engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!smh->media_flags[SCMF_RUNNING]) {
                return SWITCH_STATUS_FALSE;
        }

        engine = &smh->engines[type];

        if (!engine->read_codec.implementation || !switch_core_codec_ready(&engine->read_codec)) {
                return SWITCH_STATUS_FALSE;
        }

        switch_assert(engine->rtp_session != NULL);


        if (!switch_channel_up_nosig(session->channel) || !switch_rtp_ready(engine->rtp_session) || switch_channel_test_flag(session->channel, CF_NOT_READY)) {
                return SWITCH_STATUS_FALSE;
        }

        if (lock) {
                if (smh->read_mutex[type] && switch_mutex_trylock(smh->read_mutex[type]) != SWITCH_STATUS_SUCCESS) {
                        /* return CNG, another thread is already reading  */
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "%s is already being read for %s\n",
                                                          switch_channel_get_name(session->channel), type2str(type));
                        return SWITCH_STATUS_INUSE;
                }
        } else {
                switch_mutex_unlock(smh->read_mutex[type]);
        }

        return SWITCH_STATUS_SUCCESS;
}




//?
SWITCH_DECLARE(switch_status_t) switch_rtp_text_factory_create(switch_rtp_text_factory_t **tfP, switch_memory_pool_t *pool)
{
        int x;

        *tfP = switch_core_alloc(pool, sizeof(**tfP));

        switch_buffer_create_dynamic(&(*tfP)->write_buffer,  512, 1024, 0);
        (*tfP)->pool = pool;
        (*tfP)->text_write_frame_data = switch_core_alloc(pool, SWITCH_RTP_MAX_BUF_LEN);
        (*tfP)->text_write_frame.packet = (*tfP)->text_write_frame_data;
        (*tfP)->text_write_frame.data = (switch_byte_t *)(*tfP)->text_write_frame.packet + 12;
        (*tfP)->text_write_frame.buflen = SWITCH_RTP_MAX_BUF_LEN - 12;

        (*tfP)->red_max = 5;
        (*tfP)->red_bufsize = SWITCH_RTP_MAX_BUF_LEN;

        switch_core_timer_init(&(*tfP)->timer, "soft", TEXT_TIMER_MS, TEXT_TIMER_SAMPLES, pool);

        for(x = 0; x < (*tfP)->red_max; x++) {
                (*tfP)->red_buf[x] = switch_core_alloc(pool, SWITCH_RTP_MAX_BUF_LEN);
        }

        return SWITCH_STATUS_SUCCESS;
}

SWITCH_DECLARE(switch_status_t) switch_rtp_text_factory_destroy(switch_rtp_text_factory_t **tfP)
{
        switch_core_timer_destroy(&(*tfP)->timer);
        switch_buffer_destroy(&(*tfP)->write_buffer);

        return SWITCH_STATUS_SUCCESS;;
}

#include <wchar.h>

static int get_rtt_red_seq(int want_seq, void *data, switch_size_t datalen, int seq, switch_payload_t *new_payload, void *new_data, uint32_t *new_datalen)
{
        unsigned char *buf = data;
        int count = 0;
        unsigned char *e = (buf + datalen);

        int len[MAX_RED_FRAMES] = { 0 };
        int pt[MAX_RED_FRAMES] = { 0 };
        int idx = 0, x = 0;

        *new_datalen = datalen;

        *(buf + datalen) = '\0';

        while (*buf & 0x80) {
                if (buf + 3 > e) {
                        *new_datalen = 0;
                        return 0;
                }

                pt[count] = *buf & 0x7F;
                len[count] = (ntohs(*(uint16_t *)(buf + 2)) & 0x03ff);
                buf += 4;
                count++;
        }

        buf++;

        idx = count - (seq - want_seq);

        if (idx < 0) {
                *new_datalen = 0;
                return 0;
        }

        if (!len[idx]) {
                *new_datalen = len[idx];
                return 0;
        }

        for(x = 0; x < idx; x++) {
                buf += len[x];
        }

        *new_datalen = len[idx];
        *new_payload = pt[idx];

        memcpy(new_data, buf, len[idx]);

        *(((char *)new_data) + len[idx]) = '\0';

        return 1;

}

static void *get_rtt_payload(void *data, switch_size_t datalen, switch_payload_t *new_payload, uint32_t *new_datalen, int *red_level)
{
        unsigned char *buf = data;
        int bytes = 0, count = 0, pt = 0, len = 0;//, ts = 0;
        unsigned char *e = (buf + datalen);

        *new_datalen = datalen;
        *red_level = 1;

        while (*buf & 0x80) {
                if (buf + 3 > e) {
                        *new_datalen = 0;
                        return NULL;
                }
                count++;
                pt = *buf & 0x7F;
                //ts = ntohs(*(uint16_t *)(buf + 1)) >> 2;
                len  = (ntohs(*(uint16_t *)(buf + 2)) & 0x03ff);
                buf += 4;
                bytes += len;
        }

        *new_datalen = datalen - bytes - 1 - (count *4);
        *new_payload = pt;
        buf += bytes + 1;

        if (buf > e) {
                *new_datalen = 0;
                return NULL;
        }

        return buf;
}

//?

static void check_media_timeout_params(switch_core_session_t *session, switch_rtp_engine_t *engine)
{
        switch_media_type_t type = engine->type;
        const char *val;

        if ((val = switch_channel_get_variable(session->channel, "media_hold_timeout"))) {
                engine->media_hold_timeout = atoi(val);
        }

        if ((val = switch_channel_get_variable(session->channel, "media_timeout"))) {
                engine->media_timeout = atoi(val);
        }

        if (type == SWITCH_MEDIA_TYPE_VIDEO) {
                if ((val = switch_channel_get_variable(session->channel, "media_hold_timeout_video"))) {
                        engine->media_hold_timeout = atoi(val);
                }

                if ((val = switch_channel_get_variable(session->channel, "media_timeout_video"))) {
                        engine->media_timeout = atoi(val);
                }
        } else {

                if ((val = switch_channel_get_variable(session->channel, "media_hold_timeout_audio"))) {
                        engine->media_hold_timeout = atoi(val);
                }

                if ((val = switch_channel_get_variable(session->channel, "media_timeout_audio"))) {
                        engine->media_timeout = atoi(val);
                }
        }

        if (switch_rtp_ready(engine->rtp_session) && engine->media_timeout) {
                switch_rtp_set_media_timeout(engine->rtp_session, engine->media_timeout);
                if (engine->type == SWITCH_MEDIA_TYPE_AUDIO) {
                        /* the values are in milliseconds, not in seconds as the deprecated rtp_timeout_sec */
                        engine->max_missed_packets = (engine->read_impl.samples_per_second * engine->media_timeout / 1000) / engine->read_impl.samples_per_packet;

                        switch_rtp_set_max_missed_packets(engine->rtp_session, engine->max_missed_packets);
                        if (!engine->media_hold_timeout) {
                                engine->media_hold_timeout = engine->media_timeout * 10;
                        }

                        engine->max_missed_hold_packets = (engine->read_impl.samples_per_second * engine->media_hold_timeout / 1000) / engine->read_impl.samples_per_packet;
                }
        }
}

SWITCH_DECLARE(switch_status_t) switch_core_media_read_frame(switch_core_session_t *session, switch_frame_t **frame,
                                                                                                                         switch_io_flag_t flags, int stream_id, switch_media_type_t type)
{
        switch_rtcp_frame_t rtcp_frame;
        switch_rtp_engine_t *engine;
        switch_status_t status;
        switch_media_handle_t *smh;
        int do_cng = 0;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!smh->media_flags[SCMF_RUNNING]) {
                return SWITCH_STATUS_FALSE;
        }

        engine = &smh->engines[type];

        if (type == SWITCH_MEDIA_TYPE_AUDIO && ! switch_channel_test_flag(session->channel, CF_AUDIO)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "%s Reading audio from a non-audio session.\n", switch_channel_get_name(session->channel));
                switch_yield(50000);
                return SWITCH_STATUS_INUSE;
        }

        if (type != SWITCH_MEDIA_TYPE_TEXT && (!engine->read_codec.implementation || !switch_core_codec_ready(&engine->read_codec))) {
                switch_yield(50000);
                return SWITCH_STATUS_FALSE;
        }

        if (!switch_channel_up_nosig(session->channel) || !switch_rtp_ready(engine->rtp_session) || switch_channel_test_flag(session->channel, CF_NOT_READY)) {
                switch_yield(50000);
                return SWITCH_STATUS_FALSE;
        }

        if (smh->read_mutex[type] && switch_mutex_trylock(smh->read_mutex[type]) != SWITCH_STATUS_SUCCESS) {
                /* return CNG, another thread is already reading  */
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "%s is already being read for %s\n",
                                                  switch_channel_get_name(session->channel), type2str(type));
                return SWITCH_STATUS_INUSE;
        }


        engine->read_frame.datalen = 0;
        engine->read_frame.flags = SFF_NONE;
        engine->read_frame.m = SWITCH_FALSE;
        engine->read_frame.img = NULL;
        engine->read_frame.payload = 0;

        while (smh->media_flags[SCMF_RUNNING] && engine->read_frame.datalen == 0) {
                engine->read_frame.flags = SFF_NONE;
                status = switch_rtp_zerocopy_read_frame(engine->rtp_session, &engine->read_frame, flags);


                if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
                        if (status == SWITCH_STATUS_TIMEOUT) {

                                if (switch_channel_get_variable(session->channel, "execute_on_media_timeout")) {
                                        *frame = &engine->read_frame;
                                        switch_set_flag((*frame), SFF_CNG);
                                        (*frame)->datalen = engine->read_impl.encoded_bytes_per_packet;
                                        memset((*frame)->data, 0, (*frame)->datalen);
                                        switch_channel_execute_on(session->channel, "execute_on_media_timeout");
                                        switch_goto_status(SWITCH_STATUS_SUCCESS, end);
                                }


                                switch_channel_hangup(session->channel, SWITCH_CAUSE_MEDIA_TIMEOUT);
                        }
                        goto end;
                }

                if (switch_channel_test_flag(session->channel, CF_LEG_HOLDING)) {
                        status = SWITCH_STATUS_INUSE;
                        goto end;
                }

                if (status == SWITCH_STATUS_BREAK) {
                        goto end;
                }

                if (type == SWITCH_MEDIA_TYPE_VIDEO) {
                        if (engine->read_frame.m) {
                                if (!smh->vid_started) {
                                        smh->vid_started = switch_epoch_time_now(NULL);
                                }
                                smh->vid_frames++;

                                if ((smh->vid_frames % 5) == 0) {
                                        switch_core_media_get_video_fps(session);
                                }

                                if (video_globals.fps && (!video_globals.synced || ((smh->vid_frames % 300) == 0))) {
                                        check_jb_sync(session);
                                }
                        }
                }

                /* re-set codec if necessary */
                if (type != SWITCH_MEDIA_TYPE_TEXT && engine->reset_codec > 0) {
                        const char *val;
                        int rtp_timeout_sec = 0;
                        int rtp_hold_timeout_sec = 0;

                        engine->reset_codec = 0;

                        if (switch_rtp_ready(engine->rtp_session)) {

                                check_media_timeout_params(session, engine);

                                if (type == SWITCH_MEDIA_TYPE_VIDEO) {
                                        switch_core_media_set_video_codec(session, 1);
                                } else {

                                        if (switch_core_media_set_codec(session, 1, smh->mparams->codec_flags) != SWITCH_STATUS_SUCCESS) {
                                                *frame = NULL;
                                                switch_goto_status(SWITCH_STATUS_GENERR, end);
                                        }
                                }

                                if (type == SWITCH_MEDIA_TYPE_AUDIO && engine->read_impl.samples_per_second) {
                                        if ((val = switch_channel_get_variable(session->channel, "rtp_timeout_sec"))) {
                                                int v = atoi(val);
                                                if (v >= 0) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                                          "rtp_timeout_sec deprecated use media_timeout variable.\n"); 
                                                        rtp_timeout_sec = v;
                                                }
                                        }

                                        if ((val = switch_channel_get_variable(session->channel, "rtp_hold_timeout_sec"))) {
                                                int v = atoi(val);
                                                if (v >= 0) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                                          "rtp_hold_timeout_sec deprecated use media_timeout variable.\n"); 
                                                        rtp_hold_timeout_sec = v;
                                                }
                                        }

                                        if (rtp_timeout_sec) {
                                                engine->max_missed_packets = (engine->read_impl.samples_per_second * rtp_timeout_sec) /
                                                        engine->read_impl.samples_per_packet;

                                                switch_rtp_set_max_missed_packets(engine->rtp_session, engine->max_missed_packets);
                                                if (!rtp_hold_timeout_sec) {
                                                        rtp_hold_timeout_sec = rtp_timeout_sec * 10;
                                                }
                                        }

                                        if (rtp_hold_timeout_sec) {
                                                engine->max_missed_hold_packets = (engine->read_impl.samples_per_second * rtp_hold_timeout_sec) /
                                                        engine->read_impl.samples_per_packet;
                                        }
                                }
                        }

                        check_jb(session, NULL, 0, 0, SWITCH_FALSE);

                        engine->check_frames = 0;
                        engine->last_ts = 0;
                        engine->last_seq = 0;

                        do_cng = 1;
                }


                if (do_cng) {
                        /* return CNG for now */
                        *frame = &engine->read_frame;
                        switch_set_flag((*frame), SFF_CNG);
                        (*frame)->datalen = engine->read_impl.encoded_bytes_per_packet;
                        memset((*frame)->data, 0, (*frame)->datalen);
                        switch_goto_status(SWITCH_STATUS_SUCCESS, end);
                }


                /* Try to read an RTCP frame, if successful raise an event */
                if (switch_rtcp_zerocopy_read_frame(engine->rtp_session, &rtcp_frame) == SWITCH_STATUS_SUCCESS) {
                        switch_event_t *event;

                        if (switch_event_create(&event, SWITCH_EVENT_RECV_RTCP_MESSAGE) == SWITCH_STATUS_SUCCESS) {
                                char value[30];
                                char header[50];
                                int i;

                                char *uuid = switch_core_session_get_uuid(session);
                                if (uuid) {
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Unique-ID", switch_core_session_get_uuid(session));
                                }

                                snprintf(value, sizeof(value), "%.8x", rtcp_frame.ssrc);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "SSRC", value);

                                snprintf(value, sizeof(value), "%u", rtcp_frame.ntp_msw);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "NTP-Most-Significant-Word", value);

                                snprintf(value, sizeof(value), "%u", rtcp_frame.ntp_lsw);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "NTP-Least-Significant-Word", value);

                                snprintf(value, sizeof(value), "%u", rtcp_frame.timestamp);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "RTP-Timestamp", value);

                                snprintf(value, sizeof(value), "%u", rtcp_frame.packet_count);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Sender-Packet-Count", value);

                                snprintf(value, sizeof(value), "%u", rtcp_frame.octect_count);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Octect-Packet-Count", value);

                                snprintf(value, sizeof(value), "%u", engine->read_frame.timestamp);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Last-RTP-Timestamp", value);

                                snprintf(value, sizeof(value), "%u", engine->read_frame.rate);
                                switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "RTP-Rate", value);

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

                                // Add sources info
                                for (i = 0; i < rtcp_frame.report_count; i++) {
                                        snprintf(header, sizeof(header), "Source%u-SSRC", i);
                                        snprintf(value, sizeof(value), "%.8x", rtcp_frame.reports[i].ssrc);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
                                        snprintf(header, sizeof(header), "Source%u-Fraction", i);
                                        snprintf(value, sizeof(value), "%u", rtcp_frame.reports[i].fraction);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
                                        snprintf(header, sizeof(header), "Source%u-Lost", i);
                                        snprintf(value, sizeof(value), "%u", rtcp_frame.reports[i].lost);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
                                        snprintf(header, sizeof(header), "Source%u-Loss-Avg", i);
                                        snprintf(value, sizeof(value), "%u", rtcp_frame.reports[i].loss_avg);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
                                        snprintf(header, sizeof(header), "Source%u-Highest-Sequence-Number-Received", i);
                                        snprintf(value, sizeof(value), "%u", rtcp_frame.reports[i].highest_sequence_number_received);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
                                        snprintf(header, sizeof(header), "Source%u-Jitter", i);
                                        snprintf(value, sizeof(value), "%u", rtcp_frame.reports[i].jitter);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
                                        snprintf(header, sizeof(header), "Source%u-LSR", i);
                                        snprintf(value, sizeof(value), "%u", rtcp_frame.reports[i].lsr);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
                                        snprintf(header, sizeof(header), "Source%u-DLSR", i);
                                        snprintf(value, sizeof(value), "%u", rtcp_frame.reports[i].dlsr);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
                                        snprintf(header, sizeof(header), "Rtt%u-Avg", i);
                                        snprintf(value, sizeof(value), "%f", rtcp_frame.reports[i].rtt_avg);
                                        switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, header, value);
                                }

                                switch_event_fire(&event);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG10, "Dispatched RTCP event\n");
                        }
                }

                /* Fast PASS! */
                if (switch_test_flag((&engine->read_frame), SFF_PROXY_PACKET)) {
                        *frame = &engine->read_frame;
                        switch_goto_status(SWITCH_STATUS_SUCCESS, end);
                }

                if (switch_rtp_has_dtmf(engine->rtp_session)) {
                        switch_dtmf_t dtmf = { 0 };
                        switch_rtp_dequeue_dtmf(engine->rtp_session, &dtmf);
                        switch_channel_queue_dtmf(session->channel, &dtmf);
                }

                if (type != SWITCH_MEDIA_TYPE_TEXT && engine->read_frame.datalen > 0) {
                        uint32_t bytes = 0;
                        int frames = 1;

                        /* autofix timing */
                        if (!switch_test_flag((&engine->read_frame), SFF_CNG)) {
                                if (!engine->read_codec.implementation || !switch_core_codec_ready(&engine->read_codec)) {
                                        *frame = NULL;
                                        switch_goto_status(SWITCH_STATUS_GENERR, end);
                                }

                                /* check for timing issues */
                                if (smh->media_flags[SCMF_AUTOFIX_TIMING] && type == SWITCH_MEDIA_TYPE_AUDIO && engine->read_impl.samples_per_second) {
                                        char is_vbr;
                                        is_vbr = engine->read_impl.encoded_bytes_per_packet?0:1;

                                        engine->check_frames++;
                                        /* CBR */
                                        if ((smh->media_flags[SCMF_AUTOFIX_TIMING] && (engine->read_frame.datalen % 10) == 0)
                                                        && (engine->check_frames < MAX_CODEC_CHECK_FRAMES) && !is_vbr) {
                                                engine->check_frames++;

                                                if (engine->last_ts && engine->read_frame.datalen != engine->read_impl.encoded_bytes_per_packet) {

                                                        uint32_t codec_ms = (int) (engine->read_frame.timestamp -
                                                                                                           engine->last_ts) / (engine->read_impl.samples_per_second / 1000);
                                                        if (engine->last_seq && (int) (engine->read_frame.seq - engine->last_seq) > 1) {
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "[CBR]: Correcting calculated ptime value from [%d] to [%d] to compensate for [%d] lost packet(s). \n",  codec_ms, codec_ms / (int) (engine->read_frame.seq - engine->last_seq), (int) (engine->read_frame.seq - engine->last_seq - 1));
                                                                codec_ms = codec_ms / (int) (engine->read_frame.seq - engine->last_seq);
                                                        }

                                                        if ((codec_ms % 10) != 0 || codec_ms > engine->read_impl.samples_per_packet * 10) {
                                                                engine->last_ts = 0;
                                                                engine->last_seq = 0;
                                                                goto skip;
                                                        }

                                                        if (engine->last_codec_ms && engine->last_codec_ms == codec_ms) {
                                                                engine->mismatch_count++;
                                                        } else {
                                                                engine->mismatch_count = 0;
                                                        }

                                                        engine->last_codec_ms = codec_ms;

                                                        if (engine->mismatch_count > MAX_MISMATCH_FRAMES) {
                                                                if (codec_ms != engine->cur_payload_map->codec_ms) {

                                                                        if (codec_ms > 120) {   /* yeah right */
                                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                                                                  "[CBR]: Your phone is trying to send timestamps that suggest an increment of %dms per packet\n"
                                                                                                                  "That seems hard to believe so I am going to go on ahead and um ignore that, mmkay?\n",
                                                                                                                  (int) codec_ms);
                                                                                engine->check_frames = MAX_CODEC_CHECK_FRAMES;
                                                                                goto skip;
                                                                        }

                                                                        engine->read_frame.datalen = 0;

                                                                        if (codec_ms != engine->cur_payload_map->codec_ms) {
                                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                                                                  "[CBR]: Asynchronous PTIME not supported, changing our end from %d to %d\n",
                                                                                                                  (int) engine->cur_payload_map->codec_ms,
                                                                                                                  (int) codec_ms
                                                                                                                  );

                                                                                switch_channel_set_variable_printf(session->channel, "rtp_h_X-Broken-PTIME", "Adv=%d;Sent=%d",
                                                                                                                                                   (int) engine->cur_payload_map->codec_ms, (int) codec_ms);

                                                                                engine->cur_payload_map->codec_ms = codec_ms;

                                                                                /* mark to re-set codec */
                                                                                engine->reset_codec = 2;
                                                                        }
                                                                }
                                                        }

                                                } else {
                                                        engine->mismatch_count = 0;
                                                }

                                                engine->last_ts = engine->read_frame.timestamp;
                                                engine->last_seq = engine->read_frame.seq;

                                        } else if (smh->media_flags[SCMF_AUTOFIX_TIMING] && is_vbr && switch_rtp_get_jitter_buffer(engine->rtp_session)
                                                           && type == SWITCH_MEDIA_TYPE_AUDIO
                                                           && engine->read_frame.timestamp && engine->read_frame.seq && engine->read_impl.samples_per_second) {
                                                uint32_t codec_ms = (int) (engine->read_frame.timestamp -
                                                                   engine->last_ts) / (engine->read_impl.samples_per_second / 1000);

                                                if (engine->last_seq && (int) (engine->read_frame.seq - engine->last_seq) > 1) {
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "[VBR]: Correcting calculated ptime value from [%d] to [%d] to compensate for [%d] lost packet(s)\n", codec_ms, codec_ms / (int) (engine->read_frame.seq - engine->last_seq), (int) (engine->read_frame.seq - engine->last_seq - 1));
                                                                codec_ms = codec_ms / (int) (engine->read_frame.seq - engine->last_seq);
                                                }

                                                if (codec_ms && codec_ms != engine->cur_payload_map->codec_ms) {
                                                        if (engine->last_codec_ms && engine->last_codec_ms == codec_ms) {
                                                                engine->mismatch_count++;
                                                        }
                                                } else {
                                                        engine->mismatch_count = 0;
                                                }

                                                engine->last_codec_ms = codec_ms;

                                                if (engine->mismatch_count > MAX_MISMATCH_FRAMES) {

                                                        if (codec_ms > 120) {
                                                                /*will show too many times with packet loss*/
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG3,
                                                                                                  "[VBR]: Remote party is trying to send timestamps that suggest an increment of [%d] ms per packet, which is too high. Ignoring.\n",
                                                                                                  (int) codec_ms);
                                                                engine->last_ts = engine->read_frame.timestamp;
                                                                engine->last_seq = engine->read_frame.seq;
                                                                goto skip;
                                                        }

                                                        if (codec_ms != engine->cur_payload_map->codec_ms) {
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                                                  "[VBR]: Packet size change detected. Remote PTIME changed from [%d] to [%d]\n",
                                                                                                  (int) engine->cur_payload_map->codec_ms,
                                                                                                  (int) codec_ms
                                                                                                  );
                                                                engine->cur_payload_map->codec_ms = codec_ms;
                                                                engine->reset_codec = 2;

                                                                if (switch_channel_test_flag(session->channel, CF_CONFERENCE)) {
                                                                        switch_channel_set_flag(session->channel, CF_CONFERENCE_RESET_MEDIA);
                                                                }
                                                        }
                                                }

                                                engine->last_ts = engine->read_frame.timestamp;
                                                engine->last_seq = engine->read_frame.seq;

                                        } else {
                                                engine->mismatch_count = 0;
                                                engine->last_ts = 0;
                                                engine->last_seq = 0;
                                        }
                                }

                                /* autofix payload type */

                                if (!engine->reset_codec &&
                                        engine->codec_negotiated &&
                                        (!smh->mparams->cng_pt || engine->read_frame.payload != smh->mparams->cng_pt) &&
                                        (!smh->mparams->recv_te || engine->read_frame.payload != smh->mparams->recv_te) &&
                                        (!smh->mparams->te || engine->read_frame.payload != smh->mparams->te) &&
                                        !switch_test_flag((&engine->read_frame), SFF_CNG) &&
                                        !switch_test_flag((&engine->read_frame), SFF_PLC) &&
                                        engine->read_frame.payload != engine->cur_payload_map->recv_pt &&
                                        engine->read_frame.payload != engine->cur_payload_map->pt) {

                                        payload_map_t *pmap;


                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "alternate payload received (received %d, expecting %d)\n",
                                                                          (int) engine->read_frame.payload, (int) engine->cur_payload_map->pt);


                                        /* search for payload type */
                                        switch_mutex_lock(smh->sdp_mutex);
                                        for (pmap = engine->payload_map; pmap; pmap = pmap->next) {
                                                if (engine->read_frame.payload == pmap->recv_pt && pmap->negotiated) {
                                                        engine->cur_payload_map = pmap;
                                                        engine->cur_payload_map->current = 1;
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                                          "Changing current codec to %s (payload type %d).\n",
                                                                                          pmap->iananame, pmap->pt);

                                                        /* mark to re-set codec */
                                                        engine->reset_codec = 1;
                                                        break;
                                                }
                                        }
                                        switch_mutex_unlock(smh->sdp_mutex);

                                        if (!engine->reset_codec) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                                  "Could not change to payload type %d, ignoring...\n",
                                                                                  (int) engine->read_frame.payload);
                                        }
                                }

                        skip:

                                if ((bytes = engine->read_impl.encoded_bytes_per_packet)) {
                                        frames = (engine->read_frame.datalen / bytes);
                                }
                                engine->read_frame.samples = (int) (frames * engine->read_impl.samples_per_packet);

                                if (engine->read_frame.datalen == 0) {
                                        continue;
                                }
                        }
                        break;
                }
        }

        if (engine->read_frame.datalen == 0) {
                *frame = NULL;
        }


        if (type == SWITCH_MEDIA_TYPE_TEXT && !switch_test_flag((&engine->read_frame), SFF_CNG)) {
                if (engine->red_pt) {
                        unsigned char *p = engine->read_frame.data;

                        *(p + engine->read_frame.datalen) = '\0';
                        engine->tf->text_frame = engine->read_frame;

                        if (switch_test_flag((&engine->read_frame), SFF_PLC)) {
                                switch_jb_t *jb = switch_core_session_get_jb(session, SWITCH_MEDIA_TYPE_TEXT);
                                int i = 0;

                                engine->tf->text_frame.datalen = 0;

                                for (i = 1; i < 3; i++) {
                                        switch_frame_t frame = { 0 };
                                        uint8_t buf[SWITCH_RTP_MAX_BUF_LEN];
                                        frame.data = buf;
                                        frame.buflen = sizeof(buf);

                                        if (switch_jb_peek_frame(jb, 0, engine->read_frame.seq, i, &frame) == SWITCH_STATUS_SUCCESS) {
                                                if (get_rtt_red_seq(engine->read_frame.seq,
                                                                                        frame.data,
                                                                                        frame.datalen,
                                                                                        frame.seq,
                                                                                        &engine->tf->text_frame.payload,
                                                                                        engine->tf->text_frame.data,
                                                                                        &engine->tf->text_frame.datalen)) {
                                                        break;

                                                }
                                        }

                                }

                                if (engine->tf->text_frame.datalen == 0) {
                                        engine->tf->text_frame.data = "� ";
                                        engine->tf->text_frame.datalen = strlen(engine->tf->text_frame.data);
                                }

                        } else {
                                if (!(engine->tf->text_frame.data = get_rtt_payload(engine->read_frame.data,
                                                                                                                                        engine->tf->text_frame.datalen,
                                                                                                                                        &engine->tf->text_frame.payload,
                                                                                                                                        &engine->tf->text_frame.datalen,
                                                                                                                                        &engine->tf->red_level))) {
                                        engine->tf->text_frame.datalen = 0;
                                }
                        }

                        *frame = &engine->tf->text_frame;

                        if ((*frame)->datalen == 0) {
                                (*frame)->flags |= SFF_CNG;
                                (*frame)->data = "";
                        }
                }

        } else {
                *frame = &engine->read_frame;
        }

        status = SWITCH_STATUS_SUCCESS;

 end:

        if (smh->read_mutex[type]) {
                switch_mutex_unlock(smh->read_mutex[type]);
        }

        return status;
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_write_frame(switch_core_session_t *session,
                                                                                                  switch_frame_t *frame, switch_io_flag_t flags, int stream_id, switch_media_type_t type)
{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        int bytes = 0, samples = 0, frames = 0;
        switch_rtp_engine_t *engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!smh->media_flags[SCMF_RUNNING]) {
                return SWITCH_STATUS_FALSE;
        }

        engine = &smh->engines[type];

        if (type == SWITCH_MEDIA_TYPE_VIDEO) {
                if (engine->thread_write_lock && engine->thread_write_lock != switch_thread_self()) {
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        if (type == SWITCH_MEDIA_TYPE_AUDIO) {
                switch_media_flow_t audio_flow = switch_core_session_media_flow(session, SWITCH_MEDIA_TYPE_AUDIO);

                if (audio_flow != SWITCH_MEDIA_FLOW_SENDRECV && audio_flow != SWITCH_MEDIA_FLOW_SENDONLY) {
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        if (type != SWITCH_MEDIA_TYPE_TEXT) {

                while (!(engine->read_codec.implementation && switch_rtp_ready(engine->rtp_session))) {
                        if (switch_channel_ready(session->channel)) {
                                switch_yield(10000);
                        } else {
                                return SWITCH_STATUS_GENERR;
                        }
                }

                if (!engine->read_codec.implementation || !switch_core_codec_ready(&engine->read_codec)) {
                        return SWITCH_STATUS_GENERR;
                }

                if (!switch_test_flag(frame, SFF_CNG) && !switch_test_flag(frame, SFF_PROXY_PACKET)) {
                        if (engine->read_impl.encoded_bytes_per_packet) {
                                bytes = engine->read_impl.encoded_bytes_per_packet;
                                frames = ((int) frame->datalen / bytes);
                        } else
                                frames = 1;

                        samples = frames * engine->read_impl.samples_per_packet;
                }
        }

        engine->timestamp_send += samples;

        if (switch_rtp_write_frame(engine->rtp_session, frame) < 0) {
                status = SWITCH_STATUS_FALSE;
        }


        return status;
}


//?
SWITCH_DECLARE(void) switch_core_media_copy_t38_options(switch_t38_options_t *t38_options, switch_core_session_t *session)
{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_t38_options_t *local_t38_options = switch_channel_get_private(channel, "t38_options");

        switch_assert(t38_options);

        if (!local_t38_options) {
                local_t38_options = switch_core_session_alloc(session, sizeof(switch_t38_options_t));
        }

        local_t38_options->T38MaxBitRate = t38_options->T38MaxBitRate;
        local_t38_options->T38FaxFillBitRemoval = t38_options->T38FaxFillBitRemoval;
        local_t38_options->T38FaxTranscodingMMR = t38_options->T38FaxTranscodingMMR;
        local_t38_options->T38FaxTranscodingJBIG = t38_options->T38FaxTranscodingJBIG;
        local_t38_options->T38FaxRateManagement = switch_core_session_strdup(session, t38_options->T38FaxRateManagement);
        local_t38_options->T38FaxMaxBuffer = t38_options->T38FaxMaxBuffer;
        local_t38_options->T38FaxMaxDatagram = t38_options->T38FaxMaxDatagram;
        local_t38_options->T38FaxUdpEC = switch_core_session_strdup(session, t38_options->T38FaxUdpEC);
        local_t38_options->T38VendorInfo = switch_core_session_strdup(session, t38_options->T38VendorInfo);
        local_t38_options->remote_ip = switch_core_session_strdup(session, t38_options->remote_ip);
        local_t38_options->remote_port = t38_options->remote_port;


        switch_channel_set_private(channel, "t38_options", local_t38_options);

}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_get_offered_pt(switch_core_session_t *session, const switch_codec_implementation_t *mimp, switch_payload_t *pt)
{
        int i = 0;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle) || !mimp) {
                return SWITCH_STATUS_FALSE;
        }


        for (i = 0; i < smh->mparams->num_codecs; i++) {
                const switch_codec_implementation_t *imp = smh->codecs[i];

                if (!strcasecmp(imp->iananame, mimp->iananame) && imp->actual_samples_per_second == mimp->actual_samples_per_second) {
                        *pt = smh->ianacodes[i];

                        return SWITCH_STATUS_SUCCESS;
                }
        }

        return SWITCH_STATUS_FALSE;
}

//#define get_int_value(_var, _set) { const char *__v = switch_channel_get_variable(session->channel, _var); if (__v) { _set = atol(__v);} }
//?
static void switch_core_session_parse_codec_settings(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (!(engine = &smh->engines[type])) return;

        switch(type) {
        case SWITCH_MEDIA_TYPE_AUDIO:
                break;
        case SWITCH_MEDIA_TYPE_VIDEO: {
                uint32_t system_bw = 0;
                const char *var = NULL, *bwv;

                if ((var = switch_channel_get_variable(session->channel, "video_try_hardware_encoder"))) {
                        engine->codec_settings.video.try_hardware_encoder = switch_true(var);
                }

                if (!(bwv = switch_channel_get_variable(session->channel, "rtp_video_max_bandwidth"))) {
                        bwv = switch_channel_get_variable(session->channel, "rtp_video_max_bandwidth_out");
                }

                if (!bwv) {
                        bwv = "1mb";
                }

                system_bw = switch_parse_bandwidth_string(bwv);

                if (engine->sdp_bw && engine->sdp_bw <= system_bw) {
                        engine->codec_settings.video.bandwidth = engine->sdp_bw;
                } else {
                        engine->codec_settings.video.bandwidth = system_bw;
                }
        }
                break;
        default:
                break;
        }
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_set_video_codec(switch_core_session_t *session, int force)
{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *v_engine;

        switch_assert(session);

        switch_mutex_lock(session->codec_init_mutex);

        if (!(smh = session->media_handle)) {
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];


        if (!v_engine->codec_negotiated) {
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        if (v_engine->read_codec.implementation && switch_core_codec_ready(&v_engine->read_codec)) {
                if (!force) {
                        switch_goto_status(SWITCH_STATUS_SUCCESS, end);
                }
                if (strcasecmp(v_engine->read_codec.implementation->iananame, v_engine->cur_payload_map->rm_encoding) ||
                        v_engine->read_codec.implementation->samples_per_second != v_engine->cur_payload_map->rm_rate) {

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Changing Codec from %s to %s\n",
                                                          v_engine->read_codec.implementation->iananame, v_engine->cur_payload_map->rm_encoding);
                        switch_core_codec_destroy(&v_engine->read_codec);
                        switch_core_codec_destroy(&v_engine->write_codec);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Already using %s\n",
                                                          v_engine->read_codec.implementation->iananame);
                        switch_goto_status(SWITCH_STATUS_SUCCESS, end);
                }
        }

        switch_core_session_parse_codec_settings(session, SWITCH_MEDIA_TYPE_VIDEO);

        if (switch_core_codec_init(&v_engine->read_codec,
                                                           v_engine->cur_payload_map->rm_encoding,
                                                           v_engine->cur_payload_map->modname,
                                                           v_engine->cur_payload_map->rm_fmtp,
                                                           v_engine->cur_payload_map->rm_rate,
                                                           0,
                                                           1,
                                                           SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
                                                           &v_engine->codec_settings, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't load codec?\n");
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        } else {
                if (switch_core_codec_init(&v_engine->write_codec,
                                                                   v_engine->cur_payload_map->rm_encoding,
                                                                   v_engine->cur_payload_map->modname,
                                                                   v_engine->cur_payload_map->rm_fmtp,
                                                                   v_engine->cur_payload_map->rm_rate,
                                                                   0,
                                                                   1,
                                                                   SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE,
                                                                   &v_engine->codec_settings, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't load codec?\n");
                        switch_goto_status(SWITCH_STATUS_FALSE, end);
                } else {
                        v_engine->read_frame.rate = v_engine->cur_payload_map->rm_rate;
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set VIDEO Codec %s %s/%ld %d ms\n",
                                                          switch_channel_get_name(session->channel), v_engine->cur_payload_map->rm_encoding,
                                                          v_engine->cur_payload_map->rm_rate, v_engine->cur_payload_map->codec_ms);
                        v_engine->read_frame.codec = &v_engine->read_codec;

                        v_engine->write_codec.fmtp_out = switch_core_session_strdup(session, v_engine->write_codec.fmtp_out);

                        v_engine->write_codec.agreed_pt = v_engine->cur_payload_map->pt;
                        v_engine->read_codec.agreed_pt = v_engine->cur_payload_map->pt;
                        switch_core_session_set_video_read_codec(session, &v_engine->read_codec);
                        switch_core_session_set_video_write_codec(session, &v_engine->write_codec);


                        switch_channel_set_variable_printf(session->channel, "rtp_last_video_codec_string", "%s@%dh",
                                                                                           v_engine->cur_payload_map->rm_encoding, v_engine->cur_payload_map->rm_rate);


                        if (switch_rtp_ready(v_engine->rtp_session)) {
                                switch_core_session_message_t msg = { 0 };

                                msg.from = __FILE__;
                                msg.message_id = SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ;

                                switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->pt);

                                //XX

                                switch_core_session_receive_message(session, &msg);


                        }

                        switch_channel_set_variable(session->channel, "rtp_use_video_codec_name", v_engine->cur_payload_map->rm_encoding);
                        switch_channel_set_variable(session->channel, "rtp_use_video_codec_fmtp", v_engine->cur_payload_map->rm_fmtp);
                        switch_channel_set_variable_printf(session->channel, "rtp_use_video_codec_rate", "%d", v_engine->cur_payload_map->rm_rate);
                        switch_channel_set_variable_printf(session->channel, "rtp_use_video_codec_ptime", "%d", 0);
                }
        }

end:
        switch_mutex_unlock(session->codec_init_mutex);

        return status;
}


//?
SWITCH_DECLARE(switch_status_t) switch_core_media_set_codec(switch_core_session_t *session, int force, uint32_t codec_flags)
{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        int resetting = 0;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine;

        switch_assert(session);

        switch_core_codec_lock_full(session);

        switch_mutex_lock(session->codec_init_mutex);

        if (!(smh = session->media_handle)) {
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }
        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];

        if (!a_engine->cur_payload_map->iananame) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No audio codec available\n");
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        if (switch_core_codec_ready(&a_engine->read_codec)) {
                if (!force) {
                        switch_goto_status(SWITCH_STATUS_SUCCESS, end);
                }

                if (strcasecmp(a_engine->read_impl.iananame, a_engine->cur_payload_map->iananame) ||
                        (uint32_t) a_engine->read_impl.microseconds_per_packet / 1000 != a_engine->cur_payload_map->codec_ms ||
                        a_engine->read_impl.samples_per_second != a_engine->cur_payload_map->rm_rate ) {

                        switch_core_session_reset(session, 0, 0);

                        switch_channel_audio_sync(session->channel);

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                          "Changing Codec from %s@%dms@%dhz to %s@%dms@%luhz\n",
                                                          a_engine->read_impl.iananame,
                                                          a_engine->read_impl.microseconds_per_packet / 1000,
                                                          a_engine->read_impl.actual_samples_per_second,

                                                          a_engine->cur_payload_map->iananame,
                                                          a_engine->cur_payload_map->codec_ms,
                                                          a_engine->cur_payload_map->rm_rate);

                        resetting = 1;
                        switch_yield(a_engine->read_impl.microseconds_per_packet);
                        switch_core_codec_destroy(&a_engine->read_codec);
                        switch_core_codec_destroy(&a_engine->write_codec);
                        switch_channel_audio_sync(session->channel);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Already using %s\n", a_engine->read_impl.iananame);
                        switch_goto_status(SWITCH_STATUS_SUCCESS, end);
                }
        }


        switch_core_session_parse_codec_settings(session, SWITCH_MEDIA_TYPE_AUDIO);

        if (switch_core_codec_init_with_bitrate(&a_engine->read_codec,
                                                                                        a_engine->cur_payload_map->iananame,
                                                                                        a_engine->cur_payload_map->modname,
                                                                                        a_engine->cur_payload_map->rm_fmtp,
                                                                                        a_engine->cur_payload_map->rm_rate,
                                                                                        a_engine->cur_payload_map->codec_ms,
                                                                                        a_engine->cur_payload_map->channels,
                                                                                        a_engine->cur_payload_map->bitrate,
                                                                                        SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | codec_flags,
                                                                                        &a_engine->codec_settings, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't load codec?\n");
                switch_channel_hangup(session->channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        a_engine->read_codec.session = session;


        if (switch_core_codec_init_with_bitrate(&a_engine->write_codec,
                                                                                        a_engine->cur_payload_map->iananame,
                                                                                        a_engine->cur_payload_map->modname,
                                                                                        a_engine->cur_payload_map->rm_fmtp,
                                                                                        a_engine->cur_payload_map->rm_rate,
                                                                                        a_engine->cur_payload_map->codec_ms,
                                                                                        a_engine->cur_payload_map->channels,
                                                                                        a_engine->cur_payload_map->bitrate,
                                                                                        SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE | codec_flags,
                                                                                        &a_engine->codec_settings, switch_core_session_get_pool(session)) != SWITCH_STATUS_SUCCESS) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't load codec?\n");
                switch_channel_hangup(session->channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        a_engine->write_codec.session = session;

        if (switch_rtp_ready(a_engine->rtp_session)) {
                switch_channel_audio_sync(session->channel);
                switch_rtp_reset_jb(a_engine->rtp_session);
        }

        switch_channel_set_variable(session->channel, "rtp_use_codec_name", a_engine->cur_payload_map->iananame);
        switch_channel_set_variable(session->channel, "rtp_use_codec_fmtp", a_engine->cur_payload_map->rm_fmtp);
        switch_channel_set_variable_printf(session->channel, "rtp_use_codec_rate", "%d", a_engine->cur_payload_map->rm_rate);
        switch_channel_set_variable_printf(session->channel, "rtp_use_codec_ptime", "%d", a_engine->cur_payload_map->codec_ms);
        switch_channel_set_variable_printf(session->channel, "rtp_use_codec_channels", "%d", a_engine->cur_payload_map->channels);
        switch_channel_set_variable_printf(session->channel, "rtp_last_audio_codec_string", "%s@%dh@%di@%dc",
                                                                           a_engine->cur_payload_map->iananame, a_engine->cur_payload_map->rm_rate, a_engine->cur_payload_map->codec_ms, a_engine->cur_payload_map->channels);

        switch_assert(a_engine->read_codec.implementation);
        switch_assert(a_engine->write_codec.implementation);

        a_engine->read_impl = *a_engine->read_codec.implementation;
        a_engine->write_impl = *a_engine->write_codec.implementation;

        switch_core_session_set_read_impl(session, a_engine->read_codec.implementation);
        switch_core_session_set_write_impl(session, a_engine->write_codec.implementation);

        if (switch_rtp_ready(a_engine->rtp_session)) {
                switch_assert(a_engine->read_codec.implementation);

                if (switch_rtp_change_interval(a_engine->rtp_session,
                                                                           a_engine->read_impl.microseconds_per_packet,
                                                                           a_engine->read_impl.samples_per_packet) != SWITCH_STATUS_SUCCESS) {
                        switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                        switch_goto_status(SWITCH_STATUS_FALSE, end);
                }
        }

        a_engine->read_frame.rate = a_engine->cur_payload_map->rm_rate;

        if (!switch_core_codec_ready(&a_engine->read_codec)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Can't load codec?\n");
                switch_goto_status(SWITCH_STATUS_FALSE, end);
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set Codec %s %s/%ld %d ms %d samples %d bits %d channels\n",
                                          switch_channel_get_name(session->channel), a_engine->cur_payload_map->iananame, a_engine->cur_payload_map->rm_rate,
                                          a_engine->cur_payload_map->codec_ms,
                                          a_engine->read_impl.samples_per_packet, a_engine->read_impl.bits_per_second, a_engine->read_impl.number_of_channels);
        a_engine->read_frame.codec = &a_engine->read_codec;
        a_engine->read_frame.channels = a_engine->read_impl.number_of_channels;
        a_engine->write_codec.agreed_pt = a_engine->cur_payload_map->pt;
        a_engine->read_codec.agreed_pt = a_engine->cur_payload_map->pt;

        if (force != 2) {
                switch_core_session_set_real_read_codec(session, &a_engine->read_codec);
                switch_core_session_set_write_codec(session, &a_engine->write_codec);
        }

        a_engine->cur_payload_map->fmtp_out = switch_core_session_strdup(session, a_engine->write_codec.fmtp_out);

        if (switch_rtp_ready(a_engine->rtp_session)) {
                switch_rtp_set_default_payload(a_engine->rtp_session, a_engine->cur_payload_map->pt);
        }

 end:

        if (resetting) {
            switch_channel_execute_on(session->channel, "execute_on_audio_change");
        }

        switch_mutex_unlock(session->codec_init_mutex);

        switch_core_codec_unlock_full(session);

        return status;
}
static void clear_ice(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        engine = &smh->engines[type];

        engine->ice_in.chosen[0] = 0;
        engine->ice_in.chosen[1] = 0;
        engine->ice_in.is_chosen[0] = 0;
        engine->ice_in.is_chosen[1] = 0;
        engine->ice_in.cand_idx[0] = 0;
        engine->ice_in.cand_idx[1] = 0;
        memset(&engine->ice_in, 0, sizeof(engine->ice_in));
        engine->remote_rtcp_port = 0;

        if (engine->rtp_session) {
                switch_rtp_reset(engine->rtp_session);
        }

}

//?
SWITCH_DECLARE(void) switch_core_media_clear_ice(switch_core_session_t *session)
{
        clear_ice(session, SWITCH_MEDIA_TYPE_AUDIO);
        clear_ice(session, SWITCH_MEDIA_TYPE_VIDEO);

}

SWITCH_DECLARE(void) switch_core_media_pause(switch_core_session_t *session)
{
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (a_engine->rtp_session) {
                switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
        }

        if (v_engine->rtp_session) {
                switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
        }

        if (t_engine->rtp_session) {
                switch_rtp_set_flag(t_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
        }
}

SWITCH_DECLARE(void) switch_core_media_resume(switch_core_session_t *session)
{
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (a_engine->rtp_session) {
                switch_rtp_clear_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
        }

        if (v_engine->rtp_session) {
                switch_rtp_clear_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
        }

        if (t_engine->rtp_session) {
                switch_rtp_clear_flag(t_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
        }
}


//?
SWITCH_DECLARE(switch_status_t) switch_core_media_add_ice_acl(switch_core_session_t *session, switch_media_type_t type, const char *acl_name)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        engine = &smh->engines[type];

        if (engine->cand_acl_count < SWITCH_MAX_CAND_ACL) {
                engine->cand_acl[engine->cand_acl_count++] = switch_core_session_strdup(session, acl_name);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

//?
SWITCH_DECLARE(void) switch_core_media_check_video_codecs(switch_core_session_t *session)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (smh->mparams->num_codecs && !switch_channel_test_flag(session->channel, CF_VIDEO_POSSIBLE)) {
                int i;
                smh->video_count = 0;
                for (i = 0; i < smh->mparams->num_codecs; i++) {

                        if (smh->codecs[i]->codec_type == SWITCH_CODEC_TYPE_VIDEO) {
                                if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND &&
                                        switch_channel_test_flag(session->channel, CF_NOVIDEO)) {
                                        continue;
                                }
                                smh->video_count++;
                        }
                }
                if (smh->video_count) {
                        switch_channel_set_flag(session->channel, CF_VIDEO_POSSIBLE);
                }
        }
}

//?
static void generate_local_fingerprint(switch_media_handle_t *smh, switch_media_type_t type)
{
        switch_rtp_engine_t *engine = &smh->engines[type];

        if (!engine->local_dtls_fingerprint.len) {
                if (engine->remote_dtls_fingerprint.type) {
                        engine->local_dtls_fingerprint.type = engine->remote_dtls_fingerprint.type;
                } else {
                        engine->local_dtls_fingerprint.type = "sha-256";
                }
                switch_core_cert_gen_fingerprint(DTLS_SRTP_FNAME, &engine->local_dtls_fingerprint);
        }
}

//?
static int dtls_ok(switch_core_session_t *session)
{
        return switch_channel_test_flag(session->channel, CF_DTLS_OK);
}

#ifdef _MSC_VER
/* remove this if the break is removed from the following for loop which causes unreachable code loop */
/* for (i = 0; i < engine->cand_acl_count; i++) { */
#pragma warning(push)
#pragma warning(disable:4702)
#endif

//?
static switch_call_direction_t switch_ice_direction(switch_rtp_engine_t *engine, switch_core_session_t *session)
{
        switch_call_direction_t r = switch_channel_direction(session->channel);
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_CALL_DIRECTION_OUTBOUND;
        }
        
        if (switch_channel_test_flag(session->channel, CF_3PCC)) {
                r = (r == SWITCH_CALL_DIRECTION_INBOUND) ? SWITCH_CALL_DIRECTION_OUTBOUND : SWITCH_CALL_DIRECTION_INBOUND;
        }

        if (switch_rtp_has_dtls() && dtls_ok(smh->session)) {
                r = engine->dtls_controller ? SWITCH_CALL_DIRECTION_INBOUND : SWITCH_CALL_DIRECTION_OUTBOUND;
        } else {
                if ((switch_channel_test_flag(session->channel, CF_REINVITE) || switch_channel_test_flag(session->channel, CF_RECOVERING))
                        && switch_channel_test_flag(session->channel, CF_AVPF)) {
                        r = SWITCH_CALL_DIRECTION_OUTBOUND;
                }
        }

        return r;
}

static switch_core_media_ice_type_t switch_determine_ice_type(switch_rtp_engine_t *engine, switch_core_session_t *session) {
        switch_core_media_ice_type_t ice_type = ICE_VANILLA;

        if (switch_channel_var_true(session->channel, "ice_lite")) {
                ice_type |= ICE_CONTROLLED;
                ice_type |= ICE_LITE;
        } else {
                switch_call_direction_t direction = switch_ice_direction(engine, session);
                if (direction == SWITCH_CALL_DIRECTION_INBOUND) {
                        ice_type |= ICE_CONTROLLED;
                }
        }

        return ice_type;
}

//?
static switch_status_t ip_choose_family(switch_media_handle_t *smh, const char *ip)
{
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (zstr(ip)) {
                return status;
        }

        if (strchr(ip, ':')) {
                if (!zstr(smh->mparams->rtpip6)) {
                        smh->mparams->rtpip = smh->mparams->rtpip6;
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "%s choosing family v6\n",
                                                          switch_channel_get_name(smh->session->channel));
                        status = SWITCH_STATUS_SUCCESS;
                }
        } else {
                if (!zstr(smh->mparams->rtpip4)) {
                        smh->mparams->rtpip = smh->mparams->rtpip4;
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "%s choosing family v4\n",
                                                          switch_channel_get_name(smh->session->channel));
                        status = SWITCH_STATUS_SUCCESS;
                }
        }

        return status;
}

//?
static switch_bool_t ip_possible(switch_media_handle_t *smh, const char *ip)
{
        switch_bool_t r = SWITCH_FALSE;

        if (zstr(ip)) {
                return r;
        }

        if (strchr(ip, ':')) {
                r = (switch_bool_t) !zstr(smh->mparams->rtpip6);
        } else {
                r = (switch_bool_t) !zstr(smh->mparams->rtpip4);
        }

        return r;
}

//?
static switch_status_t check_ice(switch_media_handle_t *smh, switch_media_type_t type, sdp_session_t *sdp, sdp_media_t *m)
{
        switch_rtp_engine_t *engine = &smh->engines[type];
        sdp_attribute_t *attr = NULL, *attrs[2] = { 0 };
        int i = 0, got_rtcp_mux = 0;
        const char *val;
        int ice_seen = 0, cid = 0, ai = 0, attr_idx = 0, cand_seen = 0, relay_ok = 0;
        char con_addr[256];
        int ice_resolve = 0;
        ip_t ip;

        if (switch_true(switch_channel_get_variable_dup(smh->session->channel, "ignore_sdp_ice", SWITCH_FALSE, -1))) {
                return SWITCH_STATUS_BREAK;
        }

        //if (engine->ice_in.is_chosen[0] && engine->ice_in.is_chosen[1]) {
                //return SWITCH_STATUS_SUCCESS;
        //}

        engine->ice_in.chosen[0] = 0;
        engine->ice_in.chosen[1] = 0;
        engine->ice_in.is_chosen[0] = 0;
        engine->ice_in.is_chosen[1] = 0;
        engine->ice_in.cand_idx[0] = 0;
        engine->ice_in.cand_idx[1] = 0;
        engine->remote_ssrc = 0;

        if (m) {
                attrs[0] = m->m_attributes;
                attrs[1] = sdp->sdp_attributes;
        } else {
                attrs[0] = sdp->sdp_attributes;
        }

        ice_resolve = switch_core_media_has_resolveice();

        for (attr_idx = 0; attr_idx < 2 && !(ice_seen && cand_seen); attr_idx++) {
                for (attr = attrs[attr_idx]; attr; attr = attr->a_next) {
                        char *data;
                        char *fields[32] = {0};
                        int argc = 0, j = 0;

                        if (zstr(attr->a_name)) {
                                continue;
                        }

                        if (!strcasecmp(attr->a_name, "ice-ufrag")) {
                                if (engine->ice_in.ufrag && !strcmp(engine->ice_in.ufrag, attr->a_value)) {
                                        engine->new_ice = 0;
                                } else {
                                        engine->ice_in.ufrag = switch_core_session_strdup(smh->session, attr->a_value);
                                        engine->new_ice = 1;
                                }
                                ice_seen++;
                        } else if (!strcasecmp(attr->a_name, "ice-pwd")) {
                                if (!engine->ice_in.pwd || strcmp(engine->ice_in.pwd, attr->a_value)) {
                                        engine->ice_in.pwd = switch_core_session_strdup(smh->session, attr->a_value);
                                }
                        } else if (!strcasecmp(attr->a_name, "ice-options")) {
                                engine->ice_in.options = switch_core_session_strdup(smh->session, attr->a_value);
                        } else if (!strcasecmp(attr->a_name, "setup")) {
                                if (!strcasecmp(attr->a_value, "passive") ||
                                        (!strcasecmp(attr->a_value, "actpass") && !switch_channel_test_flag(smh->session->channel, CF_REINVITE))) {
                                        if (!engine->dtls_controller) {
                                                engine->new_dtls = 1;
                                                engine->new_ice = 1;
                                        }
                                        engine->dtls_controller = 1;
                                } else if (!strcasecmp(attr->a_value, "active")) {
                                        if (engine->dtls_controller) {
                                                engine->new_dtls = 1;
                                                engine->new_ice = 1;
                                        }
                                        engine->dtls_controller = 0;
                                }
                        } else if (switch_rtp_has_dtls() && dtls_ok(smh->session) && !strcasecmp(attr->a_name, "fingerprint") && !zstr(attr->a_value)) {
                                char *p;

                                engine->remote_dtls_fingerprint.type = switch_core_session_strdup(smh->session, attr->a_value);

                                if ((p = strchr(engine->remote_dtls_fingerprint.type, ' '))) {
                                        *p++ = '\0';

                                        if (switch_channel_test_flag(smh->session->channel, CF_REINVITE) && !switch_channel_test_flag(smh->session->channel, CF_RECOVERING) &&
                                                !zstr(engine->remote_dtls_fingerprint.str) && !strcmp(engine->remote_dtls_fingerprint.str, p)) {
                                                engine->new_dtls = 0;
                                        } else {
                                                switch_set_string(engine->remote_dtls_fingerprint.str, p);
                                                engine->new_dtls = 1;
                                                engine->new_ice = 1;
                                        }
                                }


                                //if (strcasecmp(engine->remote_dtls_fingerprint.type, "sha-256")) {
                                //      switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_WARNING, "Unsupported fingerprint type.\n");
                                //engine->local_dtls_fingerprint.type = NULL;
                                //engine->remote_dtls_fingerprint.type = NULL;
                                //}


                                generate_local_fingerprint(smh, type);
                                switch_channel_set_flag(smh->session->channel, CF_DTLS);

                        } else if (!engine->remote_ssrc && !strcasecmp(attr->a_name, "ssrc") && attr->a_value) {
                                engine->remote_ssrc = (uint32_t) atol(attr->a_value);

                                if (engine->rtp_session && engine->remote_ssrc) {
                                        switch_rtp_set_remote_ssrc(engine->rtp_session, engine->remote_ssrc);
                                }


#ifdef RTCP_MUX
                        } else if (!strcasecmp(attr->a_name, "rtcp-mux")) {
                                engine->rtcp_mux = SWITCH_TRUE;
                                engine->remote_rtcp_port = engine->cur_payload_map->remote_sdp_port;
                                got_rtcp_mux++;

                                if (!smh->mparams->rtcp_audio_interval_msec) {
                                        smh->mparams->rtcp_audio_interval_msec = SWITCH_RTCP_AUDIO_INTERVAL_MSEC;
                                }
#endif
                        } else if (!strcasecmp(attr->a_name, "candidate")) {
                                switch_channel_set_flag(smh->session->channel, CF_ICE);

                                if (!engine->cand_acl_count) {
                                        engine->cand_acl[engine->cand_acl_count++] = "wan.auto";
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_WARNING, "NO candidate ACL defined, Defaulting to wan.auto\n");
                                }


                                if (!switch_stristr(" udp ", attr->a_value)) {
                                        continue;
                                }

                                data = switch_core_session_strdup(smh->session, attr->a_value);

                                argc = switch_split(data, ' ', fields);

                                if (argc < 6 || !switch_is_uint_in_range(fields[1], 1, MAX_CAND_IDX_COUNT)) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_WARNING, "Invalid data\n");
                                        continue;
                                }

                                cid = fields[1] ? atoi(fields[1]) - 1 : 0;

                                if (engine->ice_in.cand_idx[cid] >= MAX_CAND - 1) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_WARNING, "Too many candidates\n");
                                        continue;
                                }

                                for (i = 0; i < argc; i++) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG1, "CAND %d [%s]\n", i, fields[i]);
                                }

                                if (fields[4] && (switch_inet_pton(AF_INET, fields[4], &ip) || switch_inet_pton(AF_INET6, fields[4], &ip))) {
                                                switch_copy_string(con_addr, fields[4], sizeof(con_addr));
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG1, "Is an IP address: %s\n", con_addr);
                                } else if (fields[4] && ice_resolve) {
                                                if (switch_resolve_host(fields[4], con_addr, sizeof(con_addr)) == SWITCH_STATUS_SUCCESS) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "Resolved %s to %s\n", fields[4], con_addr);
                                                } else {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO,
                                                                                        "Drop %s Candidate cid: %d proto: %s type: %s addr: %s:%s (cannot resolve)\n",
                                                                                        type == SWITCH_MEDIA_TYPE_VIDEO ? "video" : "audio",
                                                                                        cid+1, fields[2], fields[7], fields[4], fields[5]);
                                                        continue;
                                                }
                                } else {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO,
                                                                                "Drop %s Candidate cid: %d proto: %s type: %s addr: %s:%s (not an IP address)\n",
                                                                                type == SWITCH_MEDIA_TYPE_VIDEO ? "video" : "audio",
                                                                                cid+1, fields[2], fields[7], fields[4] ? fields[4] : "(null)", fields[5]);
                                                continue;
                                }

                                if (!ip_possible(smh, con_addr)) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG,
                                                                          "Drop %s Candidate cid: %d proto: %s type: %s addr: %s:%s (no network path)\n",
                                                                          type == SWITCH_MEDIA_TYPE_VIDEO ? "video" : "audio",
                                                                          cid+1, fields[2], fields[7] ? fields[7] : "N/A", con_addr, fields[5]);
                                        continue;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG,
                                                                          "Save %s Candidate cid: %d proto: %s type: %s addr: %s:%s\n",
                                                                          type == SWITCH_MEDIA_TYPE_VIDEO ? "video" : "audio",
                                                                          cid+1, fields[2], fields[7] ? fields[7] : "N/A", con_addr, fields[5]);
                                }


                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].foundation = switch_core_session_strdup(smh->session, fields[0]);
                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].component_id = atoi(fields[1]);
                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].transport = switch_core_session_strdup(smh->session, fields[2]);
                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].priority = atol(fields[3]);
                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].con_addr = switch_core_session_strdup(smh->session, con_addr);
                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].con_port = (switch_port_t)atoi(fields[5]);

                                j = 6;

                                while(j < argc && j <= sizeof(fields)/sizeof(char*) && fields[j+1] && engine->ice_in.cand_idx[cid] < MAX_CAND - 1) {
                                        if (!strcasecmp(fields[j], "typ")) {
                                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].cand_type = switch_core_session_strdup(smh->session, fields[j+1]);
                                        } else if (!strcasecmp(fields[j], "raddr")) {
                                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].raddr = switch_core_session_strdup(smh->session, fields[j+1]);
                                        } else if (!strcasecmp(fields[j], "rport")) {
                                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].rport = (switch_port_t)atoi(fields[j+1]);
                                        } else if (!strcasecmp(fields[j], "generation")) {
                                                engine->ice_in.cands[engine->ice_in.cand_idx[cid]][cid].generation = switch_core_session_strdup(smh->session, fields[j+1]);
                                        }

                                        j += 2;
                                }

                                cand_seen++;
                                engine->ice_in.cand_idx[cid]++;
                        }
                }
        }

        if (!ice_seen) {
                return SWITCH_STATUS_SUCCESS;
        }

        relay_ok = 0;
        
 relay:
        
        for (cid = 0; cid < MAX_CAND_IDX_COUNT; cid++) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "Searching for %s candidate.\n", cid ? "rtcp" : "rtp");

                for (ai = 0; ai < engine->cand_acl_count; ai++) {
                        for (i = 0; i < engine->ice_in.cand_idx[cid]; i++) {
                                int is_relay = engine->ice_in.cands[i][cid].cand_type && !strcmp(engine->ice_in.cands[i][cid].cand_type, "relay");

                                if (relay_ok != is_relay) continue;

                                if (switch_check_network_list_ip(engine->ice_in.cands[i][cid].con_addr, engine->cand_acl[ai])) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG,
                                                                          "Choose %s candidate, index %d, %s:%d\n", cid ? "rtcp" : "rtp", i,
                                                                          engine->ice_in.cands[i][cid].con_addr, engine->ice_in.cands[i][cid].con_port);

                                        engine->ice_in.chosen[cid] = i;
                                        engine->ice_in.is_chosen[cid] = 1;
                                        engine->ice_in.cands[i][cid].ready++;
                                        ip_choose_family(smh, engine->ice_in.cands[i][cid].con_addr);

                                        if (cid == 0 && got_rtcp_mux && engine->ice_in.cand_idx[1] < MAX_CAND) {

                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG,
                                                                                  "Choose same candidate, index %d, for rtcp based on rtcp-mux attribute %s:%d\n", engine->ice_in.cand_idx[1],
                                                                                  engine->ice_in.cands[i][cid].con_addr, engine->ice_in.cands[i][cid].con_port);


                                                engine->ice_in.cands[engine->ice_in.cand_idx[1]][1] = engine->ice_in.cands[i][0];
                                                engine->ice_in.chosen[1] = engine->ice_in.cand_idx[1];
                                                engine->ice_in.is_chosen[1] = 1;
                                                engine->ice_in.cand_idx[1]++;

                                                goto done_choosing;
                                        }

                                        goto next_cid;
                                }
                        }
                }

        next_cid:

                continue;
        }

 done_choosing:

        if (switch_channel_test_flag(smh->session->channel, CF_AUDIO_VIDEO_BUNDLE)) {
                engine->ice_in.is_chosen[0] = 1;
        }

        if (!engine->ice_in.is_chosen[0]) {
                if (!relay_ok) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "Look for Relay Candidates as last resort\n");
                        relay_ok = 1;
                        goto relay;
                }

                /* PUNT */
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG, "%s no suitable candidates found.\n",
                                                  switch_channel_get_name(smh->session->channel));
                return SWITCH_STATUS_FALSE;
        }

        for (i = 0; i < 2; i++) {
                if (engine->ice_in.cands[engine->ice_in.chosen[i]][i].ready) {
                        if (zstr(engine->ice_in.ufrag) || zstr(engine->ice_in.pwd)) {
                                engine->ice_in.cands[engine->ice_in.chosen[i]][i].ready = 0;
                        }
                }
        }


        if (engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr && engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port) {
                char tmp[80] = "";
                const char *media_varname = NULL, *port_varname = NULL;

                engine->cur_payload_map->remote_sdp_ip = switch_core_session_strdup(smh->session, (char *) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr);
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG,
                                                  "setting remote %s ice addr to index %d %s:%d based on candidate\n", type2str(type), engine->ice_in.chosen[0],
                                                  engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr, engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port);
                engine->ice_in.cands[engine->ice_in.chosen[0]][0].ready++;

                engine->remote_rtp_ice_port = (switch_port_t) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port;
                engine->remote_rtp_ice_addr = switch_core_session_strdup(smh->session, engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr);

                engine->cur_payload_map->remote_sdp_ip = switch_core_session_strdup(smh->session, (char *) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr);
                engine->cur_payload_map->remote_sdp_port = (switch_port_t) engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port;

                if (!smh->mparams->remote_ip) {
                        smh->mparams->remote_ip = engine->cur_payload_map->remote_sdp_ip;
                }

                if (engine->type == SWITCH_MEDIA_TYPE_VIDEO) {
                        media_varname = "remote_video_ip";
                        port_varname = "remote_video_port";
                } else if (engine->type == SWITCH_MEDIA_TYPE_AUDIO) {
                        media_varname = "remote_audio_ip";
                        port_varname = "remote_audio_port";
                } else if (engine->type == SWITCH_MEDIA_TYPE_TEXT) {
                        media_varname = "remote_text_ip";
                        port_varname = "remote_text_port";
                }

                switch_snprintf(tmp, sizeof(tmp), "%d", engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port);
                switch_channel_set_variable(smh->session->channel, media_varname, engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr);
                switch_channel_set_variable(smh->session->channel, port_varname, tmp);
        }

        if (engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port) {
                const char *media_varname = NULL, *port_varname = NULL;
                char tmp[35] = "";

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_DEBUG,
                                                  "Setting remote rtcp %s addr to %s:%d based on candidate\n", type2str(type),
                                                  engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_addr, engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port);
                engine->remote_rtcp_ice_port = engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port;
                engine->remote_rtcp_ice_addr = switch_core_session_strdup(smh->session, engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_addr);

                engine->remote_rtcp_port = engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port;


                if (engine->type == SWITCH_MEDIA_TYPE_VIDEO) {
                        media_varname = "remote_video_rtcp_ip";
                        port_varname = "remote_video_rtcp_port";
                } else if (engine->type == SWITCH_MEDIA_TYPE_AUDIO) {
                        media_varname = "remote_audio_rtcp_ip";
                        port_varname = "remote_audio_rtcp_port";
                } else if (engine->type == SWITCH_MEDIA_TYPE_TEXT) {
                        media_varname = "remote_text_rtcp_ip";
                        port_varname = "remote_text_rtcp_port";
                }

                switch_snprintf(tmp, sizeof(tmp), "%d", engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port);
                switch_channel_set_variable(smh->session->channel, media_varname, engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_addr);
                switch_channel_set_variable(smh->session->channel, port_varname, tmp);

        }


        if (m && !got_rtcp_mux) {
                engine->rtcp_mux = -1;
        }

        if (engine->new_ice) {
                if (switch_rtp_ready(engine->rtp_session) && engine->ice_in.cands[engine->ice_in.chosen[0]][0].ready) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "RE-Activating %s ICE\n", type2str(type));

                        switch_rtp_activate_ice(engine->rtp_session,
                                                                        engine->ice_in.ufrag,
                                                                        engine->ice_out.ufrag,
                                                                        engine->ice_out.pwd,
                                                                        engine->ice_in.pwd,
                                                                        IPR_RTP,
#ifdef GOOGLE_ICE
                                                                        ICE_GOOGLE_JINGLE,
                                                                        NULL
#else
                                                                        switch_determine_ice_type(engine, smh->session),
                                                                        &engine->ice_in
#endif
                                                                        );


                        engine->new_ice = 0;
                }


                if (engine->rtp_session && ((val = switch_channel_get_variable(smh->session->channel,
                                                                                                                                           type == SWITCH_MEDIA_TYPE_VIDEO ?
                                                                                                                                           "rtcp_video_interval_msec" : "rtcp_audio_interval_msec"))
                                                                        || (val = type == SWITCH_MEDIA_TYPE_VIDEO ?
                                                                                smh->mparams->rtcp_video_interval_msec : smh->mparams->rtcp_audio_interval_msec))) {

                        switch_port_t remote_rtcp_port = engine->remote_rtcp_port;

                        if (remote_rtcp_port) {
                                if (!strcasecmp(val, "passthru")) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "Activating %s RTCP PASSTHRU PORT %d\n",
                                                                          type2str(type), remote_rtcp_port);
                                        switch_rtp_activate_rtcp(engine->rtp_session, -1, remote_rtcp_port, engine->rtcp_mux > 0);
                                } else {
                                        int interval = atoi(val);
                                        if (interval < 100 || interval > 500000) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_ERROR,
                                                                                  "Invalid rtcp interval spec [%d] must be between 100 and 500000\n", interval);
                                                interval = 5000;
                                        }

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "Activating %s RTCP PORT %d\n", type2str(type), remote_rtcp_port);
                                        switch_rtp_activate_rtcp(engine->rtp_session, interval, remote_rtcp_port, engine->rtcp_mux > 0);
                                }
                        }
                }

                if (engine->rtp_session && engine->ice_in.cands[engine->ice_in.chosen[1]][1].ready) {
                        if (engine->rtcp_mux > 0 && !strcmp(engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_addr, engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_addr)
                                && engine->ice_in.cands[engine->ice_in.chosen[1]][1].con_port == engine->ice_in.cands[engine->ice_in.chosen[0]][0].con_port) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "Skipping %s RTCP ICE (Same as RTP)\n", type2str(type));
                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(smh->session), SWITCH_LOG_INFO, "Activating %s RTCP ICE\n", type2str(type));

                                switch_rtp_activate_ice(engine->rtp_session,
                                                                                engine->ice_in.ufrag,
                                                                                engine->ice_out.ufrag,
                                                                                engine->ice_out.pwd,
                                                                                engine->ice_in.pwd,
                                                                                IPR_RTCP,
#ifdef GOOGLE_ICE
                                                                                ICE_GOOGLE_JINGLE,
                                                                                NULL
#else
                                                                                switch_determine_ice_type(engine, smh->session),
                                                                                &engine->ice_in
#endif
                                                                                );
                        }

                }

        }

        return ice_seen ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_BREAK;
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif

SWITCH_DECLARE(void) switch_core_session_set_ice(switch_core_session_t *session)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        switch_channel_set_flag(session->channel, CF_VERBOSE_SDP);
        switch_channel_set_flag(session->channel, CF_AVPF);
        switch_channel_set_flag(session->channel, CF_ICE);
        smh->mparams->rtcp_audio_interval_msec = SWITCH_RTCP_AUDIO_INTERVAL_MSEC;
        smh->mparams->rtcp_video_interval_msec = SWITCH_RTCP_VIDEO_INTERVAL_MSEC;

}

#define MAX_MATCHES 30
struct matches {
        const switch_codec_implementation_t *imp;
        sdp_rtpmap_t *map;
        int rate;
        int codec_idx;
};

#ifndef MIN
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#endif

static void greedy_sort(switch_media_handle_t *smh, struct matches *matches, int m_idx, const switch_codec_implementation_t **codec_array, int total_codecs)
{
        int j = 0, f = 0, g;
        struct matches mtmp[MAX_MATCHES] = { { 0 } };

        m_idx = MIN(m_idx, MAX_MATCHES);

        for(j = 0; j < m_idx; j++) {
                *&mtmp[j] = *&matches[j];
        }

        for (g = 0; g < smh->mparams->num_codecs && g < total_codecs && f < MAX_MATCHES; g++) {
                const switch_codec_implementation_t *imp = codec_array[g];

                for(j = 0; j < m_idx; j++) {
                        if (mtmp[j].imp && mtmp[j].imp == imp) {
                                *&matches[f++] = *&mtmp[j];
                                mtmp[j].imp = NULL;
                        }
                }
        }
}

static void clear_pmaps(switch_rtp_engine_t *engine)
{
        payload_map_t *pmap;

        for (pmap = engine->payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                pmap->negotiated = 0;
                pmap->current = 0;
        }
}

static void restore_pmaps(switch_rtp_engine_t *engine)
{
        payload_map_t *pmap;
        int top = 0;

        for (pmap = engine->payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                pmap->negotiated = 1;
                if (!top++) pmap->current = 1;
        }
}

static const char *media_flow_varname(switch_media_type_t type)
{
        const char *varname = "invalid";

        switch(type) {
        case SWITCH_MEDIA_TYPE_AUDIO:
                varname = "audio_media_flow";
                break;
        case SWITCH_MEDIA_TYPE_VIDEO:
                varname = "video_media_flow";
                break;
        case SWITCH_MEDIA_TYPE_TEXT:
                varname = "text_media_flow";
                break;
        }

        return varname;
}

static const char *remote_media_flow_varname(switch_media_type_t type)
{
        const char *varname = "invalid";

        switch(type) {
        case SWITCH_MEDIA_TYPE_AUDIO:
                varname = "remote_audio_media_flow";
                break;
        case SWITCH_MEDIA_TYPE_VIDEO:
                varname = "remote_video_media_flow";
                break;
        case SWITCH_MEDIA_TYPE_TEXT:
                varname = "remote_text_media_flow";
                break;
        }

        return varname;
}

static void media_flow_get_mode(switch_media_flow_t smode, const char **mode_str, switch_media_flow_t *opp_mode)
{
        const char *smode_str = "";
        switch_media_flow_t opp_smode = smode;

        switch(smode) {
        case SWITCH_MEDIA_FLOW_SENDONLY:
                opp_smode = SWITCH_MEDIA_FLOW_RECVONLY;
                smode_str = "sendonly";
                break;
        case SWITCH_MEDIA_FLOW_RECVONLY:
                opp_smode = SWITCH_MEDIA_FLOW_SENDONLY;
                smode_str = "recvonly";
                break;
        case SWITCH_MEDIA_FLOW_INACTIVE:
                smode_str = "inactive";
                break;
        case SWITCH_MEDIA_FLOW_DISABLED:
                smode_str = "disabled";
                break;
        case SWITCH_MEDIA_FLOW_SENDRECV:
                smode_str = "sendrecv";
                break;
        }

        *mode_str = smode_str;
        *opp_mode = opp_smode;
        
}

static void check_stream_changes(switch_core_session_t *session, const char *r_sdp, switch_sdp_type_t sdp_type)
{
        switch_core_session_t *other_session = NULL;
        switch_core_session_message_t *msg;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        status = switch_core_session_get_partner(session, &other_session);
        (void)status;

        if (switch_channel_test_flag(session->channel, CF_STREAM_CHANGED)) {
                switch_channel_clear_flag(session->channel, CF_STREAM_CHANGED);
                
                if (other_session) {
                        switch_channel_set_flag(other_session->channel, CF_PROCESSING_STREAM_CHANGE);
                        switch_channel_set_flag(session->channel, CF_AWAITING_STREAM_CHANGE);

                        if (sdp_type == SDP_OFFER && r_sdp) {
                                const char *filter_codec_string = switch_channel_get_variable(session->channel, "filter_codec_string");
                                
                                switch_channel_set_variable(session->channel, "codec_string", NULL);
                                switch_core_media_merge_sdp_codec_string(session, r_sdp, sdp_type, filter_codec_string);
                        }

                        if (switch_channel_test_flag(session->channel, CF_SECURE)) {
                                other_session->media_handle->crypto_mode = session->media_handle->crypto_mode;
                                switch_core_session_check_outgoing_crypto(other_session);
                        }

                        msg = switch_core_session_alloc(other_session, sizeof(*msg));
                        msg->message_id = SWITCH_MESSAGE_INDICATE_MEDIA_RENEG;
                        msg->string_arg = switch_core_session_sprintf(other_session, "=%s", switch_channel_get_variable(session->channel, "ep_codec_string"));
                        msg->from = __FILE__;
                        switch_core_session_queue_message(other_session, msg);
                }
        }

        if (other_session) {
                if (sdp_type == SDP_ANSWER && switch_channel_test_flag(session->channel, CF_PROCESSING_STREAM_CHANGE)) {
                        switch_channel_clear_flag(session->channel, CF_PROCESSING_STREAM_CHANGE);
                        
                        if (switch_channel_test_flag(other_session->channel, CF_AWAITING_STREAM_CHANGE)) {
                                uint8_t proceed = 1;
                                const char *sdp_in, *other_ep;
                                uint8_t res = 0;

                                if ((other_ep = switch_channel_get_variable(session->channel, "ep_codec_string"))) {
                                        switch_channel_set_variable(other_session->channel, "codec_string", other_ep);
                                }

                                sdp_in = switch_channel_get_variable(other_session->channel, SWITCH_R_SDP_VARIABLE);
                                res = switch_core_media_negotiate_sdp(other_session, sdp_in, &proceed, SDP_OFFER);
                                (void)res;
                                switch_core_media_activate_rtp(other_session);
                                msg = switch_core_session_alloc(other_session, sizeof(*msg));
                                msg->message_id = SWITCH_MESSAGE_INDICATE_RESPOND;
                                msg->from = __FILE__;

                                switch_channel_set_flag(other_session->channel, CF_AWAITING_STREAM_CHANGE);
                                switch_core_session_queue_message(other_session, msg);
                        }
                }

                switch_core_session_rwunlock(other_session);
        }
}

SWITCH_DECLARE(void) switch_core_media_set_smode(switch_core_session_t *session, switch_media_type_t type, switch_media_flow_t smode, switch_sdp_type_t sdp_type)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;
        const char *varname = NULL, *smode_str = NULL;
        switch_media_flow_t old_smode, opp_smode = smode;
        switch_core_session_t *other_session;
        int pass_codecs = 0;
        
        if (!(smh = session->media_handle)) {
                return;
        }

        engine = &smh->engines[type];

        varname = media_flow_varname(type);
        
        media_flow_get_mode(smode, &smode_str, &opp_smode);

        old_smode = engine->smode;

        engine->smode = smode;

        switch_channel_set_variable(session->channel, varname, smode_str);

        if (switch_channel_var_true(session->channel, "rtp_pass_codecs_on_reinvite") || engine->pass_codecs) {
                pass_codecs = 1;
        }

        engine->pass_codecs = 0;
        
        if (switch_channel_var_true(session->channel, "rtp_pass_codecs_on_stream_change")) {
                if (sdp_type == SDP_OFFER && switch_channel_test_flag(session->channel, CF_REINVITE) && 
                        switch_channel_media_up(session->channel) && (pass_codecs || old_smode != smode)) {

                        if (switch_core_session_get_partner(session, &other_session) == SWITCH_STATUS_SUCCESS) {
                                switch_core_media_set_smode(other_session, type, opp_smode, SDP_OFFER);
                                switch_channel_set_flag(session->channel, CF_STREAM_CHANGED);
                                switch_core_session_rwunlock(other_session);
                        }
                }
        }
}

static void switch_core_media_set_rmode(switch_core_session_t *session, switch_media_type_t type, switch_media_flow_t rmode, switch_sdp_type_t sdp_type)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;
        const char *varname = NULL, *rmode_str = NULL;
        switch_media_flow_t opp_rmode = rmode;
        switch_core_session_t *other_session = NULL;

        if (!(smh = session->media_handle)) {
                return;
        }

        engine = &smh->engines[type];
        
        varname = remote_media_flow_varname(type);
        media_flow_get_mode(rmode, &rmode_str, &opp_rmode);

        if (engine->rmode != rmode) {
                engine->pass_codecs = 1;
        }
        
        engine->rmode = rmode;

        if (switch_core_session_get_partner(session, &other_session) == SWITCH_STATUS_SUCCESS) {

                if (sdp_type == SDP_ANSWER && (switch_channel_test_flag(other_session->channel, CF_REINVITE) || switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND)) {
                        switch_core_media_set_smode(other_session, type, rmode, sdp_type);
                }

                switch_core_session_rwunlock(other_session);
        }

        switch_channel_set_variable(session->channel, varname, rmode_str);
}

//?
SWITCH_DECLARE(uint8_t) switch_core_media_negotiate_sdp(switch_core_session_t *session, const char *r_sdp, uint8_t *proceed, switch_sdp_type_t sdp_type)
{
        uint8_t match = 0, vmatch = 0, almost_vmatch = 0, tmatch = 0, fmatch = 0;
        switch_payload_t best_te = 0, cng_pt = 0;
        unsigned long best_te_rate = 8000, cng_rate = 8000;
        sdp_media_t *m;
        sdp_attribute_t *attr;
        int ptime = 0, dptime = 0, maxptime = 0, dmaxptime = 0;
        int sendonly = 0, recvonly = 0, inactive = 0;
        int greedy = 0, x = 0, skip = 0;
        switch_channel_t *channel = switch_core_session_get_channel(session);
        const char *val;
        const char *crypto = NULL;
        int got_crypto = 0, got_video_crypto = 0, got_audio = 0, saw_audio = 0, saw_video = 0, got_avp = 0, got_savp = 0, got_udptl = 0, got_webrtc = 0, got_text = 0, got_text_crypto = 0, got_msrp = 0;
        int scrooge = 0;
        sdp_parser_t *parser = NULL;
        sdp_session_t *sdp;
        const switch_codec_implementation_t **codec_array;
        int total_codecs;
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_media_handle_t *smh;
        uint32_t near_rate = 0;
        const switch_codec_implementation_t *mimp = NULL, *near_match = NULL;
        sdp_rtpmap_t *mmap = NULL, *near_map = NULL;
        struct matches matches[MAX_MATCHES] = { { 0 } };
        struct matches near_matches[MAX_MATCHES] = { { 0 } };
        int codec_ms = 0;
        uint32_t remote_codec_rate = 0, fmtp_remote_codec_rate = 0;
        const char *tmp;
        int m_idx = 0, skip_rtcp = 0, skip_video_rtcp = 0, got_rtcp_mux = 0, got_video_rtcp_mux = 0;
        int nm_idx = 0;
        int vmatch_pt = 1, consider_video_fmtp = 1;
        int rtcp_auto_audio = 0, rtcp_auto_video = 0;
        int got_audio_rtcp = 0, got_video_rtcp = 0;
        switch_port_t audio_port = 0, video_port = 0;

        switch_assert(session);

        if (!r_sdp) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Tried to negotiate a blank SDP?\n");
                return 0;
        }

        if (!(smh = session->media_handle)) {
                return 0;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        smh->mparams->num_codecs = 0;
        smh->num_negotiated_codecs = 0;
        switch_core_media_prepare_codecs(session, SWITCH_TRUE);
        codec_array = smh->codecs;
        total_codecs = smh->mparams->num_codecs;

        if (!(parser = sdp_parse(NULL, r_sdp, (int) strlen(r_sdp), 0))) {
                return 0;
        }

        if (!(sdp = sdp_session(parser))) {
                sdp_parser_free(parser);
                return 0;
        }

        switch_channel_clear_flag(channel, CF_AUDIO_PAUSE_READ);
        switch_channel_clear_flag(channel, CF_AUDIO_PAUSE_WRITE);

        if (dtls_ok(session) && (tmp = switch_channel_get_variable(smh->session->channel, "webrtc_enable_dtls")) && switch_false(tmp)) {
                switch_channel_clear_flag(smh->session->channel, CF_DTLS_OK);
                switch_channel_clear_flag(smh->session->channel, CF_DTLS);
        }

        if (switch_true(switch_channel_get_variable_dup(session->channel, "rtp_assume_rtcp", SWITCH_FALSE, -1))) {
                rtcp_auto_video = 1;
                rtcp_auto_audio = 1;
        }

        v_engine->new_dtls = 1;
        v_engine->new_ice = 1;
        a_engine->new_dtls = 1;
        a_engine->new_ice = 1;
        a_engine->reject_avp = 0;

        switch_media_handle_set_media_flag(smh, SCMF_RECV_SDP);

        switch_core_session_parse_crypto_prefs(session);

        clear_pmaps(a_engine);
        clear_pmaps(v_engine);

        if (proceed) *proceed = 1;

        greedy = !!switch_media_handle_test_media_flag(smh, SCMF_CODEC_GREEDY);
        scrooge = !!switch_media_handle_test_media_flag(smh, SCMF_CODEC_SCROOGE);

        if ((val = switch_channel_get_variable(channel, "rtp_codec_negotiation"))) {
                if (!strcasecmp(val, "generous")) {
                        greedy = 0;
                        scrooge = 0;
                } else if (!strcasecmp(val, "greedy")) {
                        greedy = 1;
                        scrooge = 0;
                } else if (!strcasecmp(val, "scrooge")) {
                        scrooge = 1;
                        greedy = 1;
                } else {
                    switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "rtp_codec_negotiation ignored invalid value : '%s' \n", val );
                }
        }

        if ((smh->origin = switch_core_session_strdup(session, (char *) sdp->sdp_origin->o_username))) {

                if ((smh->mparams->auto_rtp_bugs & RTP_BUG_CISCO_SKIP_MARK_BIT_2833)) {

                        if (strstr(smh->origin, "CiscoSystemsSIP-GW-UserAgent")) {
                                a_engine->rtp_bugs |= RTP_BUG_CISCO_SKIP_MARK_BIT_2833;
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Activate Buggy RFC2833 Mode!\n");
                        }
                }

                if ((smh->mparams->auto_rtp_bugs & RTP_BUG_SONUS_SEND_INVALID_TIMESTAMP_2833)) {
                        if (strstr(smh->origin, "Sonus_UAC")) {
                                a_engine->rtp_bugs |= RTP_BUG_SONUS_SEND_INVALID_TIMESTAMP_2833;
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                  "Hello,\nI see you have a Sonus!\n"
                                                                  "FYI, Sonus cannot follow the RFC on the proper way to send DTMF.\n"
                                                                  "Sadly, my creator had to spend several hours figuring this out so I thought you'd like to know that!\n"
                                                                  "Don't worry, DTMF will work but you may want to ask them to fix it......\n");
                        }
                }
        }

        /* check dtmf_type variable */
        switch_core_media_check_dtmf_type(session);

        if ((val = switch_channel_get_variable(session->channel, "rtp_liberal_dtmf")) && switch_true(val)) {
                switch_channel_set_flag(session->channel, CF_LIBERAL_DTMF);
        }

        if (switch_stristr("T38FaxFillBitRemoval:", r_sdp) || switch_stristr("T38FaxTranscodingMMR:", r_sdp) ||
                switch_stristr("T38FaxTranscodingJBIG:", r_sdp)) {
                switch_channel_set_variable(session->channel, "t38_broken_boolean", "true");
        }

        check_ice(smh, SWITCH_MEDIA_TYPE_AUDIO, sdp, NULL);
        check_ice(smh, SWITCH_MEDIA_TYPE_VIDEO, sdp, NULL);
        check_ice(smh, SWITCH_MEDIA_TYPE_TEXT, sdp, NULL);

        if ((sdp->sdp_connection && sdp->sdp_connection->c_address && !strcmp(sdp->sdp_connection->c_address, "0.0.0.0"))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "RFC2543 from March 1999 called; They want their 0.0.0.0 hold method back.....\n");
                sendonly = 2;                   /* global sendonly always wins */
        }

        memset(smh->rejected_streams, 0, sizeof(smh->rejected_streams));
        smh->rej_idx = 0;

        switch_core_media_set_rmode(smh->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_MEDIA_FLOW_INACTIVE, sdp_type);
        switch_core_media_set_rmode(smh->session, SWITCH_MEDIA_TYPE_TEXT, SWITCH_MEDIA_FLOW_INACTIVE, sdp_type);
        
        for (m = sdp->sdp_media; m; m = m->m_next) {
                sdp_connection_t *connection;
                switch_core_session_t *other_session;

                if (!m->m_port && smh->rej_idx < MAX_REJ_STREAMS - 1) {

                        switch(m->m_type) {
                        case sdp_media_audio:
                                smh->rejected_streams[smh->rej_idx++] = sdp_media_audio;
                                continue;
                        case sdp_media_video:
                                smh->rejected_streams[smh->rej_idx++] = sdp_media_video;
                                continue;
                        case sdp_media_image:
                                smh->rejected_streams[smh->rej_idx++] = sdp_media_image;
                                continue;
                        default:
                                break;
                        }
                }

                if (m->m_type == sdp_media_audio) {
                        saw_audio = 1;
                }

                if (m->m_type == sdp_media_video) {
                        saw_video = 1;
                }

                ptime = dptime;
                maxptime = dmaxptime;

                if (m->m_proto == sdp_proto_extended_srtp || m->m_proto == sdp_proto_extended_rtp) {
                        got_webrtc++;
                        switch_core_session_set_ice(session);
                }

                if (m->m_proto_name && !strcasecmp(m->m_proto_name, "UDP/TLS/RTP/SAVPF")) {
                        switch_channel_set_flag(session->channel, CF_AVPF_MOZ);
                }

                if (m->m_proto_name && !strcasecmp(m->m_proto_name, "UDP/RTP/AVPF")) {
                        switch_channel_set_flag(session->channel, CF_AVPF_MOZ);
                }

                if (m->m_proto == sdp_proto_srtp || m->m_proto == sdp_proto_extended_srtp) {
                        if (m->m_type == sdp_media_audio) {
                                got_savp++;
                        }
                } else if (m->m_proto == sdp_proto_rtp) {
                        if (m->m_type == sdp_media_audio) {
                                got_avp++;
                        }
                } else if (m->m_proto == sdp_proto_udptl) {
                        got_udptl++;
                } else if (m->m_proto == sdp_proto_msrp || m->m_proto == sdp_proto_msrps){
                        got_msrp++;
                }

                if (got_msrp && m->m_type == sdp_media_message) {
                        if (!smh->msrp_session) {
                                smh->msrp_session = switch_msrp_session_new(switch_core_session_get_pool(session), switch_core_session_get_uuid(session), m->m_proto == sdp_proto_msrps);
                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "MSRP session created %s\n", smh->msrp_session->call_id);
                        }

                        switch_assert(smh->msrp_session);

                        for (attr = m->m_attributes; attr; attr = attr->a_next) {
                                // switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "[%s]=[%s]\n", attr->a_name, attr->a_value);
                                if (!strcasecmp(attr->a_name, "path") && attr->a_value) {
                                        smh->msrp_session->remote_path = switch_core_session_strdup(session, attr->a_value);
                                        switch_channel_set_variable(session->channel, "sip_msrp_remote_path", attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "accept-types") && attr->a_value) {
                                        smh->msrp_session->remote_accept_types = switch_core_session_strdup(session, attr->a_value);
                                        switch_channel_set_variable(session->channel, "sip_msrp_remote_accept_types", attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "accept-wrapped-types") && attr->a_value) {
                                        smh->msrp_session->remote_accept_wrapped_types = switch_core_session_strdup(session, attr->a_value);
                                        switch_channel_set_variable(session->channel, "sip_msrp_remote_accept_wrapped_types", attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "setup") && attr->a_value) {
                                        smh->msrp_session->remote_setup = switch_core_session_strdup(session, attr->a_value);
                                        switch_channel_set_variable(session->channel, "sip_msrp_remote_setup", attr->a_value);
                                        if (!strcmp(attr->a_value, "passive")) {
                                                smh->msrp_session->active = 1;
                                        }
                                } else if (!strcasecmp(attr->a_name, "file-selector") && attr->a_value) {
                                        char *tmp = switch_mprintf("%s", attr->a_value);
                                        char *argv[4] = { 0 };
                                        int argc;
                                        int i;

                                        smh->msrp_session->remote_file_selector = switch_core_session_strdup(session, attr->a_value);
                                        switch_channel_set_variable(session->channel, "sip_msrp_remote_file_selector", attr->a_value);

                                        argc = switch_separate_string(tmp, ' ', argv, (sizeof(argv) / sizeof(argv[0])));

                                        for(i = 0; i<argc; i++) {
                                                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "::::%s\n", switch_str_nil(argv[i]));
                                                if (zstr(argv[i])) {
                                                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ERRRRRRR\n");
                                                        continue;
                                                }
                                                if (!strncasecmp(argv[i], "name:", 5)) {
                                                        char *p = argv[i] + 5;
                                                        int len = strlen(p);

                                                        if (*p == '"') {
                                                                *(p + len - 1) = '\0';
                                                                p++;
                                                        }
                                                        switch_channel_set_variable(session->channel, "sip_msrp_file_name", p);
                                                } else if (!strncasecmp(argv[i], "type:", 5)) {
                                                        switch_channel_set_variable(session->channel, "sip_msrp_file_type", argv[i] + 5);
                                                }
                                                if (!strncasecmp(argv[i], "size:", 5)) {
                                                        switch_channel_set_variable(session->channel, "sip_msrp_file_size", argv[i] + 5);
                                                }
                                                if (!strncasecmp(argv[i], "hash:", 5)) {
                                                        switch_channel_set_variable(session->channel, "sip_msrp_file_hash", argv[i] + 5);
                                                }
                                        }
                                        switch_safe_free(tmp);
                                } else if (!strcasecmp(attr->a_name, "file-transfer-id") && attr->a_value) {
                                        switch_channel_set_variable(session->channel, "sip_msrp_file_transfer_id", attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "file-disposition") && attr->a_value) {
                                        switch_channel_set_variable(session->channel, "sip_msrp_file_disposition", attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "file-date") && attr->a_value) {
                                        switch_channel_set_variable(session->channel, "sip_msrp_file_date", attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "file-icon") && attr->a_value) {
                                        switch_channel_set_variable(session->channel, "sip_msrp_file_icon", attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "file-range") && attr->a_value) {
                                        switch_channel_set_variable(session->channel, "sip_msrp_file_range", attr->a_value);
                                }
                        }

                        smh->msrp_session->local_accept_types = smh->msrp_session->remote_accept_types;
                        smh->msrp_session->local_accept_wrapped_types = smh->msrp_session->remote_accept_types;
                        smh->msrp_session->local_setup = smh->msrp_session->remote_setup;

                        switch_channel_set_flag(session->channel, CF_HAS_TEXT);
                        switch_channel_set_flag(session->channel, CF_TEXT_POSSIBLE);
                        switch_channel_set_flag(session->channel, CF_TEXT_LINE_BASED);
                        switch_channel_set_flag(session->channel, CF_MSRP);

                        if (m->m_proto == sdp_proto_msrps) {
                                switch_channel_set_flag(session->channel, CF_MSRPS);
                        }

                        if (smh->msrp_session->active) {
                                const char *ip = switch_msrp_listen_ip();

                                smh->msrp_session->local_path = switch_core_session_sprintf(session,
                                        "msrp%s://%s:%d/%s;tcp",
                                        smh->msrp_session->secure ? "s" : "",
                                        ip, smh->msrp_session->local_port, smh->msrp_session->call_id);

                                switch_msrp_start_client(smh->msrp_session);
                        }

                        switch_core_session_start_text_thread(session);
                        tmatch = 1;
                }

                if (got_udptl && m->m_type == sdp_media_image) {
                        switch_channel_set_flag(session->channel, CF_IMAGE_SDP);

                        if (m->m_port) {
                                if (switch_channel_test_app_flag_key("T38", session->channel, CF_APP_T38_NEGOTIATED)) {
                                        fmatch = 1;
                                        goto done;
                                }

                                if (switch_channel_var_true(channel, "refuse_t38") || !switch_channel_var_true(channel, "fax_enable_t38")) {
                                        switch_channel_clear_app_flag_key("T38", session->channel, CF_APP_T38);
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s T38 REFUSE on %s\n",
                                                                          switch_channel_get_name(channel),
                                                                          sdp_type == SDP_ANSWER ? "response" : "request");

                                        restore_pmaps(a_engine);
                                        fmatch = 0;

                                        goto t38_done;
                                } else {
                                        switch_t38_options_t *t38_options = switch_core_media_process_udptl(session, sdp, m);
                                        const char *var = switch_channel_get_variable(channel, "t38_passthru");
                                        int pass = switch_channel_test_flag(smh->session->channel, CF_T38_PASSTHRU);

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s T38 ACCEPT on %s\n",
                                                                          switch_channel_get_name(channel),
                                                                          sdp_type == SDP_ANSWER ? "response" : "request");

                                        if (switch_channel_test_app_flag_key("T38", session->channel, CF_APP_T38)) {
                                                if (proceed) *proceed = 0;
                                        }

                                        if (var) {
                                                if (!(pass = switch_true(var))) {
                                                        if (!strcasecmp(var, "once")) {
                                                                pass = 2;
                                                        }
                                                }
                                        }

                                        if ((pass == 2 && switch_channel_test_flag(smh->session->channel, CF_T38_PASSTHRU))
                                                || !switch_channel_test_flag(session->channel, CF_REINVITE) ||

                                                switch_channel_test_flag(session->channel, CF_PROXY_MODE) ||
                                                switch_channel_test_flag(session->channel, CF_PROXY_MEDIA) ||
                                                !switch_rtp_ready(a_engine->rtp_session)) {
                                                pass = 0;
                                        }

                                        if (pass && switch_core_session_get_partner(session, &other_session) == SWITCH_STATUS_SUCCESS) {
                                                switch_channel_t *other_channel = switch_core_session_get_channel(other_session);
                                                switch_core_session_message_t *msg;
                                                char *remote_host = switch_rtp_get_remote_host(a_engine->rtp_session);
                                                switch_port_t remote_port = switch_rtp_get_remote_port(a_engine->rtp_session);
                                                char tmp[32] = "";


                                                if (!switch_channel_test_flag(other_channel, CF_ANSWERED)) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session),
                                                                                          SWITCH_LOG_WARNING, "%s Error Passing T.38 to unanswered channel %s\n",
                                                                                          switch_channel_get_name(session->channel), switch_channel_get_name(other_channel));
                                                        switch_core_session_rwunlock(other_session);

                                                        match = 0;
                                                        fmatch = 0;
                                                        goto done;
                                                }

                                                switch_channel_set_app_flag_key("T38", channel, CF_APP_T38_POSSIBLE);
                                                switch_channel_set_app_flag_key("T38", other_channel, CF_APP_T38_POSSIBLE);

                                                if (switch_true(switch_channel_get_variable(session->channel, "t38_broken_boolean")) &&
                                                        switch_true(switch_channel_get_variable(session->channel, "t38_pass_broken_boolean"))) {
                                                        switch_channel_set_variable(other_channel, "t38_broken_boolean", "true");
                                                }

                                                a_engine->cur_payload_map->remote_sdp_ip = switch_core_session_strdup(session, t38_options->remote_ip);
                                                a_engine->cur_payload_map->remote_sdp_port = t38_options->remote_port;

                                                if (remote_host && remote_port && !strcmp(remote_host, a_engine->cur_payload_map->remote_sdp_ip) && remote_port == a_engine->cur_payload_map->remote_sdp_port) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Audio params are unchanged for %s.\n",
                                                                                          switch_channel_get_name(session->channel));
                                                } else {
                                                        const char *err = NULL;

                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Audio params changed for %s from %s:%d to %s:%d\n",
                                                                                          switch_channel_get_name(session->channel),
                                                                                          remote_host, remote_port, a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);

                                                        switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->cur_payload_map->remote_sdp_port);
                                                        switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->cur_payload_map->remote_sdp_ip);
                                                        switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE, tmp);

                                                        if (switch_rtp_set_remote_address(a_engine->rtp_session, a_engine->cur_payload_map->remote_sdp_ip,
                                                                                                                          a_engine->cur_payload_map->remote_sdp_port, 0, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "AUDIO RTP REPORTS ERROR: [%s]\n", err);
                                                                switch_channel_hangup(channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
                                                        }

                                                        switch_core_media_check_autoadj(session);
                                                        switch_channel_execute_on(session->channel, "execute_on_audio_change");
                                                }



                                                switch_core_media_copy_t38_options(t38_options, other_session);

                                                switch_channel_set_flag(smh->session->channel, CF_T38_PASSTHRU);
                                                switch_channel_set_flag(other_session->channel, CF_T38_PASSTHRU);

                                                msg = switch_core_session_alloc(other_session, sizeof(*msg));
                                                msg->message_id = SWITCH_MESSAGE_INDICATE_REQUEST_IMAGE_MEDIA;
                                                msg->from = __FILE__;
                                                msg->string_arg = switch_core_session_strdup(other_session, r_sdp);
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Passing T38 req to other leg.\n%s\n", r_sdp);
                                                switch_core_session_queue_message(other_session, msg);
                                                switch_core_session_rwunlock(other_session);
                                        }
                                }

                                /* do nothing here, mod_fax will trigger a response (if it's listening =/) */
                                if (switch_channel_wait_for_app_flag(channel, CF_APP_T38_POSSIBLE, "T38", SWITCH_TRUE, 2000)) {
                                        fmatch = 1;
                                } else {

                                        fmatch = 0;
                                }

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s T38 %s POSSIBLE on %s\n",
                                                                  switch_channel_get_name(channel),
                                                                  fmatch ? "IS" : "IS NOT",
                                                                  sdp_type == SDP_ANSWER ? "response" : "request");


                                goto done;
                        }
                } else if (m->m_type == sdp_media_audio && m->m_port && got_audio && got_savp) {
                        a_engine->reject_avp = 1;
                } else if (m->m_type == sdp_media_audio && m->m_port && !got_audio) {
                        sdp_rtpmap_t *map;
                        int ice = 0;

                        nm_idx = 0;
                        m_idx = 0;
                        memset(matches, 0, sizeof(matches[0]) * MAX_MATCHES);
                        memset(near_matches, 0, sizeof(near_matches[0]) * MAX_MATCHES);

                        audio_port = m->m_port;

                        if (!sendonly && (m->m_mode == sdp_sendonly || m->m_mode == sdp_inactive)) {
                                sendonly = 1;
                                if (m->m_mode == sdp_inactive) {
                                        inactive = 1;
                                }
                        }

                        if (!sendonly && m->m_connections && m->m_connections->c_address && !strcmp(m->m_connections->c_address, "0.0.0.0")) {
                                sendonly = 1;
                        }


                        switch_core_media_set_rmode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, sdp_media_flow(m->m_mode), sdp_type);

                        if (sdp_type == SDP_OFFER) {
                                switch(a_engine->rmode) {
                                case SWITCH_MEDIA_FLOW_RECVONLY:
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_FLOW_SENDONLY, sdp_type);
                                        break;
                                case SWITCH_MEDIA_FLOW_SENDONLY:
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_FLOW_RECVONLY, sdp_type);
                                        break;
                                case SWITCH_MEDIA_FLOW_INACTIVE:
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_FLOW_INACTIVE, sdp_type);
                                        break;
                                default:
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_FLOW_SENDRECV, sdp_type);
                                        break;
                                }
                        }

                        for (attr = sdp->sdp_attributes; attr; attr = attr->a_next) {
                                if (zstr(attr->a_name)) {
                                        continue;
                                }


                                if (!strncasecmp(attr->a_name, "ice", 3)) {
                                        ice++;
                                } else if (sendonly < 2 && !strcasecmp(attr->a_name, "sendonly")) {
                                        sendonly = 1;
                                        switch_channel_set_variable(session->channel, "media_audio_mode", "recvonly");
                                } else if (sendonly < 2 && !strcasecmp(attr->a_name, "inactive")) {
                                        switch_channel_set_variable(session->channel, "media_audio_mode", "inactive");
                                } else if (!strcasecmp(attr->a_name, "recvonly")) {
                                        switch_channel_set_variable(session->channel, "media_audio_mode", "sendonly");
                                        recvonly = 1;

                                        a_engine->media_timeout = 0;
                                        a_engine->media_hold_timeout = 0;

                                        if (switch_rtp_ready(a_engine->rtp_session)) {
                                                switch_rtp_set_max_missed_packets(a_engine->rtp_session, 0);
                                                a_engine->max_missed_hold_packets = 0;
                                                a_engine->max_missed_packets = 0;
                                                switch_rtp_set_media_timeout(a_engine->rtp_session, a_engine->media_timeout);
                                        } else {
                                                switch_channel_set_variable(session->channel, "media_timeout_audio", "0");
                                                switch_channel_set_variable(session->channel, "media_hold_timeout_audio", "0");
                                                switch_channel_set_variable(session->channel, "rtp_timeout_sec", "0");
                                                switch_channel_set_variable(session->channel, "rtp_hold_timeout_sec", "0");
                                        }
                                } else if (sendonly < 2 && !strcasecmp(attr->a_name, "sendrecv")) {
                                        sendonly = 0;
                                } else if (!strcasecmp(attr->a_name, "ptime")) {
                                        ptime = dptime = atoi(attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "maxptime")) {
                                        maxptime = dmaxptime = atoi(attr->a_value);
                                }
                        }

                        if (sendonly == 2 && ice) {
                                sendonly = 0;
                        }


                        if (sendonly != 1 && recvonly != 1 && inactive != 1) {
                                switch_channel_set_variable(session->channel, "media_audio_mode", NULL);
                        }

                        if (sdp_type == SDP_ANSWER) {
                                if (inactive) {
                                        // When freeswitch had previously sent inactive in sip request. it should remain inactive otherwise smode should be sendrecv
                                        if (a_engine->smode==SWITCH_MEDIA_FLOW_INACTIVE) {
                                                switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, sdp_media_flow(sdp_inactive), sdp_type);
                                        } else {
                                                switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, sdp_media_flow(sdp_sendrecv), sdp_type);
                                        }
                                } else if (sendonly) {
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, sdp_media_flow(sdp_sendonly), sdp_type);
                                } else if (recvonly) {
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, sdp_media_flow(sdp_recvonly), sdp_type);
                                }
                        }


                        if (!(switch_media_handle_test_media_flag(smh, SCMF_DISABLE_HOLD)
                                  || ((val = switch_channel_get_variable(session->channel, "rtp_disable_hold"))
                                          && switch_true(val)))
                                && !smh->mparams->hold_laps) {
                                smh->mparams->hold_laps++;
                                switch_core_media_toggle_hold(session, sendonly);
                        }


                        if (switch_rtp_has_dtls() && dtls_ok(session)) {
                                for (attr = m->m_attributes; attr; attr = attr->a_next) {

                                        if (!strcasecmp(attr->a_name, "fingerprint") && !zstr(attr->a_value)) {
                                                got_crypto = 1;
                                        }
                                }
                        }

                        skip_rtcp = 0;
                        got_rtcp_mux = 0;
                        for (attr = m->m_attributes; attr; attr = attr->a_next) {
                                if (!strcasecmp(attr->a_name, "rtcp-mux")) {
                                        got_rtcp_mux = 1;
                                        skip_rtcp = 1;
                                        if (!smh->mparams->rtcp_video_interval_msec) {
                                                smh->mparams->rtcp_video_interval_msec = SWITCH_RTCP_VIDEO_INTERVAL_MSEC;
                                        }
                                } else if (!strcasecmp(attr->a_name, "ice-ufrag")) {
                                        skip_rtcp = 1;
                                }
                        }

                        if (!got_rtcp_mux) {
                                a_engine->rtcp_mux = -1;
                        }

                        for (attr = m->m_attributes; attr; attr = attr->a_next) {
                                if (!strcasecmp(attr->a_name, "rtcp") && attr->a_value && !skip_rtcp) {
                                        a_engine->remote_rtcp_port = (switch_port_t)atoi(attr->a_value);
                                        switch_channel_set_variable_printf(session->channel, "rtp_remote_audio_rtcp_port", "%d", a_engine->remote_rtcp_port);

                                        if (!smh->mparams->rtcp_audio_interval_msec) {
                                                smh->mparams->rtcp_audio_interval_msec = SWITCH_RTCP_AUDIO_INTERVAL_MSEC;
                                        }
                                        got_audio_rtcp = 1;
                                } else if (!strcasecmp(attr->a_name, "ptime") && attr->a_value) {
                                        ptime = atoi(attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "maxptime") && attr->a_value) {
                                        maxptime = atoi(attr->a_value);
                                } else if (got_crypto < 1 && !strcasecmp(attr->a_name, "crypto") && !zstr(attr->a_value)) {
                                        int crypto_tag;

                                        if (!(smh->mparams->ndlb & SM_NDLB_ALLOW_CRYPTO_IN_AVP) &&
                                                !switch_true(switch_channel_get_variable(session->channel, "rtp_allow_crypto_in_avp"))) {
                                                if (m->m_proto != sdp_proto_srtp && !got_webrtc) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "a=crypto in RTP/AVP, refer to rfc3711\n");
                                                        match = 0;
                                                        goto done;
                                                }
                                        }

                                        crypto = attr->a_value;
                                        crypto_tag = atoi(crypto);
                                        got_crypto = switch_core_session_check_incoming_crypto(session,
                                                                                                                                                   "rtp_has_crypto", SWITCH_MEDIA_TYPE_AUDIO, crypto, crypto_tag, sdp_type);

                                }
                        }

                        if (got_crypto == -1 && got_savp && !got_avp && !got_webrtc) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Received invite with SAVP but secure media is administratively disabled\n");
                                match = 0;
                                continue;
                        }

                        connection = sdp->sdp_connection;
                        if (m->m_connections) {
                                connection = m->m_connections;
                        }

                        if (!connection) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot find a c= line in the sdp at media or session level!\n");
                                match = 0;
                                break;
                        }

                        x = 0;

                        for (map = m->m_rtpmaps; map; map = map->rm_next) {
                                int32_t i;
                                const char *rm_encoding;
                                uint32_t map_bit_rate = 0;
                                switch_codec_fmtp_t codec_fmtp = { 0 };
                                int map_channels = map->rm_params ? atoi(map->rm_params) : 1;

                                if (!(rm_encoding = map->rm_encoding)) {
                                        rm_encoding = "";
                                }


                                if (!strcasecmp(rm_encoding, "telephone-event")) {
                                        if (!best_te || map->rm_rate == a_engine->cur_payload_map->rm_rate) {
                                                best_te = (switch_payload_t) map->rm_pt;
                                                best_te_rate = map->rm_rate;
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set telephone-event payload to %u@%ld\n", best_te, best_te_rate);
                                        }
                                        continue;
                                }

                                if (!switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) && !cng_pt && !strcasecmp(rm_encoding, "CN")) {
                                        cng_pt = (switch_payload_t) map->rm_pt;
                                        if (a_engine->rtp_session) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set comfort noise payload to %u\n", cng_pt);
                                                switch_rtp_set_cng_pt(a_engine->rtp_session, cng_pt);
                                        }
                                        continue;
                                }


                                if (x++ < skip) {
                                        continue;
                                }

                                if (match) {
                                        continue;
                                }

                                codec_ms = ptime;

                                if (switch_channel_get_variable(session->channel, "rtp_h_X-Broken-PTIME") && a_engine->read_impl.microseconds_per_packet) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Overwriting ptime from a known broken endpoint with the currently used value of %d ms\n", a_engine->read_impl.microseconds_per_packet / 1000);
                                        codec_ms = a_engine->read_impl.microseconds_per_packet / 1000;
                                }

                                if (maxptime && (!codec_ms || codec_ms > maxptime)) {
                                        codec_ms = maxptime;
                                }

                                if (!codec_ms) {
                                        codec_ms = switch_default_ptime(rm_encoding, map->rm_pt);
                                }

                                map_bit_rate = switch_known_bitrate((switch_payload_t)map->rm_pt);

                                if (!ptime && !strcasecmp(map->rm_encoding, "g723")) {
                                        codec_ms = 30;
                                }

                                remote_codec_rate = map->rm_rate;
                                fmtp_remote_codec_rate = 0;
                                memset(&codec_fmtp, 0, sizeof(codec_fmtp));

                                if (zstr(map->rm_fmtp)) {
                                        if (!strcasecmp(map->rm_encoding, "ilbc")) {
                                                codec_ms = 30;
                                                map_bit_rate = 13330;
                                        } else if (!strcasecmp(map->rm_encoding, "isac")) {
                                                codec_ms = 30;
                                                map_bit_rate = 32000;
                                        }
                                } else {
                                        if ((switch_core_codec_parse_fmtp(map->rm_encoding, map->rm_fmtp, map->rm_rate, &codec_fmtp)) == SWITCH_STATUS_SUCCESS) {
                                                if (codec_fmtp.bits_per_second) {
                                                        map_bit_rate = codec_fmtp.bits_per_second;
                                                }
                                                if (codec_fmtp.microseconds_per_packet) {
                                                        codec_ms = (codec_fmtp.microseconds_per_packet / 1000);
                                                }
                                                if (codec_fmtp.actual_samples_per_second) {
                                                        fmtp_remote_codec_rate = codec_fmtp.actual_samples_per_second;
                                                }
                                                if (codec_fmtp.stereo) {
                                                        map_channels = 2;
                                                } else if (!strcasecmp(map->rm_encoding, "opus")) {
                                                        map_channels = 1;
                                                }

                                                if (codec_fmtp.max_ptime) {
                                                        maxptime = codec_fmtp.max_ptime;
                                                }
                                        }
                                }

                                for (i = 0; i < smh->mparams->num_codecs && i < total_codecs; i++) {
                                        const switch_codec_implementation_t *imp = codec_array[i];
                                        uint32_t bit_rate = imp->bits_per_second;
                                        uint32_t codec_rate = imp->samples_per_second;

                                        if (imp->codec_type != SWITCH_CODEC_TYPE_AUDIO) {
                                                continue;
                                        }

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Audio Codec Compare [%s:%d:%u:%d:%u:%d]/[%s:%d:%u:%d:%u:%d]\n",
                                                                          rm_encoding, map->rm_pt, (int) remote_codec_rate, codec_ms, map_bit_rate, map_channels,
                                                                          imp->iananame, imp->ianacode, codec_rate, imp->microseconds_per_packet / 1000, bit_rate, imp->number_of_channels);
                                        if ((zstr(map->rm_encoding) || (smh->mparams->ndlb & SM_NDLB_ALLOW_BAD_IANANAME)) && map->rm_pt < 96) {
                                                match = (map->rm_pt == imp->ianacode) ? 1 : 0;
                                        } else {
                                                match = (!strcasecmp(rm_encoding, imp->iananame) &&
                                                                 ((map->rm_pt < 96 && imp->ianacode < 96) || (map->rm_pt > 95 && imp->ianacode > 95)) &&
                                                                 (remote_codec_rate == codec_rate || fmtp_remote_codec_rate == imp->actual_samples_per_second)) ? 1 : 0;
                                                if (fmtp_remote_codec_rate) {
                                                        remote_codec_rate = fmtp_remote_codec_rate;
                                                }
                                        }

                                        if (match && bit_rate && map_bit_rate && map_bit_rate != bit_rate && strcasecmp(map->rm_encoding, "ilbc") &&
                                                strcasecmp(map->rm_encoding, "isac")) {
                                                /* if a bit rate is specified and doesn't match, this is not a codec match, except for ILBC */
                                                match = 0;
                                        }

                                        if (match && remote_codec_rate && codec_rate && remote_codec_rate != codec_rate && (!strcasecmp(map->rm_encoding, "pcma") ||
                                                                                                                                                                                          !strcasecmp(map->rm_encoding, "pcmu"))) {
                                                /* if the sampling rate is specified and doesn't match, this is not a codec match for G.711 */
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "sampling rates have to match for G.711\n");
                                                match = 0;
                                        }

                                        if (match) {
                                                if (scrooge) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                          "Bah HUMBUG! Sticking with %s@%uh@%ui\n",
                                                                                          imp->iananame, imp->samples_per_second, imp->microseconds_per_packet / 1000);
                                                } else if ((ptime && codec_ms && codec_ms * 1000 != imp->microseconds_per_packet) || remote_codec_rate != codec_rate) {
                                                        /* ptime does not match */
                                                        match = 0;

                                                        if (nm_idx >= MAX_MATCHES) {
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                                  "Audio Codec Compare [%s:%d:%u:%u:%d:%u:%d] was not saved as a near-match. Too many. Ignoring.\n",
                                                                                                  imp->iananame, imp->ianacode, codec_rate, imp->actual_samples_per_second, imp->microseconds_per_packet / 1000, bit_rate, imp->number_of_channels);
                                                                continue;
                                                        }

                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                          "Audio Codec Compare [%s:%d:%u:%d:%u:%d] is saved as a near-match\n",
                                                                                          imp->iananame, imp->ianacode, codec_rate, imp->microseconds_per_packet / 1000, bit_rate, imp->number_of_channels);

                                                        near_matches[nm_idx].codec_idx = i;
                                                        near_matches[nm_idx].rate = remote_codec_rate;
                                                        near_matches[nm_idx].imp = imp;
                                                        near_matches[nm_idx].map = map;
                                                        nm_idx++;

                                                        continue;
                                                }

                                                matches[m_idx].codec_idx = i;
                                                matches[m_idx].rate = codec_rate;
                                                matches[m_idx].imp = imp;
                                                matches[m_idx].map = map;
                                                m_idx++;

                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                  "Audio Codec Compare [%s:%d:%u:%d:%u:%d] ++++ is saved as a match\n",
                                                                                  imp->iananame, imp->ianacode, codec_rate, imp->microseconds_per_packet / 1000, bit_rate, imp->number_of_channels);

                                                if (m_idx >= MAX_MATCHES) {
                                                        break;
                                                }

                                                match = 0;
                                        }
                                }

                                if (m_idx >= MAX_MATCHES) {
                                        break;
                                }
                        }

                        if (smh->crypto_mode == CRYPTO_MODE_MANDATORY && got_crypto < 1) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Crypto not negotiated but required.\n");
                                match = 0;
                                m_idx = nm_idx = 0;
                        }


                        if (!m_idx && nm_idx) {
                                int j;

                                for(j = 0; j < nm_idx; j++) {
                                        const switch_codec_implementation_t *search[1];
                                        char *prefs[1];
                                        char tmp[80];
                                        char fmtp[SWITCH_MAX_CODECS][MAX_FMTP_LEN];
                                        int num;
                                        const switch_codec_implementation_t *timp = NULL;

                                        near_rate = near_matches[j].rate;
                                        near_match = near_matches[j].imp;
                                        near_map = near_matches[j].map;

                                        switch_snprintf(tmp, sizeof(tmp), "%s@%uh@%ui%dc", near_match->iananame, near_rate ? near_rate : near_match->samples_per_second,
                                                                        codec_ms, near_match->number_of_channels);

                                        prefs[0] = tmp;
                                        num = switch_loadable_module_get_codecs_sorted(search, fmtp, 1, prefs, 1);

                                        if (num) {
                                                timp = search[0];
                                        } else {
                                                timp = near_match;
                                        }

                                        if (!maxptime || timp->microseconds_per_packet / 1000 <= maxptime) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Substituting codec %s@%ui@%uh@%dc\n",
                                                                                  timp->iananame, timp->microseconds_per_packet / 1000, timp->actual_samples_per_second, timp->number_of_channels);
                                                match = 1;

                                                matches[m_idx].codec_idx = near_matches[j].codec_idx;
                                                matches[m_idx].rate = near_rate;
                                                matches[m_idx].imp = timp;
                                                matches[m_idx].map = near_map;
                                                m_idx++;

                                                break;
                                        }
                                }
                        }

                        if (m_idx) {
                                int j;

                                if (greedy) { /* sort in favor of mine */
                                        greedy_sort(smh, matches, m_idx, codec_array, total_codecs);
                                }

                                match = 1;
                                a_engine->codec_negotiated = 1;

                                for(j = 0; j < m_idx && smh->num_negotiated_codecs < SWITCH_MAX_CODECS; j++) {
                                        payload_map_t *pmap = switch_core_media_add_payload_map(session,
                                                                                                                                                        SWITCH_MEDIA_TYPE_AUDIO,
                                                                                                                                                        matches[j].map->rm_encoding,
                                                                                                                                                        matches[j].imp->modname,
                                                                                                                                                        matches[j].map->rm_fmtp,
                                                                                                                                                        sdp_type,
                                                                                                                                                        matches[j].map->rm_pt,
                                                                                                                                                        matches[j].imp->samples_per_second,
                                                                                                                                                        matches[j].imp->microseconds_per_packet / 1000,
                                                                                                                                                        matches[j].imp->number_of_channels,
                                                                                                                                                        SWITCH_TRUE);

                                        mimp = matches[j].imp;
                                        mmap = matches[j].map;

                                        if (j == 0) {
                                                a_engine->cur_payload_map = pmap;
                                                a_engine->cur_payload_map->current = 1;
                                                if (a_engine->rtp_session) {
                                                        switch_rtp_set_default_payload(a_engine->rtp_session, pmap->pt);
                                                }
                                        }

                                        pmap->rm_encoding = switch_core_session_strdup(session, (char *) mmap->rm_encoding);
                                        pmap->iananame = switch_core_session_strdup(session, (char *) mimp->iananame);
                                        pmap->recv_pt = (switch_payload_t) mmap->rm_pt;
                                        pmap->rm_rate = mimp->samples_per_second;
                                        pmap->adv_rm_rate = mimp->samples_per_second;
                                        if (strcasecmp(mimp->iananame, "g722")) {
                                                pmap->rm_rate = mimp->actual_samples_per_second;
                                        }
                                        pmap->codec_ms = mimp->microseconds_per_packet / 1000;
                                        pmap->bitrate = mimp->bits_per_second;
                                        pmap->channels = mmap->rm_params ? atoi(mmap->rm_params) : 1;

                                        if (!strcasecmp((char *) mmap->rm_encoding, "opus")) {
                                                if (pmap->channels == 1) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Invalid SDP for opus.  Don't ask.. but it needs a /2\n");
                                                        pmap->adv_channels = 1;
                                                } else {
                                                        pmap->adv_channels = 2; /* IKR ???*/
                                                }
                                                if (!zstr((char *) mmap->rm_fmtp) && switch_stristr("stereo=1", (char *) mmap->rm_fmtp)) {
                                                        uint32_t allow_channels = switch_core_max_audio_channels(0);
                                                        if (!allow_channels || allow_channels >= 2) { /*default*/
                                                                pmap->channels = 2;
                                                        } else { /* allow_channels == 1 */
                                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Opus: setting 1 audio channel via config.\n");
                                                                pmap->channels = 1;
                                                        }
                                                } else {
                                                        pmap->channels = 1;
                                                }
                                        } else {
                                                pmap->adv_channels = pmap->channels;
                                        }

                                        pmap->remote_sdp_ip = switch_core_session_strdup(session, (char *) connection->c_address);
                                        pmap->remote_sdp_port = (switch_port_t) m->m_port;
                                        pmap->rm_fmtp = switch_core_session_strdup(session, (char *) mmap->rm_fmtp);

                                        smh->negotiated_codecs[smh->num_negotiated_codecs++] = mimp;
                                        pmap->recv_pt = (switch_payload_t)mmap->rm_pt;

                                }
                        }

                        if (match) {
                                char tmp[50];
                                //const char *mirror = switch_channel_get_variable(session->channel, "rtp_mirror_remote_audio_codec_payload");


                                switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->cur_payload_map->remote_sdp_port);
                                switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->cur_payload_map->remote_sdp_ip);
                                switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE, tmp);


                                if (a_engine->cur_payload_map->pt == smh->mparams->te) {
                                        switch_payload_t pl = 0;
                                        payload_map_t *pmap;

                                        switch_mutex_lock(smh->sdp_mutex);
                                        for (pmap = a_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                                                if (pmap->pt > pl) {
                                                        pl = pmap->pt;
                                                }
                                        }
                                        switch_mutex_unlock(smh->sdp_mutex);

                                        smh->mparams->te  = (switch_payload_t) ++pl;
                                }



                                switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->cur_payload_map->recv_pt);
                                switch_channel_set_variable(session->channel, "rtp_audio_recv_pt", tmp);

                                if (a_engine->read_impl.iananame) {
                                        if (!switch_core_codec_ready(&a_engine->read_codec) ||
                                                ((strcasecmp(matches[0].imp->iananame, a_engine->read_impl.iananame) ||
                                                  matches[0].imp->microseconds_per_packet != a_engine->read_impl.microseconds_per_packet ||
                                                  matches[0].imp->samples_per_second != a_engine->read_impl.samples_per_second
                                                  ))) {

                                                a_engine->reset_codec = 1;
                                        }
                                } else if (switch_core_media_set_codec(session, 0, smh->mparams->codec_flags) != SWITCH_STATUS_SUCCESS) {
                                        match = 0;
                                }

                                if (match) {
                                        if (check_ice(smh, SWITCH_MEDIA_TYPE_AUDIO, sdp, m) == SWITCH_STATUS_FALSE) {
                                                match = 0;
                                                got_audio = 0;
                                        } else {
                                                got_audio = 1;
                                        }
                                }

                        }

                        for (map = m->m_rtpmaps; map; map = map->rm_next) {
                                const char *rm_encoding;

                                if (!(rm_encoding = map->rm_encoding)) {
                                        rm_encoding = "";
                                }

                                if (!strcasecmp(rm_encoding, "telephone-event")) {
                                        if (!best_te || map->rm_rate == a_engine->cur_payload_map->adv_rm_rate) {
                                                best_te = (switch_payload_t) map->rm_pt;
                                                best_te_rate = map->rm_rate;
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set telephone-event payload to %u@%lu\n", best_te, best_te_rate);
                                        }
                                        continue;
                                }

                                if (!switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) && !strcasecmp(rm_encoding, "CN")) {

                                        if (!cng_pt || map->rm_rate == a_engine->cur_payload_map->adv_rm_rate) {
                                                cng_pt = (switch_payload_t) map->rm_pt;
                                                cng_rate = map->rm_rate;

                                                if (a_engine->rtp_session) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set comfort noise payload to %u@%lu\n", cng_pt, cng_rate);
                                                        switch_rtp_set_cng_pt(a_engine->rtp_session, cng_pt);
                                                }
                                        }
                                        continue;
                                }
                        }

                        if (cng_rate != a_engine->cur_payload_map->adv_rm_rate) {
                                cng_rate = 8000;
                        }

                        if (best_te_rate != a_engine->cur_payload_map->adv_rm_rate) {
                                best_te_rate = 8000;
                        }

                        if (!best_te && (switch_channel_test_flag(session->channel, CF_LIBERAL_DTMF))) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                  "No 2833 in SDP. Liberal DTMF mode adding %d as telephone-event.\n", smh->mparams->te);
                                best_te = smh->mparams->te;
                        }

                        if (best_te) {
                                smh->mparams->te_rate = best_te_rate;

                                if (smh->mparams->dtmf_type == DTMF_AUTO || smh->mparams->dtmf_type == DTMF_2833 ||
                                        switch_channel_test_flag(session->channel, CF_LIBERAL_DTMF)) {
                                        if (sdp_type == SDP_OFFER) {
                                                smh->mparams->te = smh->mparams->recv_te = (switch_payload_t) best_te;
                                                switch_channel_set_variable(session->channel, "dtmf_type", "rfc2833");
                                                smh->mparams->dtmf_type = DTMF_2833;
                                        } else {
                                                smh->mparams->te = (switch_payload_t) best_te;
                                                switch_channel_set_variable(session->channel, "dtmf_type", "rfc2833");
                                                smh->mparams->dtmf_type = DTMF_2833;
                                        }
                                }

                                if (a_engine->rtp_session) {
                                        switch_rtp_set_telephony_event(a_engine->rtp_session, smh->mparams->te);
                                        switch_channel_set_variable_printf(session->channel, "rtp_2833_send_payload", "%d", smh->mparams->te);
                                        switch_rtp_set_telephony_recv_event(a_engine->rtp_session, smh->mparams->recv_te);
                                        switch_channel_set_variable_printf(session->channel, "rtp_2833_recv_payload", "%d", smh->mparams->recv_te);
                                }


                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Set 2833 dtmf send payload to %u recv payload to %u\n",
                                                                  switch_channel_get_name(session->channel), smh->mparams->te, smh->mparams->recv_te);


                        } else {
                                /* by default, use SIP INFO if 2833 is not in the SDP */
                                if (!switch_false(switch_channel_get_variable(channel, "rtp_info_when_no_2833"))) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No 2833 in SDP.  Disable 2833 dtmf and switch to INFO\n");
                                        switch_channel_set_variable(session->channel, "dtmf_type", "info");
                                        smh->mparams->dtmf_type = DTMF_INFO;
                                        smh->mparams->recv_te = smh->mparams->te = 0;
                                } else {
                                        switch_channel_set_variable(session->channel, "dtmf_type", "none");
                                        smh->mparams->dtmf_type = DTMF_NONE;
                                        smh->mparams->recv_te = smh->mparams->te = 0;
                                }
                        }

                } else if (!got_text && m->m_type == sdp_media_text && m->m_port) {
                        sdp_rtpmap_t *map;
                        payload_map_t *red_pmap = NULL;

                        switch_channel_set_flag(session->channel, CF_RTT);

                        connection = sdp->sdp_connection;
                        if (m->m_connections) {
                                connection = m->m_connections;
                        }

                        if (!connection) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot find a c= line in the sdp at media or session level!\n");
                                match = 0;
                                break;
                        }

                        switch_channel_set_variable(session->channel, "text_possible", "true");
                        switch_channel_set_flag(session->channel, CF_TEXT_SDP_RECVD);
                        switch_channel_set_flag(session->channel, CF_TEXT_POSSIBLE);

                        got_text++;

                        for (map = m->m_rtpmaps; map; map = map->rm_next) {
                                payload_map_t *pmap;

                                pmap = switch_core_media_add_payload_map(session,
                                                                                                                 SWITCH_MEDIA_TYPE_TEXT,
                                                                                                                 map->rm_encoding,
                                                                                                                 NULL,
                                                                                                                 NULL,
                                                                                                                 SDP_OFFER,
                                                                                                                 map->rm_pt,
                                                                                                                 1000,
                                                                                                                 0,
                                                                                                                 1,
                                                                                                                 SWITCH_TRUE);


                                pmap->remote_sdp_ip = switch_core_session_strdup(session, (char *) connection->c_address);
                                pmap->remote_sdp_port = (switch_port_t) m->m_port;
                                if (map->rm_fmtp) {
                                        pmap->rm_fmtp = switch_core_session_strdup(session, (char *) map->rm_fmtp);
                                }


                                t_engine->cur_payload_map = pmap;

                                if (!strcasecmp(map->rm_encoding, "red")) {
                                        red_pmap = pmap;
                                }
                        }

                        if (red_pmap) {
                                t_engine->cur_payload_map = red_pmap;
                        }

                        for (attr = m->m_attributes; attr; attr = attr->a_next) {
                                if (!strcasecmp(attr->a_name, "rtcp") && attr->a_value) {
                                        switch_channel_set_variable(session->channel, "sip_remote_text_rtcp_port", attr->a_value);

                                } else if (!got_text_crypto && !strcasecmp(attr->a_name, "crypto") && !zstr(attr->a_value)) {
                                        int crypto_tag;

                                        if (!(smh->mparams->ndlb & SM_NDLB_ALLOW_CRYPTO_IN_AVP) &&
                                                !switch_true(switch_channel_get_variable(session->channel, "rtp_allow_crypto_in_avp"))) {
                                                if (m->m_proto != sdp_proto_srtp && !got_webrtc) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "a=crypto in RTP/AVP, refer to rfc3711\n");
                                                        match = 0;
                                                        goto done;
                                                }
                                        }

                                        crypto = attr->a_value;
                                        crypto_tag = atoi(crypto);

                                        got_text_crypto = switch_core_session_check_incoming_crypto(session,
                                                                                                                                                                "rtp_has_text_crypto",
                                                                                                                                                                SWITCH_MEDIA_TYPE_TEXT, crypto, crypto_tag, sdp_type);

                                }
                        }


                        //map->rm_encoding
                        //map->rm_fmtp
                        //map->rm_pt
                        //t_engine->cur_payload_map = pmap;

                        t_engine->codec_negotiated = 1;
                        tmatch = 1;


                        if (!t_engine->local_sdp_port) {
                                switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_TEXT, 1);
                        }

                        check_ice(smh, SWITCH_MEDIA_TYPE_TEXT, sdp, m);
                        //parse rtt

                } else if (m->m_type == sdp_media_video) {
                        sdp_rtpmap_t *map;
                        const char *rm_encoding;
                        const switch_codec_implementation_t *mimp = NULL;
                        int i;
                        const char *inherit_video_fmtp = NULL;
                        
                        switch_core_media_set_rmode(smh->session, SWITCH_MEDIA_TYPE_VIDEO, sdp_media_flow(m->m_mode), sdp_type);
                        
                        if (sdp_type == SDP_OFFER) {
                                sdp_bandwidth_t *bw;
                                int tias = 0;

                                for (bw = m->m_bandwidths; bw; bw = bw->b_next) {
                                        if (bw->b_modifier == sdp_bw_as && !tias) {
                                                v_engine->sdp_bw = bw->b_value;
                                        } else if (bw->b_modifier == sdp_bw_tias) {
                                                tias = 1;
                                                v_engine->sdp_bw = bw->b_value / 1024;
                                        }
                                }

                                switch(v_engine->rmode) {
                                case SWITCH_MEDIA_FLOW_RECVONLY:
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_MEDIA_FLOW_SENDONLY, sdp_type);
                                        switch_channel_set_flag(smh->session->channel, CF_VIDEO_READY);
                                        break;
                                case SWITCH_MEDIA_FLOW_SENDONLY:
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_MEDIA_FLOW_RECVONLY, sdp_type);
                                        break;
                                case SWITCH_MEDIA_FLOW_INACTIVE:
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_MEDIA_FLOW_INACTIVE, sdp_type);
                                        break;
                                default:
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_MEDIA_FLOW_SENDRECV, sdp_type);
                                        break;
                                }
                        }

                        if (!m->m_port) {
                                goto endsdp;
                        }

                        vmatch = 0;
                        almost_vmatch = 0;
                        m_idx = 0;
                        memset(matches, 0, sizeof(matches[0]) * MAX_MATCHES);
                        memset(near_matches, 0, sizeof(near_matches[0]) * MAX_MATCHES);

                        switch_channel_set_variable(session->channel, "video_possible", "true");
                        switch_channel_set_flag(session->channel, CF_VIDEO_POSSIBLE);
                        switch_channel_set_flag(session->channel, CF_VIDEO_SDP_RECVD);

                        connection = sdp->sdp_connection;
                        if (m->m_connections) {
                                connection = m->m_connections;
                        }

                        if (!connection) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Cannot find a c= line in the sdp at media or session level!\n");
                                match = 0;
                                break;
                        }

                        

                        skip_video_rtcp = 0;
                        got_video_rtcp_mux = 0;
                        for (attr = m->m_attributes; attr; attr = attr->a_next) {
                                if (!strcasecmp(attr->a_name, "rtcp-mux")) {
                                        got_video_rtcp_mux = 1;
                                        skip_video_rtcp = 1;
                                } else if (!strcasecmp(attr->a_name, "ice-ufrag")) {
                                        skip_video_rtcp = 1;
                                }
                        }

                        if (!got_video_rtcp_mux) {
                                v_engine->rtcp_mux = -1;
                        }

                        for (attr = m->m_attributes; attr; attr = attr->a_next) {
                                if (!strcasecmp(attr->a_name, "framerate") && attr->a_value) {
                                        //framerate = atoi(attr->a_value);
                                } else if (!strcasecmp(attr->a_name, "rtcp-fb")) {
                                        if (!zstr(attr->a_value)) {
                                                if (switch_stristr("fir", attr->a_value)) {
                                                        v_engine->fir++;
                                                }

                                                if (switch_stristr("pli", attr->a_value)) {
                                                        v_engine->pli++;
                                                }

                                                if (switch_stristr("nack", attr->a_value)) {
                                                        v_engine->nack++;
                                                }

                                                if (switch_stristr("tmmbr", attr->a_value)) {
                                                        v_engine->tmmbr++;
                                                }

                                                rtcp_auto_video = 1;
                                                smh->mparams->rtcp_video_interval_msec = SWITCH_RTCP_VIDEO_INTERVAL_MSEC;
                                        }
                                } else if (!strcasecmp(attr->a_name, "rtcp") && attr->a_value && !skip_video_rtcp) {
                                        v_engine->remote_rtcp_port = (switch_port_t)atoi(attr->a_value);
                                        switch_channel_set_variable_printf(session->channel, "rtp_remote_video_rtcp_port", "%d", v_engine->remote_rtcp_port);
                                        if (!smh->mparams->rtcp_video_interval_msec) {
                                                smh->mparams->rtcp_video_interval_msec = SWITCH_RTCP_VIDEO_INTERVAL_MSEC;
                                        }
                                        got_video_rtcp = 1;
                                } else if (!got_video_crypto && !strcasecmp(attr->a_name, "crypto") && !zstr(attr->a_value)) {
                                        int crypto_tag;

                                        if (!(smh->mparams->ndlb & SM_NDLB_ALLOW_CRYPTO_IN_AVP) &&
                                                !switch_true(switch_channel_get_variable(session->channel, "rtp_allow_crypto_in_avp"))) {
                                                if (m->m_proto != sdp_proto_srtp && !got_webrtc) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "a=crypto in RTP/AVP, refer to rfc3711\n");
                                                        match = 0;
                                                        goto done;
                                                }
                                        }

                                        crypto = attr->a_value;
                                        crypto_tag = atoi(crypto);

                                        got_video_crypto = switch_core_session_check_incoming_crypto(session,
                                                                                                                                                                 "rtp_has_video_crypto",
                                                                                                                                                                 SWITCH_MEDIA_TYPE_VIDEO, crypto, crypto_tag, sdp_type);

                                }
                        }


                        if (switch_true(switch_channel_get_variable_dup(session->channel, "inherit_codec", SWITCH_FALSE, -1))) {
                                vmatch_pt = 1;
                        }

                compare:

                        for (map = m->m_rtpmaps; map; map = map->rm_next) {

                                if (switch_rtp_has_dtls() && dtls_ok(session)) {
                                        for (attr = m->m_attributes; attr; attr = attr->a_next) {
                                                if (!strcasecmp(attr->a_name, "fingerprint") && !zstr(attr->a_value)) {
                                                        got_video_crypto = 1;
                                                }
                                        }
                                }

                                if (!(rm_encoding = map->rm_encoding)) {
                                        rm_encoding = "";
                                }

                                for (i = 0; i < total_codecs; i++) {
                                        const switch_codec_implementation_t *imp = codec_array[i];

                                        if (imp->codec_type != SWITCH_CODEC_TYPE_VIDEO) {
                                                continue;
                                        }

                                        if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND &&
                                                switch_channel_test_flag(session->channel, CF_NOVIDEO)) {
                                                continue;
                                        }

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Video Codec Compare [%s:%d]/[%s:%d]\n",
                                                                          rm_encoding, map->rm_pt, imp->iananame, imp->ianacode);
                                        if ((zstr(map->rm_encoding) || (smh->mparams->ndlb & SM_NDLB_ALLOW_BAD_IANANAME)) && map->rm_pt < 96) {
                                                vmatch = (map->rm_pt == imp->ianacode) ? 1 : 0;
                                        } else {
                                                vmatch = strcasecmp(rm_encoding, imp->iananame) ? 0 : 1;
                                        }

                                        if (sdp_type == SDP_ANSWER && consider_video_fmtp && vmatch && !zstr(map->rm_fmtp) && !zstr(smh->fmtps[i])) {
                                                almost_vmatch = 1;
                                                vmatch = !strcasecmp(smh->fmtps[i], map->rm_fmtp);
                                        }

                                        if (vmatch && vmatch_pt) {
                                                const char *other_pt = switch_channel_get_variable_partner(channel, "rtp_video_pt");

                                                if (other_pt) {
                                                        int opt = atoi(other_pt);
                                                        if (map->rm_pt != opt) {
                                                                vmatch = 0;
                                                        } else {
                                                                if (switch_channel_var_true(channel, "inherit_video_fmtp")) {
                                                                        inherit_video_fmtp = switch_channel_get_variable_partner(channel, "rtp_video_fmtp");
                                                                }
                                                        }
                                                }
                                        }

                                        if (vmatch) {
                                                matches[m_idx].imp = imp;
                                                matches[m_idx].map = map;

                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Video Codec Compare [%s:%d] +++ is saved as a match\n",
                                                                                  imp->iananame, map->rm_pt);

                                                m_idx++;

                                                if (m_idx >= MAX_MATCHES) {
                                                        break;
                                                }
                                        }

                                        vmatch = 0;
                                }

                                if (m_idx >= MAX_MATCHES) {
                                        break;
                                }
                        }

                        if (consider_video_fmtp && (!m_idx || almost_vmatch)) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No matches with FTMP, fallback to ignoring FMTP\n");
                                almost_vmatch = 0;
                                m_idx = 0;
                                consider_video_fmtp = 0;
                                goto compare;
                        }

                        if (vmatch_pt && !m_idx) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No matches with inherit_codec, fallback to ignoring PT\n");
                                vmatch_pt = 0;
                                goto compare;
                        }

                        if (smh->crypto_mode == CRYPTO_MODE_MANDATORY && got_video_crypto < 1) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Crypto not negotiated but required.\n");
                                vmatch = 0;
                                m_idx = 0;
                        }

                        if (m_idx) {
                                char tmp[50];
                                //const char *mirror = switch_channel_get_variable(session->channel, "rtp_mirror_remote_video_codec_payload");
                                int j = 0;

                                if (greedy) { /* sort in favor of mine */
                                        greedy_sort(smh, matches, m_idx, codec_array, total_codecs);
                                }

                                vmatch = 1;
                                v_engine->codec_negotiated = 1;
                                v_engine->payload_map = NULL;

                                for(j = 0; j < m_idx && smh->num_negotiated_codecs < SWITCH_MAX_CODECS; j++) {
                                        payload_map_t *pmap = switch_core_media_add_payload_map(session,
                                                                                                                                                        SWITCH_MEDIA_TYPE_VIDEO,
                                                                                                                                                        matches[j].map->rm_encoding,
                                                                                                                                                        matches[j].imp->modname,
                                                                                                                                                        consider_video_fmtp ? matches[j].map->rm_fmtp : NULL,
                                                                                                                                                        sdp_type,
                                                                                                                                                        matches[j].map->rm_pt,
                                                                                                                                                        matches[j].imp->samples_per_second,
                                                                                                                                                        matches[j].imp->microseconds_per_packet / 1000,
                                                                                                                                                        matches[j].imp->number_of_channels,
                                                                                                                                                        SWITCH_TRUE);

                                        if (j == 0) {
                                                v_engine->cur_payload_map = pmap;
                                                v_engine->cur_payload_map->current = 1;
                                                if (v_engine->rtp_session) {
                                                        switch_rtp_set_default_payload(v_engine->rtp_session, pmap->pt);
                                                }
                                        }

                                        mimp = matches[j].imp;
                                        map = matches[j].map;

                                        pmap->rm_encoding = switch_core_session_strdup(session, (char *) map->rm_encoding);
                                        pmap->recv_pt = (switch_payload_t) map->rm_pt;
                                        pmap->rm_rate = map->rm_rate;
                                        pmap->codec_ms = mimp->microseconds_per_packet / 1000;


                                        pmap->remote_sdp_ip = switch_core_session_strdup(session, (char *) connection->c_address);
                                        pmap->remote_sdp_port = (switch_port_t) m->m_port;
                                        pmap->rm_fmtp = switch_core_session_strdup(session, (char *) inherit_video_fmtp ? inherit_video_fmtp : map->rm_fmtp);
                                        smh->negotiated_codecs[smh->num_negotiated_codecs++] = mimp;
                                                
#if 0
                                        if (j == 0 && (!switch_true(mirror) && switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND)) {
                                                switch_core_media_get_offered_pt(session, mimp, &pmap->recv_pt);
                                        }
#endif
                                }

                                switch_snprintf(tmp, sizeof(tmp), "%d", v_engine->cur_payload_map->remote_sdp_port);
                                switch_channel_set_variable(session->channel, SWITCH_REMOTE_VIDEO_IP_VARIABLE, v_engine->cur_payload_map->remote_sdp_ip);
                                switch_channel_set_variable(session->channel, SWITCH_REMOTE_VIDEO_PORT_VARIABLE, tmp);
                                switch_channel_set_variable(session->channel, "rtp_video_fmtp", v_engine->cur_payload_map->rm_fmtp);
                                switch_snprintf(tmp, sizeof(tmp), "%d", v_engine->cur_payload_map->pt);
                                switch_channel_set_variable(session->channel, "rtp_video_pt", tmp);
                                switch_core_media_check_video_codecs(session);
                                switch_snprintf(tmp, sizeof(tmp), "%d", v_engine->cur_payload_map->recv_pt);
                                switch_channel_set_variable(session->channel, "rtp_video_recv_pt", tmp);

                                if (switch_core_codec_ready(&v_engine->read_codec) && strcasecmp(matches[0].imp->iananame, v_engine->read_codec.implementation->iananame)) {
                                        v_engine->reset_codec = 1;
                                }

                                if (switch_core_media_set_video_codec(session, 0) == SWITCH_STATUS_SUCCESS) {
                                        if (check_ice(smh, SWITCH_MEDIA_TYPE_VIDEO, sdp, m) == SWITCH_STATUS_FALSE) {
                                                vmatch = 0;
                                        }
                                }
                        }

                        video_port = m->m_port;
                }
        }

 endsdp:

        if (rtcp_auto_audio || rtcp_auto_video) {
                if (rtcp_auto_audio && !skip_rtcp && !got_audio_rtcp && audio_port) {
                        switch_channel_set_variable_printf(session->channel, "rtp_remote_audio_rtcp_port", "%d", audio_port + 1);
                        a_engine->remote_rtcp_port = audio_port + 1;

                        if (!smh->mparams->rtcp_audio_interval_msec) {
                                smh->mparams->rtcp_audio_interval_msec = SWITCH_RTCP_AUDIO_INTERVAL_MSEC;
                        }
                }
                if (rtcp_auto_video && !skip_video_rtcp && !got_video_rtcp && video_port) {
                        switch_channel_set_variable_printf(session->channel, "rtp_remote_video_rtcp_port", "%d", video_port + 1);
                        v_engine->remote_rtcp_port = video_port + 1;
                        if (!smh->mparams->rtcp_video_interval_msec) {
                                smh->mparams->rtcp_video_interval_msec = SWITCH_RTCP_VIDEO_INTERVAL_MSEC;
                        }
                }
        }


        if (!saw_audio) {
                payload_map_t *pmap;

                a_engine->rmode = SWITCH_MEDIA_FLOW_DISABLED;
                switch_channel_set_variable(smh->session->channel, "audio_media_flow", "inactive");


                pmap = switch_core_media_add_payload_map(session,
                                                                                                 SWITCH_MEDIA_TYPE_AUDIO,
                                                                                                 "L16",
                                                                                                 NULL,
                                                                                                 NULL,
                                                                                                 SDP_OFFER,
                                                                                                 97,
                                                                                                 8000,
                                                                                                 20,
                                                                                                 1,
                                                                                                 SWITCH_TRUE);

                pmap->remote_sdp_ip = "127.0.0.1";
                pmap->remote_sdp_port = 9999;
                pmap->pt = 97;
                pmap->recv_pt = 97;
                pmap->codec_ms = 20;
                a_engine->cur_payload_map = pmap;
                switch_channel_set_flag(channel, CF_AUDIO_PAUSE_READ);
                switch_channel_set_flag(channel, CF_AUDIO_PAUSE_WRITE);
        }

 done:

        if (v_engine->rtp_session) {
                if (v_engine->fir) {
                        switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_FIR);
                } else {
                        switch_rtp_clear_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_FIR);
                }
                
                if (v_engine->pli) {
                        switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PLI);
                } else {
                        switch_rtp_clear_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PLI);
                }
                
                if (v_engine->nack) {
                        switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_NACK);
                } else {
                        switch_rtp_clear_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_NACK);
                }
                
                if (v_engine->tmmbr) {
                        switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_TMMBR);
                } else {
                        switch_rtp_clear_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_TMMBR);
                }
        }

        if (match) {
                switch_channel_set_flag(channel, CF_AUDIO);
        } else {
                switch_channel_clear_flag(channel, CF_AUDIO);
        }

        if (vmatch) {
                switch_channel_set_flag(channel, CF_VIDEO);
        } else {
                if (switch_channel_test_flag(channel, CF_VIDEO) && !saw_video) {
                        //switch_core_media_set_rmode(smh->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_MEDIA_FLOW_INACTIVE, sdp_type);

                        if (sdp_type == SDP_OFFER) {
                                switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_MEDIA_FLOW_INACTIVE, sdp_type);
                        }
                }
        }

        if (tmatch) {
                switch_channel_set_flag(channel, CF_HAS_TEXT);
        } else {
                switch_channel_clear_flag(channel, CF_HAS_TEXT);
        }

        if (fmatch) {
                switch_channel_set_flag(channel, CF_IMAGE_SDP);
                switch_channel_set_flag(channel, CF_AUDIO);
        } else {
                switch_channel_clear_flag(channel, CF_IMAGE_SDP);
        }

 t38_done:

        if (parser) {
                sdp_parser_free(parser);
        }

        smh->mparams->cng_pt = cng_pt;
        smh->mparams->cng_rate = cng_rate;

        check_stream_changes(session, r_sdp, sdp_type);

        return match || vmatch || tmatch || fmatch;
}

//?
SWITCH_DECLARE(void) switch_core_media_reset_t38(switch_core_session_t *session)
{
        switch_rtp_engine_t *a_engine;
        switch_media_handle_t *smh;
        switch_channel_t *channel = switch_core_session_get_channel(session);

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];

        restore_pmaps(a_engine);

        switch_channel_set_private(channel, "t38_options", NULL);
        switch_channel_clear_flag(channel, CF_T38_PASSTHRU);
        switch_channel_clear_app_flag_key("T38", channel, CF_APP_T38);
        switch_channel_clear_app_flag_key("T38", channel, CF_APP_T38_REQ);
        switch_channel_set_app_flag_key("T38", channel, CF_APP_T38_FAIL);
}

//?

SWITCH_DECLARE(int) switch_core_media_toggle_hold(switch_core_session_t *session, int sendonly)
{
        int changed = 0;
        switch_rtp_engine_t *a_engine, *v_engine;
        switch_media_handle_t *smh;
        switch_core_session_t *b_session = NULL;
        switch_channel_t *b_channel = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return 0;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];


        if (switch_core_session_get_partner(session, &b_session) == SWITCH_STATUS_SUCCESS) {
                b_channel = switch_core_session_get_channel(b_session);
        }

        if (sendonly && switch_channel_test_flag(session->channel, CF_ANSWERED)) {
                if (!switch_channel_test_flag(session->channel, CF_PROTO_HOLD)) {
                        const char *stream;
                        const char *msg = "hold";
                        const char *info;

                        if ((switch_channel_test_flag(session->channel, CF_SLA_BARGE) || switch_channel_test_flag(session->channel, CF_SLA_BARGING)) &&
                                (!b_channel || switch_channel_test_flag(b_channel, CF_EVENT_LOCK_PRI))) {
                                switch_channel_mark_hold(session->channel, sendonly);
                                switch_channel_set_flag(session->channel, CF_PROTO_HOLD);
                                changed = 0;
                                goto end;
                        }

                        info = switch_channel_get_variable(session->channel, "presence_call_info");

                        if (info) {
                                if (switch_stristr("private", info)) {
                                        msg = "hold-private";
                                }
                        }

                        if (a_engine->rtp_session) {
                                switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
                        }

                        if (v_engine->rtp_session) {
                                switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
                        }

                        switch_channel_set_flag(session->channel, CF_PROTO_HOLD);
                        switch_channel_mark_hold(session->channel, SWITCH_TRUE);
                        switch_channel_presence(session->channel, "unknown", msg, NULL);
                        changed = 1;

                        if (a_engine->max_missed_hold_packets && a_engine->rtp_session) {
                                switch_rtp_set_max_missed_packets(a_engine->rtp_session, a_engine->max_missed_hold_packets);
                        }

                        if (a_engine->media_hold_timeout) {
                                switch_rtp_set_media_timeout(a_engine->rtp_session, a_engine->media_hold_timeout);
                        }

                        if (v_engine->media_hold_timeout) {
                                switch_rtp_set_media_timeout(v_engine->rtp_session, v_engine->media_hold_timeout);
                        }


                        if (!(stream = switch_channel_get_hold_music(session->channel))) {
                                stream = "local_stream://moh";
                        }


                        if (stream && strcasecmp(stream, "silence") && (!b_channel || !switch_channel_test_flag(b_channel, CF_EVENT_LOCK_PRI))) {
                                if (!strcasecmp(stream, "indicate_hold")) {
                                        switch_channel_set_flag(session->channel, CF_SUSPEND);
                                        switch_channel_set_flag(session->channel, CF_HOLD);
                                        switch_ivr_hold_uuid(switch_core_session_get_uuid(b_session), NULL, 0);
                                } else {
                                        switch_ivr_broadcast(switch_core_session_get_uuid(b_session), stream,
                                                                                 SMF_ECHO_ALEG | SMF_LOOP | SMF_PRIORITY);
                                        switch_yield(250000);
                                }
                        }

                }
        } else {
                if (switch_channel_test_flag(session->channel, CF_HOLD_LOCK)) {
                        switch_channel_set_flag(session->channel, CF_PROTO_HOLD);
                        switch_channel_mark_hold(session->channel, SWITCH_TRUE);

                        if (a_engine->rtp_session) {
                                switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
                        }

                        if (v_engine->rtp_session) {
                                switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
                        }

                        changed = 1;
                }

                switch_channel_clear_flag(session->channel, CF_HOLD_LOCK);

                if (switch_channel_test_flag(session->channel, CF_PROTO_HOLD)) {
                        int media_on_hold_a = switch_true(switch_channel_get_variable_dup(session->channel, "bypass_media_resume_on_hold", SWITCH_FALSE, -1));
                        int bypass_after_hold_a = 0;
                        int bypass_after_hold_b = 0;

                        if (media_on_hold_a) {
                                bypass_after_hold_a = switch_true(switch_channel_get_variable_dup(session->channel, "bypass_media_after_hold", SWITCH_FALSE, -1));
                        }

                        if (b_channel) {
                                if (switch_true(switch_channel_get_variable_dup(b_channel, "bypass_media_resume_on_hold", SWITCH_FALSE, -1))) {
                                        bypass_after_hold_b = switch_true(switch_channel_get_variable_dup(b_channel, "bypass_media_after_hold", SWITCH_FALSE, -1));
                                }
                        }

                        switch_yield(250000);

                        if (b_channel && (switch_channel_test_flag(session->channel, CF_BYPASS_MEDIA_AFTER_HOLD) ||
                                                          switch_channel_test_flag(b_channel, CF_BYPASS_MEDIA_AFTER_HOLD) || bypass_after_hold_a || bypass_after_hold_b)) {
                                /* try to stay out from media stream */
                                switch_ivr_bg_media(switch_core_session_get_uuid(session), SMF_REBRIDGE, SWITCH_FALSE, SWITCH_TRUE, 200);
                        }

                        if (a_engine->rtp_session) {
                                switch_rtp_reset_media_timer(a_engine->rtp_session);

                                if (a_engine->max_missed_packets) {
                                        switch_rtp_set_max_missed_packets(a_engine->rtp_session, a_engine->max_missed_packets);
                                }

                                if (a_engine->media_hold_timeout) {
                                        switch_rtp_set_media_timeout(a_engine->rtp_session, a_engine->media_timeout);
                                }
                        }

                        if (v_engine->rtp_session) {
                                switch_rtp_reset_media_timer(v_engine->rtp_session);

                                if (v_engine->media_hold_timeout) {
                                        switch_rtp_set_media_timeout(v_engine->rtp_session, v_engine->media_timeout);
                                }
                        }

                        if (b_channel) {
                                if (switch_channel_test_flag(session->channel, CF_HOLD)) {
                                        switch_ivr_unhold(b_session);
                                        switch_channel_clear_flag(session->channel, CF_SUSPEND);
                                        switch_channel_clear_flag(session->channel, CF_HOLD);
                                } else {
                                        switch_channel_stop_broadcast(b_channel);
                                        switch_channel_wait_for_flag(b_channel, CF_BROADCAST, SWITCH_FALSE, 5000, NULL);
                                }
                        }

                        switch_core_media_check_autoadj(session);

                        switch_channel_clear_flag(session->channel, CF_PROTO_HOLD);
                        switch_channel_mark_hold(session->channel, SWITCH_FALSE);
                        switch_channel_presence(session->channel, "unknown", "unhold", NULL);

                        if (a_engine->rtp_session) {
                                switch_rtp_clear_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
                        }

                        if (v_engine->rtp_session) {
                                switch_rtp_clear_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PAUSE);
                        }

                        changed = 1;
                }
        }


 end:
        switch_core_session_request_video_refresh(session);


        if (b_session) {
                switch_core_session_request_video_refresh(b_session);
                switch_core_session_rwunlock(b_session);
        }


        return changed;
}


SWITCH_DECLARE(switch_file_handle_t *) switch_core_media_get_video_file(switch_core_session_t *session, switch_rw_t rw)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *v_engine;
        switch_file_handle_t *fh;

        switch_assert(session);

        if (!switch_channel_test_flag(session->channel, CF_VIDEO)) {
                return NULL;
        }

        if (!(smh = session->media_handle)) {
                return NULL;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];



        if (rw == SWITCH_RW_READ) {
                switch_mutex_lock(v_engine->mh.file_read_mutex);
                fh = smh->video_read_fh;
                switch_mutex_unlock(v_engine->mh.file_read_mutex);
        } else {
                switch_mutex_lock(v_engine->mh.file_write_mutex);
                fh = smh->video_write_fh;
                switch_mutex_unlock(v_engine->mh.file_write_mutex);
        }



        return fh;
}

SWITCH_DECLARE(void) switch_core_session_write_blank_video(switch_core_session_t *session, uint32_t ms)
{
        switch_frame_t fr = { 0 };
        int i = 0;
        switch_rgb_color_t bgcolor = { 0 };
        int buflen = SWITCH_RTP_MAX_BUF_LEN;
        unsigned char buf[SWITCH_RTP_MAX_BUF_LEN];
        switch_media_handle_t *smh;
        switch_image_t *blank_img = NULL;
        uint32_t frames = 0, frame_ms = 0;
        uint32_t fps, width, height;
        switch_assert(session != NULL);

        if (!(smh = session->media_handle)) {
                return;
        }

        fps = smh->vid_params.fps;
        width = smh->vid_params.width;
        height = smh->vid_params.height;

        if (!width) width = 352;
        if (!height) height = 288;
        if (!fps) fps = 15;

        fr.packet = buf;
        fr.packetlen = buflen;
        fr.data = buf + 12;
        fr.buflen = buflen - 12;


        blank_img = switch_img_alloc(NULL, SWITCH_IMG_FMT_I420, width, height, 1);
        switch_color_set_rgb(&bgcolor, "#000000");
        switch_img_fill(blank_img, 0, 0, blank_img->d_w, blank_img->d_h, &bgcolor);

        if (fps < 15) fps = 15;
        frame_ms = (uint32_t) 1000 / fps;
        if (frame_ms <= 0) frame_ms = 66;
        frames = (uint32_t) ms / frame_ms;

        switch_core_media_gen_key_frame(session);
        for (i = 0; i < frames; i++) {
                fr.img = blank_img;
                switch_core_session_write_video_frame(session, &fr, SWITCH_IO_FLAG_NONE, 0);
                switch_yield(frame_ms * 1000);
        }
        switch_core_media_gen_key_frame(session);

        switch_img_free(&blank_img);

}

static void *SWITCH_THREAD_FUNC video_write_thread(switch_thread_t *thread, void *obj)
{
        switch_core_session_t *session = (switch_core_session_t *) obj;
        switch_media_handle_t *smh;
        unsigned char *buf = NULL;
        switch_frame_t fr = { 0 };
        switch_rtp_engine_t *v_engine;
        int buflen = SWITCH_RTP_MAX_BUF_LEN;
        switch_timer_t timer = { 0 };
        switch_video_read_flag_t read_flags = SVR_FLUSH;
        switch_core_session_t *b_session = NULL;
        switch_fps_t fps_data = { 0 };
        float fps = 15.0f;
        switch_image_t *last_frame = NULL;
        int last_w = 0, last_h = 0, kps = 0;
        switch_status_t res;

        if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
                return NULL;
        }

        if (!(smh = session->media_handle)) {
                switch_core_session_rwunlock(session);

                return NULL;
        }

        res = switch_core_session_get_partner(session, &b_session);
        (void)res;

        switch_channel_set_flag(session->channel, CF_VIDEO_WRITING);

        if (b_session) {
                switch_channel_set_flag(b_session->channel, CF_VIDEO_BLANK);
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        switch_mutex_lock(smh->write_mutex[SWITCH_MEDIA_TYPE_VIDEO]);
        v_engine->thread_write_lock = switch_thread_self();

        
        buf = switch_core_session_alloc(session, buflen);
        fr.packet = buf;
        fr.packetlen = buflen;
        fr.data = buf + 12;
        fr.buflen = buflen - 12;
        switch_core_media_gen_key_frame(session);

        if (smh->video_write_fh) {
                if (smh->video_write_fh->mm.fps) {
                        fps = smh->video_write_fh->mm.fps;
                } else if (smh->video_write_fh->mm.source_fps) {
                        fps = smh->video_write_fh->mm.source_fps;
                }
        } else if (video_globals.fps) {
                fps = video_globals.fps;
        }
        switch_calc_video_fps(&fps_data, fps);

        switch_core_timer_init(&timer, "soft", fps_data.ms, fps_data.samples, switch_core_session_get_pool(session));

        if (smh->video_write_fh && smh->video_write_fh->mm.source_kps) {
                int min = 0, max = 10000000;
                const char *var;

                kps = smh->video_write_fh->mm.source_kps;

                if ((var = switch_channel_get_variable(session->channel, "video_file_min_kps"))) {
                        min = atoi(var);
                        if (min < 0) min = 0;
                }

                if ((var = switch_channel_get_variable(session->channel, "video_file_max_kps"))) {
                        max = atoi(var);
                        if (max < 0) max = 10000000;
                }

                if (min && kps < min) kps = min;
                if (max != 10000000 && kps > max) kps = max;
                
                switch_core_media_set_outgoing_bitrate(session, SWITCH_MEDIA_TYPE_VIDEO, kps);
        }

        while (smh->video_write_thread_running > 0 &&
                   switch_channel_up_nosig(session->channel) && smh->video_write_fh && switch_test_flag(smh->video_write_fh, SWITCH_FILE_OPEN)) {
                switch_status_t wstatus = SWITCH_STATUS_FALSE;

                switch_core_timer_next(&timer);

                switch_mutex_lock(v_engine->mh.file_write_mutex);

                //if (smh->video_write_fh && smh->video_write_fh->mm.source_fps && smh->video_write_fh->mm.source_fps != fps) {
                //      switch_core_timer_destroy(&timer);
                //      switch_calc_video_fps(&fps_data, fps);
                //      switch_core_timer_init(&timer, "soft", fps_data.ms, fps_data.samples, switch_core_session_get_pool(session));
                //}

                if (smh->video_write_fh && !switch_test_flag(smh->video_write_fh, SWITCH_FILE_FLAG_VIDEO_EOF)) {
                        wstatus = switch_core_file_read_video(smh->video_write_fh, &fr, read_flags);

                        if (wstatus == SWITCH_STATUS_BREAK) {
                                switch_core_timer_sync(&timer);
                        }

                        if (wstatus == SWITCH_STATUS_SUCCESS) {
                                if (!kps && fr.img && (last_w != fr.img->d_w || last_h != fr.img->d_h)) {
                                        kps = switch_calc_bitrate(fr.img->d_w, fr.img->d_h, 1, fps);
                                        switch_core_media_set_outgoing_bitrate(session, SWITCH_MEDIA_TYPE_VIDEO, kps);
                                        last_w = fr.img->d_w;
                                        last_h = fr.img->d_h;
                                }
                                
                                fr.timestamp = timer.samplecount;
                                fr.flags = SFF_USE_VIDEO_TIMESTAMP|SFF_RAW_RTP|SFF_RAW_RTP_PARSE_FRAME;
                                
                                if (fr.img && smh->vid_params.d_width && smh->vid_params.d_height) {
                                        switch_img_fit(&fr.img, smh->vid_params.d_width, smh->vid_params.d_height, SWITCH_FIT_SIZE);
                                }

                                switch_core_session_write_video_frame(session, &fr, SWITCH_IO_FLAG_FORCE, 0);

                                switch_img_free(&last_frame);
                                last_frame = fr.img;
                                fr.img = NULL;
                                
                        } else if (wstatus != SWITCH_STATUS_BREAK && wstatus != SWITCH_STATUS_IGNORE) {
                                switch_set_flag_locked(smh->video_write_fh, SWITCH_FILE_FLAG_VIDEO_EOF);
                        }
                }

                switch_mutex_unlock(v_engine->mh.file_write_mutex);
        }

        if (last_frame) {
                int x = 0;
                switch_rgb_color_t bgcolor;

                switch_color_set_rgb(&bgcolor, "#000000");
                switch_img_fill(last_frame, 0, 0, last_frame->d_w, last_frame->d_h, &bgcolor);
                fr.img = last_frame;

                for (x = 0; x < (int)(fps_data.fps / 2); x++) {
                        switch_core_timer_next(&timer);
                        fr.timestamp = timer.samplecount;
                        fr.flags = SFF_USE_VIDEO_TIMESTAMP|SFF_RAW_RTP|SFF_RAW_RTP_PARSE_FRAME;
                        switch_core_session_write_video_frame(session, &fr, SWITCH_IO_FLAG_FORCE, 0);
                }

                switch_core_media_gen_key_frame(session);
                switch_core_session_request_video_refresh(session);
                switch_img_free(&last_frame);
        }

        switch_core_timer_destroy(&timer);

        switch_core_session_rwunlock(session);

        if (b_session) {
                switch_channel_clear_flag(b_session->channel, CF_VIDEO_BLANK);
                switch_core_session_rwunlock(b_session);
        }

        v_engine->thread_write_lock = 0;
        switch_mutex_unlock(smh->write_mutex[SWITCH_MEDIA_TYPE_VIDEO]);

        switch_channel_clear_flag(session->channel, CF_VIDEO_WRITING);
        smh->video_write_thread_running = 0;

        return NULL;
}

SWITCH_DECLARE(switch_status_t) switch_core_media_lock_video_file(switch_core_session_t *session, switch_rw_t rw)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *v_engine;

        switch_assert(session);

        if (!switch_channel_test_flag(session->channel, CF_VIDEO)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        if (rw == SWITCH_RW_READ) {
                switch_mutex_lock(v_engine->mh.file_read_mutex);
        } else {
                switch_mutex_lock(v_engine->mh.file_write_mutex);
        }

        return SWITCH_STATUS_SUCCESS;

}

SWITCH_DECLARE(switch_status_t) switch_core_media_unlock_video_file(switch_core_session_t *session, switch_rw_t rw)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *v_engine;

        switch_assert(session);

        if (!switch_channel_test_flag(session->channel, CF_VIDEO)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        if (rw == SWITCH_RW_READ) {
                switch_mutex_unlock(v_engine->mh.file_read_mutex);
        } else {
                switch_mutex_unlock(v_engine->mh.file_write_mutex);
        }

        return SWITCH_STATUS_SUCCESS;
}

SWITCH_DECLARE(switch_status_t) switch_core_media_set_video_file(switch_core_session_t *session, switch_file_handle_t *fh, switch_rw_t rw)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *v_engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!smh->video_read_fh && !smh->video_write_fh && !switch_channel_test_flag(session->channel, CF_VIDEO)) {
                return SWITCH_STATUS_FALSE;
        }

        if (fh && !switch_core_file_has_video(fh, SWITCH_TRUE)) {
                return SWITCH_STATUS_FALSE;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        switch_core_session_start_video_thread(session);

        //if (!v_engine->media_thread) {
        //      return SWITCH_STATUS_FALSE;
        //}



        if (rw == SWITCH_RW_READ) {
                switch_mutex_lock(v_engine->mh.file_read_mutex);

                if (fh && smh->video_read_fh) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "File is already open\n");
                        switch_mutex_unlock(v_engine->mh.file_read_mutex);
                        return SWITCH_STATUS_FALSE;
                }


                if (fh) {
                        switch_channel_set_flag_recursive(session->channel, CF_VIDEO_DECODED_READ);
                        switch_channel_set_flag(session->channel, CF_VIDEO_READ_FILE_ATTACHED);
                } else if (smh->video_read_fh) {
                        switch_channel_clear_flag_recursive(session->channel, CF_VIDEO_DECODED_READ);
                        switch_core_session_video_reset(session);
                }

                if (!fh) {
                        switch_channel_clear_flag(session->channel, CF_VIDEO_READ_FILE_ATTACHED);
                }

                smh->video_read_fh = fh;

                switch_mutex_unlock(v_engine->mh.file_read_mutex);

        } else {
                if (!fh && smh->video_write_thread) {
                        if (smh->video_write_thread_running > 0) {
                                smh->video_write_thread_running = -1;
                        }
                }

                switch_mutex_lock(v_engine->mh.file_write_mutex);

                if (fh && smh->video_write_fh) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "File is already open\n");
                        smh->video_write_fh = fh;
                        switch_mutex_unlock(v_engine->mh.file_write_mutex);
                        return SWITCH_STATUS_SUCCESS;
                }

                if (fh) {
                        switch_channel_set_flag(session->channel, CF_VIDEO_WRITE_FILE_ATTACHED);
                } else {
                        switch_channel_clear_flag(session->channel, CF_VIDEO_WRITE_FILE_ATTACHED);
                }

                switch_core_media_gen_key_frame(session);
                switch_core_session_request_video_refresh(session);

                if (fh) {
                        switch_threadattr_t *thd_attr = NULL;
                        //switch_core_session_write_blank_video(session, 500);
                        switch_threadattr_create(&thd_attr, switch_core_session_get_pool(session));
                        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
                        smh->video_write_thread_running = 1;
                        switch_thread_create(&smh->video_write_thread, thd_attr, video_write_thread, session, switch_core_session_get_pool(session));
                }

                if (!fh && smh->video_write_thread) {
                        switch_status_t st;

                        if (smh->video_write_thread_running > 0) {
                                smh->video_write_thread_running = -1;
                        }
                        switch_mutex_unlock(v_engine->mh.file_write_mutex);
                        switch_thread_join(&st, smh->video_write_thread);
                        switch_mutex_lock(v_engine->mh.file_write_mutex);
                        smh->video_write_thread = NULL;
                        //switch_core_session_write_blank_video(session, 500);
                }

                smh->video_write_fh = fh;

                switch_mutex_unlock(v_engine->mh.file_write_mutex);
        }

        if (!fh) switch_channel_video_sync(session->channel);

        switch_core_session_wake_video_thread(session);


        return SWITCH_STATUS_SUCCESS;
}

int next_cpu(void)
{
        int x = 0;

        switch_mutex_lock(video_globals.mutex);
        x = video_globals.cur_cpu++;
        if (video_globals.cur_cpu == video_globals.cpu_count) {
                video_globals.cur_cpu = 0;
        }
        switch_mutex_unlock(video_globals.mutex);
        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Binding to CPU %d\n", x);

        return x;
}

SWITCH_DECLARE(void) switch_core_autobind_cpu(void)
{
        if (video_globals.cpu_count > 1) {
                switch_core_thread_set_cpu_affinity(next_cpu());
        }
}

static switch_status_t perform_write(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
        switch_io_event_hook_write_frame_t *ptr;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_media_handle_t *smh;

        switch_assert(session != NULL);

        if ((smh = session->media_handle)) {
                switch_rtp_engine_t *a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];

                if (a_engine && a_engine->write_fb && !(flags & SWITCH_IO_FLAG_QUEUED)) {
                        switch_frame_t *dupframe = NULL;

                        if (switch_frame_buffer_dup(a_engine->write_fb, frame, &dupframe) == SWITCH_STATUS_SUCCESS) {
                                switch_frame_buffer_push(a_engine->write_fb, dupframe);
                                dupframe = NULL;
                                return SWITCH_STATUS_SUCCESS;
                        }
                }
        }

        if (session->bugs && !(frame->flags & SFF_NOT_AUDIO)) {
                switch_media_bug_t *bp;
                switch_bool_t ok = SWITCH_TRUE;
                int prune = 0;

                switch_thread_rwlock_rdlock(session->bug_rwlock);

                for (bp = session->bugs; bp; bp = bp->next) {
                        ok = SWITCH_TRUE;

                        if (switch_core_media_bug_test_flag(bp, SMBF_PAUSE) || (switch_channel_test_flag(session->channel, CF_PAUSE_BUGS) && !switch_core_media_bug_test_flag(bp, SMBF_NO_PAUSE))) {
                                continue;
                        }

                        if (!switch_channel_test_flag(session->channel, CF_ANSWERED) && switch_core_media_bug_test_flag(bp, SMBF_ANSWER_REQ)) {
                                continue;
                        }
                        if (switch_test_flag(bp, SMBF_PRUNE)) {
                                prune++;
                                continue;
                        }

                        if (bp->ready) {
                                if (switch_test_flag(bp, SMBF_TAP_NATIVE_WRITE)) {
                                        if (bp->callback) {
                                                bp->native_write_frame = frame;
                                                ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_TAP_NATIVE_WRITE);
                                                bp->native_write_frame = NULL;
                                        }
                                }
                        }

                        if ((bp->stop_time && bp->stop_time <= switch_epoch_time_now(NULL)) || ok == SWITCH_FALSE) {
                                switch_set_flag(bp, SMBF_PRUNE);
                                prune++;
                        }
                }
                switch_thread_rwlock_unlock(session->bug_rwlock);

                if (prune) {
                        switch_core_media_bug_prune(session);
                }
        }


        if (session->endpoint_interface->io_routines->write_frame) {
                if ((status = session->endpoint_interface->io_routines->write_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
                        for (ptr = session->event_hooks.write_frame; ptr; ptr = ptr->next) {
                                if ((status = ptr->write_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }
                        }
                }
        }

        return status;
}


static void *SWITCH_THREAD_FUNC audio_write_thread(switch_thread_t *thread, void *obj)
{
        struct media_helper *mh = obj;
        switch_core_session_t *session = mh->session;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine = NULL;
        switch_codec_implementation_t write_impl;
        switch_timer_t timer = {0};

        if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
                return NULL;
        }

        if (!(smh = session->media_handle)) {
                switch_core_session_rwunlock(session);
                return NULL;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        a_engine->thread_id = switch_thread_self();


        write_impl = session->write_impl;

        switch_core_timer_init(&timer, "soft", write_impl.microseconds_per_packet / 1000,
                                                   write_impl.samples_per_packet, switch_core_session_get_pool(session));

        mh->up = 1;

        switch_frame_buffer_create(&a_engine->write_fb, 500);

        while(switch_channel_up_nosig(session->channel) && mh->up == 1) {
                void *pop;

                if (session->write_impl.microseconds_per_packet != write_impl.microseconds_per_packet ||
                        session->write_impl.samples_per_packet != write_impl.samples_per_packet) {


                        write_impl = session->write_impl;
                        switch_core_timer_destroy(&timer);
                        switch_core_timer_init(&timer, "soft", write_impl.microseconds_per_packet / 1000,
                                                                   write_impl.samples_per_packet, switch_core_session_get_pool(session));

                }

                switch_core_timer_next(&timer);

                if (switch_frame_buffer_trypop(a_engine->write_fb, &pop) == SWITCH_STATUS_SUCCESS && pop) {
                        switch_frame_t *frame = (switch_frame_t *)pop;

                        if ((switch_size_t)pop == 1) {
                                break;
                        }

                        perform_write(session, frame, SWITCH_IO_FLAG_QUEUED, 0);
                        switch_frame_buffer_free(a_engine->write_fb, &frame);
                }
        }

        switch_mutex_lock(smh->control_mutex);
        mh->up = 0;
        switch_mutex_unlock(smh->control_mutex);

        switch_core_timer_destroy(&timer);

        switch_core_session_rwunlock(session);
        return NULL;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_start_audio_write_thread(switch_core_session_t *session)
{
        switch_threadattr_t *thd_attr = NULL;
        switch_memory_pool_t *pool = switch_core_session_get_pool(session);
        switch_rtp_engine_t *a_engine = NULL;
        switch_media_handle_t *smh;

        if (!switch_channel_test_flag(session->channel, CF_AUDIO)) {
                return SWITCH_STATUS_NOTIMPL;
        }

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];

        if (a_engine->media_thread) {
                return SWITCH_STATUS_INUSE;
        }

        switch_mutex_lock(smh->control_mutex);

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Starting Audio write thread\n", switch_core_session_get_name(session));

        a_engine->mh.session = session;
        switch_threadattr_create(&thd_attr, pool);
        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);

        switch_thread_cond_create(&a_engine->mh.cond, pool);
        switch_mutex_init(&a_engine->mh.cond_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_thread_create(&a_engine->media_thread, thd_attr, audio_write_thread, &a_engine->mh, switch_core_session_get_pool(session));

        switch_mutex_unlock(smh->control_mutex);
        return SWITCH_STATUS_SUCCESS;
}



static void *SWITCH_THREAD_FUNC text_helper_thread(switch_thread_t *thread, void *obj)
{
        struct media_helper *mh = obj;
        switch_core_session_t *session;
        switch_channel_t *channel;
        switch_status_t status;
        switch_frame_t *read_frame = NULL;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *t_engine = NULL;
        unsigned char CR[] = TEXT_UNICODE_LINEFEED;
        switch_frame_t cr_frame = { 0 };


        session = mh->session;
        
        if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
                mh->ready = -1;
                return NULL;
        }

        if (!(smh = session->media_handle)) {
                switch_core_session_rwunlock(session);
                mh->ready = -1;
                return NULL;
        }

        mh->ready = 1;

        channel = switch_core_session_get_channel(session);

        if (switch_channel_var_true(session->channel, "fire_text_events")) {
                switch_channel_set_flag(session->channel, CF_FIRE_TEXT_EVENTS);
        }

        cr_frame.data = CR;
        cr_frame.datalen = 3;

        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];
        t_engine->thread_id = switch_thread_self();

        mh->up = 1;

        switch_core_media_check_dtls(session, SWITCH_MEDIA_TYPE_TEXT);

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Text thread started.\n", switch_channel_get_name(session->channel));

        if (!switch_channel_test_flag(channel, CF_MSRP)) {
                switch_core_session_write_text_frame(session, &cr_frame, 0, 0);
        }

        while (switch_channel_up_nosig(channel)) {

                if (t_engine->engine_function) {
                        int run = 0;

                        switch_mutex_lock(smh->control_mutex);
                        if (t_engine->engine_function_running == 0) {
                                t_engine->engine_function_running = 1;
                                run = 1;
                        }
                        switch_mutex_unlock(smh->control_mutex);

                        if (run) {
                                t_engine->engine_function(session, t_engine->engine_user_data);
                                switch_mutex_lock(smh->control_mutex);
                                t_engine->engine_function = NULL;
                                t_engine->engine_user_data = NULL;
                                t_engine->engine_function_running = 0;
                                switch_mutex_unlock(smh->control_mutex);
                        }
                }

                if (!switch_channel_test_flag(session->channel, CF_TEXT_PASSIVE)) {

                        status = switch_core_session_read_text_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                        if (!SWITCH_READ_ACCEPTABLE(status)) {
                                switch_cond_next();
                                continue;
                        }

                        if (!switch_test_flag(read_frame, SFF_CNG)) {
                                if (switch_channel_test_flag(session->channel, CF_TEXT_ECHO)) {
                                        switch_core_session_write_text_frame(session, read_frame, 0, 0);
                                }
                        }
                }

                switch_core_session_write_text_frame(session, NULL, 0, 0);


        }

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Text thread ended\n", switch_channel_get_name(session->channel));

        switch_core_session_rwunlock(session);

        mh->up = 0;
        return NULL;
}


SWITCH_DECLARE(switch_status_t) switch_core_session_start_text_thread(switch_core_session_t *session)
{
        switch_threadattr_t *thd_attr = NULL;
        switch_memory_pool_t *pool = switch_core_session_get_pool(session);
        switch_rtp_engine_t *t_engine = NULL;
        switch_media_handle_t *smh;

        if (!switch_channel_test_flag(session->channel, CF_HAS_TEXT)) {
                return SWITCH_STATUS_NOTIMPL;
        }

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        switch_mutex_lock(smh->control_mutex);

        if (t_engine->media_thread) {
                switch_mutex_unlock(smh->control_mutex);
                return SWITCH_STATUS_FALSE;
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Starting Text thread\n", switch_core_session_get_name(session));

        if (t_engine->rtp_session) {
                switch_rtp_set_default_payload(t_engine->rtp_session, t_engine->cur_payload_map->pt);
        }

        t_engine->mh.session = session;
        switch_threadattr_create(&thd_attr, pool);
        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);

        switch_thread_cond_create(&t_engine->mh.cond, pool);
        switch_mutex_init(&t_engine->mh.cond_mutex, SWITCH_MUTEX_NESTED, pool);
        //switch_mutex_init(&t_engine->mh.file_read_mutex, SWITCH_MUTEX_NESTED, pool);
        //switch_mutex_init(&t_engine->mh.file_write_mutex, SWITCH_MUTEX_NESTED, pool);
        //switch_mutex_init(&smh->read_mutex[SWITCH_MEDIA_TYPE_TEXT], SWITCH_MUTEX_NESTED, pool);
        //switch_mutex_init(&smh->write_mutex[SWITCH_MEDIA_TYPE_TEXT], SWITCH_MUTEX_NESTED, pool);

        t_engine->mh.ready = 0;

        if (switch_thread_create(&t_engine->media_thread, thd_attr, text_helper_thread, &t_engine->mh, 
                                                         switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) {
                while(!t_engine->mh.ready) {
                        switch_cond_next();
                }
        }

        switch_mutex_unlock(smh->control_mutex);
        return SWITCH_STATUS_SUCCESS;
}

static void *SWITCH_THREAD_FUNC video_helper_thread(switch_thread_t *thread, void *obj)
{
        struct media_helper *mh = obj;
        switch_core_session_t *session;
        switch_channel_t *channel;
        switch_status_t status;
        switch_frame_t *read_frame = NULL;
        switch_media_handle_t *smh;
        uint32_t loops = 0, xloops = 0;
        switch_image_t *blank_img = NULL;
        switch_frame_t fr = { 0 };
        unsigned char *buf = NULL;
        switch_rgb_color_t bgcolor;
        switch_rtp_engine_t *v_engine = NULL;
        const char *var;
        int buflen = SWITCH_RTP_MAX_BUF_LEN;
        int blank_enabled = 1;

        session = mh->session;
        
        if (switch_core_session_read_lock(session) != SWITCH_STATUS_SUCCESS) {
                mh->ready = -1;
                return NULL;
        }

        if (!(smh = session->media_handle)) {
                switch_core_session_rwunlock(session);
                mh->ready = -1;
                return NULL;
        }

        mh->ready = 1;

        channel = switch_core_session_get_channel(session);

        switch_core_autobind_cpu();

        if ((var = switch_channel_get_variable(session->channel, "core_video_blank_image"))) {
                if (switch_false(var)) {
                        blank_enabled = 0;
                } else {
                        blank_img = switch_img_read_png(var, SWITCH_IMG_FMT_I420);
                }
        }

        if (!blank_img) {
                switch_color_set_rgb(&bgcolor, "#000000");
                if ((blank_img = switch_img_alloc(NULL, SWITCH_IMG_FMT_I420, 352, 288, 1))) {
                        switch_img_fill(blank_img, 0, 0, blank_img->d_w, blank_img->d_h, &bgcolor);
                }
        }



        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        v_engine->thread_id = switch_thread_self();

        mh->up = 1;
        switch_mutex_lock(mh->cond_mutex);

        switch_core_media_check_dtls(session, SWITCH_MEDIA_TYPE_VIDEO);

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Video thread started. Echo is %s\n",
                                          switch_channel_get_name(session->channel), switch_channel_test_flag(channel, CF_VIDEO_ECHO) ? "on" : "off");
        switch_core_session_request_video_refresh(session);

        buf = switch_core_session_alloc(session, buflen);
        fr.packet = buf;
        fr.packetlen = buflen;
        fr.data = buf + 12;
        fr.buflen = buflen - 12;

        switch_core_media_gen_key_frame(session);

        while (switch_channel_up_nosig(channel)) {
                int send_blank = 0;

                if (!switch_channel_test_flag(channel, CF_VIDEO)) {
                        if ((++loops % 100) == 0) switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Waiting for video......\n");
                        switch_yield(20000);
                        continue;
                }

                if (!switch_channel_test_flag(channel, CF_VIDEO_READY) &&
                        switch_channel_test_flag(channel, CF_VIDEO_DECODED_READ) && (++xloops > 10 || switch_channel_test_flag(channel, CF_VIDEO_PASSIVE))) {
                        switch_channel_set_flag(channel, CF_VIDEO_READY);
                }

                if (switch_channel_test_flag(channel, CF_VIDEO_PASSIVE)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Video thread paused. Echo is %s\n",
                                                          switch_channel_get_name(session->channel), switch_channel_test_flag(channel, CF_VIDEO_ECHO) ? "on" : "off");
                        switch_thread_cond_wait(mh->cond, mh->cond_mutex);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Video thread resumed  Echo is %s\n",
                                                          switch_channel_get_name(session->channel), switch_channel_test_flag(channel, CF_VIDEO_ECHO) ? "on" : "off");
                        switch_core_session_request_video_refresh(session);
                }

                if (switch_channel_test_flag(channel, CF_VIDEO_PASSIVE)) {
                        continue;
                }

                if (!switch_channel_media_up(session->channel)) {
                        switch_yield(10000);
                        continue;
                }

                if (v_engine->engine_function) {
                        int run = 0;

                        switch_mutex_lock(smh->control_mutex);
                        if (v_engine->engine_function_running == 0) {
                                v_engine->engine_function_running = 1;
                                run = 1;
                        }
                        switch_mutex_unlock(smh->control_mutex);

                        if (run) {
                                v_engine->engine_function(session, v_engine->engine_user_data);
                                switch_mutex_lock(smh->control_mutex);
                                v_engine->engine_function = NULL;
                                v_engine->engine_user_data = NULL;
                                v_engine->engine_function_running = 0;
                                switch_mutex_unlock(smh->control_mutex);
                        }
                }

                status = switch_core_session_read_video_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        switch_cond_next();
                        continue;
                }

                send_blank = blank_enabled || switch_channel_test_flag(channel, CF_VIDEO_ECHO);

                if (switch_channel_test_flag(channel, CF_VIDEO_READY) && !switch_test_flag(read_frame, SFF_CNG)) {
                        switch_mutex_lock(mh->file_read_mutex);
                        if (smh->video_read_fh && switch_test_flag(smh->video_read_fh, SWITCH_FILE_OPEN) && read_frame->img) {
                                smh->video_read_fh->mm.fps = smh->vid_params.fps;
                                switch_core_file_write_video(smh->video_read_fh, read_frame);
                        }
                        switch_mutex_unlock(mh->file_read_mutex);
                }

                if ((switch_channel_test_flag(channel, CF_VIDEO_WRITING) || session->video_read_callback) && !switch_channel_test_flag(channel, CF_VIDEO_BLANK)) {
                        send_blank = 0;
                }

                if (send_blank) {
                        if (read_frame && (switch_channel_test_flag(channel, CF_VIDEO_ECHO))) {
                                switch_core_session_write_video_frame(session, read_frame, SWITCH_IO_FLAG_NONE, 0);
                        } else if (blank_img) {
                                fr.img = blank_img;
                                switch_yield(10000);
                                switch_core_session_write_video_frame(session, &fr, SWITCH_IO_FLAG_FORCE, 0);
                        }
                }
        }

        switch_img_free(&blank_img);

        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "%s Video thread ended\n", switch_channel_get_name(session->channel));

        switch_mutex_unlock(mh->cond_mutex);
        switch_core_session_rwunlock(session);

        mh->up = 0;
        return NULL;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_start_video_thread(switch_core_session_t *session)
{
        switch_threadattr_t *thd_attr = NULL;
        switch_memory_pool_t *pool = switch_core_session_get_pool(session);
        switch_rtp_engine_t *v_engine = NULL;
        switch_media_handle_t *smh;

        if (!switch_channel_test_flag(session->channel, CF_VIDEO)) {
                return SWITCH_STATUS_NOTIMPL;
        }

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        switch_mutex_lock(smh->control_mutex);

        if (v_engine->media_thread) {
                switch_mutex_unlock(smh->control_mutex);
                return SWITCH_STATUS_FALSE;
        }

        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Starting Video thread\n", switch_core_session_get_name(session));

        if (v_engine->rtp_session) {
                switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->pt);
        }

        v_engine->mh.session = session;
        switch_threadattr_create(&thd_attr, pool);
        switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);

        switch_thread_cond_create(&v_engine->mh.cond, pool);
        switch_mutex_init(&v_engine->mh.cond_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&v_engine->mh.file_read_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&v_engine->mh.file_write_mutex, SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&smh->read_mutex[SWITCH_MEDIA_TYPE_VIDEO], SWITCH_MUTEX_NESTED, pool);
        switch_mutex_init(&smh->write_mutex[SWITCH_MEDIA_TYPE_VIDEO], SWITCH_MUTEX_NESTED, pool);
        v_engine->mh.ready = 0;

        if (switch_thread_create(&v_engine->media_thread, thd_attr, video_helper_thread, &v_engine->mh, 
                                                         switch_core_session_get_pool(session)) == SWITCH_STATUS_SUCCESS) {
                while(!v_engine->mh.ready) {
                        switch_cond_next();
                }
        }

        switch_mutex_unlock(smh->control_mutex);
        return SWITCH_STATUS_SUCCESS;
}

SWITCH_DECLARE(void) switch_core_media_start_engine_function(switch_core_session_t *session, switch_media_type_t type, switch_engine_function_t engine_function, void *user_data)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        if (!(smh = session->media_handle)) {
                return;
        }

        engine = &smh->engines[type];

        if (type == SWITCH_MEDIA_TYPE_VIDEO) {
                switch_core_session_start_video_thread(session);
        }

        if (type == SWITCH_MEDIA_TYPE_TEXT) {
                switch_core_session_start_text_thread(session);
        }

        switch_mutex_lock(smh->control_mutex);
        if (!engine->engine_function_running) {
                engine->engine_function = engine_function;
                engine->engine_user_data = user_data;
                switch_core_session_video_reset(session);
        }
        switch_mutex_unlock(smh->control_mutex);
}

SWITCH_DECLARE(int) switch_core_media_check_engine_function(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;
        int r;
        switch_rtp_engine_t *engine;

        if (!(smh = session->media_handle)) {
                return 0;
        }

        engine = &smh->engines[type];

        switch_mutex_lock(smh->control_mutex);
        r = (engine->engine_function_running > 0);
        switch_mutex_unlock(smh->control_mutex);

        return r;
}

SWITCH_DECLARE(void) switch_core_media_end_engine_function(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        if (!(smh = session->media_handle)) {
                return;
        }

        engine = &smh->engines[type];

        switch_mutex_lock(smh->control_mutex);
        if (engine->engine_function_running > 0) {
                engine->engine_function_running = -1;
        }
        switch_mutex_unlock(smh->control_mutex);

        while(engine->engine_function_running != 0) {
                switch_yield(10000);
        }
}

SWITCH_DECLARE(switch_bool_t) switch_core_session_in_video_thread(switch_core_session_t *session)
{
        switch_rtp_engine_t *v_engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_FALSE;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        return switch_thread_equal(switch_thread_self(), v_engine->thread_id) ? SWITCH_TRUE : SWITCH_FALSE;
}


SWITCH_DECLARE(void) switch_core_media_parse_media_flags(switch_core_session_t *session)
{
        const char *var;
        switch_media_handle_t *smh;

        if (!(smh = session->media_handle)) {
                return;
        }

        if ((var = switch_channel_get_variable(session->channel, "rtp_media_autofix_timing"))) {
                if (switch_true(var)) {
                        switch_media_handle_set_media_flag(smh, SCMF_AUTOFIX_TIMING);
                } else {
                        switch_media_handle_clear_media_flag(smh, SCMF_AUTOFIX_TIMING);
                }
        }
}

//?
#define RA_PTR_LEN 512
SWITCH_DECLARE(switch_status_t) switch_core_media_proxy_remote_addr(switch_core_session_t *session, const char *sdp_str)
{
        const char *err;
        char rip[RA_PTR_LEN] = "";
        char rp[RA_PTR_LEN] = "";
        char rvp[RA_PTR_LEN] = "";
        char rtp[RA_PTR_LEN] = "";
        char *p, *ip_ptr = NULL, *port_ptr = NULL, *vid_port_ptr = NULL, *text_port_ptr = NULL, *pe;
        int x;
        const char *val;
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (zstr(sdp_str)) {
                sdp_str = smh->mparams->remote_sdp_str;
        }

        if (zstr(sdp_str)) {
                goto end;
        }

        if ((p = (char *) switch_stristr("c=IN IP4 ", sdp_str)) || (p = (char *) switch_stristr("c=IN IP6 ", sdp_str))) {
                ip_ptr = p + 9;
        }

        if ((p = (char *) switch_stristr("m=audio ", sdp_str))) {
                port_ptr = p + 8;
        }

        if ((p = (char *) switch_stristr("m=image ", sdp_str))) {
                char *tmp = p + 8;

                if (tmp && atoi(tmp)) {
                        port_ptr = tmp;
                }
        }

        if ((p = (char *) switch_stristr("m=video ", sdp_str))) {
                vid_port_ptr = p + 8;
        }

        if ((p = (char *) switch_stristr("m=text ", sdp_str))) {
                text_port_ptr = p + 7;
        }

        if (!(ip_ptr && port_ptr)) {
                goto end;
        }

        p = ip_ptr;
        pe = p + strlen(p);
        x = 0;
        while (x < sizeof(rip) - 1 && p && *p && ((*p >= '0' && *p <= '9') || *p == '.' || *p == ':' || (*p >= 'a' && *p <= 'f') || (*p >= 'A' && *p <= 'F'))) {
                rip[x++] = *p;
                p++;
                if (p >= pe) {
                        goto end;
                }
        }

        if (port_ptr) {
                p = port_ptr;
                x = 0;
                while (x < sizeof(rp) - 1 && p && *p && (*p >= '0' && *p <= '9')) {
                        rp[x++] = *p;
                        p++;
                        if (p >= pe) {
                                goto end;
                        }
                }
        }

        if (vid_port_ptr) {
                p = vid_port_ptr;
                x = 0;
                while (x < sizeof(rvp) - 1 && p && *p && (*p >= '0' && *p <= '9')) {
                        rvp[x++] = *p;
                        p++;
                        if (p >= pe) {
                                goto end;
                        }
                }
        }

        if (text_port_ptr) {
                p = text_port_ptr;
                x = 0;
                while (x < sizeof(rtp) - 1 && p && *p && (*p >= '0' && *p <= '9')) {
                        rtp[x++] = *p;
                        p++;
                        if (p >= pe) {
                                goto end;
                        }
                }
        }

        if (!(*rip && *rp)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "invalid SDP\n");
                goto end;
        }

        a_engine->cur_payload_map->remote_sdp_ip = switch_core_session_strdup(session, rip);
        a_engine->cur_payload_map->remote_sdp_port = (switch_port_t) atoi(rp);

        if (*rvp) {
                v_engine->cur_payload_map->remote_sdp_ip = switch_core_session_strdup(session, rip);
                v_engine->cur_payload_map->remote_sdp_port = (switch_port_t) atoi(rvp);
                switch_channel_set_flag(session->channel, CF_VIDEO_POSSIBLE);
                switch_channel_set_flag(session->channel, CF_VIDEO);
        }

        if (*rtp) {
                t_engine->cur_payload_map->remote_sdp_ip = switch_core_session_strdup(session, rip);
                t_engine->cur_payload_map->remote_sdp_port = (switch_port_t) atoi(rtp);
                switch_channel_set_flag(session->channel, CF_HAS_TEXT);
                switch_channel_set_flag(session->channel, CF_TEXT_POSSIBLE);
        }

        if (v_engine->cur_payload_map && v_engine->cur_payload_map->remote_sdp_ip && v_engine->cur_payload_map->remote_sdp_port) {
                if (!strcmp(v_engine->cur_payload_map->remote_sdp_ip, rip) && atoi(rvp) == v_engine->cur_payload_map->remote_sdp_port) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Remote video address:port [%s:%d] has not changed.\n",
                                                          v_engine->cur_payload_map->remote_sdp_ip, v_engine->cur_payload_map->remote_sdp_port);
                } else {
                        switch_channel_set_flag(session->channel, CF_VIDEO_POSSIBLE);
                        switch_channel_set_flag(session->channel, CF_VIDEO);
                        if (switch_rtp_ready(v_engine->rtp_session)) {
                                const char *rport = NULL;
                                switch_port_t remote_rtcp_port = v_engine->remote_rtcp_port;

                                if (!remote_rtcp_port) {
                                        if ((rport = switch_channel_get_variable(session->channel, "rtp_remote_video_rtcp_port"))) {
                                                remote_rtcp_port = (switch_port_t)atoi(rport);
                                        }
                                }


                                if (switch_rtp_set_remote_address(v_engine->rtp_session, v_engine->cur_payload_map->remote_sdp_ip,
                                                                                                  v_engine->cur_payload_map->remote_sdp_port, remote_rtcp_port, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "VIDEO RTP REPORTS ERROR: [%s]\n", err);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "VIDEO RTP CHANGING DEST TO: [%s:%d]\n",
                                                                          v_engine->cur_payload_map->remote_sdp_ip, v_engine->cur_payload_map->remote_sdp_port);
                                        if (switch_media_handle_test_media_flag(smh, SCMF_AUTOFIX_TIMING)) {
                                                v_engine->check_frames = 0;
                                        }
                                }
                        }
                }
                if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_PROXY_MODE) &&
                        !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) &&
                        v_engine->rtp_session &&
                        !switch_channel_test_flag(session->channel, CF_AVPF)) {
                        /* Reactivate the NAT buster flag. */
                        switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                }
        }

        if (t_engine->cur_payload_map && t_engine->cur_payload_map->remote_sdp_ip && t_engine->cur_payload_map->remote_sdp_port) {
                if (!strcmp(t_engine->cur_payload_map->remote_sdp_ip, rip) && atoi(rvp) == t_engine->cur_payload_map->remote_sdp_port) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Remote text address:port [%s:%d] has not changed.\n",
                                                          t_engine->cur_payload_map->remote_sdp_ip, t_engine->cur_payload_map->remote_sdp_port);
                } else {
                        switch_channel_set_flag(session->channel, CF_HAS_TEXT);
                        switch_channel_set_flag(session->channel, CF_TEXT_POSSIBLE);
                        if (switch_rtp_ready(t_engine->rtp_session)) {
                                const char *rport = NULL;
                                switch_port_t remote_rtcp_port = t_engine->remote_rtcp_port;

                                if (!remote_rtcp_port) {
                                        if ((rport = switch_channel_get_variable(session->channel, "rtp_remote_text_rtcp_port"))) {
                                                remote_rtcp_port = (switch_port_t)atoi(rport);
                                        }
                                }


                                if (switch_rtp_set_remote_address(t_engine->rtp_session, t_engine->cur_payload_map->remote_sdp_ip,
                                                                                                  t_engine->cur_payload_map->remote_sdp_port, remote_rtcp_port, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "TEXT RTP REPORTS ERROR: [%s]\n", err);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "TEXT RTP CHANGING DEST TO: [%s:%d]\n",
                                                                          t_engine->cur_payload_map->remote_sdp_ip, t_engine->cur_payload_map->remote_sdp_port);
                                        if (switch_media_handle_test_media_flag(smh, SCMF_AUTOFIX_TIMING)) {
                                                t_engine->check_frames = 0;
                                        }
                                }
                        }
                }
                if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_PROXY_MODE) &&
                        !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) &&
                        t_engine->rtp_session &&
                        !switch_channel_test_flag(session->channel, CF_AVPF)) {
                        /* Reactivate the NAT buster flag. */
                        switch_rtp_set_flag(t_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                }
        }

        if (switch_rtp_ready(a_engine->rtp_session)) {
                char *remote_host = switch_rtp_get_remote_host(a_engine->rtp_session);
                switch_port_t remote_port = switch_rtp_get_remote_port(a_engine->rtp_session);
                const char *rport = NULL;
                switch_port_t remote_rtcp_port = 0;

                if (remote_host && remote_port && !strcmp(remote_host, a_engine->cur_payload_map->remote_sdp_ip) && remote_port == a_engine->cur_payload_map->remote_sdp_port) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Remote address:port [%s:%d] has not changed.\n",
                                                          a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);
                        switch_goto_status(SWITCH_STATUS_BREAK, end);
                } else if (remote_host && ( (strcmp(remote_host, "0.0.0.0") == 0) ||
                                                                        (strcmp(a_engine->cur_payload_map->remote_sdp_ip, "0.0.0.0") == 0))) {

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                          "Remote address changed from [%s] to [%s]. Ignoring...\n",
                                                          a_engine->cur_payload_map->remote_sdp_ip, remote_host);
                        switch_goto_status(SWITCH_STATUS_BREAK, end);
                }

                if ((rport = switch_channel_get_variable(session->channel, "rtp_remote_audio_rtcp_port"))) {
                        remote_rtcp_port = (switch_port_t)atoi(rport);
                }


                if (switch_rtp_set_remote_address(a_engine->rtp_session, a_engine->cur_payload_map->remote_sdp_ip,
                                                                                  a_engine->cur_payload_map->remote_sdp_port, remote_rtcp_port, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "AUDIO RTP REPORTS ERROR: [%s]\n", err);
                        status = SWITCH_STATUS_GENERR;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "AUDIO RTP CHANGING DEST TO: [%s:%d]\n",
                                                          a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);
                        if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) &&
                                !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) &&
                                !switch_channel_test_flag(session->channel, CF_AVPF)) {
                                /* Reactivate the NAT buster flag. */
                                switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                        }
                        if (switch_media_handle_test_media_flag(smh, SCMF_AUTOFIX_TIMING)) {
                                a_engine->check_frames = 0;
                        }
                        status = SWITCH_STATUS_SUCCESS;
                }
        }

 end:

        return status;
}

//?
SWITCH_DECLARE(int) switch_core_media_check_nat(switch_media_handle_t *smh, const char *network_ip)
{
        switch_assert(network_ip);

        return (smh->mparams->extsipip &&
                        !switch_check_network_list_ip(network_ip, "loopback.auto") &&
                        !switch_check_network_list_ip(network_ip, smh->mparams->local_network));
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_ext_address_lookup(switch_core_session_t *session, char **ip, switch_port_t *port, const char *sourceip)

{
        char *error = "";
        switch_status_t status = SWITCH_STATUS_FALSE;
        int x;
        switch_port_t myport = *port;
        switch_port_t stun_port = SWITCH_STUN_DEFAULT_PORT;
        char *stun_ip = NULL;
        switch_media_handle_t *smh;
        switch_memory_pool_t *pool = switch_core_session_get_pool(session);

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!sourceip) {
                return status;
        }

        if (!strncasecmp(sourceip, "host:", 5)) {
                status = (*ip = switch_stun_host_lookup(sourceip + 5, pool)) ? SWITCH_STATUS_SUCCESS : SWITCH_STATUS_FALSE;
        } else if (!strncasecmp(sourceip, "stun:", 5)) {
                char *p;

                stun_ip = strdup(sourceip + 5);

                if ((p = strchr(stun_ip, ':'))) {
                        int iport;
                        *p++ = '\0';
                        iport = atoi(p);
                        if (iport > 0 && iport < 0xFFFF) {
                                stun_port = (switch_port_t) iport;
                        }
                }

                if (zstr(stun_ip)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "STUN Failed! NO STUN SERVER\n");
                        goto out;
                }

                for (x = 0; x < 5; x++) {
                        if ((status = switch_stun_lookup(ip, port, stun_ip, stun_port, &error, pool)) != SWITCH_STATUS_SUCCESS) {
                                switch_yield(100000);
                        } else {
                                break;
                        }
                }
                if (status != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "STUN Failed! %s:%d [%s]\n", stun_ip, stun_port, error);
                        goto out;
                }
                if (!*ip) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "STUN Failed! No IP returned\n");
                        goto out;
                }
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "STUN Success [%s]:[%d]\n", *ip, *port);
                status = SWITCH_STATUS_SUCCESS;

                if (myport == *port && !strcmp(*ip, smh->mparams->rtpip)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "STUN Not Required ip and port match. [%s]:[%d]\n", *ip, *port);
                } else {
                        smh->mparams->stun_ip = switch_core_session_strdup(session, stun_ip);
                        smh->mparams->stun_port = stun_port;
                        smh->mparams->stun_flags |= STUN_FLAG_SET;
                }
        } else {
                *ip = (char *) sourceip;
                status = SWITCH_STATUS_SUCCESS;
        }

 out:

        switch_safe_free(stun_ip);

        return status;
}

//?
SWITCH_DECLARE(void) switch_core_media_reset_autofix(switch_core_session_t *session, switch_media_type_t type)
{
        switch_rtp_engine_t *engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        engine = &smh->engines[type];

        engine->check_frames = 0;
        engine->last_ts = 0;
        engine->last_seq = 0;
}



//?
SWITCH_DECLARE(switch_status_t) switch_core_media_choose_port(switch_core_session_t *session, switch_media_type_t type, int force)
{
        char *lookup_rtpip;     /* Pointer to externally looked up address */
        switch_port_t sdp_port;         /* The external port to be sent in the SDP */
        const char *use_ip = NULL;      /* The external IP to be sent in the SDP */
        switch_rtp_engine_t *engine;
        switch_media_handle_t *smh;
        const char *tstr = switch_media_type2str(type);
        char vname[128] = "";

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        engine = &smh->engines[type];

        lookup_rtpip = smh->mparams->rtpip;

        if (!lookup_rtpip) {
                return SWITCH_STATUS_FALSE;
        }

        /* Don't do anything if we're in proxy mode or if a (remote) port already has been found */
        if (!force) {
                if (switch_channel_test_flag(session->channel, CF_PROXY_MODE) ||
                        switch_channel_test_flag(session->channel, CF_PROXY_MEDIA) || engine->adv_sdp_port) {
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        /* Always too late when RTP has already started */
        if (engine->rtp_session) {
                return SWITCH_STATUS_SUCCESS;
        }

        /* Release the local sdp port */
        if (engine->local_sdp_port) {
                switch_rtp_release_port(smh->mparams->rtpip, engine->local_sdp_port);
        }

        /* Request a local port from the core's allocator */
        if (!(engine->local_sdp_port = switch_rtp_request_port(smh->mparams->rtpip))) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "No %s RTP ports available!\n", tstr);
                return SWITCH_STATUS_FALSE;
        }

        engine->local_sdp_ip = smh->mparams->rtpip;


        sdp_port = engine->local_sdp_port;

        /* Check if NAT is detected  */
        if (!zstr(smh->mparams->remote_ip) && switch_core_media_check_nat(smh, smh->mparams->remote_ip)) {
                /* Yes, map the port through switch_nat */
                switch_nat_add_mapping(engine->local_sdp_port, SWITCH_NAT_UDP, &sdp_port, SWITCH_FALSE);

                switch_snprintf(vname, sizeof(vname), "rtp_adv_%s_ip", tstr);

                /* Find an IP address to use */
                if (!(use_ip = switch_channel_get_variable(session->channel, vname))
                        && !zstr(smh->mparams->extrtpip)) {
                        use_ip = smh->mparams->extrtpip;
                }

                if (use_ip) {
                        if (switch_core_media_ext_address_lookup(session, &lookup_rtpip, &sdp_port, use_ip) != SWITCH_STATUS_SUCCESS) {
                                /* Address lookup was required and fail (external ip was "host:..." or "stun:...") */
                                return SWITCH_STATUS_FALSE;
                        } else {
                                /* Address properly resolved, use it as external ip */
                                use_ip = lookup_rtpip;
                        }
                } else {
                        /* No external ip found, use the profile's rtp ip */
                        use_ip = smh->mparams->rtpip;
                }
        } else {
                /* No NAT traversal required, use the profile's rtp ip */
                use_ip = smh->mparams->rtpip;
        }

        if (zstr(smh->mparams->remote_ip)) { /* no remote_ip, we're originating */
                if (!zstr(smh->mparams->extrtpip)) { /* and we've got an ext-rtp-ip, eg, from verto config */
                        use_ip = smh->mparams->extrtpip; /* let's use it for composing local sdp to send to client */
                        /*
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                                                "%s will use %s instead of %s in SDP, because we're originating and we have an ext-rtp-ip setting\n",
                                                switch_channel_get_name(smh->session->channel), smh->mparams->extrtpip, smh->mparams->rtpip);
                        */
                }
        }
        engine->adv_sdp_port = sdp_port;
        engine->adv_sdp_ip = smh->mparams->adv_sdp_audio_ip = smh->mparams->extrtpip = switch_core_session_strdup(session, use_ip);

        if (type == SWITCH_MEDIA_TYPE_AUDIO) {
                switch_channel_set_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE, engine->local_sdp_ip);
                switch_channel_set_variable_printf(session->channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE, "%d", sdp_port);
                switch_channel_set_variable(session->channel, SWITCH_ADVERTISED_MEDIA_IP_VARIABLE, engine->adv_sdp_ip);
        } else if (type == SWITCH_MEDIA_TYPE_VIDEO) {
                switch_channel_set_variable(session->channel, SWITCH_LOCAL_VIDEO_IP_VARIABLE, engine->adv_sdp_ip);
                switch_channel_set_variable_printf(session->channel, SWITCH_LOCAL_VIDEO_PORT_VARIABLE, "%d", sdp_port);
        } else if (type == SWITCH_MEDIA_TYPE_TEXT) {
                switch_channel_set_variable(session->channel, SWITCH_LOCAL_TEXT_IP_VARIABLE, engine->adv_sdp_ip);
                switch_channel_set_variable_printf(session->channel, SWITCH_LOCAL_TEXT_PORT_VARIABLE, "%d", sdp_port);
        }


        return SWITCH_STATUS_SUCCESS;
}

SWITCH_DECLARE(switch_status_t) switch_core_media_choose_ports(switch_core_session_t *session, switch_bool_t audio, switch_bool_t video)
{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_media_handle_t *smh;

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (zstr(smh->mparams->rtpip)) {

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "%s has no media ip\n",
                                                  switch_channel_get_name(smh->session->channel));
                switch_channel_hangup(smh->session->channel, SWITCH_CAUSE_BEARERCAPABILITY_NOTAVAIL);

                return SWITCH_STATUS_FALSE;
        }

        if (audio && (status = switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_AUDIO, 0)) == SWITCH_STATUS_SUCCESS) {
                if (video) {
                        switch_core_media_check_video_codecs(session);
                        if (switch_channel_test_flag(session->channel, CF_VIDEO_POSSIBLE)) {
                                switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 0);
                        }
                }
        }

        return status;
}



//?
SWITCH_DECLARE(void) switch_core_media_deactivate_rtp(switch_core_session_t *session)
{
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (t_engine->tf) {
                switch_rtp_text_factory_destroy(&t_engine->tf);
        }

        if (a_engine->media_thread) {
                switch_status_t st;

                switch_mutex_lock(smh->control_mutex);
                if (a_engine->mh.up && a_engine->write_fb) {
                        switch_frame_buffer_push(a_engine->write_fb, (void *) 1);
                }
                a_engine->mh.up = 0;
                switch_mutex_unlock(smh->control_mutex);

                switch_thread_join(&st, a_engine->media_thread);
                a_engine->media_thread = NULL;
        }

        if (v_engine->media_thread) {
                switch_status_t st;
                switch_channel_clear_flag(session->channel, CF_VIDEO_PASSIVE);

                v_engine->mh.up = 0;
                switch_thread_join(&st, v_engine->media_thread);
                v_engine->media_thread = NULL;
        }

        if (v_engine->rtp_session) {
                switch_rtp_destroy(&v_engine->rtp_session);
        } else if (v_engine->local_sdp_port) {
                switch_rtp_release_port(smh->mparams->rtpip, v_engine->local_sdp_port);
        }


        if (v_engine->local_sdp_port > 0 && !zstr(smh->mparams->remote_ip) &&
                switch_core_media_check_nat(smh, smh->mparams->remote_ip)) {
                switch_nat_del_mapping((switch_port_t) v_engine->local_sdp_port, SWITCH_NAT_UDP);
                switch_nat_del_mapping((switch_port_t) v_engine->local_sdp_port + 1, SWITCH_NAT_UDP);
        }


        if (t_engine->media_thread) {
                switch_status_t st;

                t_engine->mh.up = 0;
                switch_thread_join(&st, t_engine->media_thread);
                t_engine->media_thread = NULL;
        }


        if (t_engine->rtp_session) {
                switch_rtp_destroy(&t_engine->rtp_session);
        } else if (t_engine->local_sdp_port) {
                switch_rtp_release_port(smh->mparams->rtpip, t_engine->local_sdp_port);
        }


        if (t_engine->local_sdp_port > 0 && !zstr(smh->mparams->remote_ip) &&
                switch_core_media_check_nat(smh, smh->mparams->remote_ip)) {
                switch_nat_del_mapping((switch_port_t) t_engine->local_sdp_port, SWITCH_NAT_UDP);
                switch_nat_del_mapping((switch_port_t) t_engine->local_sdp_port + 1, SWITCH_NAT_UDP);
        }


        if (a_engine->rtp_session) {
                switch_rtp_destroy(&a_engine->rtp_session);
        } else if (a_engine->local_sdp_port) {
                switch_rtp_release_port(smh->mparams->rtpip, a_engine->local_sdp_port);
        }

        if (a_engine->local_sdp_port > 0 && !zstr(smh->mparams->remote_ip) &&
                switch_core_media_check_nat(smh, smh->mparams->remote_ip)) {
                switch_nat_del_mapping((switch_port_t) a_engine->local_sdp_port, SWITCH_NAT_UDP);
                switch_nat_del_mapping((switch_port_t) a_engine->local_sdp_port + 1, SWITCH_NAT_UDP);
        }

}


//?
static void gen_ice(switch_core_session_t *session, switch_media_type_t type, const char *ip, switch_port_t port)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;
        char tmp[33] = "";

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        engine = &smh->engines[type];

        //#ifdef RTCP_MUX
        //if (!engine->rtcp_mux) {//  && type == SWITCH_MEDIA_TYPE_AUDIO) {
        //      engine->rtcp_mux = SWITCH_TRUE;
        //}
        //#endif

        if (!smh->msid) {
                switch_stun_random_string(tmp, 32, NULL);
                tmp[32] = '\0';
                smh->msid = switch_core_session_strdup(session, tmp);
        }

        if (!smh->cname) {
                switch_stun_random_string(tmp, 16, NULL);
                tmp[16] = '\0';
                smh->cname = switch_core_session_strdup(session, tmp);
        }

        if (type == SWITCH_MEDIA_TYPE_VIDEO && switch_channel_var_true(switch_core_session_get_channel(session), "video_use_audio_ice")) {
                switch_rtp_engine_t *audio_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];

                if (audio_engine->ice_out.ufrag) {
                        engine->ice_out.ufrag = switch_core_session_strdup(session, audio_engine->ice_out.ufrag);
                }

                if (audio_engine->ice_out.pwd) {
                        engine->ice_out.pwd = switch_core_session_strdup(session, audio_engine->ice_out.pwd);
                }
        }

        if (!engine->ice_out.ufrag) {
                switch_stun_random_string(tmp, 16, NULL);
                tmp[16] = '\0';
                engine->ice_out.ufrag = switch_core_session_strdup(session, tmp);
        }

        if (!engine->ice_out.pwd) {
                switch_stun_random_string(tmp, 24, NULL);
                tmp[24] = '\0';
                engine->ice_out.pwd = switch_core_session_strdup(session, tmp);
        }

        if (!engine->ice_out.cands[0][0].foundation) {
                switch_stun_random_string(tmp, 10, "0123456789");
                tmp[10] = '\0';
                engine->ice_out.cands[0][0].foundation = switch_core_session_strdup(session, tmp);
        }

        engine->ice_out.cands[0][0].transport = "udp";

        if (!engine->ice_out.cands[0][0].component_id) {
                engine->ice_out.cands[0][0].component_id = 1;
                engine->ice_out.cands[0][0].priority = (1<<24)*126 + (1<<8)*65535 + (1<<0)*(256 - engine->ice_out.cands[0][0].component_id);
        }

        if (!zstr(ip)) {
                engine->ice_out.cands[0][0].con_addr = switch_core_session_strdup(session, ip);
        }

        if (port) {
                engine->ice_out.cands[0][0].con_port = port;
        }

        engine->ice_out.cands[0][0].generation = "0";
        //add rport stuff later

        engine->ice_out.cands[0][0].ready = 1;


}

SWITCH_DECLARE(void) switch_core_session_wake_video_thread(switch_core_session_t *session)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *v_engine;

        if (!(smh = session->media_handle)) {
                return;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        if ((!smh->mparams->external_video_source) && (!v_engine->rtp_session)) {
                return;
        }

        if (!v_engine->media_thread) {
                return;
        }

        if (!v_engine->mh.cond_mutex) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Channel %s has no cond?\n",
                                                  switch_channel_get_name(session->channel));
                return;
        }

        if (switch_mutex_trylock(v_engine->mh.cond_mutex) == SWITCH_STATUS_SUCCESS) {
                switch_thread_cond_broadcast(v_engine->mh.cond);
                switch_mutex_unlock(v_engine->mh.cond_mutex);
        }
}

static void check_dtls_reinvite(switch_core_session_t *session, switch_rtp_engine_t *engine)
{
        if (switch_channel_test_flag(session->channel, CF_REINVITE) && engine->new_dtls) {

                if (!zstr(engine->local_dtls_fingerprint.str) && switch_rtp_has_dtls() && dtls_ok(session)) {

#ifdef HAVE_OPENSSL_DTLSv1_2_method
                        uint8_t want_DTLSv1_2 = 1;
#else
                        uint8_t want_DTLSv1_2 = 0;
#endif // HAVE_OPENSSL_DTLSv1_2_method

                        dtls_type_t xtype, dtype = engine->dtls_controller ? DTLS_TYPE_CLIENT : DTLS_TYPE_SERVER;

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "RE-SETTING %s DTLS\n", type2str(engine->type));

                        xtype = DTLS_TYPE_RTP;
                        if (engine->rtcp_mux > 0) xtype |= DTLS_TYPE_RTCP;

                        if (switch_channel_var_true(session->channel, "legacyDTLS")) {
                                switch_channel_clear_flag(session->channel, CF_WANT_DTLSv1_2);
                                want_DTLSv1_2 = 0;
                        }

                        switch_rtp_add_dtls(engine->rtp_session, &engine->local_dtls_fingerprint, &engine->remote_dtls_fingerprint, dtype | xtype, want_DTLSv1_2);

                        if (engine->rtcp_mux < 1) {
                                xtype = DTLS_TYPE_RTCP;
                                switch_rtp_add_dtls(engine->rtp_session, &engine->local_dtls_fingerprint, &engine->remote_dtls_fingerprint, dtype | xtype, want_DTLSv1_2);
                        }

                }
                engine->new_dtls = 0;
        }
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_activate_rtp(switch_core_session_t *session)

{
        const char *err = NULL;
        const char *val = NULL;
        switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID] = {0};
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        char tmp[50];
        char *timer_name = NULL;
        const char *var;
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_media_handle_t *smh;
        int is_reinvite = 0;

#ifdef HAVE_OPENSSL_DTLSv1_2_method
                        uint8_t want_DTLSv1_2 = 1;
#else
                        uint8_t want_DTLSv1_2 = 0;
#endif

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (a_engine->rtp_session || v_engine->rtp_session || t_engine->rtp_session || switch_channel_test_flag(session->channel, CF_REINVITE)) {
                is_reinvite = 1;
        }


        if (switch_channel_down(session->channel)) {
                return SWITCH_STATUS_FALSE;
        }

        switch_core_media_parse_media_flags(session);

        if (switch_rtp_ready(a_engine->rtp_session)) {
                switch_rtp_reset_media_timer(a_engine->rtp_session);
                check_media_timeout_params(session, a_engine);
                check_media_timeout_params(session, v_engine);
        }

        if (a_engine->crypto_type != CRYPTO_INVALID) {
                switch_channel_set_flag(session->channel, CF_SECURE);
        }
        
        if (want_DTLSv1_2) {
                switch_channel_set_flag(session->channel, CF_WANT_DTLSv1_2);
        }

        if (switch_channel_test_flag(session->channel, CF_PROXY_MODE)) {
                status = SWITCH_STATUS_SUCCESS;
                goto end;
        }

        if (switch_channel_var_true(session->channel, "fire_rtcp_events")) {
                flags[SWITCH_RTP_FLAG_AUDIO_FIRE_SEND_RTCP_EVENT] = 1;
                if (switch_channel_test_flag(session->channel, CF_VIDEO_POSSIBLE) && 
                                switch_channel_var_true(session->channel, "rtp_video_send_rtcp_message_event")) { 
                        flags[SWITCH_RTP_FLAG_VIDEO_FIRE_SEND_RTCP_EVENT] = 1;
                }
        }

        if (!is_reinvite) {
                if (switch_rtp_ready(a_engine->rtp_session)) {
                        if (switch_channel_test_flag(session->channel, CF_TEXT_POSSIBLE) && !switch_rtp_ready(t_engine->rtp_session)) {
                                goto text;
                        }

                        if (switch_channel_test_flag(session->channel, CF_VIDEO_POSSIBLE) && !switch_rtp_ready(v_engine->rtp_session)) {
                                goto video;
                        }

                        status = SWITCH_STATUS_SUCCESS;
                        goto end;
                }
        }

        if ((status = switch_core_media_set_codec(session, 0, smh->mparams->codec_flags)) != SWITCH_STATUS_SUCCESS) {
                goto end;
        }

        switch_core_media_set_video_codec(session, 0);

        flags[SWITCH_RTP_FLAG_DATAWAIT]++;

        if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                flags[SWITCH_RTP_FLAG_AUTOADJ]++;
        }

        if (switch_media_handle_test_media_flag(smh, SCMF_PASS_RFC2833)
                || ((val = switch_channel_get_variable(session->channel, "pass_rfc2833")) && switch_true(val))) {
                switch_channel_set_flag(session->channel, CF_PASS_RFC2833);
        }


        if (switch_media_handle_test_media_flag(smh, SCMF_AUTOFLUSH)
                || ((val = switch_channel_get_variable(session->channel, "rtp_autoflush")) && switch_true(val))) {
                flags[SWITCH_RTP_FLAG_AUTOFLUSH]++;
        }

        if (!(switch_media_handle_test_media_flag(smh, SCMF_REWRITE_TIMESTAMPS) ||
                  ((val = switch_channel_get_variable(session->channel, "rtp_rewrite_timestamps")) && switch_true(val)))) {
                flags[SWITCH_RTP_FLAG_RAW_WRITE]++;
        }

        if (switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG)) {
                smh->mparams->cng_pt = 0;
        } else if (smh->mparams->cng_pt) {
                flags[SWITCH_RTP_FLAG_AUTO_CNG]++;
        }

#if __BYTE_ORDER == __LITTLE_ENDIAN
        if (!strcasecmp(a_engine->read_impl.iananame, "L16")) {
                flags[SWITCH_RTP_FLAG_BYTESWAP]++;
        }
#endif

        if ((flags[SWITCH_RTP_FLAG_BYTESWAP]) && (val = switch_channel_get_variable(session->channel, "rtp_disable_byteswap")) && switch_true(val)) {
                flags[SWITCH_RTP_FLAG_BYTESWAP] = 0;
        }

        if (a_engine->rtp_session && is_reinvite) {
                //const char *ip = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE);
                //const char *port = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE);
                char *remote_host = switch_rtp_get_remote_host(a_engine->rtp_session);
                switch_port_t remote_port = switch_rtp_get_remote_port(a_engine->rtp_session);

                if (remote_host && remote_port && !strcmp(remote_host, a_engine->cur_payload_map->remote_sdp_ip) &&
                        remote_port == a_engine->cur_payload_map->remote_sdp_port) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Audio params are unchanged for %s.\n",
                                                          switch_channel_get_name(session->channel));
                        a_engine->cur_payload_map->negotiated = 1;
                        //XX
                        goto video;
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Audio params changed for %s from %s:%d to %s:%d\n",
                                                          switch_channel_get_name(session->channel),
                                                          remote_host, remote_port, a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);

                        switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->cur_payload_map->remote_sdp_port);
                        switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->cur_payload_map->remote_sdp_ip);
                        switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE, tmp);
                        switch_channel_execute_on(session->channel, "execute_on_audio_change");
                }
        }

        if (!switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "AUDIO RTP [%s] %s port %d -> %s port %d codec: %u ms: %d\n",
                                                  switch_channel_get_name(session->channel),
                                                  a_engine->local_sdp_ip,
                                                  a_engine->local_sdp_port,
                                                  a_engine->cur_payload_map->remote_sdp_ip,
                                                  a_engine->cur_payload_map->remote_sdp_port, a_engine->cur_payload_map->pt, a_engine->read_impl.microseconds_per_packet / 1000);

                //XX
        }

        switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->local_sdp_port);
        switch_channel_set_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE, a_engine->local_sdp_ip);
        switch_channel_set_variable(session->channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE, tmp);
        switch_channel_set_variable(session->channel, SWITCH_ADVERTISED_MEDIA_IP_VARIABLE, a_engine->adv_sdp_ip);

        if (a_engine->rtp_session && is_reinvite) {
                const char *rport = NULL;
                switch_port_t remote_rtcp_port = a_engine->remote_rtcp_port;

                if (!remote_rtcp_port) {
                        if ((rport = switch_channel_get_variable(session->channel, "rtp_remote_audio_rtcp_port"))) {
                                remote_rtcp_port = (switch_port_t)atoi(rport);
                        }
                }

                if (switch_rtp_set_remote_address(a_engine->rtp_session, a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port,
                                                                                  remote_rtcp_port, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "AUDIO RTP REPORTS ERROR: [%s]\n", err);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "AUDIO RTP CHANGING DEST TO: [%s:%d]\n",
                                                          a_engine->cur_payload_map->remote_sdp_ip, a_engine->cur_payload_map->remote_sdp_port);

                        //if (switch_channel_test_flag(session->channel, CF_PROTO_HOLD) && strcmp(a_engine->cur_payload_map->remote_sdp_ip, "0.0.0.0")) {
                        //      switch_core_media_toggle_hold(session, 0);
                        //}


                        if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) &&
                                !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) &&
                                !switch_channel_test_flag(session->channel, CF_AVPF)) {
                                /* Reactivate the NAT buster flag. */
                                switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                        }
                }

                if (session && a_engine) {
                        check_dtls_reinvite(session, a_engine);
                }

                goto video;
        }

        if (switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                switch_core_media_proxy_remote_addr(session, NULL);

                memset(flags, 0, sizeof(flags));
                flags[SWITCH_RTP_FLAG_DATAWAIT]++;
                flags[SWITCH_RTP_FLAG_PROXY_MEDIA]++;

                if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                        !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                        flags[SWITCH_RTP_FLAG_AUTOADJ]++;
                }

                timer_name = NULL;

                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                  "PROXY AUDIO RTP [%s] %s:%d->%s:%d codec: %u ms: %d\n",
                                                  switch_channel_get_name(session->channel),
                                                  a_engine->cur_payload_map->remote_sdp_ip,
                                                  a_engine->cur_payload_map->remote_sdp_port,
                                                  a_engine->cur_payload_map->remote_sdp_ip,
                                                  a_engine->cur_payload_map->remote_sdp_port, a_engine->cur_payload_map->pt, a_engine->read_impl.microseconds_per_packet / 1000);

                if (switch_rtp_ready(a_engine->rtp_session)) {
                        switch_rtp_set_default_payload(a_engine->rtp_session, a_engine->cur_payload_map->pt);
                }

        } else {
                timer_name = smh->mparams->timer_name;

                if ((var = switch_channel_get_variable(session->channel, "rtp_timer_name"))) {
                        timer_name = (char *) var;
                }
        }


        if (switch_channel_up(session->channel)) {
                switch_channel_set_variable(session->channel, "rtp_use_timer_name", timer_name);

                a_engine->rtp_session = switch_rtp_new(a_engine->local_sdp_ip,
                                                                                           a_engine->local_sdp_port,
                                                                                           a_engine->cur_payload_map->remote_sdp_ip,
                                                                                           a_engine->cur_payload_map->remote_sdp_port,
                                                                                           a_engine->cur_payload_map->pt,
                                                                                           strcasecmp("opus", a_engine->read_impl.iananame) ? a_engine->read_impl.samples_per_packet : 
                                                                                           a_engine->read_impl.samples_per_second * (a_engine->read_impl.microseconds_per_packet / 1000) / 1000,
                                                                                           a_engine->cur_payload_map->codec_ms * 1000,
                                                                                           flags, timer_name, &err, switch_core_session_get_pool(session),
                                                                                           0, 0);

                if (switch_rtp_ready(a_engine->rtp_session)) {
                        switch_rtp_set_payload_map(a_engine->rtp_session, &a_engine->payload_map);
                }
        }

        if (switch_rtp_ready(a_engine->rtp_session)) {
                uint8_t vad_in = (smh->mparams->vflags & VAD_IN);
                uint8_t vad_out = (smh->mparams->vflags & VAD_OUT);
                uint8_t inb = switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND;
                const char *ssrc;

                switch_mutex_init(&smh->read_mutex[SWITCH_MEDIA_TYPE_AUDIO], SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
                switch_mutex_init(&smh->write_mutex[SWITCH_MEDIA_TYPE_AUDIO], SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));

                //switch_core_media_set_rtp_session(session, SWITCH_MEDIA_TYPE_AUDIO, a_engine->rtp_session);

                if ((ssrc = switch_channel_get_variable(session->channel, "rtp_use_ssrc"))) {
                        uint32_t ssrc_ul = (uint32_t) strtoul(ssrc, NULL, 10);
                        switch_rtp_set_ssrc(a_engine->rtp_session, ssrc_ul);
                        a_engine->ssrc = ssrc_ul;
                } else {
                        switch_rtp_set_ssrc(a_engine->rtp_session, a_engine->ssrc);
                }

                if (a_engine->remote_ssrc) {
                        switch_rtp_set_remote_ssrc(a_engine->rtp_session, a_engine->remote_ssrc);
                }

                check_media_timeout_params(session, a_engine);

                switch_channel_set_flag(session->channel, CF_FS_RTP);

                switch_channel_set_variable_printf(session->channel, "rtp_use_pt", "%d", a_engine->cur_payload_map->pt);

                if ((val = switch_channel_get_variable(session->channel, "rtp_enable_vad_in")) && switch_true(val)) {
                        vad_in = 1;
                }
                if ((val = switch_channel_get_variable(session->channel, "rtp_enable_vad_out")) && switch_true(val)) {
                        vad_out = 1;
                }

                if ((val = switch_channel_get_variable(session->channel, "rtp_disable_vad_in")) && switch_true(val)) {
                        vad_in = 0;
                }
                if ((val = switch_channel_get_variable(session->channel, "rtp_disable_vad_out")) && switch_true(val)) {
                        vad_out = 0;
                }


                a_engine->ssrc = switch_rtp_get_ssrc(a_engine->rtp_session);
                switch_channel_set_variable_printf(session->channel, "rtp_use_ssrc", "%u", a_engine->ssrc);



                if (smh->mparams->auto_rtp_bugs & RTP_BUG_IGNORE_MARK_BIT) {
                        a_engine->rtp_bugs |= RTP_BUG_IGNORE_MARK_BIT;
                }

                if ((val = switch_channel_get_variable(session->channel, "rtp_manual_rtp_bugs"))) {
                        switch_core_media_parse_rtp_bugs(&a_engine->rtp_bugs, val);
                }

                //if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                //      smh->mparams->manual_rtp_bugs = RTP_BUG_SEND_LINEAR_TIMESTAMPS;
                //}

                switch_rtp_intentional_bugs(a_engine->rtp_session, a_engine->rtp_bugs | smh->mparams->manual_rtp_bugs);

                if ((vad_in && inb) || (vad_out && !inb)) {
                        switch_rtp_enable_vad(a_engine->rtp_session, session, &a_engine->read_codec, SWITCH_VAD_FLAG_TALKING | SWITCH_VAD_FLAG_EVENTS_TALK | SWITCH_VAD_FLAG_EVENTS_NOTALK);

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "AUDIO RTP Engage VAD for %s ( %s %s )\n",
                                                          switch_channel_get_name(switch_core_session_get_channel(session)), vad_in ? "in" : "", vad_out ? "out" : "");
                }


                if (a_engine->ice_in.cands[a_engine->ice_in.chosen[0]][0].ready) {

                        gen_ice(session, SWITCH_MEDIA_TYPE_AUDIO, NULL, 0);

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating Audio ICE\n");

                        switch_rtp_activate_ice(a_engine->rtp_session,
                                                                        a_engine->ice_in.ufrag,
                                                                        a_engine->ice_out.ufrag,
                                                                        a_engine->ice_out.pwd,
                                                                        a_engine->ice_in.pwd,
                                                                        IPR_RTP,
#ifdef GOOGLE_ICE
                                                                        ICE_GOOGLE_JINGLE,
                                                                        NULL
#else
                                                                        switch_determine_ice_type(a_engine, session),
                                                                        &a_engine->ice_in
#endif
                                                                        );



                }

                if ((val = switch_channel_get_variable(session->channel, "rtcp_audio_interval_msec")) || (val = smh->mparams->rtcp_audio_interval_msec)) {
                        const char *rport = switch_channel_get_variable(session->channel, "rtp_remote_audio_rtcp_port");
                        switch_port_t remote_rtcp_port = a_engine->remote_rtcp_port;

                        if (!remote_rtcp_port && rport) {
                                remote_rtcp_port = (switch_port_t)atoi(rport);
                        }

                        if (!strcasecmp(val, "passthru")) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating RTCP PASSTHRU PORT %d\n", remote_rtcp_port);
                                switch_rtp_activate_rtcp(a_engine->rtp_session, -1, remote_rtcp_port, a_engine->rtcp_mux > 0);
                        } else {
                                int interval = atoi(val);
                                if (interval < 100 || interval > 500000) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                                                                          "Invalid rtcp interval spec [%d] must be between 100 and 500000\n", interval);
                                        interval = 5000;
                                }

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Activating RTCP PORT %d\n", remote_rtcp_port);
                                switch_rtp_activate_rtcp(a_engine->rtp_session, interval, remote_rtcp_port, a_engine->rtcp_mux > 0);

                        }

                        if (a_engine->ice_in.cands[a_engine->ice_in.chosen[1]][1].ready && a_engine->ice_in.cands[a_engine->ice_in.chosen[0]][0].ready &&
                                !zstr(a_engine->ice_in.cands[a_engine->ice_in.chosen[1]][1].con_addr) && 
                                !zstr(a_engine->ice_in.cands[a_engine->ice_in.chosen[0]][0].con_addr)) {
                                if (a_engine->rtcp_mux > 0 && 
                                        !strcmp(a_engine->ice_in.cands[a_engine->ice_in.chosen[1]][1].con_addr, a_engine->ice_in.cands[a_engine->ice_in.chosen[0]][0].con_addr)
                                        && a_engine->ice_in.cands[a_engine->ice_in.chosen[1]][1].con_port == a_engine->ice_in.cands[a_engine->ice_in.chosen[0]][0].con_port) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Skipping RTCP ICE (Same as RTP)\n");
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating RTCP ICE\n");

                                        switch_rtp_activate_ice(a_engine->rtp_session,
                                                                                        a_engine->ice_in.ufrag,
                                                                                        a_engine->ice_out.ufrag,
                                                                                        a_engine->ice_out.pwd,
                                                                                        a_engine->ice_in.pwd,
                                                                                        IPR_RTCP,
#ifdef GOOGLE_ICE
                                                                                        ICE_GOOGLE_JINGLE,
                                                                                        NULL
#else
                                                                                        switch_determine_ice_type(a_engine, session),
                                                                                        &a_engine->ice_in
#endif
                                                                                );
                                }

                        }
                }

                if (!zstr(a_engine->local_dtls_fingerprint.str) && switch_rtp_has_dtls() && dtls_ok(smh->session)) {
                        dtls_type_t xtype, dtype = a_engine->dtls_controller ? DTLS_TYPE_CLIENT : DTLS_TYPE_SERVER;

                        //if (switch_channel_test_flag(smh->session->channel, CF_3PCC)) {
                        //      dtype = (dtype == DTLS_TYPE_CLIENT) ? DTLS_TYPE_SERVER : DTLS_TYPE_CLIENT;
                        //}

                        xtype = DTLS_TYPE_RTP;
                        if (a_engine->rtcp_mux > 0 && smh->mparams->rtcp_audio_interval_msec) xtype |= DTLS_TYPE_RTCP;

                        if (switch_channel_var_true(session->channel, "legacyDTLS")) {
                                switch_channel_clear_flag(session->channel, CF_WANT_DTLSv1_2);
                                want_DTLSv1_2 = 0;
                        }

                        switch_rtp_add_dtls(a_engine->rtp_session, &a_engine->local_dtls_fingerprint, &a_engine->remote_dtls_fingerprint, dtype | xtype, want_DTLSv1_2);

                        if (a_engine->rtcp_mux < 1 && smh->mparams->rtcp_audio_interval_msec) {
                                xtype = DTLS_TYPE_RTCP;
                                switch_rtp_add_dtls(a_engine->rtp_session, &a_engine->local_dtls_fingerprint, &a_engine->remote_dtls_fingerprint, dtype | xtype, want_DTLSv1_2);
                        }

                }

                check_jb(session, NULL, 0, 0, SWITCH_FALSE);

                if ((val = switch_channel_get_variable(session->channel, "rtp_timeout_sec"))) {
                        int v = atoi(val);
                        if (v >= 0) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                  "rtp_timeout_sec deprecated use media_timeout variable.\n"); 
                                smh->mparams->rtp_timeout_sec = v;
                        }
                }

                if ((val = switch_channel_get_variable(session->channel, "rtp_hold_timeout_sec"))) {
                        int v = atoi(val);
                        if (v >= 0) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                  "rtp_hold_timeout_sec deprecated use media_hold_timeout variable.\n"); 
                                smh->mparams->rtp_hold_timeout_sec = v;
                        }
                }

                if (smh->mparams->rtp_timeout_sec) {
                        a_engine->max_missed_packets = (a_engine->read_impl.samples_per_second * smh->mparams->rtp_timeout_sec) / a_engine->read_impl.samples_per_packet;

                        switch_rtp_set_max_missed_packets(a_engine->rtp_session, a_engine->max_missed_packets);
                        if (!smh->mparams->rtp_hold_timeout_sec) {
                                smh->mparams->rtp_hold_timeout_sec = smh->mparams->rtp_timeout_sec * 10;
                        }
                }

                if (smh->mparams->rtp_hold_timeout_sec) {
                        a_engine->max_missed_hold_packets = (a_engine->read_impl.samples_per_second * smh->mparams->rtp_hold_timeout_sec) / a_engine->read_impl.samples_per_packet;
                }

                if (smh->mparams->te) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Set 2833 dtmf send payload to %u\n",
                                                          switch_channel_get_name(session->channel), smh->mparams->te);
                        switch_rtp_set_telephony_event(a_engine->rtp_session, smh->mparams->te);
                        switch_channel_set_variable_printf(session->channel, "rtp_2833_send_payload", "%d", smh->mparams->te);
                }

                if (smh->mparams->recv_te) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Set 2833 dtmf receive payload to %u\n",
                                                          switch_channel_get_name(session->channel), smh->mparams->recv_te);
                        switch_rtp_set_telephony_recv_event(a_engine->rtp_session, smh->mparams->recv_te);
                        switch_channel_set_variable_printf(session->channel, "rtp_2833_recv_payload", "%d", smh->mparams->recv_te);
                }

                //XX

                if (switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) ||
                        ((val = switch_channel_get_variable(session->channel, "supress_cng")) && switch_true(val)) ||
                        ((val = switch_channel_get_variable(session->channel, "suppress_cng")) && switch_true(val))) {
                        smh->mparams->cng_pt = 0;
                }

                if (((val = switch_channel_get_variable(session->channel, "rtp_digit_delay")))) {
                        int delayi = atoi(val);
                        if (delayi < 0) delayi = 0;
                        smh->mparams->dtmf_delay = (uint32_t) delayi;
                }


                if (smh->mparams->dtmf_delay) {
                        switch_rtp_set_interdigit_delay(a_engine->rtp_session, smh->mparams->dtmf_delay);
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                          "%s Set rtp dtmf delay to %u\n", switch_channel_get_name(session->channel), smh->mparams->dtmf_delay);

                }

                if (smh->mparams->cng_pt && !switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Set comfort noise payload to %u\n", smh->mparams->cng_pt);
                        switch_rtp_set_cng_pt(a_engine->rtp_session, smh->mparams->cng_pt);
                }

                switch_core_session_apply_crypto(session, SWITCH_MEDIA_TYPE_AUDIO);

                switch_snprintf(tmp, sizeof(tmp), "%d", a_engine->cur_payload_map->remote_sdp_port);
                switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE, a_engine->cur_payload_map->remote_sdp_ip);
                switch_channel_set_variable(session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE, tmp);


        text:

                //if (switch_channel_test_flag(session->channel, CF_MSRP)) { // skip RTP RTT
                //      goto video;
                //}

                if (!t_engine->cur_payload_map) {
                        goto text_up;
                }

                if (switch_channel_test_flag(session->channel, CF_TEXT_POSSIBLE) && t_engine->cur_payload_map->rm_encoding && t_engine->cur_payload_map->remote_sdp_port) {
                        /******************************************************************************************/
                        if (t_engine->rtp_session && is_reinvite) {
                                //const char *ip = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE);
                                //const char *port = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE);
                                char *remote_host = switch_rtp_get_remote_host(t_engine->rtp_session);
                                switch_port_t remote_port = switch_rtp_get_remote_port(t_engine->rtp_session);



                                if (remote_host && remote_port && !strcmp(remote_host, t_engine->cur_payload_map->remote_sdp_ip) && remote_port == t_engine->cur_payload_map->remote_sdp_port) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Text params are unchanged for %s.\n",
                                                                          switch_channel_get_name(session->channel));
                                        t_engine->cur_payload_map->negotiated = 1;
                                        goto text_up;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Text params changed for %s from %s:%d to %s:%d\n",
                                                                          switch_channel_get_name(session->channel),
                                                                          remote_host, remote_port, t_engine->cur_payload_map->remote_sdp_ip, t_engine->cur_payload_map->remote_sdp_port);
                                }
                        }

                        if (!switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                                if (switch_rtp_ready(t_engine->rtp_session)) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "TEXT RTP [%s] %s port %d -> %s port %d codec: %u\n", switch_channel_get_name(session->channel),
                                                                          t_engine->local_sdp_ip, t_engine->local_sdp_port, t_engine->cur_payload_map->remote_sdp_ip,
                                                                          t_engine->cur_payload_map->remote_sdp_port, t_engine->cur_payload_map->pt);

                                        switch_rtp_set_default_payload(t_engine->rtp_session, t_engine->cur_payload_map->pt);
                                }
                        }

                        switch_snprintf(tmp, sizeof(tmp), "%d", t_engine->local_sdp_port);
                        switch_channel_set_variable(session->channel, SWITCH_LOCAL_TEXT_IP_VARIABLE, a_engine->adv_sdp_ip);
                        switch_channel_set_variable(session->channel, SWITCH_LOCAL_TEXT_PORT_VARIABLE, tmp);


                        if (t_engine->rtp_session && is_reinvite) {
                                const char *rport = NULL;
                                switch_port_t remote_rtcp_port = t_engine->remote_rtcp_port;

                                //switch_channel_clear_flag(session->channel, CF_REINVITE);

                                if (!remote_rtcp_port) {
                                        if ((rport = switch_channel_get_variable(session->channel, "rtp_remote_text_rtcp_port"))) {
                                                remote_rtcp_port = (switch_port_t)atoi(rport);
                                        }
                                }

                                if (switch_rtp_set_remote_address
                                        (t_engine->rtp_session, t_engine->cur_payload_map->remote_sdp_ip, t_engine->cur_payload_map->remote_sdp_port, remote_rtcp_port, SWITCH_TRUE,
                                         &err) != SWITCH_STATUS_SUCCESS) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "TEXT RTP REPORTS ERROR: [%s]\n", err);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "TEXT RTP CHANGING DEST TO: [%s:%d]\n",
                                                                          t_engine->cur_payload_map->remote_sdp_ip, t_engine->cur_payload_map->remote_sdp_port);
                                        if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                                                !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                                                /* Reactivate the NAT buster flag. */
                                                switch_rtp_set_flag(t_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                                        }

                                }
                                goto text_up;
                        }

                        if (switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                                switch_core_media_proxy_remote_addr(session, NULL);

                                memset(flags, 0, sizeof(flags));
                                flags[SWITCH_RTP_FLAG_PROXY_MEDIA]++;
                                flags[SWITCH_RTP_FLAG_DATAWAIT]++;

                                if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                                        !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                                        flags[SWITCH_RTP_FLAG_AUTOADJ]++;
                                }

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                  "PROXY TEXT RTP [%s] %s:%d->%s:%d codec: %u ms: %d\n",
                                                                  switch_channel_get_name(session->channel),
                                                                  a_engine->cur_payload_map->remote_sdp_ip,
                                                                  t_engine->local_sdp_port,
                                                                  t_engine->cur_payload_map->remote_sdp_ip,
                                                                  t_engine->cur_payload_map->remote_sdp_port, t_engine->cur_payload_map->pt, t_engine->read_impl.microseconds_per_packet / 1000);

                                if (switch_rtp_ready(t_engine->rtp_session)) {
                                        switch_rtp_set_default_payload(t_engine->rtp_session, t_engine->cur_payload_map->pt);
                                }
                        }

                        /******************************************************************************************/

                        if (t_engine->rtp_session) {
                                goto text_up;
                        }


                        if (!t_engine->local_sdp_port) {
                                switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_TEXT, 1);
                        }

                        memset(flags, 0, sizeof(flags));
                        flags[SWITCH_RTP_FLAG_DATAWAIT]++;
                        flags[SWITCH_RTP_FLAG_RAW_WRITE]++;

                        if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_PROXY_MODE) &&
                                !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) &&
                                !switch_channel_test_flag(session->channel, CF_AVPF)) {
                                flags[SWITCH_RTP_FLAG_AUTOADJ]++;
                        }

                        if (switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                                flags[SWITCH_RTP_FLAG_PROXY_MEDIA]++;
                        }
                        //TEXT switch_core_media_set_text_codec(session, 0);

                        flags[SWITCH_RTP_FLAG_USE_TIMER] = 1;
                        flags[SWITCH_RTP_FLAG_NOBLOCK] = 0;
                        flags[SWITCH_RTP_FLAG_TEXT]++;
                        //flags[SWITCH_RTP_FLAG_VIDEO]++;

                        t_engine->rtp_session = switch_rtp_new(a_engine->local_sdp_ip,
                                                                                                   t_engine->local_sdp_port,
                                                                                                   t_engine->cur_payload_map->remote_sdp_ip,
                                                                                                   t_engine->cur_payload_map->remote_sdp_port,
                                                                                                   t_engine->cur_payload_map->pt,
                                                                                                   TEXT_TIMER_SAMPLES, TEXT_TIMER_MS * 1000, flags, NULL, &err, switch_core_session_get_pool(session),
                                                                                                   0, 0);


                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%sTEXT RTP [%s] %s:%d->%s:%d codec: %u ms: %d [%s]\n",
                                                          switch_channel_test_flag(session->channel, CF_PROXY_MEDIA) ? "PROXY " : "",
                                                          switch_channel_get_name(session->channel),
                                                          a_engine->local_sdp_ip,
                                                          t_engine->local_sdp_port,
                                                          t_engine->cur_payload_map->remote_sdp_ip,
                                                          t_engine->cur_payload_map->remote_sdp_port, t_engine->cur_payload_map->pt,
                                                          0, switch_rtp_ready(t_engine->rtp_session) ? "SUCCESS" : err);


                        if (switch_rtp_ready(t_engine->rtp_session)) {
                                const char *ssrc;


                                if (!t_engine->tf) {
                                        switch_rtp_text_factory_create(&t_engine->tf, switch_core_session_get_pool(session));
                                }

                                switch_rtp_set_video_buffer_size(t_engine->rtp_session, 2, 2048);

                                switch_rtp_set_payload_map(t_engine->rtp_session, &t_engine->payload_map);
                                switch_channel_set_flag(session->channel, CF_HAS_TEXT);
                                switch_core_session_start_text_thread(session);

                                if ((ssrc = switch_channel_get_variable(session->channel, "rtp_use_text_ssrc"))) {
                                        uint32_t ssrc_ul = (uint32_t) strtoul(ssrc, NULL, 10);
                                        switch_rtp_set_ssrc(t_engine->rtp_session, ssrc_ul);
                                        t_engine->ssrc = ssrc_ul;
                                } else {
                                        switch_rtp_set_ssrc(t_engine->rtp_session, t_engine->ssrc);
                                }

                                if (t_engine->remote_ssrc) {
                                        switch_rtp_set_remote_ssrc(t_engine->rtp_session, t_engine->remote_ssrc);
                                }

                                if (t_engine->ice_in.cands[t_engine->ice_in.chosen[0]][0].ready) {

                                        gen_ice(session, SWITCH_MEDIA_TYPE_TEXT, NULL, 0);

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating Text ICE\n");

                                        switch_rtp_activate_ice(t_engine->rtp_session,
                                                                                        t_engine->ice_in.ufrag,
                                                                                        t_engine->ice_out.ufrag,
                                                                                        t_engine->ice_out.pwd,
                                                                                        t_engine->ice_in.pwd,
                                                                                        IPR_RTP,
#ifdef GOOGLE_ICE
                                                                                        ICE_GOOGLE_JINGLE,
                                                                                        NULL
#else
                                                                                        switch_determine_ice_type(t_engine, session),
                                                                                        &t_engine->ice_in
#endif
                                                                                        );


                                }

                                if ((val = switch_channel_get_variable(session->channel, "rtcp_text_interval_msec")) || (val = smh->mparams->rtcp_text_interval_msec)) {
                                        const char *rport = switch_channel_get_variable(session->channel, "rtp_remote_text_rtcp_port");
                                        switch_port_t remote_port = t_engine->remote_rtcp_port;

                                        if (rport) {
                                                remote_port = (switch_port_t)atoi(rport);
                                        }
                                        if (!strcasecmp(val, "passthru")) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating TEXT RTCP PASSTHRU PORT %d\n", remote_port);
                                                switch_rtp_activate_rtcp(t_engine->rtp_session, -1, remote_port, t_engine->rtcp_mux > 0);
                                        } else {
                                                int interval = atoi(val);
                                                if (interval < 100 || interval > 500000) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                                                                                          "Invalid rtcp interval spec [%d] must be between 100 and 500000\n", interval);
                                                        interval = 5000;
                                                }
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO,
                                                                                  "Activating TEXT RTCP PORT %d interval %d mux %d\n", remote_port, interval, t_engine->rtcp_mux);
                                                switch_rtp_activate_rtcp(t_engine->rtp_session, interval, remote_port, t_engine->rtcp_mux > 0);

                                        }


                                        if (t_engine->ice_in.cands[t_engine->ice_in.chosen[1]][1].ready && t_engine->ice_in.cands[t_engine->ice_in.chosen[0]][0].ready &&
                                                !zstr(t_engine->ice_in.cands[t_engine->ice_in.chosen[1]][1].con_addr) && 
                                                !zstr(t_engine->ice_in.cands[t_engine->ice_in.chosen[0]][0].con_addr)) {
                                                if (t_engine->rtcp_mux > 0 && !strcmp(t_engine->ice_in.cands[t_engine->ice_in.chosen[1]][1].con_addr,
                                                                                                                          t_engine->ice_in.cands[t_engine->ice_in.chosen[0]][0].con_addr) &&
                                                        t_engine->ice_in.cands[t_engine->ice_in.chosen[1]][1].con_port == t_engine->ice_in.cands[t_engine->ice_in.chosen[0]][0].con_port) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Skipping TEXT RTCP ICE (Same as TEXT RTP)\n");
                                                } else {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating TEXT RTCP ICE\n");
                                                        switch_rtp_activate_ice(t_engine->rtp_session,
                                                                                                        t_engine->ice_in.ufrag,
                                                                                                        t_engine->ice_out.ufrag,
                                                                                                        t_engine->ice_out.pwd,
                                                                                                        t_engine->ice_in.pwd,
                                                                                                        IPR_RTCP,
#ifdef GOOGLE_ICE
                                                                                                        ICE_GOOGLE_JINGLE,
                                                                                                        NULL
#else
                                                                                                        switch_determine_ice_type(t_engine, session),
                                                                                                        &t_engine->ice_in
#endif
                                                                                                        );



                                                }

                                        }
                                }

                                if (!zstr(t_engine->local_dtls_fingerprint.str) && switch_rtp_has_dtls() && dtls_ok(smh->session)) {
                                        dtls_type_t xtype,
                                                dtype = t_engine->dtls_controller ? DTLS_TYPE_CLIENT : DTLS_TYPE_SERVER;
                                        xtype = DTLS_TYPE_RTP;
                                        if (t_engine->rtcp_mux > 0 && smh->mparams->rtcp_text_interval_msec) xtype |= DTLS_TYPE_RTCP;
                        
                                        if (switch_channel_var_true(session->channel, "legacyDTLS")) {
                                                switch_channel_clear_flag(session->channel, CF_WANT_DTLSv1_2);
                                                want_DTLSv1_2 = 0;
                                        }

                                        switch_rtp_add_dtls(t_engine->rtp_session, &t_engine->local_dtls_fingerprint, &t_engine->remote_dtls_fingerprint, dtype | xtype, want_DTLSv1_2);

                                        if (t_engine->rtcp_mux < 1 && smh->mparams->rtcp_text_interval_msec) {
                                                xtype = DTLS_TYPE_RTCP;
                                                switch_rtp_add_dtls(t_engine->rtp_session, &t_engine->local_dtls_fingerprint, &t_engine->remote_dtls_fingerprint, dtype | xtype, want_DTLSv1_2);
                                        }
                                }


                                if ((val = switch_channel_get_variable(session->channel, "rtp_manual_text_rtp_bugs"))) {
                                        switch_core_media_parse_rtp_bugs(&t_engine->rtp_bugs, val);
                                }


                                //if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                                        //smh->mparams->manual_video_rtp_bugs = RTP_BUG_SEND_LINEAR_TIMESTAMPS;
                                //}

                                switch_rtp_intentional_bugs(t_engine->rtp_session, t_engine->rtp_bugs | smh->mparams->manual_text_rtp_bugs);

                                //XX


                                switch_channel_set_variable_printf(session->channel, "rtp_use_text_pt", "%d", t_engine->cur_payload_map->pt);
                                t_engine->ssrc = switch_rtp_get_ssrc(t_engine->rtp_session);
                                switch_channel_set_variable_printf(session->channel, "rtp_use_text_ssrc", "%u", t_engine->ssrc);

                                switch_core_session_apply_crypto(session, SWITCH_MEDIA_TYPE_TEXT);

                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "TEXT RTP REPORTS ERROR: [%s]\n", switch_str_nil(err));
                                switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                goto end;
                        }
                }


        text_up:
        video:

                if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
                        switch_core_media_check_video_codecs(session);
                }

                if (switch_channel_test_flag(session->channel, CF_VIDEO_POSSIBLE) && v_engine->cur_payload_map->rm_encoding && v_engine->cur_payload_map->remote_sdp_port) {
                        /******************************************************************************************/
                        if (v_engine->rtp_session && is_reinvite) {
                                //const char *ip = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE);
                                //const char *port = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE);
                                char *remote_host = switch_rtp_get_remote_host(v_engine->rtp_session);
                                switch_port_t remote_port = switch_rtp_get_remote_port(v_engine->rtp_session);



                                if (remote_host && remote_port && !strcmp(remote_host, v_engine->cur_payload_map->remote_sdp_ip) && remote_port == v_engine->cur_payload_map->remote_sdp_port) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Video params are unchanged for %s.\n",
                                                                          switch_channel_get_name(session->channel));
                                        v_engine->cur_payload_map->negotiated = 1;
                                        goto video_up;
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Video params changed for %s from %s:%d to %s:%d\n",
                                                                          switch_channel_get_name(session->channel),
                                                                          remote_host, remote_port, v_engine->cur_payload_map->remote_sdp_ip, v_engine->cur_payload_map->remote_sdp_port);
                                }
                        }

                        if (!switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                                if (switch_rtp_ready(v_engine->rtp_session)) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "VIDEO RTP [%s] %s port %d -> %s port %d codec: %u\n", switch_channel_get_name(session->channel),
                                                                          v_engine->local_sdp_ip, v_engine->local_sdp_port, v_engine->cur_payload_map->remote_sdp_ip,
                                                                          v_engine->cur_payload_map->remote_sdp_port, v_engine->cur_payload_map->pt);

                                        switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->pt);
                                }
                        }

                        switch_snprintf(tmp, sizeof(tmp), "%d", v_engine->local_sdp_port);
                        switch_channel_set_variable(session->channel, SWITCH_LOCAL_VIDEO_IP_VARIABLE, a_engine->adv_sdp_ip);
                        switch_channel_set_variable(session->channel, SWITCH_LOCAL_VIDEO_PORT_VARIABLE, tmp);


                        if (v_engine->rtp_session && is_reinvite) {
                                const char *rport = NULL;
                                switch_port_t remote_rtcp_port = v_engine->remote_rtcp_port;

                                //switch_channel_clear_flag(session->channel, CF_REINVITE);

                                if (!remote_rtcp_port) {
                                        if ((rport = switch_channel_get_variable(session->channel, "rtp_remote_video_rtcp_port"))) {
                                                remote_rtcp_port = (switch_port_t)atoi(rport);
                                        }
                                }

                                if (switch_rtp_set_remote_address
                                        (v_engine->rtp_session, v_engine->cur_payload_map->remote_sdp_ip, v_engine->cur_payload_map->remote_sdp_port, remote_rtcp_port, SWITCH_TRUE,
                                         &err) != SWITCH_STATUS_SUCCESS) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "VIDEO RTP REPORTS ERROR: [%s]\n", err);
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "VIDEO RTP CHANGING DEST TO: [%s:%d]\n",
                                                                          v_engine->cur_payload_map->remote_sdp_ip, v_engine->cur_payload_map->remote_sdp_port);
                                        if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                                                !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                                                /* Reactivate the NAT buster flag. */
                                                switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                                        }

                                }
                                goto video_up;
                        }

                        if (switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                                switch_core_media_proxy_remote_addr(session, NULL);

                                memset(flags, 0, sizeof(flags));
                                flags[SWITCH_RTP_FLAG_PROXY_MEDIA]++;
                                flags[SWITCH_RTP_FLAG_DATAWAIT]++;

                                if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                                        !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val))) {
                                        flags[SWITCH_RTP_FLAG_AUTOADJ]++;
                                }

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                  "PROXY VIDEO RTP [%s] %s:%d->%s:%d codec: %u ms: %d\n",
                                                                  switch_channel_get_name(session->channel),
                                                                  a_engine->cur_payload_map->remote_sdp_ip,
                                                                  v_engine->local_sdp_port,
                                                                  v_engine->cur_payload_map->remote_sdp_ip,
                                                                  v_engine->cur_payload_map->remote_sdp_port, v_engine->cur_payload_map->pt, v_engine->read_impl.microseconds_per_packet / 1000);

                                if (switch_rtp_ready(v_engine->rtp_session)) {
                                        switch_rtp_set_default_payload(v_engine->rtp_session, v_engine->cur_payload_map->pt);
                                }
                        }

                        /******************************************************************************************/

                        if (v_engine->rtp_session) {
                                goto video_up;
                        }


                        if (!v_engine->local_sdp_port) {
                                switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 1);
                        }

                        memset(flags, 0, sizeof(flags));
                        flags[SWITCH_RTP_FLAG_DATAWAIT]++;
                        flags[SWITCH_RTP_FLAG_RAW_WRITE]++;

                        if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_PROXY_MODE) &&
                                !((val = switch_channel_get_variable(session->channel, "disable_rtp_auto_adjust")) && switch_true(val)) &&
                                !switch_channel_test_flag(session->channel, CF_AVPF)) {
                                flags[SWITCH_RTP_FLAG_AUTOADJ]++;
                        }

                        if (switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                                flags[SWITCH_RTP_FLAG_PROXY_MEDIA]++;
                        }
                        switch_core_media_set_video_codec(session, 0);

                        flags[SWITCH_RTP_FLAG_USE_TIMER] = 0;
                        flags[SWITCH_RTP_FLAG_NOBLOCK] = 0;
                        flags[SWITCH_RTP_FLAG_VIDEO]++;

                        if (v_engine->fir) {
                                flags[SWITCH_RTP_FLAG_FIR]++;
                        }

                        if (v_engine->pli) {
                                flags[SWITCH_RTP_FLAG_PLI]++;
                        }

                        if ((v_engine->nack) && !switch_channel_var_true(session->channel, "rtp_video_nack_disable")) { 
                                flags[SWITCH_RTP_FLAG_NACK]++;
                        }

                        if (v_engine->tmmbr) {
                                flags[SWITCH_RTP_FLAG_TMMBR]++;
                        }
                        
                        v_engine->rtp_session = switch_rtp_new(a_engine->local_sdp_ip,
                                                                                                                 v_engine->local_sdp_port,
                                                                                                                 v_engine->cur_payload_map->remote_sdp_ip,
                                                                                                                 v_engine->cur_payload_map->remote_sdp_port,
                                                                                                                 v_engine->cur_payload_map->pt,
                                                                                                                 1, 90000, flags, NULL, &err, switch_core_session_get_pool(session),
                                                                                                                 0, 0);


                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%sVIDEO RTP [%s] %s:%d->%s:%d codec: %u ms: %d [%s]\n",
                                                          switch_channel_test_flag(session->channel, CF_PROXY_MEDIA) ? "PROXY " : "",
                                                          switch_channel_get_name(session->channel),
                                                          a_engine->local_sdp_ip,
                                                          v_engine->local_sdp_port,
                                                          v_engine->cur_payload_map->remote_sdp_ip,
                                                          v_engine->cur_payload_map->remote_sdp_port, v_engine->cur_payload_map->pt,
                                                          0, switch_rtp_ready(v_engine->rtp_session) ? "SUCCESS" : err);


                        if (switch_rtp_ready(v_engine->rtp_session)) {
                                const char *ssrc;

                                if (v_engine->fir) {
                                        switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_FIR);
                                }

                                if (v_engine->pli) {
                                        switch_rtp_set_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PLI);
                                }

                                switch_rtp_set_payload_map(v_engine->rtp_session, &v_engine->payload_map);
                                switch_channel_set_flag(session->channel, CF_VIDEO);
                                switch_core_session_start_video_thread(session);

                                switch_rtp_set_video_buffer_size(v_engine->rtp_session, 1, 0);
                                if ((ssrc = switch_channel_get_variable(session->channel, "rtp_use_video_ssrc"))) {
                                        uint32_t ssrc_ul = (uint32_t) strtoul(ssrc, NULL, 10);
                                        switch_rtp_set_ssrc(v_engine->rtp_session, ssrc_ul);
                                        v_engine->ssrc = ssrc_ul;
                                } else {
                                        switch_rtp_set_ssrc(v_engine->rtp_session, v_engine->ssrc);
                                }

                                if (v_engine->remote_ssrc) {
                                        switch_rtp_set_remote_ssrc(v_engine->rtp_session, v_engine->remote_ssrc);
                                }

                                check_media_timeout_params(session, v_engine);

                                if (v_engine->ice_in.cands[v_engine->ice_in.chosen[0]][0].ready) {

                                        gen_ice(session, SWITCH_MEDIA_TYPE_VIDEO, NULL, 0);

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating Video ICE\n");

                                        switch_rtp_activate_ice(v_engine->rtp_session,
                                                                                        v_engine->ice_in.ufrag,
                                                                                        v_engine->ice_out.ufrag,
                                                                                        v_engine->ice_out.pwd,
                                                                                        v_engine->ice_in.pwd,
                                                                                        IPR_RTP,
#ifdef GOOGLE_ICE
                                                                                        ICE_GOOGLE_JINGLE,
                                                                                        NULL
#else
                                                                                        switch_determine_ice_type(v_engine, session),
                                                                                        &v_engine->ice_in
#endif
                                                                                        );


                                }

                                if ((val = switch_channel_get_variable(session->channel, "rtcp_video_interval_msec")) || (val = smh->mparams->rtcp_video_interval_msec)) {
                                        const char *rport = switch_channel_get_variable(session->channel, "rtp_remote_video_rtcp_port");
                                        switch_port_t remote_port = v_engine->remote_rtcp_port;

                                        if (rport) {
                                                remote_port = (switch_port_t)atoi(rport);
                                        }
                                        if (!strcasecmp(val, "passthru")) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating VIDEO RTCP PASSTHRU PORT %d\n", remote_port);
                                                switch_rtp_activate_rtcp(v_engine->rtp_session, -1, remote_port, v_engine->rtcp_mux > 0);
                                        } else {
                                                int interval = atoi(val);
                                                if (interval < 100 || interval > 500000) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
                                                                                          "Invalid rtcp interval spec [%d] must be between 100 and 500000\n", interval);
                                                        interval = 5000;
                                                }
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO,
                                                                                  "Activating VIDEO RTCP PORT %d interval %d mux %d\n", remote_port, interval, v_engine->rtcp_mux);
                                                switch_rtp_activate_rtcp(v_engine->rtp_session, interval, remote_port, v_engine->rtcp_mux > 0);

                                        }


                                        if (v_engine->ice_in.cands[v_engine->ice_in.chosen[1]][1].ready && v_engine->ice_in.cands[v_engine->ice_in.chosen[0]][0].ready &&
                                                !zstr(v_engine->ice_in.cands[v_engine->ice_in.chosen[1]][1].con_addr) && 
                                                !zstr(v_engine->ice_in.cands[v_engine->ice_in.chosen[0]][0].con_addr)) {

                                                if (v_engine->rtcp_mux > 0 && !strcmp(v_engine->ice_in.cands[v_engine->ice_in.chosen[1]][1].con_addr, v_engine->ice_in.cands[v_engine->ice_in.chosen[0]][0].con_addr)
                                                        && v_engine->ice_in.cands[v_engine->ice_in.chosen[1]][1].con_port == v_engine->ice_in.cands[v_engine->ice_in.chosen[0]][0].con_port) {
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Skipping VIDEO RTCP ICE (Same as VIDEO RTP)\n");
                                                } else {

                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_INFO, "Activating VIDEO RTCP ICE\n");
                                                        switch_rtp_activate_ice(v_engine->rtp_session,
                                                                                                        v_engine->ice_in.ufrag,
                                                                                                        v_engine->ice_out.ufrag,
                                                                                                        v_engine->ice_out.pwd,
                                                                                                        v_engine->ice_in.pwd,
                                                                                                        IPR_RTCP,
#ifdef GOOGLE_ICE
                                                                                                        ICE_GOOGLE_JINGLE,
                                                                                                        NULL
#else
                                                                                                        switch_determine_ice_type(v_engine, session),
                                                                                                        &v_engine->ice_in
#endif
                                                                                                        );



                                                }

                                        }
                                }

                                if (!zstr(v_engine->local_dtls_fingerprint.str) && switch_rtp_has_dtls() && dtls_ok(smh->session)) {
                                        dtls_type_t xtype,
                                                dtype = v_engine->dtls_controller ? DTLS_TYPE_CLIENT : DTLS_TYPE_SERVER;
                                        xtype = DTLS_TYPE_RTP;
                                        if (v_engine->rtcp_mux > 0 && smh->mparams->rtcp_video_interval_msec) xtype |= DTLS_TYPE_RTCP;
                        

                                        if (switch_channel_var_true(session->channel, "legacyDTLS")) {
                                                switch_channel_clear_flag(session->channel, CF_WANT_DTLSv1_2);
                                                want_DTLSv1_2 = 0;
                                        }

                                        switch_rtp_add_dtls(v_engine->rtp_session, &v_engine->local_dtls_fingerprint, &v_engine->remote_dtls_fingerprint, dtype | xtype, want_DTLSv1_2);

                                        if (v_engine->rtcp_mux < 1 && smh->mparams->rtcp_video_interval_msec) {
                                                xtype = DTLS_TYPE_RTCP;
                                                switch_rtp_add_dtls(v_engine->rtp_session, &v_engine->local_dtls_fingerprint, &v_engine->remote_dtls_fingerprint, dtype | xtype, want_DTLSv1_2);
                                        }
                                }


                                if ((val = switch_channel_get_variable(session->channel, "rtp_manual_video_rtp_bugs"))) {
                                        switch_core_media_parse_rtp_bugs(&v_engine->rtp_bugs, val);
                                }

                                if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                                        smh->mparams->manual_video_rtp_bugs = RTP_BUG_SEND_LINEAR_TIMESTAMPS;
                                }

                                switch_rtp_intentional_bugs(v_engine->rtp_session, v_engine->rtp_bugs | smh->mparams->manual_video_rtp_bugs);

                                //XX


                                switch_channel_set_variable_printf(session->channel, "rtp_use_video_pt", "%d", v_engine->cur_payload_map->pt);
                                v_engine->ssrc = switch_rtp_get_ssrc(v_engine->rtp_session);
                                switch_channel_set_variable_printf(session->channel, "rtp_use_video_ssrc", "%u", v_engine->ssrc);

                                switch_core_session_apply_crypto(session, SWITCH_MEDIA_TYPE_VIDEO);


                        } else {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "VIDEO RTP REPORTS ERROR: [%s]\n", switch_str_nil(err));
                                switch_channel_hangup(session->channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
                                goto end;
                        }
                }

        } else {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "AUDIO RTP REPORTS ERROR: [%s]\n", switch_str_nil(err));
                switch_channel_hangup(session->channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
                status = SWITCH_STATUS_FALSE;
                goto end;
        }

 video_up:

        if (session && v_engine) {
                check_dtls_reinvite(session, v_engine);
        }

        status = SWITCH_STATUS_SUCCESS;

 end:

        switch_channel_clear_flag(session->channel, CF_REINVITE);

        switch_core_recovery_track(session);

        return status;

}

static const char *get_media_profile_name(switch_core_session_t *session, int secure, switch_core_media_avp_secure_t avp)
{
        switch_assert(session);

        if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                if (switch_channel_test_flag(session->channel, CF_DTLS) || secure) {
                        if (switch_channel_test_flag(session->channel, CF_AVPF_MOZ)) {
                                return "UDP/TLS/RTP/SAVPF";
                        } else {
                                return "RTP/SAVPF";
                        }
                } else {
                        if (switch_channel_test_flag(session->channel, CF_AVPF_MOZ)) {
                                return "UDP/AVPF";
                        } else {
                                return "RTP/AVPF";
                        }
                }
        }

        if (secure) {
                switch (avp) {
                        case AVP_NO_SECURE:
                                break;
                        case AVP_SECURE:
                        case AVP_UNDEFINED:
                                return "RTP/SAVP";
                        default:
                                break;
                }
        }

        return "RTP/AVP";

}

static char *get_setup(switch_rtp_engine_t *engine, switch_core_session_t *session, switch_sdp_type_t sdp_type)
{

        if (sdp_type == SDP_OFFER) {
                engine->dtls_controller = 0;
                engine->new_dtls = 1;
                engine->new_ice = 1;
                return "actpass";
        } else {
                return engine->dtls_controller ? "active" : "passive";
        }
}


//?
static void generate_m(switch_core_session_t *session, char *buf, size_t buflen,
                                           switch_port_t port, const char *family, const char *ip,
                                           int cur_ptime, const char *append_audio, const char *sr, int use_cng, int cng_type, switch_event_t *map, int secure,
                                           switch_sdp_type_t sdp_type)
{
        int i = 0;
        int rate;
        int already_did[128] = { 0 };
        int ptime = 0, noptime = 0;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine;
        int include_external;
        switch_core_media_avp_secure_t avp_secure = AVP_NO_SECURE;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];

        //switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "m=audio %d RTP/%sAVP%s",
        //port, secure ? "S" : "", switch_channel_test_flag(session->channel, CF_AVPF) ? "F" : "");

        /* Check if there is a crypto */
        if (secure && !switch_channel_test_flag(session->channel, CF_DTLS)) {
                int i;

                for (i = 0; smh->crypto_suite_order[i] != CRYPTO_INVALID; i++) {
                        switch_rtp_crypto_key_type_t j = SUITES[smh->crypto_suite_order[i]].type;

                        if ((a_engine->crypto_type == j || a_engine->crypto_type == CRYPTO_INVALID) && !zstr(a_engine->ssec[j].local_crypto_key)) {
                                avp_secure = AVP_SECURE;
                                break;
                        }
                }
        }

        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "m=audio %d %s", port,
                                        get_media_profile_name(session, secure || a_engine->crypto_type != CRYPTO_INVALID, avp_secure));

        include_external = switch_channel_var_true(session->channel, "include_external_ip");

        for (i = 0; i < smh->mparams->num_codecs; i++) {
                const switch_codec_implementation_t *imp = smh->codecs[i];
                int this_ptime = (imp->microseconds_per_packet / 1000);
                payload_map_t *pmap;
                
                if (!strcasecmp(imp->iananame, "ilbc") || !strcasecmp(imp->iananame, "isac") ) {
                        this_ptime = 20;
                }

                if (imp->codec_type != SWITCH_CODEC_TYPE_AUDIO) {
                        continue;
                }

                if (!noptime) {
                        if (!cur_ptime) {
                                if (!ptime) {
                                        ptime = this_ptime;
                                }
                        } else {
                                if (this_ptime != cur_ptime) {
                                        continue;
                                }
                        }
                }

                if (smh->ianacodes[i] >= 128 || already_did[smh->ianacodes[i]]) {
                        continue;
                }


                switch_mutex_lock(smh->sdp_mutex);
                for (pmap = a_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                        if (pmap->negotiated && !strcasecmp(imp->iananame, pmap->iananame)) {
                                smh->ianacodes[i] = pmap->pt;
                                break;
                        }
                }
                switch_mutex_unlock(smh->sdp_mutex);
                
                already_did[smh->ianacodes[i]] = 1;

                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), " %d", smh->ianacodes[i]);
        }

        if (smh->mparams->dtmf_type == DTMF_2833 && smh->mparams->te > 95) {
                if (sdp_type == SDP_ANSWER) {
                        switch_rtp_engine_t *a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
                        if (a_engine) {
                                payload_map_t *pmap;
                                for (pmap = a_engine->payload_map; pmap; pmap = pmap->next) {
                                        if (pmap->pt >= 128 || already_did[pmap->pt]) {
                                                continue;
                                        }

                                        if (!strncasecmp(pmap->iananame, "telephone-event", 15)) {
                                                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), " %d", pmap->pt);
                                                already_did[pmap->pt] = 1;
                                        }
                                }
                        }
                } else {
                        int i;

                        for (i = 0; i < smh->num_rates; i++) {
                                if (smh->dtmf_ianacodes[i] < 128 && !already_did[smh->dtmf_ianacodes[i]]) {
                                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), " %d", smh->dtmf_ianacodes[i]);
                                        already_did[smh->dtmf_ianacodes[i]] = 1;
                                }
                                if (smh->cng_ianacodes[i] < 128 && !already_did[smh->cng_ianacodes[i]] && !switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) && cng_type && use_cng) {
                                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), " %d", smh->cng_ianacodes[i]);
                                        already_did[smh->cng_ianacodes[i]] = 1;
                                }
                        }
                }
        }

        //if (!switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) && cng_type && use_cng) {
                //switch_snprintf(buf + strlen(buf), buflen - strlen(buf), " %d", cng_type);
        //}

        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "\r\n");


        memset(already_did, 0, sizeof(already_did));


        for (i = 0; i < smh->mparams->num_codecs; i++) {
                const switch_codec_implementation_t *imp = smh->codecs[i];
                char *fmtp = imp->fmtp;
                int this_ptime = imp->microseconds_per_packet / 1000;

                if (imp->codec_type != SWITCH_CODEC_TYPE_AUDIO) {
                        continue;
                }

                if (!strcasecmp(imp->iananame, "ilbc") || !strcasecmp(imp->iananame, "isac")) {
                        this_ptime = 20;
                }

                if (!noptime) {
                        if (!cur_ptime) {
                                if (!ptime) {
                                        ptime = this_ptime;
                                }
                        } else {
                                if (this_ptime != cur_ptime) {
                                        continue;
                                }
                        }
                }

                if (smh->ianacodes[i] >= 128 || already_did[smh->ianacodes[i]]) {
                        continue;
                }

                already_did[smh->ianacodes[i]] = 1;
                rate = imp->samples_per_second;

                if (map) {
                        char key[128] = "";
                        char *check = NULL;
                        switch_snprintf(key, sizeof(key), "%s:%u", imp->iananame, imp->bits_per_second);

                        if ((check = switch_event_get_header(map, key)) || (check = switch_event_get_header(map, imp->iananame))) {
                                fmtp = check;
                        }
                }

                if (smh->fmtps[i]) {
                        fmtp = smh->fmtps[i];
                }


                if (smh->ianacodes[i] > 95 || switch_channel_test_flag(session->channel, CF_VERBOSE_SDP)) {
                        int channels = get_channels(imp->iananame, imp->number_of_channels);

                        if (channels > 1) {
                                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d %s/%d/%d\r\n", smh->ianacodes[i], imp->iananame, rate, channels);

                        } else {
                                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d %s/%d\r\n", smh->ianacodes[i], imp->iananame, rate);
                        }
                }

                if (fmtp) {
                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=fmtp:%d %s\r\n", smh->ianacodes[i], fmtp);
                }
        }


        if ((smh->mparams->dtmf_type == DTMF_2833 || switch_channel_test_flag(session->channel, CF_LIBERAL_DTMF)) && smh->mparams->te > 95) {
                if (smh->mparams->dtmf_type == DTMF_2833 && sdp_type == SDP_ANSWER) {
                        switch_rtp_engine_t *a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
                        if (a_engine) {
                                payload_map_t *pmap;
                                for (pmap = a_engine->payload_map; pmap; pmap = pmap->next) {
                                        if (!strncasecmp(pmap->iananame, "telephone-event", 15)) {
                                                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d telephone-event/%d\r\n",
                                                        pmap->pt, pmap->rate);
                                        }
                                }
                        }
                } else {
                        uint8_t NDLB_line_flash_16 = switch_channel_var_true(session->channel, "NDLB_line_flash_16");

                        for (i = 0; i < smh->num_rates; i++) {
                                if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d telephone-event/%d\r\n",
                                                smh->dtmf_ianacodes[i], smh->rates[i]);
                                }
                                else {
                                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d telephone-event/%d\r\na=fmtp:%d 0-%d\r\n",
                                                smh->dtmf_ianacodes[i], smh->rates[i], smh->dtmf_ianacodes[i], (NDLB_line_flash_16 ? 16 : 15));
                                }
                        }
                }
        }

        if (!zstr(a_engine->local_dtls_fingerprint.type) && secure) {
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=fingerprint:%s %s\r\na=setup:%s\r\n", a_engine->local_dtls_fingerprint.type,
                                                a_engine->local_dtls_fingerprint.str, get_setup(a_engine, session, sdp_type));
        }

        if (smh->mparams->rtcp_audio_interval_msec) {
                if (a_engine->rtcp_mux > 0) {
                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-mux\r\n");
                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp:%d IN %s %s\r\n", port, family, ip);
                } else {
                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp:%d IN %s %s\r\n", port + 1, family, ip);
                }
        }

        //switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u\r\n", a_engine->ssrc);

        if (a_engine->ice_out.cands[0][0].ready) {
                char tmp1[11] = "";
                char tmp2[11] = "";
                char tmp3[11] = "";
                uint32_t c1 = (1<<24)*126 + (1<<8)*65535 + (1<<0)*(256 - 1);
                uint32_t c2 = c1 - 1;
                ice_t *ice_out;

                tmp1[10] = '\0';
                tmp2[10] = '\0';
                tmp3[10] = '\0';
                switch_stun_random_string(tmp1, 10, "0123456789");
                switch_stun_random_string(tmp2, 10, "0123456789");
                switch_stun_random_string(tmp3, 10, "0123456789");

                gen_ice(session, SWITCH_MEDIA_TYPE_AUDIO, NULL, 0);

                ice_out = &a_engine->ice_out;

                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ssrc:%u cname:%s\r\n", a_engine->ssrc, smh->cname);
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ssrc:%u msid:%s a0\r\n", a_engine->ssrc, smh->msid);
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ssrc:%u mslabel:%s\r\n", a_engine->ssrc, smh->msid);
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ssrc:%u label:%sa0\r\n", a_engine->ssrc, smh->msid);


                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ice-ufrag:%s\r\n", ice_out->ufrag);
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ice-pwd:%s\r\n", ice_out->pwd);


                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ host generation 0\r\n",
                                                tmp1, ice_out->cands[0][0].transport, c1,
                                                ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port
                                                );

                if (include_external && !zstr(smh->mparams->extsipip)) {
                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ host generation 0\r\n",
                                tmp3, ice_out->cands[0][0].transport, c1,
                                smh->mparams->extsipip, ice_out->cands[0][0].con_port
                                );
                }

                if (!zstr(a_engine->local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) && 
                        strcmp(a_engine->local_sdp_ip, ice_out->cands[0][0].con_addr)
                        && a_engine->local_sdp_port != ice_out->cands[0][0].con_port) {

                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ srflx raddr %s rport %d generation 0\r\n",
                                                        tmp2, ice_out->cands[0][0].transport, c2,
                                                        ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port,
                                                        a_engine->local_sdp_ip, a_engine->local_sdp_port
                                                        );
                }

                if (a_engine->rtcp_mux < 1 || switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND || switch_channel_test_flag(session->channel, CF_RECOVERING)) {


                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ host generation 0\r\n",
                                                        tmp1, ice_out->cands[0][0].transport, c1,
                                                        ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (a_engine->rtcp_mux > 0 ? 0 : 1)
                                                        );
                        
                        if (include_external && !zstr(smh->mparams->extsipip)) {
                                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ host generation 0\r\n",
                                        tmp3, ice_out->cands[0][0].transport, c1,
                                        smh->mparams->extsipip, ice_out->cands[0][0].con_port
                                        );
                        }

                        if (!zstr(a_engine->local_sdp_ip) && !zstr(ice_out->cands[0][1].con_addr) && 
                                strcmp(a_engine->local_sdp_ip, ice_out->cands[0][1].con_addr)
                                && a_engine->local_sdp_port != ice_out->cands[0][1].con_port) {

                                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ srflx raddr %s rport %d generation 0\r\n",
                                                                tmp2, ice_out->cands[0][0].transport, c2,
                                                                ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (a_engine->rtcp_mux > 0 ? 0 : 1),
                                                                a_engine->local_sdp_ip, a_engine->local_sdp_port + (a_engine->rtcp_mux > 0 ? 0 : 1)
                                                                );
                        }
                }



#ifdef GOOGLE_ICE
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ice-options:google-ice\r\n");
#endif
        }


        if (secure && !switch_channel_test_flag(session->channel, CF_DTLS)) {
                int i;

                for (i = 0; smh->crypto_suite_order[i] != CRYPTO_INVALID; i++) {
                        switch_rtp_crypto_key_type_t j = SUITES[smh->crypto_suite_order[i]].type;

                        if ((a_engine->crypto_type == j || a_engine->crypto_type == CRYPTO_INVALID) && !zstr(a_engine->ssec[j].local_crypto_key)) {
                                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=crypto:%s\r\n", a_engine->ssec[j].local_crypto_key);
                        }
                }
                //switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "a=encryption:optional\r\n");
        }

        if (cng_type) {
                for (i = 0; i < smh->num_rates; i++) {
                        //if (smh->rates[i] == 8000) {
                        //      switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d CN/%d\r\n", cng_type, smh->rates[i]);
                        //} else {
                                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtpmap:%d CN/%d\r\n", smh->cng_ianacodes[i], smh->rates[i]);
                                //}
                }
        } else {
                if (switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG)) {
                        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=silenceSupp:off - - - -\r\n");
                }
        }

        if (append_audio) {
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "%s%s", append_audio, end_of(append_audio) == '\n' ? "" : "\r\n");
        }

        if (!cur_ptime) {
                cur_ptime = ptime;
        }

        if (!noptime && cur_ptime) {
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=ptime:%d\r\n", cur_ptime);
        }

        if (!zstr(sr)) {
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=%s\r\n", sr);
        }
}

//?
SWITCH_DECLARE(void) switch_core_media_check_dtmf_type(switch_core_session_t *session)
{
        const char *val;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if ((val = switch_channel_get_variable(session->channel, "dtmf_type"))) {
                if (!strcasecmp(val, "rfc2833")) {
                        smh->mparams->dtmf_type = DTMF_2833;
                } else if (!strcasecmp(val, "info")) {
                        smh->mparams->dtmf_type = DTMF_INFO;
                } else if (!strcasecmp(val, "none")) {
                        smh->mparams->dtmf_type = DTMF_NONE;
                }
        }
}

//?
switch_status_t switch_core_media_sdp_map(const char *r_sdp, switch_event_t **fmtp, switch_event_t **pt)
{
        sdp_media_t *m;
        sdp_parser_t *parser = NULL;
        sdp_session_t *sdp;

        if (!(parser = sdp_parse(NULL, r_sdp, (int) strlen(r_sdp), 0))) {
                return SWITCH_STATUS_FALSE;
        }

        if (!(sdp = sdp_session(parser))) {
                sdp_parser_free(parser);
                return SWITCH_STATUS_FALSE;
        }

        switch_event_create(&(*fmtp), SWITCH_EVENT_REQUEST_PARAMS);
        switch_event_create(&(*pt), SWITCH_EVENT_REQUEST_PARAMS);

        for (m = sdp->sdp_media; m; m = m->m_next) {
                if (m->m_proto == sdp_proto_rtp) {
                        sdp_rtpmap_t *map;

                        for (map = m->m_rtpmaps; map; map = map->rm_next) {
                                if (map->rm_encoding) {
                                        char buf[25] = "";
                                        char key[128] = "";
                                        char *br = NULL;

                                        if (map->rm_fmtp) {
                                                if ((br = strstr(map->rm_fmtp, "bitrate="))) {
                                                        br += 8;
                                                }
                                        }

                                        switch_snprintf(buf, sizeof(buf), "%d", map->rm_pt);

                                        if (br) {
                                                switch_snprintf(key, sizeof(key), "%s:%s", map->rm_encoding, br);
                                        } else {
                                                switch_snprintf(key, sizeof(key), "%s", map->rm_encoding);
                                        }

                                        switch_event_add_header_string(*pt, SWITCH_STACK_BOTTOM, key, buf);

                                        if (map->rm_fmtp) {
                                                switch_event_add_header_string(*fmtp, SWITCH_STACK_BOTTOM, key, map->rm_fmtp);
                                        }
                                }
                        }
                }
        }

        sdp_parser_free(parser);

        return SWITCH_STATUS_SUCCESS;

}

//?
SWITCH_DECLARE(void)switch_core_media_set_local_sdp(switch_core_session_t *session, const char *sdp_str, switch_bool_t dup)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (smh->sdp_mutex) switch_mutex_lock(smh->sdp_mutex);
        smh->mparams->local_sdp_str = dup ? switch_core_session_strdup(session, sdp_str) : (char *) sdp_str;
        switch_channel_set_variable(session->channel, "rtp_local_sdp_str", smh->mparams->local_sdp_str);
        if (smh->sdp_mutex) switch_mutex_unlock(smh->sdp_mutex);
}

static void add_fb(char *buf, uint32_t buflen, int pt, int fir, int nack, int pli, int tmmbr)
{
        if (fir) {
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-fb:%d ccm fir\r\n", pt);
        }

        if (tmmbr) {
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-fb:%d ccm tmmbr\r\n", pt);
        }

        if (nack) {
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-fb:%d nack\r\n", pt);
        }

        if (pli) {
                switch_snprintf(buf + strlen(buf), buflen - strlen(buf), "a=rtcp-fb:%d nack pli\r\n", pt);
        }

}

//?
#define SDPBUFLEN 65536
SWITCH_DECLARE(void) switch_core_media_gen_local_sdp(switch_core_session_t *session, switch_sdp_type_t sdp_type, const char *ip, switch_port_t port, const char *sr, int force)
{
        char *buf;
        int ptime = 0;
        uint32_t rate = 0;
        uint32_t v_port, t_port;
        int use_cng = 1;
        const char *val;
        const char *family;
        const char *pass_fmtp = switch_channel_get_variable(session->channel, "rtp_video_fmtp");
        const char *ov_fmtp = switch_channel_get_variable(session->channel, "rtp_force_video_fmtp");
        const char *append_audio = switch_channel_get_variable(session->channel, "rtp_append_audio_sdp");
        const char *append_video = switch_channel_get_variable(session->channel, "rtp_append_video_sdp");
        char srbuf[128] = "";
        const char *var_val;
        const char *username;
        const char *fmtp_out;
        const char *fmtp_out_var = switch_channel_get_variable(session->channel, "rtp_force_audio_fmtp");
        switch_event_t *map = NULL, *ptmap = NULL;
        //const char *b_sdp = NULL;
        //const char *local_audio_crypto_key = switch_core_session_local_crypto_key(session, SWITCH_MEDIA_TYPE_AUDIO);
        const char *tmp;
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_media_handle_t *smh;
        ice_t *ice_out;
        //int vp8 = 0;
        //int red = 0;
        payload_map_t *pmap;
        int is_outbound = switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND;
        const char *vbw;
        int bw = 256, i = 0;
        uint8_t fir = 0, nack = 0, pli = 0, tmmbr = 0, has_vid = 0;
        const char *use_rtcp_mux = NULL;
        int include_external;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        include_external = switch_channel_var_true(session->channel, "include_external_ip");

        use_rtcp_mux = switch_channel_get_variable(session->channel, "rtcp_mux");

        if (use_rtcp_mux && switch_false(use_rtcp_mux)) {
                a_engine->rtcp_mux = -1;
                v_engine->rtcp_mux = -1;
        }

        if ((a_engine->rtcp_mux != -1 && v_engine->rtcp_mux != -1) && (sdp_type == SDP_OFFER)) {
                a_engine->rtcp_mux = 1;
                v_engine->rtcp_mux = 1;
        }

        if (!smh->mparams->rtcp_audio_interval_msec) {
                smh->mparams->rtcp_audio_interval_msec = (char *)switch_channel_get_variable(session->channel, "rtcp_audio_interval_msec");
        }

        if (!smh->mparams->rtcp_video_interval_msec) {
                smh->mparams->rtcp_video_interval_msec = (char *)switch_channel_get_variable(session->channel, "rtcp_video_interval_msec");
        }

        if (dtls_ok(session) && (tmp = switch_channel_get_variable(smh->session->channel, "webrtc_enable_dtls")) && switch_false(tmp)) {
                switch_channel_clear_flag(smh->session->channel, CF_DTLS_OK);
                switch_channel_clear_flag(smh->session->channel, CF_DTLS);
        }

        if (switch_channel_test_flag(session->channel, CF_PROXY_OFF) && (tmp = switch_channel_get_variable(smh->session->channel, "uuid_media_secure_media"))) {
                switch_channel_set_variable(smh->session->channel, "rtp_secure_media", tmp);
                switch_core_session_parse_crypto_prefs(session);
                switch_core_session_check_outgoing_crypto(session);
        }

        if (is_outbound || switch_channel_test_flag(session->channel, CF_RECOVERING) ||
                switch_channel_test_flag(session->channel, CF_3PCC)) {
                if (!switch_channel_test_flag(session->channel, CF_AVPF) &&
                        switch_true(switch_channel_get_variable(session->channel, "media_webrtc"))) {
                        switch_channel_set_flag(session->channel, CF_AVPF);
                        switch_channel_set_flag(session->channel, CF_ICE);
                        smh->mparams->rtcp_audio_interval_msec = SWITCH_RTCP_AUDIO_INTERVAL_MSEC;
                        smh->mparams->rtcp_video_interval_msec = SWITCH_RTCP_VIDEO_INTERVAL_MSEC;
                }

                if (switch_true(switch_channel_get_variable(session->channel, "add_ice_candidates"))) {
                        switch_channel_set_flag(session->channel, CF_ICE);
                }

                if ( switch_rtp_has_dtls() && dtls_ok(session)) {
                        if (switch_channel_test_flag(session->channel, CF_AVPF) ||
                                switch_true(switch_channel_get_variable(smh->session->channel, "rtp_use_dtls"))) {
                                switch_channel_set_flag(smh->session->channel, CF_DTLS);
                                switch_channel_set_flag(smh->session->channel, CF_SECURE);
                                generate_local_fingerprint(smh, SWITCH_MEDIA_TYPE_AUDIO);
                        }
                }
                switch_core_session_parse_crypto_prefs(session);
                switch_core_session_check_outgoing_crypto(session);
        }

        fmtp_out = a_engine->cur_payload_map->fmtp_out;
        username = smh->mparams->sdp_username;


        switch_zmalloc(buf, SDPBUFLEN);

        switch_core_media_check_dtmf_type(session);

        if (switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) ||
                ((val = switch_channel_get_variable(session->channel, "supress_cng")) && switch_true(val)) ||
                ((val = switch_channel_get_variable(session->channel, "suppress_cng")) && switch_true(val))) {
                use_cng = 0;
                smh->mparams->cng_pt = 0;
        }




        if (!smh->payload_space) {
                /* it could be 98 but chrome reserves 98 and 99 for some internal stuff even though they should not.  
                   Everyone expects dtmf to be at 101 and Its not worth the trouble so we'll start at 102 */
                smh->payload_space = 102;
                memset(smh->rates, 0, sizeof(smh->rates));
                smh->num_rates = 0;

                for (i = 0; i < smh->mparams->num_codecs; i++) {
                        int j;
                        smh->ianacodes[i] = smh->codecs[i]->ianacode;

                        if (smh->codecs[i]->codec_type != SWITCH_CODEC_TYPE_AUDIO) {
                                continue;
                        }

                        if (sdp_type == SDP_OFFER) {
                                for (j = 0; j < SWITCH_MAX_CODECS; j++) {
                                        if (smh->rates[j] == 0) {
                                                break;
                                        }

                                        if (smh->rates[j] == smh->codecs[i]->samples_per_second) {
                                                goto do_next;
                                        }
                                }

                                smh->rates[smh->num_rates++] = smh->codecs[i]->samples_per_second;
                        }

                do_next:
                        continue;
                }

                if (sdp_type == SDP_OFFER) {
                        switch_core_session_t *orig_session = NULL;

                        switch_core_session_get_partner(session, &orig_session);

                        if (orig_session && !switch_channel_test_flag(session->channel, CF_ANSWERED)) {
                                switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO,
                                                                                        switch_core_session_remote_media_flow(orig_session, SWITCH_MEDIA_TYPE_AUDIO), sdp_type);
                                switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_VIDEO,
                                                                                        switch_core_session_remote_media_flow(orig_session, SWITCH_MEDIA_TYPE_VIDEO), sdp_type);
                        }

                        for (i = 0; i < smh->mparams->num_codecs; i++) {
                                const switch_codec_implementation_t *imp = smh->codecs[i];
                                switch_payload_t orig_pt = 0;
                                char *orig_fmtp = NULL;

                                if (smh->ianacodes[i] > 64) {
                                        if (smh->mparams->dtmf_type == DTMF_2833 && smh->mparams->te > 95 && smh->mparams->te == smh->payload_space) {
                                                smh->payload_space++;
                                        }
                                        if (!switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) &&
                                                smh->mparams->cng_pt && use_cng  && smh->mparams->cng_pt == smh->payload_space) {
                                                smh->payload_space++;
                                        }

                                        if (orig_session &&
                                                switch_core_session_get_payload_code(orig_session,
                                                                                                                         imp->codec_type == SWITCH_CODEC_TYPE_AUDIO ? SWITCH_MEDIA_TYPE_AUDIO : SWITCH_MEDIA_TYPE_VIDEO,
                                                                                                                         imp->iananame, imp->samples_per_second, smh->fmtp[i], &orig_pt, NULL, &orig_fmtp) == SWITCH_STATUS_SUCCESS) {

                                                if (orig_pt == smh->mparams->te) {
                                                        smh->mparams->te  = (switch_payload_t)smh->payload_space++;
                                                }

                                                smh->ianacodes[i] = orig_pt;

                                                if (!zstr(orig_fmtp)) {
                                                        smh->fmtps[i] = switch_core_session_strdup(session, orig_fmtp);
                                                }
                                        } else {
                                                smh->ianacodes[i] = (switch_payload_t)smh->payload_space++;
                                        }
                                }

                                switch_core_media_add_payload_map(session,
                                                                                                  imp->codec_type == SWITCH_CODEC_TYPE_AUDIO ? SWITCH_MEDIA_TYPE_AUDIO : SWITCH_MEDIA_TYPE_VIDEO,
                                                                                                  imp->iananame,
                                                                                                  imp->modname,
                                                                                                  smh->fmtps[i],
                                                                                                  sdp_type,
                                                                                                  smh->ianacodes[i],
                                                                                                  imp->samples_per_second,
                                                                                                  imp->microseconds_per_packet / 1000,
                                                                                                  imp->number_of_channels,
                                                                                                  SWITCH_FALSE);
                        }

                        for (i = 0; i < smh->num_rates; i++) {
                                if (smh->rates[i] == 8000 || smh->num_rates == 1) {
                                        smh->dtmf_ianacodes[i] = smh->mparams->te;
                                        smh->cng_ianacodes[i] = smh->mparams->cng_pt;
                                } else {
                                        int j = 0;

                                        for (j = 0; j < smh->mparams->num_codecs; j++) {
                                                if (smh->ianacodes[j] == smh->payload_space) {
                                                        smh->payload_space++;
                                                        break;
                                                }
                                        }

                                        smh->dtmf_ianacodes[i] = (switch_payload_t)smh->payload_space++;
                                        smh->cng_ianacodes[i] = (switch_payload_t)smh->payload_space++;
                                }
                        }


                        if (orig_session) {
                                switch_core_session_rwunlock(orig_session);
                        }
                }
        }

        if (fmtp_out_var) {
                fmtp_out = fmtp_out_var;
        }

        val = switch_channel_get_variable(session->channel, "verbose_sdp");

        if (!val || switch_true(val)) {
                switch_channel_set_flag(session->channel, CF_VERBOSE_SDP);
        }

        if (!force && !ip && zstr(sr)
                && (switch_channel_test_flag(session->channel, CF_PROXY_MODE) || switch_channel_test_flag(session->channel, CF_PROXY_MEDIA))) {
                switch_safe_free(buf);
                return;
        }

        if (!ip) {
                if (!(ip = a_engine->adv_sdp_ip)) {
                        ip = a_engine->proxy_sdp_ip;
                }
        }

        if (!ip) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "%s NO IP!\n", switch_channel_get_name(session->channel));
                switch_safe_free(buf);
                return;
        }

        if (!port) {
                if (!(port = a_engine->adv_sdp_port)) {
                        port = a_engine->proxy_sdp_port;
                }
        }

        if (!port) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "%s NO PORT!\n", switch_channel_get_name(session->channel));
                switch_safe_free(buf);
                return;
        }

        //if (!a_engine->cur_payload_map->rm_encoding && (b_sdp = switch_channel_get_variable(session->channel, SWITCH_B_SDP_VARIABLE))) {
        //switch_core_media_sdp_map(b_sdp, &map, &ptmap);
        //}

        for (i = 0; i < smh->mparams->num_codecs; i++) {
                const switch_codec_implementation_t *imp = smh->codecs[i];
                
                if (imp->codec_type == SWITCH_CODEC_TYPE_AUDIO && a_engine->smode == SWITCH_MEDIA_FLOW_DISABLED) {
                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_AUDIO, SWITCH_MEDIA_FLOW_SENDRECV, sdp_type);
                        break;
                }
        }
        
        if (zstr(sr)) {
                if (a_engine->smode == SWITCH_MEDIA_FLOW_SENDONLY) {
                        sr = "sendonly";
                } else if (a_engine->smode == SWITCH_MEDIA_FLOW_RECVONLY) {
                        sr = "recvonly";
                } else if (a_engine->smode == SWITCH_MEDIA_FLOW_INACTIVE) {
                        sr = "inactive";
                } else {
                        sr = "sendrecv";
                }

                if ((var_val = switch_channel_get_variable(session->channel, "origination_audio_mode"))) {
                        if (!strcasecmp(sr, "sendonly") || !strcasecmp(sr, "recvonly") || !strcasecmp(sr, "sendrecv") || !strcasecmp(sr, "inactive")) {
                                sr = var_val;
                        }
                        switch_channel_set_variable(session->channel, "origination_audio_mode", NULL);
                }

                if (zstr(sr)) {
                        sr = "sendrecv";
                }
        }

        if (!smh->owner_id) {
                smh->owner_id = (uint32_t)(switch_time_t)switch_epoch_time_now(NULL) - port;
        }

        if (!smh->session_id) {
                smh->session_id = smh->owner_id;
        }

        if (switch_true(switch_channel_get_variable_dup(session->channel, "drop_dtmf", SWITCH_FALSE, -1))) {
                switch_channel_set_flag(session->channel, CF_DROP_DTMF);
        }

        smh->session_id++;

        if ((smh->mparams->ndlb & SM_NDLB_SENDRECV_IN_SESSION) ||
                ((var_val = switch_channel_get_variable(session->channel, "ndlb_sendrecv_in_session")) && switch_true(var_val))) {
                if (!zstr(sr)) {
                        switch_snprintf(srbuf, sizeof(srbuf), "a=%s\r\n", sr);
                }
                sr = NULL;
        }

        family = strchr(ip, ':') ? "IP6" : "IP4";
        switch_snprintf(buf, SDPBUFLEN,
                                        "v=0\r\n"
                                        "o=%s %010u %010u IN %s %s\r\n"
                                        "s=%s\r\n"
                                        "c=IN %s %s\r\n"
                                        "t=0 0\r\n"
                                        "%s",
                                        username, smh->owner_id, smh->session_id, family, ip, username, family, ip, srbuf);

        if (switch_channel_test_flag(smh->session->channel, CF_ICE) && switch_channel_var_true(session->channel, "ice_lite")) {
                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-lite\r\n");
        }

        if (a_engine->rmode == SWITCH_MEDIA_FLOW_DISABLED) {
                goto video;
        }

        if (switch_channel_test_flag(smh->session->channel, CF_ICE)) {
                gen_ice(session, SWITCH_MEDIA_TYPE_AUDIO, ip, port);
                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=msid-semantic: WMS %s\r\n", smh->msid);
        }

        if (a_engine->codec_negotiated && !switch_channel_test_flag(session->channel, CF_NOSDP_REINVITE)) {
                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "m=audio %d %s", port,
                                                get_media_profile_name(session, !a_engine->no_crypto &&
                                                                                           (switch_channel_test_flag(session->channel, CF_DTLS) || a_engine->crypto_type != CRYPTO_INVALID), AVP_UNDEFINED));


                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", a_engine->cur_payload_map->pt);


                if (switch_media_handle_test_media_flag(smh, SCMF_MULTI_ANSWER_AUDIO)) {
                        switch_mutex_lock(smh->sdp_mutex);
                        for (pmap = a_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                                if (pmap->pt != a_engine->cur_payload_map->pt) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", pmap->pt);
                                }
                        }
                        switch_mutex_unlock(smh->sdp_mutex);
                }

                if ((smh->mparams->dtmf_type == DTMF_2833 || switch_channel_test_flag(session->channel, CF_LIBERAL_DTMF)) && smh->mparams->te > 95) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", smh->mparams->te);
                }

                if (!switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) && smh->mparams->cng_pt && use_cng) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", smh->mparams->cng_pt);
                }

                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "\r\n");


                rate = a_engine->cur_payload_map->adv_rm_rate;

                if (!a_engine->cur_payload_map->adv_channels) {
                        a_engine->cur_payload_map->adv_channels = get_channels(a_engine->cur_payload_map->rm_encoding, 1);
                }

                if (a_engine->cur_payload_map->adv_channels > 1) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%d/%d\r\n",
                                                        a_engine->cur_payload_map->pt, a_engine->cur_payload_map->rm_encoding, rate, a_engine->cur_payload_map->adv_channels);
                } else {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%d\r\n",
                                                        a_engine->cur_payload_map->pt, a_engine->cur_payload_map->rm_encoding, rate);
                }

                if (fmtp_out) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fmtp:%d %s\r\n", a_engine->cur_payload_map->pt, fmtp_out);
                }

                if (switch_media_handle_test_media_flag(smh, SCMF_MULTI_ANSWER_AUDIO)) {
                        switch_mutex_lock(smh->sdp_mutex);
                        for (pmap = a_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                                if (pmap->pt != a_engine->cur_payload_map->pt) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%ld\r\n",
                                                                        pmap->pt, pmap->iananame,
                                                                        pmap->rate);
                                }
                        }
                        switch_mutex_unlock(smh->sdp_mutex);
                }


                if (a_engine->read_codec.implementation && !ptime) {
                        ptime = a_engine->read_codec.implementation->microseconds_per_packet / 1000;
                }


                if ((smh->mparams->dtmf_type == DTMF_2833 || switch_channel_test_flag(session->channel, CF_LIBERAL_DTMF))
                        && smh->mparams->te > 95) {

                        if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d telephone-event/%d\r\n",
                                                                smh->mparams->te, smh->mparams->te_rate);
                        } else {
                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d telephone-event/%d\r\na=fmtp:%d 0-%d\r\n",
                                                                smh->mparams->te, smh->mparams->te_rate, smh->mparams->te, (switch_channel_var_true(session->channel, "NDLB_line_flash_16") ? 16 : 15));
                        }
                }

                if (switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG)) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=silenceSupp:off - - - -\r\n");
                } else if (smh->mparams->cng_pt && use_cng) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d CN/%lu\r\n", smh->mparams->cng_pt, smh->mparams->cng_rate);

                        if (!a_engine->codec_negotiated) {
                                smh->mparams->cng_pt = 0;
                        }
                }

                if (append_audio) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "%s%s", append_audio, end_of(append_audio) == '\n' ? "" : "\r\n");
                }

                if (ptime) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ptime:%d\r\n", ptime);
                }


                if (!zstr(sr)) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=%s\r\n", sr);
                }


                if (!zstr(a_engine->local_dtls_fingerprint.type)) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fingerprint:%s %s\r\na=setup:%s\r\n",
                                                        a_engine->local_dtls_fingerprint.type,
                                                        a_engine->local_dtls_fingerprint.str, get_setup(a_engine, session, sdp_type));
                }

                if (smh->mparams->rtcp_audio_interval_msec) {
                        if (a_engine->rtcp_mux > 0) {
                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtcp-mux\r\n");
                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtcp:%d IN %s %s\r\n", port, family, ip);
                        } else {
                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtcp:%d IN %s %s\r\n", port + 1, family, ip);
                        }
                }

                //switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u\r\n", a_engine->ssrc);

                if (a_engine->ice_out.cands[0][0].ready) {
                        char tmp1[11] = "";
                        char tmp2[11] = "";
                        char tmp3[11] = "";
                        uint32_t c1 = (1<<24)*126 + (1<<8)*65535 + (1<<0)*(256 - 1);
                        uint32_t c2 = c1 - 1;
                        uint32_t c3 = c1 - 2;
                        uint32_t c4 = c1 - 3;

                        tmp1[10] = '\0';
                        tmp2[10] = '\0';
                        tmp3[10] = '\0';
                        switch_stun_random_string(tmp1, 10, "0123456789");
                        switch_stun_random_string(tmp2, 10, "0123456789");
                        switch_stun_random_string(tmp3, 10, "0123456789");

                        ice_out = &a_engine->ice_out;


                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-ufrag:%s\r\n", ice_out->ufrag);
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-pwd:%s\r\n", ice_out->pwd);


                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ host generation 0\r\n",
                                                        tmp1, ice_out->cands[0][0].transport, c1,
                                                        ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port
                                                        );

                        if (include_external && !zstr(smh->mparams->extsipip)) {
                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ host generation 0\r\n",
                                        tmp3, ice_out->cands[0][0].transport, c1,
                                        smh->mparams->extsipip, ice_out->cands[0][0].con_port
                                        );
                        }

                        if (!zstr(a_engine->local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) && 
                                strcmp(a_engine->local_sdp_ip, ice_out->cands[0][0].con_addr)
                                && a_engine->local_sdp_port != ice_out->cands[0][0].con_port) {

                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ srflx raddr %s rport %d generation 0\r\n",
                                                                tmp2, ice_out->cands[0][0].transport, c3,
                                                                ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port,
                                                                a_engine->local_sdp_ip, a_engine->local_sdp_port
                                                                );
                        }


                        if (a_engine->rtcp_mux < 1 || is_outbound || switch_channel_test_flag(session->channel, CF_RECOVERING)) {

                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ host generation 0\r\n",
                                                                tmp1, ice_out->cands[0][0].transport, c2,
                                                                ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (a_engine->rtcp_mux > 0 ? 0 : 1)
                                                                );

                                if (include_external && !zstr(smh->mparams->extsipip)) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ host generation 0\r\n",
                                                tmp3, ice_out->cands[0][0].transport, c2,
                                                smh->mparams->extsipip, ice_out->cands[0][0].con_port + (a_engine->rtcp_mux > 0 ? 0 : 1)
                                                );
                                }



                                if (!zstr(a_engine->local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) &&
                                        strcmp(a_engine->local_sdp_ip, ice_out->cands[0][0].con_addr)
                                        && a_engine->local_sdp_port != ice_out->cands[0][0].con_port) {

                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ srflx raddr %s rport %d generation 0\r\n",
                                                                        tmp2, ice_out->cands[0][0].transport, c4,
                                                                        ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (a_engine->rtcp_mux > 0 ? 0 : 1),
                                                                        a_engine->local_sdp_ip, a_engine->local_sdp_port + (a_engine->rtcp_mux > 0 ? 0 : 1)
                                                                        );
                                }
                        }

                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=end-of-candidates\r\n");

                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u cname:%s\r\n", a_engine->ssrc, smh->cname);
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u msid:%s a0\r\n", a_engine->ssrc, smh->msid);
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u mslabel:%s\r\n", a_engine->ssrc, smh->msid);
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u label:%sa0\r\n", a_engine->ssrc, smh->msid);


#ifdef GOOGLE_ICE
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-options:google-ice\r\n");
#endif
                }

                if (a_engine->crypto_type != CRYPTO_INVALID && !switch_channel_test_flag(session->channel, CF_DTLS) &&
                        !zstr(a_engine->ssec[a_engine->crypto_type].local_crypto_key) && switch_channel_test_flag(session->channel, CF_SECURE)) {

                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=crypto:%s\r\n", a_engine->ssec[a_engine->crypto_type].local_crypto_key);
                //switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=encryption:optional\r\n");
                }

                if (a_engine->reject_avp) {
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "m=audio 0 RTP/AVP 19\r\n");
                }

        } else if (smh->mparams->num_codecs) {
                int cur_ptime = 0, this_ptime = 0, cng_type = 0;
                const char *mult;


                if (!switch_media_handle_test_media_flag(smh, SCMF_SUPPRESS_CNG) && smh->mparams->cng_pt && use_cng) {
                        cng_type = smh->mparams->cng_pt;

                        if (!a_engine->codec_negotiated) {
                                smh->mparams->cng_pt = 0;
                        }
                }

                mult = switch_channel_get_variable(session->channel, "sdp_m_per_ptime");

                if (switch_channel_test_flag(session->channel, CF_AVPF) || (mult && switch_false(mult))) {
                        char *bp = buf;
                        int both = (switch_channel_test_flag(session->channel, CF_AVPF) || switch_channel_test_flag(session->channel, CF_DTLS)) ? 0 : 1;

                        if ((!a_engine->no_crypto && switch_channel_test_flag(session->channel, CF_SECURE)) ||
                                switch_channel_test_flag(session->channel, CF_DTLS)) {
                                generate_m(session, buf, SDPBUFLEN, port, family, ip, 0, append_audio, sr, use_cng, cng_type, map, 1, sdp_type);
                                bp = (buf + strlen(buf));

                                if (smh->crypto_mode == CRYPTO_MODE_MANDATORY) {
                                        both = 0;
                                }

                        }

                        if (both) {
                                generate_m(session, bp, SDPBUFLEN - strlen(buf), port, family, ip, 0, append_audio, sr, use_cng, cng_type, map, 0, sdp_type);
                        }

                } else {

                        for (i = 0; i < smh->mparams->num_codecs; i++) {
                                const switch_codec_implementation_t *imp = smh->codecs[i];

                                if (imp->codec_type != SWITCH_CODEC_TYPE_AUDIO) {
                                        continue;
                                }

                                this_ptime = imp->microseconds_per_packet / 1000;

                                if (!strcasecmp(imp->iananame, "ilbc") || !strcasecmp(imp->iananame, "isac")) {
                                        this_ptime = 20;
                                }

                                if (cur_ptime != this_ptime) {
                                        char *bp = buf;
                                        int both = 1;

                                        cur_ptime = this_ptime;

                                        if ((!a_engine->no_crypto && switch_channel_test_flag(session->channel, CF_SECURE)) ||
                                                switch_channel_test_flag(session->channel, CF_DTLS)) {
                                                generate_m(session, bp, SDPBUFLEN - strlen(buf), port, family, ip, cur_ptime, append_audio, sr, use_cng, cng_type, map, 1, sdp_type);
                                                bp = (buf + strlen(buf));

                                                if (smh->crypto_mode == CRYPTO_MODE_MANDATORY) {
                                                        both = 0;
                                                }
                                        }

                                        if (switch_channel_test_flag(session->channel, CF_AVPF) || switch_channel_test_flag(session->channel, CF_DTLS)) {
                                                both = 0;
                                        }

                                        if (both) {
                                                generate_m(session, bp, SDPBUFLEN - strlen(buf), port, family, ip, cur_ptime, append_audio, sr, use_cng, cng_type, map, 0, sdp_type);
                                        }
                                }

                        }
                }

        }

        if (switch_channel_test_flag(session->channel, CF_IMAGE_SDP)) {
                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "m=image 0 UDPTL T38\r\n", SWITCH_VA_NONE);

        }


 video:


        if (!switch_channel_test_flag(session->channel, CF_VIDEO_POSSIBLE) && switch_media_handle_test_media_flag(smh, SCMF_RECV_SDP)) {
                has_vid = 0;
        } else {
                for (i = 0; i < smh->mparams->num_codecs; i++) {
                        const switch_codec_implementation_t *imp = smh->codecs[i];


                        if (imp->codec_type == SWITCH_CODEC_TYPE_VIDEO) {
                                has_vid = 1;
                                break;
                        }
                }

        }


        if (!has_vid) {
                if (switch_channel_test_flag(session->channel, CF_VIDEO_SDP_RECVD)) {
                        switch_channel_clear_flag(session->channel, CF_VIDEO_SDP_RECVD);
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "m=video 0 %s 19\r\n",
                                                        get_media_profile_name(session,
                                                                                                   (switch_channel_test_flag(session->channel, CF_SECURE)
                                                                                                        && switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND) ||
                                                                                                   a_engine->crypto_type != CRYPTO_INVALID || switch_channel_test_flag(session->channel, CF_DTLS), AVP_UNDEFINED));
                }
        } else {
                if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                        if (switch_channel_test_flag(smh->session->channel, CF_DTLS)) {
                                v_engine->no_crypto = 1;
                        }
                }


                if (!v_engine->local_sdp_port) {
                        switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 0);
                }

                //if (switch_channel_test_flag(session->channel, CF_AVPF)) {
                //      switch_media_handle_set_media_flag(smh, SCMF_MULTI_ANSWER_VIDEO);
                //}

                if ((v_port = v_engine->adv_sdp_port)) {
                        int loops;
                        int got_vid = 0;

                        for (loops = 0; loops < 2; loops++) {

                                if (switch_channel_test_flag(smh->session->channel, CF_ICE)) {
                                        gen_ice(session, SWITCH_MEDIA_TYPE_VIDEO, ip, (switch_port_t)v_port);
                                }


                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "m=video %d %s",
                                                                v_port,
                                                                get_media_profile_name(session,
                                                                                                           (loops == 0 && switch_channel_test_flag(session->channel, CF_SECURE)
                                                                                                                && switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND) ||
                                                                                                           a_engine->crypto_type != CRYPTO_INVALID || switch_channel_test_flag(session->channel, CF_DTLS), AVP_UNDEFINED));




                                /*****************************/
                                if (v_engine->codec_negotiated) {
                                        payload_map_t *pmap;
                                        switch_core_media_set_video_codec(session, 0);
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", v_engine->cur_payload_map->pt);

                                        if (switch_media_handle_test_media_flag(smh, SCMF_MULTI_ANSWER_VIDEO)) {
                                                switch_mutex_lock(smh->sdp_mutex);
                                                for (pmap = v_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                                                        if (pmap->pt != v_engine->cur_payload_map->pt && pmap->negotiated) {
                                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", pmap->pt);
                                                        }
                                                }
                                                switch_mutex_unlock(smh->sdp_mutex);
                                        }
                                        
                                } else if (smh->mparams->num_codecs) {
                                        int already_did[128] = { 0 };
                                        for (i = 0; i < smh->mparams->num_codecs; i++) {
                                                const switch_codec_implementation_t *imp = smh->codecs[i];


                                                if (imp->codec_type != SWITCH_CODEC_TYPE_VIDEO) {
                                                        continue;
                                                }

                                                if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND &&
                                                        switch_channel_test_flag(session->channel, CF_NOVIDEO)) {
                                                        continue;
                                                }

                                                if (smh->ianacodes[i] >= 128 || already_did[smh->ianacodes[i]]) {
                                                        continue;
                                                }

                                                switch_mutex_lock(smh->sdp_mutex);
                                                for (pmap = v_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                                                        if (pmap->negotiated && !strcasecmp(imp->iananame, pmap->iananame)) {
                                                                smh->ianacodes[i] = pmap->pt;
                                                                break;
                                                        }
                                                }
                                                switch_mutex_unlock(smh->sdp_mutex);
                
                                                already_did[smh->ianacodes[i]] = 1;
                                                
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", smh->ianacodes[i]);

                                                if (!ptime) {
                                                        ptime = imp->microseconds_per_packet / 1000;
                                                }

                                                got_vid++;
                                        }                                       
                                }
                                if (got_vid && v_engine->smode == SWITCH_MEDIA_FLOW_DISABLED) {
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_MEDIA_FLOW_SENDRECV, sdp_type);
                                }
                                
                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "\r\n");


                                if (!(vbw = switch_channel_get_variable(smh->session->channel, "rtp_video_max_bandwidth"))) {
                                        vbw = switch_channel_get_variable(smh->session->channel, "rtp_video_max_bandwidth_in");
                                }

                                if (!vbw) {
                                        vbw = "1mb";
                                }

                                bw = switch_parse_bandwidth_string(vbw);

                                if (bw > 0) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "b=AS:%d\r\n", bw);
                                        //switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "b=TIAS:%d\r\n", bw);
                                }



                                if (v_engine->codec_negotiated) {
                                        payload_map_t *pmap;

                                        //if (!strcasecmp(v_engine->cur_payload_map->rm_encoding, "VP8")) {
                                        //      vp8 = v_engine->cur_payload_map->pt;
                                        //}

                                        //if (!strcasecmp(v_engine->cur_payload_map->rm_encoding, "red")) {
                                        //      red = v_engine->cur_payload_map->pt;
                                        //}

                                        rate = v_engine->cur_payload_map->rm_rate;
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%ld\r\n",
                                                                        v_engine->cur_payload_map->pt, v_engine->cur_payload_map->rm_encoding,
                                                                        v_engine->cur_payload_map->rm_rate);

                                        if (switch_channel_test_flag(session->channel, CF_RECOVERING)) {
                                                pass_fmtp = v_engine->cur_payload_map->rm_fmtp;
                                        } else {

                                                pass_fmtp = NULL;

                                                if (ov_fmtp) {
                                                        pass_fmtp = ov_fmtp;
                                                } else {

                                                        pass_fmtp = v_engine->cur_payload_map->fmtp_out;

                                                        if (!pass_fmtp || switch_true(switch_channel_get_variable_dup(session->channel, "rtp_mirror_fmtp", SWITCH_FALSE, -1))) {
                                                                pass_fmtp = switch_channel_get_variable(session->channel, "rtp_video_fmtp");
                                                        }
                                                }
                                        }


                                        if (pass_fmtp) {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fmtp:%d %s\r\n", v_engine->cur_payload_map->pt, pass_fmtp);
                                        }


                                        if (switch_media_handle_test_media_flag(smh, SCMF_MULTI_ANSWER_VIDEO)) {
                                                switch_mutex_lock(smh->sdp_mutex);
                                                for (pmap = v_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                                                        if (pmap->pt != v_engine->cur_payload_map->pt && pmap->negotiated) {
                                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%ld\r\n",
                                                                                                pmap->pt, pmap->iananame, pmap->rate);
                                                        }
                                                }
                                                switch_mutex_unlock(smh->sdp_mutex);
                                        }


                                        if (append_video) {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "%s%s", append_video, end_of(append_video) == '\n' ? "" : "\r\n");
                                        }
                                        
                                } else if (smh->mparams->num_codecs) {
                                        int already_did[128] = { 0 };

                                        for (i = 0; i < smh->mparams->num_codecs; i++) {
                                                const switch_codec_implementation_t *imp = smh->codecs[i];
                                                char *fmtp = NULL;
                                                uint32_t ianacode = smh->ianacodes[i];
                                                int channels;

                                                if (imp->codec_type != SWITCH_CODEC_TYPE_VIDEO) {
                                                        continue;
                                                }

                                                if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND &&
                                                        switch_channel_test_flag(session->channel, CF_NOVIDEO)) {
                                                        continue;
                                                }

                                                if (ianacode < 128) {
                                                        if (already_did[ianacode]) {
                                                                continue;
                                                        }
                                                        already_did[ianacode] = 1;
                                                }

                                                if (!rate) {
                                                        rate = imp->samples_per_second;
                                                }

                                                channels = get_channels(imp->iananame, imp->number_of_channels);

                                                //if (!strcasecmp(imp->iananame, "VP8")) {
                                                //      vp8 = ianacode;
                                                //}

                                                //if (!strcasecmp(imp->iananame, "red")) {
                                                //              red = ianacode;
                                                //}

                                                if (channels > 1) {
                                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%d/%d\r\n", ianacode, imp->iananame,
                                                                                        imp->samples_per_second, channels);
                                                } else {
                                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%d\r\n", ianacode, imp->iananame,
                                                                                        imp->samples_per_second);
                                                }



                                                if (!zstr(ov_fmtp)) {
                                                        fmtp = (char *) ov_fmtp;
                                                } else {

                                                        if (map) {
                                                                fmtp = switch_event_get_header(map, imp->iananame);
                                                        }

                                                        if (!zstr(smh->fmtp[i])) {
                                                                fmtp = smh->fmtp[i];
                                                        } else if (smh->fmtps[i]) {
                                                                fmtp = smh->fmtps[i];
                                                        }

                                                        if (zstr(fmtp)) fmtp = imp->fmtp;

                                                        if (zstr(fmtp)) fmtp = (char *) pass_fmtp;
                                                }

                                                if (!zstr(fmtp) && strcasecmp(fmtp, "_blank_")) {
                                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fmtp:%d %s\r\n", ianacode, fmtp);
                                                }
                                        }

                                }
                                
                                if (v_engine->smode == SWITCH_MEDIA_FLOW_SENDRECV) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "%s", "a=sendrecv\r\n");
                                } else if (v_engine->smode == SWITCH_MEDIA_FLOW_SENDONLY) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "%s", "a=sendonly\r\n");
                                } else if (v_engine->smode == SWITCH_MEDIA_FLOW_RECVONLY) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "%s", "a=recvonly\r\n");
                                } else if (v_engine->smode == SWITCH_MEDIA_FLOW_INACTIVE) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "%s", "a=inactive\r\n");
                                }


                                if ((is_outbound || switch_channel_test_flag(session->channel, CF_RECOVERING))
                                        && switch_channel_test_flag(smh->session->channel, CF_DTLS)) {
                                        generate_local_fingerprint(smh, SWITCH_MEDIA_TYPE_VIDEO);
                                }


                                if (!zstr(v_engine->local_dtls_fingerprint.type)) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fingerprint:%s %s\r\na=setup:%s\r\n",
                                                                        v_engine->local_dtls_fingerprint.type, v_engine->local_dtls_fingerprint.str, get_setup(v_engine, session, sdp_type));
                                }


                                if (smh->mparams->rtcp_video_interval_msec) {
                                        if (v_engine->rtcp_mux > 0) {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtcp-mux\r\n");
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtcp:%d IN %s %s\r\n", v_port, family, ip);
                                        } else {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtcp:%d IN %s %s\r\n", v_port + 1, family, ip);
                                        }
                                }

                                if (sdp_type == SDP_OFFER) {
                                        fir++;
                                        pli++;
                                        nack++;
                                        tmmbr++;
                                }

                                /* DFF nack pli etc */
                                //nack = v_engine->nack = 0;
                                //pli = v_engine->pli = 0;


                                if (v_engine->codec_negotiated) {
                                        add_fb(buf, SDPBUFLEN, v_engine->cur_payload_map->pt, v_engine->fir || fir,
                                                   v_engine->nack || nack, v_engine->pli || pli, v_engine->tmmbr || tmmbr);

                                        if (switch_media_handle_test_media_flag(smh, SCMF_MULTI_ANSWER_VIDEO)) {
                                                switch_mutex_lock(smh->sdp_mutex);
                                                for (pmap = v_engine->cur_payload_map; pmap && pmap->allocated; pmap = pmap->next) {
                                                        if (pmap->pt != v_engine->cur_payload_map->pt && pmap->negotiated) {
                                                                add_fb(buf, SDPBUFLEN, pmap->pt, v_engine->fir || fir, v_engine->nack || nack, v_engine->pli || pli, v_engine->tmmbr || tmmbr);
                                                        }
                                                }
                                                switch_mutex_unlock(smh->sdp_mutex);
                                        }

                                } else if (smh->mparams->num_codecs) {
                                        int already_did[128] = { 0 };
                                        for (i = 0; i < smh->mparams->num_codecs; i++) {
                                                const switch_codec_implementation_t *imp = smh->codecs[i];


                                                if (imp->codec_type != SWITCH_CODEC_TYPE_VIDEO) {
                                                        continue;
                                                }

                                                if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND &&
                                                        switch_channel_test_flag(session->channel, CF_NOVIDEO)) {
                                                        continue;
                                                }

                                                if (smh->ianacodes[i] < 128) {
                                                        if (already_did[smh->ianacodes[i]]) {
                                                                continue;
                                                        }
                                                        already_did[smh->ianacodes[i]] = 1;
                                                }

                                                add_fb(buf, SDPBUFLEN, smh->ianacodes[i], v_engine->fir || fir, v_engine->nack || nack, v_engine->pli || pli, v_engine->pli || pli);
                                        }

                                }

                                //switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u\r\n", v_engine->ssrc);

                                if (v_engine->ice_out.cands[0][0].ready) {
                                        char tmp1[11] = "";
                                        char tmp2[11] = "";
                                        char tmp3[11] = "";
                                        uint32_t c1 = (1<<24)*126 + (1<<8)*65535 + (1<<0)*(256 - 1);
                                        uint32_t c2 = c1 - 1;
                                        uint32_t c3 = c1 - 2;
                                        uint32_t c4 = c1 - 3;

                                        tmp1[10] = '\0';
                                        tmp2[10] = '\0';
                                        tmp3[10] = '\0';
                                        switch_stun_random_string(tmp1, 10, "0123456789");
                                        switch_stun_random_string(tmp2, 10, "0123456789");
                                        switch_stun_random_string(tmp3, 10, "0123456789");

                                        ice_out = &v_engine->ice_out;


                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u cname:%s\r\n", v_engine->ssrc, smh->cname);
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u msid:%s v0\r\n", v_engine->ssrc, smh->msid);
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u mslabel:%s\r\n", v_engine->ssrc, smh->msid);
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u label:%sv0\r\n", v_engine->ssrc, smh->msid);



                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-ufrag:%s\r\n", ice_out->ufrag);
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-pwd:%s\r\n", ice_out->pwd);


                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ host generation 0\r\n",
                                                                        tmp1, ice_out->cands[0][0].transport, c1,
                                                                        ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port
                                                                        );

                                        if (include_external && !zstr(smh->mparams->extsipip)) {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ host generation 0\r\n",
                                                        tmp3, ice_out->cands[0][0].transport, c1,
                                                        smh->mparams->extsipip, ice_out->cands[0][0].con_port
                                                        );
                                        }

                                        if (!zstr(v_engine->local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) && 
                                                strcmp(v_engine->local_sdp_ip, ice_out->cands[0][0].con_addr)
                                                && v_engine->local_sdp_port != ice_out->cands[0][0].con_port) {

                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ srflx raddr %s rport %d generation 0\r\n",
                                                                                tmp2, ice_out->cands[0][0].transport, c3,
                                                                                ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port,
                                                                                v_engine->local_sdp_ip, v_engine->local_sdp_port
                                                                                );
                                        }


                                        if (v_engine->rtcp_mux < 1 || is_outbound || switch_channel_test_flag(session->channel, CF_RECOVERING)) {

                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ host generation 0\r\n",
                                                                                tmp1, ice_out->cands[0][0].transport, c2,
                                                                                ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (v_engine->rtcp_mux > 0 ? 0 : 1)
                                                                                );

                                        if (include_external && !zstr(smh->mparams->extsipip)) {
                                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ host generation 0\r\n",
                                                                tmp3, ice_out->cands[0][0].transport, c2,
                                                                smh->mparams->extsipip, ice_out->cands[0][0].con_port + (v_engine->rtcp_mux > 0 ? 0 : 1)
                                                                );
                                                }


                                                if (!zstr(v_engine->local_sdp_ip) && !zstr(ice_out->cands[0][1].con_addr) && 
                                                        strcmp(v_engine->local_sdp_ip, ice_out->cands[0][1].con_addr)
                                                        && v_engine->local_sdp_port != ice_out->cands[0][1].con_port) {

                                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ srflx generation 0\r\n",
                                                                                        tmp2, ice_out->cands[0][0].transport, c4,
                                                                                        ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (v_engine->rtcp_mux > 0 ? 0 : 1),
                                                                                        v_engine->local_sdp_ip, v_engine->local_sdp_port + (v_engine->rtcp_mux > 0 ? 0 : 1)
                                                                                        );
                                                }
                                        }



#ifdef GOOGLE_ICE
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-options:google-ice\r\n");
#endif
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=end-of-candidates\r\n");

                                }



                                if (loops == 0 && switch_channel_test_flag(session->channel, CF_SECURE) && !switch_channel_test_flag(session->channel, CF_DTLS)) {

                                        for (i = 0; smh->crypto_suite_order[i] != CRYPTO_INVALID; i++) {
                                                switch_rtp_crypto_key_type_t j = SUITES[smh->crypto_suite_order[i]].type;

                                                if ((a_engine->crypto_type == j || a_engine->crypto_type == CRYPTO_INVALID) && !zstr(a_engine->ssec[j].local_crypto_key)) {
                                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=crypto:%s\r\n", v_engine->ssec[j].local_crypto_key);
                                                }
                                        }
                                        //switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "a=encryption:optional\r\n");
                                }


                                if (switch_channel_test_flag(session->channel, CF_DTLS) ||
                                        !switch_channel_test_flag(session->channel, CF_SECURE) ||
                                        smh->crypto_mode == CRYPTO_MODE_MANDATORY || smh->crypto_mode == CRYPTO_MODE_FORBIDDEN) {
                                        break;
                                }
                        }
                }

        }

        if (switch_channel_test_cap(session->channel, CC_MSRP) && !smh->msrp_session) {
                int want_msrp = switch_channel_var_true(session->channel, "sip_enable_msrp");
                int want_msrps = switch_channel_var_true(session->channel, "sip_enable_msrps");

                if (!want_msrp) {
                        want_msrp = switch_channel_test_flag(session->channel, CF_WANT_MSRP);
                }

                if (!want_msrps) {
                        want_msrps = switch_channel_test_flag(session->channel, CF_WANT_MSRPS);
                }

                if (want_msrp || want_msrps) {
                        smh->msrp_session = switch_msrp_session_new(switch_core_session_get_pool(session), switch_core_session_get_uuid(session), want_msrps);

                        switch_assert(smh->msrp_session);
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "MSRP session created %s\n", smh->msrp_session->call_id);

                        switch_channel_set_flag(session->channel, CF_HAS_TEXT);
                        switch_channel_set_flag(session->channel, CF_TEXT_POSSIBLE);
                        switch_channel_set_flag(session->channel, CF_TEXT_LINE_BASED);
                        switch_channel_set_flag(session->channel, CF_MSRP);

                        if (want_msrps) {
                                switch_channel_set_flag(session->channel, CF_MSRPS);
                        }

                        switch_core_session_start_text_thread(session);
                }
        }

        if (smh->msrp_session) {
                switch_msrp_session_t *msrp_session = smh->msrp_session;

                if (!zstr(msrp_session->remote_path)) {
                        if (zstr(msrp_session->local_path)) {
                                msrp_session->local_path = switch_core_session_sprintf(session,
                                        "msrp%s://%s:%d/%s;tcp",
                                        msrp_session->secure ? "s" : "",
                                        ip, msrp_session->local_port, msrp_session->call_id);
                        }

                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf),
                                "m=message %d TCP/%sMSRP *\r\n"
                                "a=path:%s\r\n"
                                "a=accept-types:%s\r\n"
                                "a=accept-wrapped-types:%s\r\n"
                                "a=setup:%s\r\n",
                                msrp_session->local_port,
                                msrp_session->secure ? "TLS/" : "",
                                msrp_session->local_path,
                                msrp_session->local_accept_types,
                                msrp_session->local_accept_wrapped_types,
                                msrp_session->active ? "active" : "passive");
                } else {
                        char *uuid = switch_core_session_get_uuid(session);
                        const char *file_selector = switch_channel_get_variable(session->channel, "sip_msrp_local_file_selector");
                        const char *msrp_offer_active = switch_channel_get_variable(session->channel, "sip_msrp_offer_active");

                        if (switch_true(msrp_offer_active)) {
                                msrp_session->active = 1;
                                // switch_msrp_start_client(msrp_session);
                        }

                        if (zstr(msrp_session->local_path)) {
                                msrp_session->local_path = switch_core_session_sprintf(session,
                                        "msrp%s://%s:%d/%s;tcp",
                                        msrp_session->secure ? "s" : "",
                                        ip, msrp_session->local_port, uuid);
                        }

                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf),
                                "m=message %d TCP/%sMSRP *\r\n"
                                "a=path:%s\r\n"
                                "a=accept-types:message/cpim text/* application/im-iscomposing+xml\r\n"
                                "a=accept-wrapped-types:*\r\n"
                                "a=setup:%s\r\n",
                                msrp_session->local_port,
                                msrp_session->secure ? "TLS/" : "",
                                msrp_session->local_path,
                                msrp_session->active ? "active" : "passive");

                        if (!zstr(file_selector)) {
                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf),
                                        "a=sendonly\r\na=file-selector:%s\r\n", file_selector);
                        }
                }
        }

        // RTP TEXT

        if (sdp_type == SDP_ANSWER && !switch_channel_test_flag(session->channel, CF_RTT)) {
                if (switch_channel_test_flag(session->channel, CF_TEXT_SDP_RECVD)) {
                        switch_channel_clear_flag(session->channel, CF_TEXT_SDP_RECVD);
                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "m=text 0 %s 19\r\n",
                                                        get_media_profile_name(session,
                                                                                                   (switch_channel_test_flag(session->channel, CF_SECURE)
                                                                                                        && switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND) ||
                                                                                                   a_engine->crypto_type != CRYPTO_INVALID || switch_channel_test_flag(session->channel, CF_DTLS), AVP_UNDEFINED));
                }
        } else if ((switch_channel_test_flag(session->channel, CF_WANT_RTT) || switch_channel_test_flag(session->channel, CF_RTT) ||
                                switch_channel_var_true(session->channel, "rtp_enable_text")) &&
                           switch_channel_test_cap(session->channel, CC_RTP_RTT)) {
                t_engine->t140_pt = 0;
                t_engine->red_pt = 0;

                if (sdp_type == SDP_OFFER) {
                        t_engine->t140_pt = 96;
                        t_engine->red_pt = 97;

                        switch_core_media_add_payload_map(session,
                                                                                          SWITCH_MEDIA_TYPE_TEXT,
                                                                                          "red",
                                                                                          NULL,
                                                                                          NULL,
                                                                                          SDP_OFFER,
                                                                                          t_engine->red_pt,
                                                                                          1000,
                                                                                          0,
                                                                                          1,
                                                                                          SWITCH_TRUE);

                        switch_core_media_add_payload_map(session,
                                                                                          SWITCH_MEDIA_TYPE_TEXT,
                                                                                          "t140",
                                                                                          NULL,
                                                                                          NULL,
                                                                                          SDP_OFFER,
                                                                                          t_engine->t140_pt,
                                                                                          1000,
                                                                                          0,
                                                                                          1,
                                                                                          SWITCH_TRUE);

                        t_engine->codec_negotiated = 1;
                }

                if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND) {
                        if (switch_channel_test_flag(smh->session->channel, CF_DTLS)) {
                                t_engine->no_crypto = 1;
                        }
                }


                if (!t_engine->local_sdp_port) {
                        switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_TEXT, 0);
                }

                if ((t_port = t_engine->adv_sdp_port)) {
                        int loops;

                        for (loops = 0; loops < 2; loops++) {

                                if (switch_channel_test_flag(smh->session->channel, CF_ICE)) {
                                        gen_ice(session, SWITCH_MEDIA_TYPE_TEXT, ip, (switch_port_t)t_port);
                                }


                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "m=text %d %s",
                                                                t_port,
                                                                get_media_profile_name(session,
                                                                                                           (loops == 0 && switch_channel_test_flag(session->channel, CF_SECURE)
                                                                                                                && switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_OUTBOUND) ||
                                                                                                           a_engine->crypto_type != CRYPTO_INVALID || switch_channel_test_flag(session->channel, CF_DTLS), AVP_UNDEFINED));


                                /*****************************/
                                if (t_engine->codec_negotiated) {

                                        switch_mutex_lock(smh->sdp_mutex);
                                        for (pmap = t_engine->payload_map; pmap && pmap->allocated; pmap = pmap->next) {

                                                if (pmap->type != SWITCH_MEDIA_TYPE_TEXT || !pmap->negotiated) {
                                                        continue;
                                                }

                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), " %d", pmap->pt);

                                        }
                                        switch_mutex_unlock(smh->sdp_mutex);
                                } else {
                                        switch_core_media_set_smode(smh->session, SWITCH_MEDIA_TYPE_TEXT, SWITCH_MEDIA_FLOW_SENDRECV, sdp_type);
                                }

                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "\r\n");

                                if (t_engine->codec_negotiated) {
                                        switch_mutex_lock(smh->sdp_mutex);
                                        for (pmap = t_engine->payload_map; pmap && pmap->allocated; pmap = pmap->next) {

                                                if (pmap->type != SWITCH_MEDIA_TYPE_TEXT || !pmap->negotiated) {
                                                        continue;
                                                }

                                                if (!strcasecmp(pmap->iananame, "t140")) {
                                                        t_engine->t140_pt = pmap->pt;
                                                }

                                                if (!strcasecmp(pmap->iananame, "red")) {
                                                        t_engine->red_pt = pmap->pt;
                                                }

                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtpmap:%d %s/%ld\r\n",
                                                                                pmap->pt, pmap->iananame, pmap->rate);

                                        }
                                        switch_mutex_unlock(smh->sdp_mutex);


                                        if (t_engine->t140_pt && t_engine->red_pt) {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fmtp:%d %d/%d/%d\r\n", t_engine->red_pt, t_engine->t140_pt, t_engine->t140_pt, t_engine->t140_pt);
                                        }


                                        if (t_engine->smode == SWITCH_MEDIA_FLOW_SENDONLY) {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "%s", "a=sendonly\r\n");
                                        } else if (t_engine->smode == SWITCH_MEDIA_FLOW_RECVONLY) {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "%s", "a=recvonly\r\n");
                                        }

                                }

                                if ((is_outbound || switch_channel_test_flag(session->channel, CF_RECOVERING))
                                        && switch_channel_test_flag(smh->session->channel, CF_DTLS)) {
                                        generate_local_fingerprint(smh, SWITCH_MEDIA_TYPE_TEXT);
                                }


                                if (!zstr(t_engine->local_dtls_fingerprint.type)) {
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=fingerprint:%s %s\r\na=setup:%s\r\n", t_engine->local_dtls_fingerprint.type,
                                                                        t_engine->local_dtls_fingerprint.str, get_setup(t_engine, session, sdp_type));
                                }


                                if (smh->mparams->rtcp_text_interval_msec) {
                                        if (t_engine->rtcp_mux > 0) {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtcp-mux\r\n");
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtcp:%d IN %s %s\r\n", t_port, family, ip);
                                        } else {
                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=rtcp:%d IN %s %s\r\n", t_port + 1, family, ip);
                                        }
                                }

                                //switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u\r\n", t_engine->ssrc);

                                if (t_engine->ice_out.cands[0][0].ready) {
                                        char tmp1[11] = "";
                                        char tmp2[11] = "";
                                        uint32_t c1 = (1<<24)*126 + (1<<8)*65535 + (1<<0)*(256 - 1);
                                        uint32_t c2 = c1 - 1;
                                        uint32_t c3 = c1 - 2;
                                        uint32_t c4 = c1 - 3;

                                        tmp1[10] = '\0';
                                        tmp2[10] = '\0';
                                        switch_stun_random_string(tmp1, 10, "0123456789");
                                        switch_stun_random_string(tmp2, 10, "0123456789");

                                        ice_out = &t_engine->ice_out;


                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u cname:%s\r\n", t_engine->ssrc, smh->cname);
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u msid:%s v0\r\n", t_engine->ssrc, smh->msid);
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u mslabel:%s\r\n", t_engine->ssrc, smh->msid);
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ssrc:%u label:%sv0\r\n", t_engine->ssrc, smh->msid);



                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-ufrag:%s\r\n", ice_out->ufrag);
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-pwd:%s\r\n", ice_out->pwd);


                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ host generation 0\r\n",
                                                                        tmp1, ice_out->cands[0][0].transport, c1,
                                                                        ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port
                                                                        );

                                        if (!zstr(t_engine->local_sdp_ip) && !zstr(ice_out->cands[0][0].con_addr) &&
                                                strcmp(t_engine->local_sdp_ip, ice_out->cands[0][0].con_addr)
                                                && t_engine->local_sdp_port != ice_out->cands[0][0].con_port) {

                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 1 %s %u %s %d typ srflx raddr %s rport %d generation 0\r\n",
                                                                                tmp2, ice_out->cands[0][0].transport, c3,
                                                                                ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port,
                                                                                t_engine->local_sdp_ip, t_engine->local_sdp_port
                                                                                );
                                        }


                                        if (t_engine->rtcp_mux < 1 || is_outbound || switch_channel_test_flag(session->channel, CF_RECOVERING)) {

                                                switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ host generation 0\r\n",
                                                                                tmp1, ice_out->cands[0][0].transport, c2,
                                                                                ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (t_engine->rtcp_mux > 0 ? 0 : 1)
                                                                                );


                                                if (!zstr(t_engine->local_sdp_ip) && !zstr(ice_out->cands[0][1].con_addr) &&
                                                        strcmp(t_engine->local_sdp_ip, ice_out->cands[0][1].con_addr)
                                                        && t_engine->local_sdp_port != ice_out->cands[0][1].con_port) {

                                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=candidate:%s 2 %s %u %s %d typ srflx generation 0\r\n",
                                                                                        tmp2, ice_out->cands[0][0].transport, c4,
                                                                                        ice_out->cands[0][0].con_addr, ice_out->cands[0][0].con_port + (t_engine->rtcp_mux > 0 ? 0 : 1),
                                                                                        t_engine->local_sdp_ip, t_engine->local_sdp_port + (t_engine->rtcp_mux > 0 ? 0 : 1)
                                                                                        );
                                                }
                                        }



#ifdef GOOGLE_ICE
                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=ice-options:google-ice\r\n");
#endif
                                }



                                if (loops == 0 && switch_channel_test_flag(session->channel, CF_SECURE) && !switch_channel_test_flag(session->channel, CF_DTLS)) {

                                        for (i = 0; smh->crypto_suite_order[i] != CRYPTO_INVALID; i++) {
                                                switch_rtp_crypto_key_type_t j = SUITES[smh->crypto_suite_order[i]].type;

                                                if ((t_engine->crypto_type == j || t_engine->crypto_type == CRYPTO_INVALID) && !zstr(t_engine->ssec[j].local_crypto_key)) {
                                                        switch_snprintf(buf + strlen(buf), SDPBUFLEN - strlen(buf), "a=crypto:%s\r\n", t_engine->ssec[j].local_crypto_key);
                                                }
                                        }
                                        //switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "a=encryption:optional\r\n");
                                }


                                if (switch_channel_test_flag(session->channel, CF_DTLS) ||
                                        !switch_channel_test_flag(session->channel, CF_SECURE) ||
                                        smh->crypto_mode == CRYPTO_MODE_MANDATORY || smh->crypto_mode == CRYPTO_MODE_FORBIDDEN) {
                                        break;
                                }
                        }
                }

        }

        if (map) {
                switch_event_destroy(&map);
        }

        if (ptmap) {
                switch_event_destroy(&ptmap);
        }

        switch_core_media_set_local_sdp(session, buf, SWITCH_TRUE);

        check_stream_changes(session, NULL, sdp_type);

        switch_safe_free(buf);
}



//?
SWITCH_DECLARE(void) switch_core_media_absorb_sdp(switch_core_session_t *session)
{
        const char *sdp_str;
        switch_rtp_engine_t *a_engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];

        if ((sdp_str = switch_channel_get_variable(session->channel, SWITCH_B_SDP_VARIABLE))) {
                sdp_parser_t *parser;
                sdp_session_t *sdp;
                sdp_media_t *m;
                sdp_connection_t *connection;

                if ((parser = sdp_parse(NULL, sdp_str, (int) strlen(sdp_str), 0))) {
                        if ((sdp = sdp_session(parser))) {
                                for (m = sdp->sdp_media; m; m = m->m_next) {
                                        if (m->m_type != sdp_media_audio || !m->m_port) {
                                                continue;
                                        }

                                        connection = sdp->sdp_connection;
                                        if (m->m_connections) {
                                                connection = m->m_connections;
                                        }

                                        if (connection) {
                                                a_engine->proxy_sdp_ip = switch_core_session_strdup(session, connection->c_address);
                                        }
                                        a_engine->proxy_sdp_port = (switch_port_t) m->m_port;
                                        if (a_engine->proxy_sdp_ip && a_engine->proxy_sdp_port) {
                                                break;
                                        }
                                }
                        }
                        sdp_parser_free(parser);
                }
                switch_core_media_set_local_sdp(session, sdp_str, SWITCH_TRUE);
        }
}

static switch_bool_t stream_rejected(switch_media_handle_t *smh, sdp_media_e st)
{
        int x;

        for (x = 0; x < smh->rej_idx; x++) {
                if (smh->rejected_streams[x] == st) {
                        return SWITCH_TRUE;
                }
        }

        return SWITCH_FALSE;
}

//?
SWITCH_DECLARE(void) switch_core_media_set_udptl_image_sdp(switch_core_session_t *session, switch_t38_options_t *t38_options, int insist)
{
        char buf[2048] = "";
        char max_buf[128] = "";
        char max_data[128] = "";
        const char *ip;
        uint32_t port;
        const char *family = "IP4";
        const char *username;
        const char *bit_removal_on = "a=T38FaxFillBitRemoval\r\n";
        const char *bit_removal_off = "";

        const char *mmr_on = "a=T38FaxTranscodingMMR\r\n";
        const char *mmr_off = "";

        const char *jbig_on = "a=T38FaxTranscodingJBIG\r\n";
        const char *jbig_off = "";
        const char *var;
        int broken_boolean;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];

        switch_channel_clear_flag(session->channel, CF_IMAGE_SDP);

        switch_assert(t38_options);

        ip = t38_options->local_ip;
        port = t38_options->local_port;
        username = smh->mparams->sdp_username;

        var = switch_channel_get_variable(session->channel, "t38_broken_boolean");

        broken_boolean = switch_true(var);


        if (!ip) {
                if (!(ip = a_engine->adv_sdp_ip)) {
                        ip = a_engine->proxy_sdp_ip;
                }
        }

        if (!ip) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "%s NO IP!\n", switch_channel_get_name(session->channel));
                return;
        }

        if (!port) {
                if (!(port = a_engine->adv_sdp_port)) {
                        port = a_engine->proxy_sdp_port;
                }
        }

        if (!port) {
                switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "%s NO PORT!\n", switch_channel_get_name(session->channel));
                return;
        }

        if (!smh->owner_id) {
                smh->owner_id = (uint32_t)(switch_time_t)switch_epoch_time_now(NULL) - port;
        }

        if (!smh->session_id) {
                smh->session_id = smh->owner_id;
        }

        smh->session_id++;

        family = strchr(ip, ':') ? "IP6" : "IP4";


        switch_snprintf(buf, sizeof(buf),
                                        "v=0\r\n"
                                        "o=%s %010u %010u IN %s %s\r\n"
                                        "s=%s\r\n" "c=IN %s %s\r\n" "t=0 0\r\n", username, smh->owner_id, smh->session_id, family, ip, username, family, ip);

        if (t38_options->T38FaxMaxBuffer) {
                switch_snprintf(max_buf, sizeof(max_buf), "a=T38FaxMaxBuffer:%d\r\n", t38_options->T38FaxMaxBuffer);
        };

        if (t38_options->T38FaxMaxDatagram) {
                switch_snprintf(max_data, sizeof(max_data), "a=T38FaxMaxDatagram:%d\r\n", t38_options->T38FaxMaxDatagram);
        };




        if (broken_boolean) {
                bit_removal_on = "a=T38FaxFillBitRemoval:1\r\n";
                bit_removal_off = "a=T38FaxFillBitRemoval:0\r\n";

                mmr_on = "a=T38FaxTranscodingMMR:1\r\n";
                mmr_off = "a=T38FaxTranscodingMMR:0\r\n";

                jbig_on = "a=T38FaxTranscodingJBIG:1\r\n";
                jbig_off = "a=T38FaxTranscodingJBIG:0\r\n";

        }

        if (stream_rejected(smh, sdp_media_audio)) {
                switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
                                                "m=audio 0 RTP/AVP 0\r\n");
        }

        switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
                                        "m=image %d udptl t38\r\n"
                                        "a=T38FaxVersion:%d\r\n"
                                        "a=T38MaxBitRate:%d\r\n"
                                        "%s"
                                        "%s"
                                        "%s"
                                        "a=T38FaxRateManagement:%s\r\n"
                                        "%s"
                                        "%s"
                                        "a=T38FaxUdpEC:%s\r\n",
                                        //"a=T38VendorInfo:%s\r\n",
                                        port,
                                        t38_options->T38FaxVersion,
                                        t38_options->T38MaxBitRate,
                                        t38_options->T38FaxFillBitRemoval ? bit_removal_on : bit_removal_off,
                                        t38_options->T38FaxTranscodingMMR ? mmr_on : mmr_off,
                                        t38_options->T38FaxTranscodingJBIG ? jbig_on : jbig_off,
                                        t38_options->T38FaxRateManagement,
                                        max_buf,
                                        max_data,
                                        t38_options->T38FaxUdpEC
                                        //t38_options->T38VendorInfo ? t38_options->T38VendorInfo : "0 0 0"
                                        );



        if (insist) {
                switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "m=audio 0 RTP/AVP 19\r\n");
        }

        switch_core_media_set_local_sdp(session, buf, SWITCH_TRUE);


        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s image media sdp:\n%s\n",
                                          switch_channel_get_name(session->channel), smh->mparams->local_sdp_str);


}



//?
SWITCH_DECLARE(void) switch_core_media_patch_sdp(switch_core_session_t *session)
{
        switch_size_t len;
        char *p, *q, *pe, *qe;
        int has_video = 0, has_audio = 0, has_text = 0, has_ip = 0;
        char port_buf[25] = "";
        char vport_buf[25] = "";
        char tport_buf[25] = "";
        char *new_sdp;
        int bad = 0;
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        payload_map_t *pmap;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (zstr(smh->mparams->local_sdp_str)) {
                return;
        }

        len = strlen(smh->mparams->local_sdp_str) * 2;

        if (!(smh->mparams->ndlb & SM_NDLB_NEVER_PATCH_REINVITE)) {
                if (switch_channel_test_flag(session->channel, CF_ANSWERED) &&
                        (switch_stristr("sendonly", smh->mparams->local_sdp_str) || switch_stristr("inactive", smh->mparams->local_sdp_str) || switch_stristr("0.0.0.0", smh->mparams->local_sdp_str))) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Skip patch on hold SDP\n");
                        return;
                }
        }

        if (zstr(a_engine->local_sdp_ip) || !a_engine->local_sdp_port) {// || switch_channel_test_flag(session->channel, CF_PROXY_MEDIA)) {
                if (switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_AUDIO, 1) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "%s I/O Error\n",
                                                          switch_channel_get_name(session->channel));
                        return;
                }

                clear_pmaps(a_engine);

                switch_channel_set_flag(session->channel, CF_AUDIO);

                pmap = switch_core_media_add_payload_map(session,
                                                                                                 SWITCH_MEDIA_TYPE_AUDIO,
                                                                                                 "PROXY",
                                                                                                 NULL,
                                                                                                 NULL,
                                                                                                 SDP_ANSWER,
                                                                                                 0,
                                                                                                 8000,
                                                                                                 20,
                                                                                                 1,
                                                                                                 SWITCH_TRUE);

                a_engine->cur_payload_map = pmap;

        }

        new_sdp = switch_core_session_alloc(session, len);
        switch_snprintf(port_buf, sizeof(port_buf), "%u", a_engine->local_sdp_port);


        p = smh->mparams->local_sdp_str;
        q = new_sdp;
        pe = p + strlen(p);
        qe = q + len - 1;


        while (p && *p) {
                if (p >= pe) {
                        bad = 1;
                        goto end;
                }

                if (q >= qe) {
                        bad = 2;
                        goto end;
                }

                if (a_engine->local_sdp_ip && !strncmp("c=IN IP", p, 7)) {
                        strncpy(q, p, 7);
                        p += 7;
                        q += 7;
                        memcpy(q, strchr(a_engine->adv_sdp_ip, ':') ? "6 " : "4 ", 2);
                        p +=2;
                        q +=2;
                        snprintf(q, qe - q, "%s", a_engine->adv_sdp_ip);
                        q += strlen(a_engine->adv_sdp_ip);

                        while (p && *p && ((*p >= '0' && *p <= '9') || *p == '.' || *p == ':' || (*p >= 'A' && *p <= 'F') || (*p >= 'a' && *p <= 'f'))) {
                                if (p >= pe) {
                                        bad = 3;
                                        goto end;
                                }
                                p++;
                        }

                        has_ip++;

                } else if (!strncmp("o=", p, 2)) {
                        char *oe = strchr(p, '\n');
                        switch_size_t len;

                        if (oe) {
                                const char *family = "IP4";
                                char o_line[1024] = "";

                                if (oe >= pe) {
                                        bad = 4;
                                        goto end;
                                }

                                len = (oe - p);
                                p += len;


                                family = strchr(smh->mparams->sipip, ':') ? "IP6" : "IP4";

                                if (!smh->owner_id) {
                                        smh->owner_id = (uint32_t)(switch_time_t) switch_epoch_time_now(NULL) * 31821U + 13849U;
                                }

                                if (!smh->session_id) {
                                        smh->session_id = smh->owner_id;
                                }

                                smh->session_id++;


                                snprintf(o_line, sizeof(o_line), "o=%s %010u %010u IN %s %s\r\n",
                                                 smh->mparams->sdp_username, smh->owner_id, smh->session_id, family, smh->mparams->sipip);

                                snprintf(q, qe-q, "%s", o_line);
                                q += strlen(o_line) - 1;

                        }

                } else if (!strncmp("s=", p, 2)) {
                        char *se = strchr(p, '\n');
                        switch_size_t len;

                        if (se) {
                                char s_line[1024] = "";

                                if (se >= pe) {
                                        bad = 5;
                                        goto end;
                                }

                                len = (se - p);
                                p += len;

                                snprintf(s_line, sizeof(s_line), "s=%s\r\n", smh->mparams->sdp_username);
                                snprintf(q, qe-q, "%s", s_line);

                                q += strlen(s_line) - 1;

                        }

                } else if ((!strncmp("m=audio ", p, 8) && *(p + 8) != '0') || (!strncmp("m=image ", p, 8) && *(p + 8) != '0')) {
                        strncpy(q, p, 8);
                        p += 8;

                        if (p >= pe) {
                                bad = 6;
                                goto end;
                        }


                        q += 8;

                        if (q >= qe) {
                                bad = 7;
                                goto end;
                        }


                        snprintf(q, qe - q, "%s", port_buf);
                        q += strlen(port_buf);

                        if (q >= qe) {
                                bad = 8;
                                goto end;
                        }

                        while (p && *p && (*p >= '0' && *p <= '9')) {
                                if (p >= pe) {
                                        bad = 9;
                                        goto end;
                                }
                                p++;
                        }

                        has_audio++;

                } else if (!strncmp("m=video ", p, 8) && *(p + 8) != '0') {
                        if (!has_video) {
                                switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 1);
                                clear_pmaps(v_engine);
                                pmap = switch_core_media_add_payload_map(session,
                                                                                                                 SWITCH_MEDIA_TYPE_VIDEO,
                                                                                                                 "PROXY-VID",
                                                                                                                 NULL,
                                                                                                                 NULL,
                                                                                                                 SDP_ANSWER,
                                                                                                                 0,
                                                                                                                 90000,
                                                                                                                 90000,
                                                                                                                 1,
                                                                                                                 SWITCH_TRUE);
                                v_engine->cur_payload_map = pmap;

                                switch_snprintf(vport_buf, sizeof(vport_buf), "%u", v_engine->adv_sdp_port);

                                if (switch_channel_media_ready(session->channel) && !switch_rtp_ready(v_engine->rtp_session)) {
                                        switch_channel_set_flag(session->channel, CF_VIDEO_POSSIBLE);
                                        switch_channel_set_flag(session->channel, CF_REINVITE);
                                        switch_core_media_activate_rtp(session);
                                }

                                v_engine->codec_negotiated = 1;
                                switch_core_media_set_video_codec(session, SWITCH_FALSE);
                        }

                        strncpy(q, p, 8);
                        p += 8;

                        if (p >= pe) {
                                bad = 10;
                                goto end;
                        }

                        q += 8;

                        if (q >= qe) {
                                bad = 11;
                                goto end;
                        }

                        snprintf(q, qe-q, "%s", vport_buf);
                        q += strlen(vport_buf);

                        if (q >= qe) {
                                bad = 12;
                                goto end;
                        }

                        while (p && *p && (*p >= '0' && *p <= '9')) {

                                if (p >= pe) {
                                        bad = 13;
                                        goto end;
                                }

                                p++;
                        }

                        has_video++;
                } else if (!strncmp("m=text ", p, 7) && *(p + 7) != '0') {
                        if (!has_text) {
                                switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_TEXT, 1);
                                clear_pmaps(t_engine);
                                pmap = switch_core_media_add_payload_map(session,
                                                                                                                 SWITCH_MEDIA_TYPE_TEXT,
                                                                                                                 "PROXY-TXT",
                                                                                                                 NULL,
                                                                                                                 NULL,
                                                                                                                 SDP_ANSWER,
                                                                                                                 0,
                                                                                                                 90000,
                                                                                                                 90000,
                                                                                                                 1,
                                                                                                                 SWITCH_TRUE);
                                t_engine->cur_payload_map = pmap;

                                switch_snprintf(tport_buf, sizeof(tport_buf), "%u", t_engine->adv_sdp_port);

                                if (switch_channel_media_ready(session->channel) && !switch_rtp_ready(t_engine->rtp_session)) {
                                        switch_channel_set_flag(session->channel, CF_TEXT_POSSIBLE);
                                        switch_channel_set_flag(session->channel, CF_REINVITE);
                                        switch_core_media_activate_rtp(session);
                                }

                                t_engine->codec_negotiated = 1;
                                //TEXT switch_core_media_set_text_codec(session, SWITCH_FALSE);
                        }

                        strncpy(q, p, 7);
                        p += 7;

                        if (p >= pe) {
                                bad = 14;
                                goto end;
                        }

                        q += 7;

                        if (q >= qe) {
                                bad = 15;
                                goto end;
                        }

                        snprintf(q, qe-q, "%s", tport_buf);
                        q += strlen(tport_buf);

                        if (q >= qe) {
                                bad = 16;
                                goto end;
                        }

                        while (p && *p && (*p >= '0' && *p <= '9')) {

                                if (p >= pe) {
                                        bad = 17;
                                        goto end;
                                }

                                p++;
                        }

                        has_text++;
                }


                while (p && *p && *p != '\n') {

                        if (p >= pe) {
                                bad = 18;
                                goto end;
                        }

                        if (q >= qe) {
                                bad = 19;
                                goto end;
                        }

                        *q++ = *p++;
                }

                if (p >= pe) {
                        bad = 20;
                        goto end;
                }

                if (q >= qe) {
                        bad = 21;
                        goto end;
                }

                *q++ = *p++;

        }

 end:

        if (bad) {
                return;
        }


        if (switch_channel_down(session->channel)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s too late.\n", switch_channel_get_name(session->channel));
                return;
        }


        if (!has_ip && !has_audio) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s SDP has no audio in it.\n%s\n",
                                                  switch_channel_get_name(session->channel), smh->mparams->local_sdp_str);
                return;
        }


        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Patched SDP\n---\n%s\n+++\n%s\n",
                                          switch_channel_get_name(session->channel), smh->mparams->local_sdp_str, new_sdp);

        switch_core_media_set_local_sdp(session, new_sdp, SWITCH_FALSE);

}

//?
SWITCH_DECLARE(void) switch_core_media_start_udptl(switch_core_session_t *session, switch_t38_options_t *t38_options)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_channel_down(session->channel)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];


        if (switch_rtp_ready(a_engine->rtp_session)) {
                char *remote_host = switch_rtp_get_remote_host(a_engine->rtp_session);
                switch_port_t remote_port = switch_rtp_get_remote_port(a_engine->rtp_session);
                const char *err, *val;

                switch_channel_clear_flag(session->channel, CF_NOTIMER_DURING_BRIDGE);
                switch_rtp_udptl_mode(a_engine->rtp_session);

                if (!t38_options || !t38_options->remote_ip) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "No remote address\n");
                        return;
                }

                if (remote_host && remote_port && remote_port == t38_options->remote_port && !strcmp(remote_host, t38_options->remote_ip)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Remote address:port [%s:%d] has not changed.\n",
                                                          t38_options->remote_ip, t38_options->remote_port);
                        return;
                }

                if (switch_rtp_set_remote_address(a_engine->rtp_session, t38_options->remote_ip,
                                                                                  t38_options->remote_port, 0, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "IMAGE UDPTL REPORTS ERROR: [%s]\n", err);
                } else {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "IMAGE UDPTL CHANGING DEST TO: [%s:%d]\n",
                                                          t38_options->remote_ip, t38_options->remote_port);
                        if (!switch_media_handle_test_media_flag(smh, SCMF_DISABLE_RTP_AUTOADJ) && !switch_channel_test_flag(session->channel, CF_AVPF) &&
                                !((val = switch_channel_get_variable(session->channel, "disable_udptl_auto_adjust")) && switch_true(val))) {
                                /* Reactivate the NAT buster flag. */
                                switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
                        }
                }
        }
}

//?
SWITCH_DECLARE(void) switch_core_media_hard_mute(switch_core_session_t *session, switch_bool_t on)
{
        switch_core_session_message_t msg = { 0 };

        msg.from = __FILE__;

        msg.message_id = SWITCH_MESSAGE_INDICATE_HARD_MUTE;
        msg.numeric_arg = on;
        switch_core_session_receive_message(session, &msg);
}

SWITCH_DECLARE(cJSON *) switch_core_media_gen_json_constraint(float min, float ideal, float max)
{
        cJSON *ret = NULL, *n = NULL;

        if ((!ideal && !max)) {
                ret = cJSON_CreateNumber(min);
        } else {
                ret = cJSON_CreateObject();
                n = cJSON_CreateNumber(min);
                cJSON_AddItemToObject(ret, "min", n);
                
                if (ideal) {
                        n = cJSON_CreateNumber(ideal);
                        cJSON_AddItemToObject(ret, "ideal", n);
                }

                if (max) {
                        n = cJSON_CreateNumber(max);
                        cJSON_AddItemToObject(ret, "max", n);
                }
        }

        return ret;
}

static cJSON *parse_val(char *str) {
        char *argv[3];
        int argc = 0;
        float min = 0, ideal = 0, max = 0;
        
        argc = switch_separate_string(str, ':', argv, (sizeof(argv) / sizeof(argv[0])));

        if (argc > 0) {
                min = atof(argv[0]);
        }

        if (argc > 1) {
                ideal = atof(argv[1]);
        }

        if (argc > 2) {
                max = atof(argv[2]);
        }
        
        return switch_core_media_gen_json_constraint(min, ideal, max);

}

SWITCH_DECLARE(switch_status_t) switch_core_media_media_params(switch_core_session_t *session, const char *json)
{
        switch_core_session_message_t msg = { 0 };
        char *parse = NULL;
        char *argv[25];
    int argc = 0, i;
        switch_status_t r = SWITCH_STATUS_SUCCESS;
        cJSON *obj = NULL;
        char *aspect = NULL, *fps = NULL, *width = NULL, *height = NULL, *jtmp = NULL;

        
        if (switch_channel_test_flag(session->channel, CF_MANUAL_MEDIA_PARAMS)) {
                return SWITCH_STATUS_INUSE;
        }
        
        if (switch_stristr("=", json)) {
                char *name, *val;
                cJSON *video, *p;
                int vid = 0;
                
                parse = strdup(json);
                argc = switch_separate_string(parse, ' ', argv, (sizeof(argv) / sizeof(argv[0])));

                for(i = 0; i < argc; i++) {
                        name = argv[i];
                        if ((val = strchr(name, '='))) {
                                *val++ = '\0';
                        }

                        if (val) {
                                if (!strcmp(name, "aspect")) {
                                        aspect = val;
                                        vid++;
                                } else if (!strcmp(name, "fps")) {
                                        fps = val;              
                                        vid++;
                                } else if (!strcmp(name, "width")) {
                                        width = val;
                                        vid++;
                                } else if (!strcmp(name, "height")) {
                                        height = val;
                                        vid++;
                                }
                        }
                }

                obj = cJSON_CreateObject();

                if (vid) {
                        video = cJSON_CreateObject();

                        if (fps) {
                                p = parse_val(fps);
                                cJSON_AddItemToObject(video, "frameRate", p);
                        }

                        if (width) {
                                p = parse_val(width);
                                cJSON_AddItemToObject(video, "width", p);
                        }

                        if (height) {
                                p = parse_val(height);
                                cJSON_AddItemToObject(video, "height", p);
                        }

                        if (aspect) {
                                p = cJSON_CreateNumber(atof(aspect));
                                cJSON_AddItemToObject(video, "aspectRatio", p);
                        }
                        
                        cJSON_AddItemToObject(obj, "video", video);
                }

                jtmp = cJSON_PrintUnformatted(obj);
                json = jtmp;
        }


        
        msg.from = __FILE__;

        msg.message_id = SWITCH_MESSAGE_INDICATE_MEDIA_PARAMS;
        msg.string_arg = json;
        r = switch_core_session_receive_message(session, &msg);

        switch_safe_free(parse);
        switch_safe_free(jtmp);
        if (obj) {
                cJSON_Delete(obj);
        }
        
        return r;
}

static int check_engine(switch_rtp_engine_t *engine)
{
        dtls_state_t dtls_state = switch_rtp_dtls_state(engine->rtp_session, DTLS_TYPE_RTP);
        int flags = 0;
        switch_status_t status;

        if (dtls_state == DS_READY || dtls_state >= DS_FAIL) return 0;

        status = switch_rtp_zerocopy_read_frame(engine->rtp_session, &engine->read_frame, flags);

        if (!SWITCH_READ_ACCEPTABLE(status)) {
                return 0;
        }

        return 1;
}

SWITCH_DECLARE(switch_bool_t) switch_core_media_check_dtls(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;
        int checking = 0;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_FALSE;
        }

        if (!switch_channel_media_up(session->channel)) {
                return SWITCH_FALSE;
        }

        if (!switch_channel_test_flag(session->channel, CF_DTLS)) {
                return SWITCH_TRUE;
        }

        engine = &smh->engines[type];

        if (engine->rmode == SWITCH_MEDIA_FLOW_DISABLED) {
                return SWITCH_TRUE;
        }

        do {
                if (engine->rtp_session) checking = check_engine(engine);
        } while (switch_channel_ready(session->channel) && checking);

        if (!checking) {
                return SWITCH_TRUE;
        }

        return SWITCH_FALSE;
}

SWITCH_DECLARE(uint32_t) switch_core_media_get_orig_bitrate(switch_core_session_t *session, switch_media_type_t type) 
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        if (!(smh = session->media_handle)) {
                return 0;
        }

        if (switch_channel_down(session->channel)) {
                return 0;
        }

        engine = &smh->engines[type];

        if (engine) {
                return engine->orig_bitrate;
        } else {
                return 0;
        }
}

SWITCH_DECLARE(switch_status_t) switch_core_media_set_outgoing_bitrate(switch_core_session_t *session, switch_media_type_t type, uint32_t bitrate)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;
        switch_status_t status = SWITCH_STATUS_FALSE;
        uint32_t new_bitrate;

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_down(session->channel)) {
                return SWITCH_STATUS_FALSE;
        }

        engine = &smh->engines[type];

        new_bitrate = bitrate - bitrate * engine->bw_mult;
        if (switch_core_codec_ready(&engine->write_codec)) {
                status = switch_core_codec_control(&engine->write_codec, SCC_VIDEO_BANDWIDTH,
                                                                                   SCCT_INT, &new_bitrate, SCCT_NONE, NULL, NULL, NULL);
        }
        engine->orig_bitrate = bitrate;

        return status;
}

SWITCH_DECLARE(float) switch_core_media_get_media_bw_mult(switch_core_session_t *session) 
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        if (!(smh = session->media_handle)) {
                return 0;
        }

        if (switch_channel_down(session->channel)) {
                return 0;
        }

        engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        if (engine) {
                return engine->bw_mult;
        }
        return 0;
}

SWITCH_DECLARE(void) switch_core_media_set_media_bw_mult(switch_core_session_t *session, float mult)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_channel_down(session->channel)) {
                return;
        }

        engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        if (engine) {
                engine->bw_mult = mult;
        }
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_reset_jb(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *engine;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        engine = &smh->engines[type];

        if (switch_rtp_ready(engine->rtp_session)) {
                switch_rtp_reset_jb(engine->rtp_session);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg)
{
        switch_media_handle_t *smh;
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_status_t status = SWITCH_STATUS_SUCCESS;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_down(session->channel)) {
                return SWITCH_STATUS_FALSE;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        switch (msg->message_id) {

        case SWITCH_MESSAGE_RESAMPLE_EVENT:
                {
                        if (switch_rtp_ready(a_engine->rtp_session)) {
                                switch_channel_audio_sync(session->channel);
                                switch_rtp_reset_jb(a_engine->rtp_session);
                        }

                        if (switch_channel_test_flag(session->channel, CF_CONFERENCE)) {
                                switch_channel_set_flag(session->channel, CF_CONFERENCE_RESET_MEDIA);
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_HOLD:
                {
                        if (a_engine && a_engine->rtp_session) {
                                switch_rtp_set_max_missed_packets(a_engine->rtp_session, a_engine->max_missed_hold_packets);
                                switch_rtp_set_media_timeout(a_engine->rtp_session, a_engine->media_hold_timeout);
                        }

                        if (v_engine && v_engine->rtp_session) {
                                switch_rtp_set_media_timeout(v_engine->rtp_session, v_engine->media_hold_timeout);
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_UNHOLD:
                {
                        if (a_engine && a_engine->rtp_session) {
                                switch_rtp_set_max_missed_packets(a_engine->rtp_session, a_engine->max_missed_packets);
                                switch_rtp_set_media_timeout(a_engine->rtp_session, a_engine->media_timeout);
                        }

                        if (v_engine && v_engine->rtp_session) {
                                switch_rtp_set_media_timeout(v_engine->rtp_session, v_engine->media_timeout);
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ:
                {
                        if (v_engine->rtp_session) {
                                if (msg->numeric_arg || !switch_channel_test_flag(session->channel, CF_MANUAL_VID_REFRESH)) {
                                        if (switch_rtp_test_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_FIR)) {
                                                switch_rtp_video_refresh(v_engine->rtp_session);
                                        }// else {
                                        if (switch_rtp_test_flag(v_engine->rtp_session, SWITCH_RTP_FLAG_PLI)) {
                                                switch_rtp_video_loss(v_engine->rtp_session);
                                        }
                                        //}
                                }
                        }
                }

                break;

        case SWITCH_MESSAGE_INDICATE_PROXY_MEDIA:
                {
                        if (switch_rtp_ready(a_engine->rtp_session)) {
                                if (msg->numeric_arg) {
                                        switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA);
                                } else {
                                        switch_rtp_clear_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA);
                                }
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_JITTER_BUFFER:
                {
                        if (switch_rtp_ready(a_engine->rtp_session)) {
                                check_jb(session, msg->string_arg, 0, 0, SWITCH_FALSE);
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_HARD_MUTE:
                if (a_engine->rtp_session) {
                        a_engine->last_seq = 0;
                        
                        if (session->bugs && msg->numeric_arg) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
                                                                  "%s has a media bug, hard mute not allowed.\n", switch_channel_get_name(session->channel));
                        } else {
                                if (msg->numeric_arg) {
                                        switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_MUTE);
                                } else {
                                        switch_rtp_clear_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_MUTE);
                                }

                                rtp_flush_read_buffer(a_engine->rtp_session, SWITCH_RTP_FLUSH_ONCE);
                        }
                }

                break;

        case SWITCH_MESSAGE_INDICATE_BITRATE_REQ:
                {
                        if (v_engine->rtp_session) {
                                switch_rtp_req_bitrate(v_engine->rtp_session, msg->numeric_arg);
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_BITRATE_ACK:
                {
                        if (v_engine->rtp_session) {
                                switch_rtp_ack_bitrate(v_engine->rtp_session, msg->numeric_arg);
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_CODEC_DEBUG_REQ:
                {
                        switch_rtp_engine_t *engine = &smh->engines[msg->numeric_reply];
                        uint32_t level = (uint32_t) msg->numeric_arg;

                        if (engine->rtp_session) {
                                switch_core_codec_control(&engine->read_codec, SCC_DEBUG, SCCT_INT, (void *)&level, SCCT_NONE, NULL, NULL, NULL);
                                switch_core_codec_control(&engine->write_codec, SCC_DEBUG, SCCT_INT, (void *)&level, SCCT_NONE, NULL, NULL, NULL);
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_CODEC_SPECIFIC_REQ:
                {
                        switch_rtp_engine_t *engine;
                        switch_io_type_t iotype = SWITCH_IO_READ;
                        switch_media_type_t type = SWITCH_MEDIA_TYPE_AUDIO;
                        switch_codec_control_type_t reply_type = SCCT_NONE;
                        void *reply = NULL;

                        if (!strcasecmp(msg->string_array_arg[0], "video")) {
                                type = SWITCH_MEDIA_TYPE_VIDEO;
                        }

                        if (!strcasecmp(msg->string_array_arg[1], "write")) {
                                iotype = SWITCH_IO_WRITE;
                        }

                        engine = &smh->engines[type];

                        if (engine->rtp_session) {
                                if (iotype == SWITCH_IO_READ) {
                                        switch_core_codec_control(&engine->read_codec, SCC_CODEC_SPECIFIC,
                                                                                          SCCT_STRING, (void *)msg->string_array_arg[2],
                                                                                          SCCT_STRING, (void *)msg->string_array_arg[3], &reply_type, &reply);
                                } else {
                                        switch_core_codec_control(&engine->write_codec, SCC_CODEC_SPECIFIC,
                                                                                          SCCT_STRING, (void *)msg->string_array_arg[2],
                                                                                          SCCT_STRING, (void *)msg->string_array_arg[3], &reply_type, &reply);
                                }


                                if (reply_type == SCCT_STRING) {
                                        msg->string_array_arg[4] = (char *)reply;
                                }
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_DEBUG_MEDIA:
                {
                        switch_rtp_t *rtp = a_engine->rtp_session;
                        const char *direction = msg->string_array_arg[0];

                        if (direction && *direction == 'v') {
                                direction++;
                                rtp = v_engine->rtp_session;
                        } else if (direction && *direction == 't' && t_engine) {
                                direction++;
                                rtp = t_engine->rtp_session;
                        }

                        if (switch_rtp_ready(rtp) && !zstr(direction) && !zstr(msg->string_array_arg[1])) {
                                switch_rtp_flag_t flags[SWITCH_RTP_FLAG_INVALID] = {0};
                                int both = !strcasecmp(direction, "both");
                                int set = 0;

                                if (both || !strcasecmp(direction, "read")) {
                                        flags[SWITCH_RTP_FLAG_DEBUG_RTP_READ]++;
                                        set++;
                                }

                                if (both || !strcasecmp(direction, "write")) {
                                        flags[SWITCH_RTP_FLAG_DEBUG_RTP_WRITE]++;
                                        set++;
                                }

                                if (set) {
                                        if (switch_true(msg->string_array_arg[1])) {
                                                switch_rtp_set_flags(rtp, flags);
                                        } else {
                                                switch_rtp_clear_flags(rtp, flags);
                                        }
                                } else {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid Options\n");
                                }
                        }
                }
                goto end;
        case SWITCH_MESSAGE_INDICATE_TRANSCODING_NECESSARY:
                if (a_engine->rtp_session && switch_rtp_test_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PASS_RFC2833)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Pass 2833 mode may not work on a transcoded call.\n");
                }
                goto end;

        case SWITCH_MESSAGE_INDICATE_BRIDGE:
                {

#if 0
                        if (switch_rtp_ready(v_engine->rtp_session)) {
                                const char *val;

                                if ((!(val = switch_channel_get_variable(session->channel, "rtp_jitter_buffer_during_bridge")) || switch_false(val))) {
                                        if (switch_rtp_get_jitter_buffer(v_engine->rtp_session) && switch_channel_test_cap_partner(session->channel, CC_FS_RTP)) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                  "%s PAUSE Jitterbuffer\n", switch_channel_get_name(session->channel));
                                                switch_rtp_pause_jitter_buffer(v_engine->rtp_session, SWITCH_TRUE);
                                                switch_set_flag(smh, SMF_VB_PAUSED);
                                        }
                                }
                        }
#endif 

                        if (switch_rtp_ready(a_engine->rtp_session)) {
                                const char *val;
                                int ok = 0;

                                if (!switch_channel_test_flag(session->channel, CF_VIDEO_READY) && 
                                        (!(val = switch_channel_get_variable(session->channel, "rtp_jitter_buffer_during_bridge")) || switch_false(val))) {
                                        if (switch_channel_test_flag(session->channel, CF_JITTERBUFFER) && switch_channel_test_cap_partner(session->channel, CC_FS_RTP)) {
                                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                                  "%s PAUSE Jitterbuffer\n", switch_channel_get_name(session->channel));
                                                switch_rtp_pause_jitter_buffer(a_engine->rtp_session, SWITCH_TRUE);
                                                switch_set_flag(smh, SMF_JB_PAUSED);
                                        }
                                }

                                if (switch_channel_test_flag(session->channel, CF_PASS_RFC2833) && switch_channel_test_flag_partner(session->channel, CF_FS_RTP)) {
                                        switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PASS_RFC2833);
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "%s activate passthru 2833 mode.\n", switch_channel_get_name(session->channel));
                                }


                                if ((val = switch_channel_get_variable(session->channel, "rtp_notimer_during_bridge"))) {
                                        ok = switch_true(val);
                                } else {
                                        ok = switch_channel_test_flag(session->channel, CF_RTP_NOTIMER_DURING_BRIDGE);
                                }

                                if (ok && !switch_rtp_test_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_USE_TIMER)) {
                                        ok = 0;
                                }

                                if (ok) {
                                        switch_rtp_clear_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
                                        //switch_rtp_clear_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
                                        switch_channel_set_flag(session->channel, CF_NOTIMER_DURING_BRIDGE);
                                }

                                if (ok && switch_channel_test_flag(session->channel, CF_NOTIMER_DURING_BRIDGE)) {
                                        /* these are not compat */
                                        ok = 0;
                                } else {
                                        if ((val = switch_channel_get_variable(session->channel, "rtp_autoflush_during_bridge"))) {
                                                ok = switch_true(val);
                                        } else {
                                                ok = smh->media_flags[SCMF_RTP_AUTOFLUSH_DURING_BRIDGE];
                                        }
                                }

                                if (ok) {
                                        rtp_flush_read_buffer(a_engine->rtp_session, SWITCH_RTP_FLUSH_STICK);
                                        switch_channel_set_flag(session->channel, CF_AUTOFLUSH_DURING_BRIDGE);
                                } else {
                                        rtp_flush_read_buffer(a_engine->rtp_session, SWITCH_RTP_FLUSH_ONCE);
                                }

                        }
                }
                goto end;
        case SWITCH_MESSAGE_INDICATE_UNBRIDGE:

#if 0
                if (switch_rtp_ready(v_engine->rtp_session)) {

                        if (switch_test_flag(smh, SMF_VB_PAUSED)) {
                                switch_clear_flag(smh, SMF_VB_PAUSED);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                  "%s RESUME Video Jitterbuffer\n", switch_channel_get_name(session->channel));
                                switch_rtp_pause_jitter_buffer(v_engine->rtp_session, SWITCH_FALSE);
                                
                        }
                }
#endif

                if (switch_rtp_ready(a_engine->rtp_session)) {

                        if (switch_test_flag(smh, SMF_JB_PAUSED)) {
                                switch_clear_flag(smh, SMF_JB_PAUSED);
                                if (switch_channel_test_flag(session->channel, CF_JITTERBUFFER)) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                          "%s RESUME Jitterbuffer\n", switch_channel_get_name(session->channel));
                                        switch_rtp_pause_jitter_buffer(a_engine->rtp_session, SWITCH_FALSE);
                                }
                        }


                        if (switch_rtp_test_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PASS_RFC2833)) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s deactivate passthru 2833 mode.\n",
                                                                  switch_channel_get_name(session->channel));
                                switch_rtp_clear_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PASS_RFC2833);
                        }

                        if (switch_channel_test_flag(session->channel, CF_NOTIMER_DURING_BRIDGE)) {
                                if (!switch_rtp_test_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_UDPTL) &&
                                        !switch_rtp_test_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA)) {
                                        switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
                                        //switch_rtp_set_flag(a_engine->rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
                                }
                                switch_channel_clear_flag(session->channel, CF_NOTIMER_DURING_BRIDGE);
                        }

                        if (switch_channel_test_flag(session->channel, CF_AUTOFLUSH_DURING_BRIDGE)) {
                                rtp_flush_read_buffer(a_engine->rtp_session, SWITCH_RTP_FLUSH_UNSTICK);
                                switch_channel_clear_flag(session->channel, CF_AUTOFLUSH_DURING_BRIDGE);
                        } else {
                                rtp_flush_read_buffer(a_engine->rtp_session, SWITCH_RTP_FLUSH_ONCE);
                        }

                }
                goto end;
        case SWITCH_MESSAGE_INDICATE_AUDIO_SYNC:
                if (switch_rtp_ready(a_engine->rtp_session)) {
                        switch_rtp_reset_jb(a_engine->rtp_session);
                        rtp_flush_read_buffer(a_engine->rtp_session, SWITCH_RTP_FLUSH_ONCE);
                }
                goto end;

        case SWITCH_MESSAGE_INDICATE_VIDEO_SYNC:
                if (switch_rtp_ready(v_engine->rtp_session)) {
                        switch_rtp_reset_jb(v_engine->rtp_session);
                        switch_rtp_flush(v_engine->rtp_session);
                }
                goto end;
        case SWITCH_MESSAGE_INDICATE_3P_MEDIA:
        case SWITCH_MESSAGE_INDICATE_MEDIA:
                {

                        a_engine->codec_negotiated = 0;
                        v_engine->codec_negotiated = 0;

                        if (session->track_duration) {
                                switch_core_session_enable_heartbeat(session, session->track_duration);
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_3P_NOMEDIA:
                switch_channel_set_flag(session->channel, CF_PROXY_MODE);
                switch_core_media_set_local_sdp(session, NULL, SWITCH_FALSE);
                break;
        case SWITCH_MESSAGE_INDICATE_NOMEDIA:
                {
                        const char *uuid;
                        switch_core_session_t *other_session;
                        switch_channel_t *other_channel;
                        const char *ip = NULL, *port = NULL;

                        switch_channel_set_flag(session->channel, CF_PROXY_MODE);

                        switch_core_media_set_local_sdp(session, NULL, SWITCH_FALSE);

                        if (switch_true(switch_channel_get_variable(session->channel, "bypass_keep_codec"))) {
                                switch_channel_set_variable(session->channel, "absolute_codec_string", switch_channel_get_variable(session->channel, "ep_codec_string"));
                        }


                        if ((uuid = switch_channel_get_partner_uuid(session->channel))
                                && (other_session = switch_core_session_locate(uuid))) {
                                other_channel = switch_core_session_get_channel(other_session);
                                ip = switch_channel_get_variable(other_channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE);
                                port = switch_channel_get_variable(other_channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE);
                                switch_core_session_rwunlock(other_session);

                                if (ip && port) {
                                        switch_core_media_prepare_codecs(session, 1);
                                        clear_pmaps(a_engine);
                                        clear_pmaps(v_engine);
                                        switch_core_media_gen_local_sdp(session, SDP_OFFER, ip, (switch_port_t)atoi(port), NULL, 1);
                                }
                        }


                        if (!smh->mparams->local_sdp_str) {
                                switch_core_media_absorb_sdp(session);
                        }

                        if (session->track_duration) {
                                switch_core_session_enable_heartbeat(session, session->track_duration);
                        }

                }
                break;


        default:
                break;
        }


        if (smh->mutex) switch_mutex_lock(smh->mutex);


        if (switch_channel_down(session->channel)) {
                status = SWITCH_STATUS_FALSE;
                goto end_lock;
        }

        switch (msg->message_id) {
        case SWITCH_MESSAGE_INDICATE_MEDIA_RENEG:
                {
                        switch_core_session_t *nsession;

                        if (msg->string_arg) {
                                switch_channel_set_variable(session->channel, "absolute_codec_string", NULL);

                                if (*msg->string_arg == '=') {
                                        switch_channel_set_variable(session->channel, "codec_string", msg->string_arg);
                                } else {
                                        switch_channel_set_variable_printf(session->channel,
                                                                                                           "codec_string", "=%s", switch_channel_get_variable(session->channel, "ep_codec_string"));
                                }
                                
                                a_engine->codec_negotiated = 0;
                                v_engine->codec_negotiated = 0;
                                smh->num_negotiated_codecs = 0;
                                switch_channel_clear_flag(session->channel, CF_VIDEO_POSSIBLE);
                                switch_core_media_prepare_codecs(session, SWITCH_TRUE);
                                switch_core_media_check_video_codecs(session);
                                
                                switch_core_media_gen_local_sdp(session, SDP_OFFER, NULL, 0, NULL, 1);
                        }

                        if (msg->numeric_arg && switch_core_session_get_partner(session, &nsession) == SWITCH_STATUS_SUCCESS) {
                                msg->numeric_arg = 0;
                                switch_core_session_receive_message(nsession, msg);
                                switch_core_session_rwunlock(nsession);
                        }

                }
                break;

        case SWITCH_MESSAGE_INDICATE_AUDIO_DATA:
                {
                        if (switch_rtp_ready(a_engine->rtp_session)) {
                                if (msg->numeric_arg) {
                                        if (switch_channel_test_flag(session->channel, CF_JITTERBUFFER)) {
                                                switch_rtp_pause_jitter_buffer(a_engine->rtp_session, SWITCH_TRUE);
                                                switch_set_flag(smh, SMF_JB_PAUSED);
                                        }

                                        rtp_flush_read_buffer(a_engine->rtp_session, SWITCH_RTP_FLUSH_UNSTICK);

                                } else {
                                        if (switch_test_flag(smh, SMF_JB_PAUSED)) {
                                                switch_clear_flag(smh, SMF_JB_PAUSED);
                                                if (switch_channel_test_flag(session->channel, CF_JITTERBUFFER)) {
                                                        switch_rtp_pause_jitter_buffer(a_engine->rtp_session, SWITCH_FALSE);
                                                }
                                        }
                                }
                        }
                }
                break;

        case SWITCH_MESSAGE_INDICATE_UDPTL_MODE:
                {
                        switch_t38_options_t *t38_options = switch_channel_get_private(session->channel, "t38_options");

                        if (t38_options) {
                                switch_core_media_start_udptl(session, t38_options);
                        }

                }


        default:
                break;
        }


 end_lock:

        if (smh->mutex) switch_mutex_unlock(smh->mutex);

 end:

        if (switch_channel_down(session->channel)) {
                status = SWITCH_STATUS_FALSE;
        }

        return status;

}

//?
SWITCH_DECLARE(void) switch_core_media_break(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                switch_rtp_break(smh->engines[type].rtp_session);
        }
}

//?
SWITCH_DECLARE(void) switch_core_media_kill_socket(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                switch_rtp_kill_socket(smh->engines[type].rtp_session);
        }
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_queue_rfc2833(switch_core_session_t *session, switch_media_type_t type, const switch_dtmf_t *dtmf)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                return switch_rtp_queue_rfc2833(smh->engines[type].rtp_session, dtmf);
        }

        return SWITCH_STATUS_FALSE;
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_queue_rfc2833_in(switch_core_session_t *session, switch_media_type_t type, const switch_dtmf_t *dtmf)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                return switch_rtp_queue_rfc2833_in(smh->engines[type].rtp_session, dtmf);
        }

        return SWITCH_STATUS_FALSE;
}

//?
SWITCH_DECLARE(uint8_t) switch_core_media_ready(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return 0;
        }

        return switch_rtp_ready(smh->engines[type].rtp_session);
}

//?
SWITCH_DECLARE(void) switch_core_media_set_rtp_flag(switch_core_session_t *session, switch_media_type_t type, switch_rtp_flag_t flag)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                switch_rtp_set_flag(smh->engines[type].rtp_session, flag);
        }
}

//?
SWITCH_DECLARE(void) switch_core_media_clear_rtp_flag(switch_core_session_t *session, switch_media_type_t type, switch_rtp_flag_t flag)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                switch_rtp_clear_flag(smh->engines[type].rtp_session, flag);
        }
}

//?
SWITCH_DECLARE(void) switch_core_media_set_telephony_event(switch_core_session_t *session, switch_media_type_t type, switch_payload_t te)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                switch_rtp_set_telephony_event(smh->engines[type].rtp_session, te);
        }
}

//?
SWITCH_DECLARE(void) switch_core_media_set_telephony_recv_event(switch_core_session_t *session, switch_media_type_t type, switch_payload_t te)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                switch_rtp_set_telephony_recv_event(smh->engines[type].rtp_session, te);
        }
}

//?
SWITCH_DECLARE(switch_rtp_stats_t *) switch_core_media_get_stats(switch_core_session_t *session, switch_media_type_t type, switch_memory_pool_t *pool)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return NULL;
        }

        if (smh->engines[type].rtp_session) {
                return switch_rtp_get_stats(smh->engines[type].rtp_session, pool);
        }

        return NULL;
}

//?
SWITCH_DECLARE(switch_bool_t) switch_core_media_check_udptl_mode(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_FALSE;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                return switch_rtp_test_flag(smh->engines[type].rtp_session, SWITCH_RTP_FLAG_UDPTL) ? SWITCH_TRUE : SWITCH_FALSE;
        }

        return SWITCH_FALSE;
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_udptl_mode(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                return switch_rtp_udptl_mode(smh->engines[type].rtp_session);
        }

        return SWITCH_STATUS_FALSE;
}

//?
SWITCH_DECLARE(switch_jb_t *) switch_core_media_get_jb(switch_core_session_t *session, switch_media_type_t type)
{
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return NULL;
        }

        if (switch_rtp_ready(smh->engines[type].rtp_session)) {
                return switch_rtp_get_jitter_buffer(smh->engines[type].rtp_session);
        }

        return NULL;
}


//?
SWITCH_DECLARE(void) switch_core_media_set_sdp_codec_string(switch_core_session_t *session, const char *r_sdp, switch_sdp_type_t sdp_type)
{
        switch_core_media_merge_sdp_codec_string(session, r_sdp, sdp_type, switch_core_media_get_codec_string(session));
}

SWITCH_DECLARE(void) switch_core_media_merge_sdp_codec_string(switch_core_session_t *session, const char *r_sdp,
                                                                                                                          switch_sdp_type_t sdp_type, const char *codec_string)
{
        sdp_parser_t *parser;
        sdp_session_t *sdp;

        switch_assert(session);

        if (!session->media_handle) {
                return;
        }

        if (!r_sdp) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "Setting NULL SDP is invalid\n");
                return;
        }

        if (zstr(codec_string)) {
                codec_string = switch_core_media_get_codec_string(session);
        }
        
        if ((parser = sdp_parse(NULL, r_sdp, (int) strlen(r_sdp), 0))) {

                if ((sdp = sdp_session(parser))) {
                        switch_core_media_set_r_sdp_codec_string(session, codec_string, sdp, sdp_type);
                }

                sdp_parser_free(parser);
        }
}


static void add_audio_codec(sdp_rtpmap_t *map, const switch_codec_implementation_t *imp, int ptime, char *buf, switch_size_t buflen)
{
        int codec_ms = ptime;
        uint32_t map_bit_rate = 0, map_channels = 1;
        char ptstr[20] = "";
        char ratestr[20] = "";
        char bitstr[20] = "";
        switch_codec_fmtp_t codec_fmtp = { 0 };

        if (!codec_ms) {
                codec_ms = switch_default_ptime(map->rm_encoding, map->rm_pt);
        }

        map_channels = map->rm_params ? atoi(map->rm_params) : 1;
        map_bit_rate = switch_known_bitrate((switch_payload_t)map->rm_pt);

        if (!ptime && !strcasecmp(map->rm_encoding, "g723")) {
                codec_ms = 30;
        }

        if (zstr(map->rm_fmtp)) {
                if (!strcasecmp(map->rm_encoding, "ilbc")) {
                        codec_ms = 30;
                        map_bit_rate = 13330;
                } else if (!strcasecmp(map->rm_encoding, "isac")) {
                        codec_ms = 30;
                        map_bit_rate = 32000;
                }
        } else {
                if ((switch_core_codec_parse_fmtp(map->rm_encoding, map->rm_fmtp, map->rm_rate, &codec_fmtp)) == SWITCH_STATUS_SUCCESS) {
                        if (codec_fmtp.bits_per_second) {
                                map_bit_rate = codec_fmtp.bits_per_second;
                        }
                        if (codec_fmtp.microseconds_per_packet) {
                                codec_ms = (codec_fmtp.microseconds_per_packet / 1000);
                        }
                }
        }

        if (map->rm_rate) {
                switch_snprintf(ratestr, sizeof(ratestr), "@%uh", (unsigned int) map->rm_rate);
        }

        if (codec_ms) {
                switch_snprintf(ptstr, sizeof(ptstr), "@%di", codec_ms);
        }

        if (map_bit_rate) {
                switch_snprintf(bitstr, sizeof(bitstr), "@%db", map_bit_rate);
        }

        if (map_channels > 1) {
                switch_snprintf(bitstr, sizeof(bitstr), "@%dc", map_channels);
        }

        switch_snprintf(buf + strlen(buf), buflen - strlen(buf), ",%s.%s%s%s%s", imp->modname, map->rm_encoding, ratestr, ptstr, bitstr);

}


static void switch_core_media_set_r_sdp_codec_string(switch_core_session_t *session, const char *codec_string, sdp_session_t *sdp, switch_sdp_type_t sdp_type)
{
        char buf[1024] = { 0 };
        sdp_media_t *m;
        sdp_attribute_t *attr;
        int ptime = 0, dptime = 0;
        sdp_connection_t *connection;
        sdp_rtpmap_t *map;
        short int match = 0;
        int i;
        int already_did[128] = { 0 };
        int num_codecs = 0;
        char *codec_order[SWITCH_MAX_CODECS];
        const switch_codec_implementation_t *codecs[SWITCH_MAX_CODECS] = { 0 };
        char fmtp[SWITCH_MAX_CODECS][MAX_FMTP_LEN];

        switch_channel_t *channel = switch_core_session_get_channel(session);
        int prefer_sdp = 0;
        const char *var;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }


        if ((var = switch_channel_get_variable(channel, "ep_codec_prefer_sdp")) && switch_true(var)) {
                prefer_sdp = 1;
        }


        if (!zstr(codec_string)) {
                char *tmp_codec_string;

                if (*codec_string == '=') codec_string++;

                if ((tmp_codec_string = strdup(codec_string))) {
                        num_codecs = switch_separate_string(tmp_codec_string, ',', codec_order, SWITCH_MAX_CODECS);
                        num_codecs = switch_loadable_module_get_codecs_sorted(codecs, fmtp, SWITCH_MAX_CODECS, codec_order, num_codecs);
                        switch_safe_free(tmp_codec_string);
                }
        } else {
                num_codecs = switch_loadable_module_get_codecs(codecs, SWITCH_MAX_CODECS);
        }

        if (!channel || !num_codecs) {
                return;
        }

        for (attr = sdp->sdp_attributes; attr; attr = attr->a_next) {
                if (zstr(attr->a_name)) {
                        continue;
                }

                if (!strcasecmp(attr->a_name, "ptime")) {
                        dptime = atoi(attr->a_value);
                        break;
                }
        }

        for (m = sdp->sdp_media; m; m = m->m_next) {
                ptime = dptime;

                if ((m->m_type == sdp_media_audio || m->m_type == sdp_media_video) && m->m_port) {
                        for (map = m->m_rtpmaps; map; map = map->rm_next) {
                                int found = 0;

                                for (attr = m->m_attributes; attr && found < 2; attr = attr->a_next) {
                                        if (zstr(attr->a_name)) {
                                                continue;
                                        }

                                        if (!strcasecmp(attr->a_name, "ptime") && attr->a_value) {
                                                ptime = atoi(attr->a_value);
                                                found++;
                                        }

                                        if (!strcasecmp(attr->a_name, "rtcp-mux")) {
                                                if (switch_channel_var_true(channel, "rtcp_mux_auto_detect")) {
                                                        switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG, "setting rtcp-mux from sdp\n");
                                                        switch_channel_set_variable(channel, "rtcp_mux", "true");
                                                }

                                                found++;
                                        }
                                }

                                switch_core_media_add_payload_map(session,
                                                                                                  m->m_type == sdp_media_audio ? SWITCH_MEDIA_TYPE_AUDIO : SWITCH_MEDIA_TYPE_VIDEO,
                                                                                                  map->rm_encoding,
                                                                                                  NULL,
                                                                                                  map->rm_fmtp,
                                                                                                  sdp_type,
                                                                                                  map->rm_pt,
                                                                                                  map->rm_rate,
                                                                                                  ptime,
                                                                                                  map->rm_params ? atoi(map->rm_params) : 1,
                                                                                                  SWITCH_FALSE);
                        }
                }
        }

        for (m = sdp->sdp_media; m; m = m->m_next) {
                ptime = dptime;

                if (m->m_type == sdp_media_image && m->m_port) {
                        switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ",t38");
                } else if (m->m_type == sdp_media_audio && m->m_port) {
                        for (attr = m->m_attributes; attr; attr = attr->a_next) {
                                if (zstr(attr->a_name)) {
                                        continue;
                                }

                                if (!strcasecmp(attr->a_name, "ptime") && attr->a_value) {
                                        ptime = atoi(attr->a_value);
                                        break;
                                }
                        }

                        connection = sdp->sdp_connection;
                        if (m->m_connections) {
                                connection = m->m_connections;
                        }

                        if (!connection) {
                                switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_ERROR, "Cannot find a c= line in the sdp at media or session level!\n");
                                break;
                        }

                        if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND || prefer_sdp) {
                                for (map = m->m_rtpmaps; map; map = map->rm_next) {

                                        if (already_did[map->rm_pt]) {
                                                continue;
                                        }

                                        for (i = 0; i < num_codecs; i++) {
                                                const switch_codec_implementation_t *imp = codecs[i];

                                                if ((zstr(map->rm_encoding) || (smh->mparams->ndlb & SM_NDLB_ALLOW_BAD_IANANAME)) && map->rm_pt < 96) {
                                                        match = (map->rm_pt == imp->ianacode) ? 1 : 0;
                                                } else {
                                                        if (map->rm_encoding) {
                                                                match = !strcasecmp(map->rm_encoding, imp->iananame) &&
                                                                        ((map->rm_pt < 96 && imp->ianacode < 96) || (map->rm_pt > 95 && imp->ianacode > 95));
                                                        } else {
                                                                match = 0;
                                                        }
                                                }

                                                if (match) {
                                                        add_audio_codec(map, imp, ptime, buf, sizeof(buf));
                                                }
                                        }
                                }

                        } else {
                                for (i = 0; i < num_codecs; i++) {
                                        const switch_codec_implementation_t *imp = codecs[i];

                                        if (imp->codec_type != SWITCH_CODEC_TYPE_AUDIO || imp->ianacode > 127 || already_did[imp->ianacode]) {
                                                continue;
                                        }

                                        for (map = m->m_rtpmaps; map; map = map->rm_next) {

                                                if (already_did[map->rm_pt]) {
                                                        continue;
                                                }

                                                if ((zstr(map->rm_encoding) || (smh->mparams->ndlb & SM_NDLB_ALLOW_BAD_IANANAME)) && map->rm_pt < 96) {
                                                        match = (map->rm_pt == imp->ianacode) ? 1 : 0;
                                                } else {
                                                        if (map->rm_encoding) {
                                                                match = !strcasecmp(map->rm_encoding, imp->iananame) &&
                                                                        ((map->rm_pt < 96 && imp->ianacode < 96) || (map->rm_pt > 95 && imp->ianacode > 95));
                                                        } else {
                                                                match = 0;
                                                        }
                                                }

                                                if (match) {
                                                        add_audio_codec(map, imp, ptime, buf, sizeof(buf));
                                                }
                                        }
                                }
                        }

                } else if (m->m_type == sdp_media_video && m->m_port) {
                        connection = sdp->sdp_connection;
                        if (m->m_connections) {
                                connection = m->m_connections;
                        }

                        if (!connection) {
                                switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_ERROR, "Cannot find a c= line in the sdp at media or session level!\n");
                                break;
                        }

                        if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_INBOUND || prefer_sdp) {
                                for (map = m->m_rtpmaps; map; map = map->rm_next) {

                                        if (already_did[map->rm_pt]) {
                                                continue;
                                        }

                                        for (i = 0; i < num_codecs; i++) {
                                                const switch_codec_implementation_t *imp = codecs[i];

                                                if ((zstr(map->rm_encoding) || (smh->mparams->ndlb & SM_NDLB_ALLOW_BAD_IANANAME)) && map->rm_pt < 96) {
                                                        match = (map->rm_pt == imp->ianacode) ? 1 : 0;
                                                } else {
                                                        if (map->rm_encoding) {
                                                                match = !strcasecmp(map->rm_encoding, imp->iananame) &&
                                                                        ((map->rm_pt < 96 && imp->ianacode < 96) || (map->rm_pt > 95 && imp->ianacode > 95));
                                                        } else {
                                                                match = 0;
                                                        }
                                                }

                                                if (match) {
                                                        if (map->rm_fmtp) {
                                                                switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ",%s.%s~%s", imp->modname, imp->iananame, map->rm_fmtp);
                                                        } else {
                                                                switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ",%s.%s", imp->modname, imp->iananame);
                                                        }

                                                        already_did[imp->ianacode] = 1;
                                                }
                                        }
                                }
                        } else {
                                for (i = 0; i < num_codecs; i++) {
                                        const switch_codec_implementation_t *imp = codecs[i];

                                        if (imp->codec_type != SWITCH_CODEC_TYPE_VIDEO || imp->ianacode > 127 || already_did[imp->ianacode]) {
                                                continue;
                                        }

                                        if (switch_channel_direction(session->channel) == SWITCH_CALL_DIRECTION_INBOUND &&
                                                switch_channel_test_flag(session->channel, CF_NOVIDEO)) {
                                                continue;
                                        }

                                        for (map = m->m_rtpmaps; map; map = map->rm_next) {

                                                if (already_did[map->rm_pt]) {
                                                        continue;
                                                }

                                                if ((zstr(map->rm_encoding) || (smh->mparams->ndlb & SM_NDLB_ALLOW_BAD_IANANAME)) && map->rm_pt < 96) {
                                                        match = (map->rm_pt == imp->ianacode) ? 1 : 0;
                                                } else {
                                                        if (map->rm_encoding) {
                                                                match = !strcasecmp(map->rm_encoding, imp->iananame) &&
                                                                        ((map->rm_pt < 96 && imp->ianacode < 96) || (map->rm_pt > 95 && imp->ianacode > 95));
                                                        } else {
                                                                match = 0;
                                                        }
                                                }

                                                if (match) {
                                                        if (map->rm_fmtp) {
                                                                switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ",%s.%s~%s", imp->modname, imp->iananame, map->rm_fmtp);
                                                        } else {
                                                                switch_snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), ",%s.%s", imp->modname, imp->iananame);
                                                        }

                                                        already_did[imp->ianacode] = 1;
                                                }
                                        }
                                }
                        }
                } else if (m->m_proto == sdp_proto_msrp) {
                        switch_channel_set_flag(channel, CF_WANT_MSRP);
                } else if (m->m_proto == sdp_proto_msrps) {
                        switch_channel_set_flag(channel, CF_WANT_MSRPS);
                } else if (m->m_type == sdp_media_text) {
                        switch_channel_set_flag(channel, CF_WANT_RTT);
                }
        }

        if (buf[0] == ',') {
                switch_channel_set_variable(channel, "ep_codec_string", buf + 1);
        }
}

//?
SWITCH_DECLARE(switch_status_t) switch_core_media_codec_chosen(switch_core_session_t *session, switch_media_type_t type)
{
        switch_rtp_engine_t *engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        engine = &smh->engines[type];

        if (engine->cur_payload_map->iananame) {
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

SWITCH_DECLARE(void) switch_core_session_stop_media(switch_core_session_t *session)
{
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_media_handle_t *smh;
        int type;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (switch_core_codec_ready(&v_engine->read_codec)) {
                type = 1;
                switch_core_codec_control(&v_engine->read_codec, SCC_VIDEO_RESET, SCCT_INT, (void *)&type, SCCT_NONE, NULL, NULL, NULL);
        }

        if (switch_core_codec_ready(&v_engine->write_codec)) {
                type = 2;
                switch_core_codec_control(&v_engine->write_codec, SCC_VIDEO_RESET, SCCT_INT, (void *)&type, SCCT_NONE, NULL, NULL, NULL);
        }

        if (a_engine->rtp_session) {
                switch_rtp_reset(a_engine->rtp_session);
        }

        if (v_engine->rtp_session) {
                switch_rtp_reset(v_engine->rtp_session);
        }

        if (t_engine->rtp_session) {
                switch_rtp_reset(t_engine->rtp_session);
        }


        smh->msid = NULL;
        smh->cname = NULL;
        v_engine->ice_out.ufrag = NULL;
        v_engine->ice_out.pwd = NULL;
        v_engine->ice_out.cands[0][0].foundation = NULL;
        v_engine->ice_out.cands[0][0].component_id = 0;

        t_engine->ice_out.ufrag = NULL;
        t_engine->ice_out.pwd = NULL;
        t_engine->ice_out.cands[0][0].foundation = NULL;
        t_engine->ice_out.cands[0][0].component_id = 0;


        a_engine->ice_out.ufrag = NULL;
        a_engine->ice_out.pwd = NULL;
        a_engine->ice_out.cands[0][0].foundation = NULL;
        a_engine->ice_out.cands[0][0].component_id = 0;

        if (v_engine->ice_in.cands[v_engine->ice_in.chosen[0]][0].ready) {
                gen_ice(smh->session, SWITCH_MEDIA_TYPE_VIDEO, NULL, 0);
        }

        if (t_engine->ice_in.cands[t_engine->ice_in.chosen[0]][0].ready) {
                gen_ice(smh->session, SWITCH_MEDIA_TYPE_TEXT, NULL, 0);
        }

        if (a_engine->ice_in.cands[a_engine->ice_in.chosen[0]][0].ready) {
                gen_ice(smh->session, SWITCH_MEDIA_TYPE_AUDIO, NULL, 0);
        }

        smh->owner_id = 0;
        smh->session_id = 0;

        a_engine->local_dtls_fingerprint.len = 0;
        v_engine->local_dtls_fingerprint.len = 0;
        t_engine->local_dtls_fingerprint.len = 0;

        a_engine->remote_ssrc = 0;
        v_engine->remote_ssrc = 0;
        t_engine->remote_ssrc = 0;

        switch_channel_clear_flag(smh->session->channel, CF_VIDEO_READY);
        switch_core_session_wake_video_thread(smh->session);
        switch_core_session_request_video_refresh(smh->session);
}



//?
SWITCH_DECLARE(void) switch_core_media_check_outgoing_proxy(switch_core_session_t *session, switch_core_session_t *o_session)
{
        switch_rtp_engine_t *a_engine, *v_engine, *t_engine;
        switch_media_handle_t *smh;
        const char *r_sdp = NULL;
        payload_map_t *pmap;

        switch_assert(session);

        if (!switch_channel_test_flag(o_session->channel, CF_PROXY_MEDIA)) {
                return;
        }

        if (!(smh = session->media_handle)) {
                return;
        }

        r_sdp = switch_channel_get_variable(o_session->channel, SWITCH_R_SDP_VARIABLE);

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        switch_channel_set_flag(session->channel, CF_PROXY_MEDIA);

        clear_pmaps(a_engine);
        clear_pmaps(v_engine);

        pmap = switch_core_media_add_payload_map(session,
                                                                                         SWITCH_MEDIA_TYPE_AUDIO,
                                                                                         "PROXY",
                                                                                         NULL,
                                                                                         NULL,
                                                                                         SDP_ANSWER,
                                                                                         0,
                                                                                         8000,
                                                                                         20,
                                                                                         1,
                                                                                         SWITCH_TRUE);

        a_engine->cur_payload_map = pmap;

        if (switch_stristr("m=video", r_sdp)) {
                switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 1);
                pmap = switch_core_media_add_payload_map(session,
                                                                                                 SWITCH_MEDIA_TYPE_AUDIO,
                                                                                                 "PROXY-VID",
                                                                                                 NULL,
                                                                                                 NULL,
                                                                                                 SDP_ANSWER,
                                                                                                 0,
                                                                                                 90000,
                                                                                                 90000,
                                                                                                 1,
                                                                                                 SWITCH_TRUE);

                v_engine->cur_payload_map = pmap;

                switch_channel_set_flag(session->channel, CF_VIDEO);
                switch_channel_set_flag(session->channel, CF_VIDEO_POSSIBLE);
        }


        if (switch_stristr("m=text", r_sdp)) {
                switch_core_media_choose_port(session, SWITCH_MEDIA_TYPE_VIDEO, 1);
                pmap = switch_core_media_add_payload_map(session,
                                                                                                 SWITCH_MEDIA_TYPE_AUDIO,
                                                                                                 "PROXY-TXT",
                                                                                                 NULL,
                                                                                                 NULL,
                                                                                                 SDP_ANSWER,
                                                                                                 0,
                                                                                                 1000,
                                                                                                 1000,
                                                                                                 1,
                                                                                                 SWITCH_TRUE);

                t_engine->cur_payload_map = pmap;

                switch_channel_set_flag(session->channel, CF_HAS_TEXT);
                switch_channel_set_flag(session->channel, CF_TEXT_POSSIBLE);
        }
}


SWITCH_DECLARE (void) switch_core_media_recover_session(switch_core_session_t *session)
{
        const char *ip;
        const char *port;
        const char *a_ip;
        const char *r_ip;
        const char *r_port;
        const char *tmp;
        switch_rtp_engine_t *a_engine, *v_engine;
        switch_media_handle_t *smh;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        ip = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_IP_VARIABLE);
        port = switch_channel_get_variable(session->channel, SWITCH_LOCAL_MEDIA_PORT_VARIABLE);

        if (switch_channel_test_flag(session->channel, CF_PROXY_MODE)  || !(ip && port)) {
                return;
        } else {
                a_ip = switch_channel_get_variable(session->channel, SWITCH_ADVERTISED_MEDIA_IP_VARIABLE);
                r_ip = switch_channel_get_variable(session->channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE);
                r_port = switch_channel_get_variable(session->channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE);
        }

        a_engine = &smh->engines[SWITCH_MEDIA_TYPE_AUDIO];
        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        a_engine->cur_payload_map->iananame = a_engine->cur_payload_map->rm_encoding = (char *) switch_channel_get_variable(session->channel, "rtp_use_codec_name");
        a_engine->cur_payload_map->rm_fmtp = (char *) switch_channel_get_variable(session->channel, "rtp_use_codec_fmtp");

        if ((tmp = switch_channel_get_variable(session->channel, SWITCH_R_SDP_VARIABLE))) {
                smh->mparams->remote_sdp_str = switch_core_session_strdup(session, tmp);
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_timer_name"))) {
                smh->mparams->timer_name = switch_core_session_strdup(session, tmp);
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_last_audio_codec_string"))) {
                const char *vtmp = switch_channel_get_variable(session->channel, "rtp_last_video_codec_string");
                switch_channel_set_variable_printf(session->channel, "rtp_use_codec_string", "%s%s%s", tmp, vtmp ? "," : "", vtmp ? vtmp : "");
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_codec_string"))) {
                char *tmp_codec_string = switch_core_session_strdup(smh->session, tmp);
                smh->codec_order_last = switch_separate_string(tmp_codec_string, ',', smh->codec_order, SWITCH_MAX_CODECS);
                smh->mparams->num_codecs = switch_loadable_module_get_codecs_sorted(smh->codecs, smh->fmtp, SWITCH_MAX_CODECS, smh->codec_order, smh->codec_order_last);
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_2833_send_payload"))) {
                smh->mparams->te = (switch_payload_t)atoi(tmp);
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_2833_recv_payload"))) {
                smh->mparams->recv_te = (switch_payload_t)atoi(tmp);
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_codec_rate"))) {
                a_engine->cur_payload_map->rm_rate = atoi(tmp);
                a_engine->cur_payload_map->adv_rm_rate = a_engine->cur_payload_map->rm_rate;
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_codec_ptime"))) {
                a_engine->cur_payload_map->codec_ms = atoi(tmp);
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_codec_channels"))) {
                a_engine->cur_payload_map->channels = atoi(tmp);
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_pt"))) {
                a_engine->cur_payload_map->pt = (switch_payload_t)(smh->payload_space = atoi(tmp));
        }

        if ((tmp = switch_channel_get_variable(session->channel, "rtp_audio_recv_pt"))) {
                a_engine->cur_payload_map->recv_pt = (switch_payload_t)atoi(tmp);
        }

        switch_core_media_set_codec(session, 0, smh->mparams->codec_flags);

        a_engine->adv_sdp_ip = smh->mparams->extrtpip = (char *) ip;
        a_engine->adv_sdp_port = a_engine->local_sdp_port = (switch_port_t)atoi(port);
        a_engine->codec_negotiated = 1;

        if (!zstr(ip)) {
                a_engine->local_sdp_ip = switch_core_session_strdup(session, ip);
                smh->mparams->rtpip = a_engine->local_sdp_ip;
        }

        if (!zstr(a_ip)) {
                a_engine->adv_sdp_ip = switch_core_session_strdup(session, a_ip);
        }

        if (r_ip && r_port) {
                a_engine->cur_payload_map->remote_sdp_ip = (char *) r_ip;
                a_engine->cur_payload_map->remote_sdp_port = (switch_port_t)atoi(r_port);
        }

        if (switch_channel_test_flag(session->channel, CF_VIDEO)) {
                if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_video_pt"))) {
                        v_engine->cur_payload_map->pt = (switch_payload_t)atoi(tmp);
                }

                if ((tmp = switch_channel_get_variable(session->channel, "rtp_video_recv_pt"))) {
                        v_engine->cur_payload_map->recv_pt = (switch_payload_t)atoi(tmp);
                }

                v_engine->cur_payload_map->rm_encoding = (char *) switch_channel_get_variable(session->channel, "rtp_use_video_codec_name");
                v_engine->cur_payload_map->rm_fmtp = (char *) switch_channel_get_variable(session->channel, "rtp_use_video_codec_fmtp");
                v_engine->codec_negotiated = 1;

                port = switch_channel_get_variable(session->channel, SWITCH_LOCAL_VIDEO_PORT_VARIABLE);
                r_ip = switch_channel_get_variable(session->channel, SWITCH_REMOTE_VIDEO_IP_VARIABLE);
                r_port = switch_channel_get_variable(session->channel, SWITCH_REMOTE_VIDEO_PORT_VARIABLE);

                switch_channel_set_flag(session->channel, CF_VIDEO_POSSIBLE);

                if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_video_codec_rate"))) {
                        v_engine->cur_payload_map->rm_rate = atoi(tmp);
                        v_engine->cur_payload_map->adv_rm_rate = v_engine->cur_payload_map->rm_rate;
                }

                if ((tmp = switch_channel_get_variable(session->channel, "rtp_use_video_codec_ptime"))) {
                        v_engine->cur_payload_map->codec_ms = atoi(tmp);
                }

                v_engine->adv_sdp_port = v_engine->local_sdp_port = (switch_port_t)atoi(port);
                v_engine->local_sdp_ip = smh->mparams->rtpip;

                if (r_ip && r_port) {
                        v_engine->cur_payload_map->remote_sdp_ip = (char *) r_ip;
                        v_engine->cur_payload_map->remote_sdp_port = (switch_port_t)atoi(r_port);
                }
        }

        switch_core_media_gen_local_sdp(session, SDP_OFFER, NULL, 0, NULL, 1);
        switch_core_media_set_video_codec(session, 1);

        if (switch_core_media_activate_rtp(session) != SWITCH_STATUS_SUCCESS) {
                return;
        }

        switch_core_session_get_recovery_crypto_key(session, SWITCH_MEDIA_TYPE_AUDIO);
        switch_core_session_get_recovery_crypto_key(session, SWITCH_MEDIA_TYPE_VIDEO);


        if ((tmp = switch_channel_get_variable(session->channel, "rtp_last_audio_local_crypto_key")) && a_engine->ssec[a_engine->crypto_type].remote_crypto_key) {
                int idx = atoi(tmp);

                a_engine->ssec[a_engine->crypto_type].local_crypto_key = switch_core_session_strdup(session, tmp);
                switch_core_media_add_crypto(session, &a_engine->ssec[a_engine->crypto_type],SWITCH_RTP_CRYPTO_SEND);
                switch_core_media_add_crypto(session, &a_engine->ssec[a_engine->crypto_type],SWITCH_RTP_CRYPTO_RECV);
                switch_channel_set_flag(smh->session->channel, CF_SECURE);

                switch_rtp_add_crypto_key(a_engine->rtp_session, SWITCH_RTP_CRYPTO_SEND, idx, &a_engine->ssec[a_engine->crypto_type]);

                switch_rtp_add_crypto_key(a_engine->rtp_session, SWITCH_RTP_CRYPTO_RECV, a_engine->ssec[a_engine->crypto_type].crypto_tag, &a_engine->ssec[a_engine->crypto_type]);
        }


        if (switch_core_media_ready(session, SWITCH_MEDIA_TYPE_AUDIO)) {
                switch_rtp_set_telephony_event(a_engine->rtp_session, smh->mparams->te);
                switch_rtp_set_telephony_recv_event(a_engine->rtp_session, smh->mparams->recv_te);
        }

}


SWITCH_DECLARE(void) switch_core_media_init(void)
{
        if (switch_core_check_dtls_pem(DTLS_SRTP_FNAME ".pem") != SWITCH_TRUE) {
                switch_core_gen_certs(DTLS_SRTP_FNAME ".pem");
        }

        video_globals.cpu_count = switch_core_cpu_count();
        video_globals.cur_cpu = 0;

        switch_core_new_memory_pool(&video_globals.pool);
        switch_mutex_init(&video_globals.mutex, SWITCH_MUTEX_NESTED, video_globals.pool);

}

SWITCH_DECLARE(void) switch_core_media_deinit(void)
{
        if (video_globals.pool) {
                switch_core_destroy_memory_pool(&video_globals.pool);
        }
}

static int payload_number(const char *name)
{
        if (!strcasecmp(name, "pcmu")) {
                return 0;
        }

        if (!strcasecmp(name, "pcma")) {
                return 8;
        }

        if (!strcasecmp(name, "gsm")) {
                return 3;
        }

        if (!strcasecmp(name, "g722")) {
                return 9;
        }

        if (!strcasecmp(name, "g729")) {
                return 18;
        }

        if (!strcasecmp(name, "dvi4")) {
                return 5;
        }

        if (!strcasecmp(name, "h261")) {
                return 31;
        }

        if (!strcasecmp(name, "h263")) {
                return 34;
        }

        return -1;
}

static int find_pt(const char *sdp, const char *name)
{
        const char *p;

        if ((p = switch_stristr(name, sdp))) {
                if (p < end_of_p(sdp) && *(p+strlen(name)) == '/' && *(p-1) == ' ') {
                        p -= 2;

                        while(*p > 47 && *p < 58) {
                                p--;
                        }
                        p++;

                        if (p) {
                                return atoi(p);
                        }
                }
        }

        return -1;
}


SWITCH_DECLARE(char *) switch_core_media_filter_sdp(const char *sdp_str, const char *cmd, const char *arg)
{
        char *new_sdp = NULL;
        int pt = -1, te = -1;
        switch_size_t len;
        const char *i;
        char *o;
        int in_m = 0, slash = 0;
        int number = 0, skip = 0;
        int remove = !strcasecmp(cmd, "remove");
        int only = !strcasecmp(cmd, "only");
        char *end = end_of_p((char *)sdp_str);
        int tst;
        end++;


        if (remove || only) {
                pt = payload_number(arg);

                if (pt < 0) {
                        pt = find_pt(sdp_str, arg);
                }
        } else {
                return NULL;
        }

        if (only) {
                te = find_pt(sdp_str, "telephone-event");
        }


        len = strlen(sdp_str) + 2;
        new_sdp = malloc(len);
        o = new_sdp;
        i = sdp_str;


        while(i && *i && i < end) {

                if (*i == 'm' && *(i+1) == '=') {
                        in_m = 1;
                }

                if (in_m) {
                        if (*i == '\r' || *i == '\n') {
                                in_m = 0;
                                slash = 0;
                        } else {
                                if (*i == '/') {
                                        slash++;
                                        while(*i != ' ' && i < end) {
                                                *o++ = *i++;
                                        }

                                        *o++ = *i++;
                                }

                                if (slash && switch_is_leading_number(i)) {


                                        number = atoi(i);

                                        while(i < end && ((*i > 47 && *i < 58) || *i == ' ')) {

                                                if (remove)  {
                                                        tst = (number != pt);
                                                } else {
                                                        tst = (number == pt || number == te);
                                                }

                                                if (tst) {
                                                        *o++ = *i;
                                                }
                                                i++;

                                                if (*i == ' ') {
                                                        break;
                                                }

                                        }

                                        if (remove)  {
                                                tst = (number == pt);
                                        } else {
                                                tst = (number != pt && number != te);
                                        }

                                        if (tst) {
                                                skip++;
                                        }
                                }
                        }
                }

                while (i < end && !strncasecmp(i, "a=rtpmap:", 9)) {
                        const char *t = i + 9;

                        number = atoi(t);

                        if (remove)  {
                                tst = (number == pt);
                        } else {
                                tst = (number != pt && number != te);
                        }

                        while(i < end && (*i != '\r' && *i != '\n')) {
                                if (!tst) *o++ = *i;
                                i++;
                        }

                        while(i < end && (*i == '\r' || *i == '\n')) {
                                if (!tst) *o++ = *i;
                                i++;
                        }
                }

                while (i < end && !strncasecmp(i, "a=fmtp:", 7)) {
                        const char *t = i + 7;

                        number = atoi(t);

                        if (remove)  {
                                tst = (number == pt);
                        } else {
                                tst = (number != pt && number != te);
                        }

                        while(i < end && (*i != '\r' && *i != '\n')) {
                                if (!tst) *o++ = *i;
                                i++;
                        }

                        while(i < end && (*i == '\r' || *i == '\n')) {
                                if (!tst) *o++ = *i;
                                i++;
                        }
                }

                if (!skip) {
                        *o++ = *i;
                }

                skip = 0;

                i++;
        }

        *o = '\0';

        return new_sdp;
}

SWITCH_DECLARE(char *) switch_core_media_process_sdp_filter(const char *sdp, const char *cmd_buf, switch_core_session_t *session)
{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        char *cmd = switch_core_session_strdup(session, cmd_buf);
        int argc = 0;
        char *argv[50];
        int x = 0;
        char *patched_sdp = NULL;

        argc = switch_split(cmd, '|', argv);

        for (x = 0; x < argc; x++) {
                char *command = argv[x];
                char *arg = strchr(command, '(');

                if (arg) {
                        char *e = switch_find_end_paren(arg, '(', ')');
                        *arg++ = '\0';
                        if (e) *e = '\0';
                }

                if (zstr(command) || zstr(arg)) {
                        switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_WARNING, "%s SDP FILTER PARSE ERROR\n", switch_channel_get_name(channel));
                } else {
                        char *tmp_sdp = NULL;

                        if (patched_sdp) {
                                tmp_sdp = switch_core_media_filter_sdp(patched_sdp, command, arg);
                        } else {
                                tmp_sdp = switch_core_media_filter_sdp(sdp, command, arg);
                        }


                        switch_log_printf(SWITCH_CHANNEL_CHANNEL_LOG(channel), SWITCH_LOG_DEBUG,
                                                          "%s Filter command %s(%s)\nFROM:\n==========\n%s\nTO:\n==========\n%s\n\n",
                                                          switch_channel_get_name(channel),
                                                          command, arg, patched_sdp ? patched_sdp : sdp, tmp_sdp);


                        if (tmp_sdp) {
                                switch_safe_free(patched_sdp);
                                patched_sdp = tmp_sdp;
                        }
                }
        }

        return patched_sdp;

}


SWITCH_DECLARE(switch_timer_t *) switch_core_media_get_timer(switch_core_session_t *session, switch_media_type_t mtype)
{
        switch_rtp_engine_t *engine = NULL;
        switch_media_handle_t *smh = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return NULL;
        }

        if (!(engine = &smh->engines[mtype])) {
                return NULL;
        }

        return switch_rtp_get_media_timer(engine->rtp_session);

}

SWITCH_DECLARE(switch_status_t) _switch_core_session_request_video_refresh(switch_core_session_t *session, int force, const char *file, const char *func, int line)
{
        switch_channel_t *channel = switch_core_session_get_channel(session);
        switch_media_handle_t *smh = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_media_up(channel) && switch_channel_test_flag(channel, CF_VIDEO)) {
                switch_core_session_message_t msg = { 0 };
                switch_time_t now = switch_micro_time_now();

                if (!force && (smh->last_video_refresh_req && (now - smh->last_video_refresh_req) < VIDEO_REFRESH_FREQ)) {
                        return SWITCH_STATUS_BREAK;
                }

                smh->last_video_refresh_req = now;

                if (force) {
                        msg.numeric_arg = 1;
                }

                msg._file = file;
                msg._func = func;
                msg._line = line;
                switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, switch_core_session_get_uuid(session), 
                                                  SWITCH_LOG_DEBUG1, "%s Video refresh requested.\n", switch_channel_get_name(session->channel));
                msg.from = __FILE__;
                msg.message_id = SWITCH_MESSAGE_INDICATE_VIDEO_REFRESH_REQ;
                switch_core_session_receive_message(session, &msg);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_send_and_request_video_refresh(switch_core_session_t *session)
{
        if (switch_channel_test_flag(session->channel, CF_VIDEO)) {
                switch_core_session_request_video_refresh(session);
                switch_core_media_gen_key_frame(session);
                return SWITCH_STATUS_SUCCESS;
        }

        return SWITCH_STATUS_FALSE;
}


SWITCH_DECLARE(switch_status_t) switch_core_media_codec_control(switch_core_session_t *session,
                                                                                                                                switch_media_type_t mtype,
                                                                                                                                switch_io_type_t iotype,
                                                                                                                                switch_codec_control_command_t cmd,
                                                                                                                                switch_codec_control_type_t ctype,
                                                                                                                                void *cmd_data,
                                                                                                                                switch_codec_control_type_t atype,
                                                                                                                                void *cmd_arg,
                                                                                                                                switch_codec_control_type_t *rtype,
                                                                                                                                void **ret_data)
{
        switch_rtp_engine_t *engine = NULL;
        switch_media_handle_t *smh = NULL;
        switch_codec_t *codec = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!(engine = &smh->engines[mtype])) {
                return SWITCH_STATUS_NOTIMPL;
        }

        if (iotype == SWITCH_IO_READ) {
                codec = &engine->read_codec;
        } else {
                codec = &engine->write_codec;
        }

        if (!switch_core_codec_ready(codec)) {
                return SWITCH_STATUS_FALSE;
        }

        if (mtype == SWITCH_MEDIA_TYPE_VIDEO) {
                if (!switch_channel_test_flag(session->channel, CF_VIDEO)) {
                        return SWITCH_STATUS_FALSE;
                }
        }

        if (codec) {
                return switch_core_codec_control(codec, cmd, ctype, cmd_data, atype, cmd_arg, rtype, ret_data);
        }

        return SWITCH_STATUS_FALSE;
}

SWITCH_DECLARE(switch_bool_t) switch_core_media_codec_get_cap(switch_core_session_t *session,
                                                                                                                                switch_media_type_t mtype,
                                                                                                                                switch_codec_flag_t flag) {
        switch_rtp_engine_t *engine = NULL;
        switch_media_handle_t *smh = NULL;
        switch_codec_t *codec = NULL;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_FALSE;
        }

        if (!(engine = &smh->engines[mtype])) {
                return SWITCH_FALSE;
        }

        codec = &engine->write_codec;

        if (!switch_core_codec_ready(codec)) {
                return SWITCH_FALSE;
        }

        if (switch_test_flag(codec, flag)){
                return SWITCH_TRUE;
        }

        return SWITCH_FALSE;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_write_encoded_video_frame(switch_core_session_t *session,
                                                                                                                                                switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
{
        switch_io_event_hook_video_write_frame_t *ptr;
        switch_status_t status = SWITCH_STATUS_FALSE;

        if (switch_core_session_media_flow(session, SWITCH_MEDIA_TYPE_VIDEO) == SWITCH_MEDIA_FLOW_RECVONLY || switch_core_session_media_flow(session, SWITCH_MEDIA_TYPE_VIDEO) == SWITCH_MEDIA_FLOW_INACTIVE) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG3, "Writing video to RECVONLY/INACTIVE session\n");
                return SWITCH_STATUS_SUCCESS;
        }

        if (session->endpoint_interface->io_routines->write_video_frame) {
                if ((status = session->endpoint_interface->io_routines->write_video_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
                        for (ptr = session->event_hooks.video_write_frame; ptr; ptr = ptr->next) {
                                if ((status = ptr->video_write_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }
                        }
                }
        }

        return status;
}

SWITCH_DECLARE(void) switch_core_session_video_reinit(switch_core_session_t *session)
{
        switch_media_handle_t *smh;
        int type;

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return;
        }

        if (switch_channel_down(session->channel)) {
                return;
        }

        smh->video_init = 0;
        smh->video_last_key_time = 0;
        switch_core_session_send_and_request_video_refresh(session);

        type = 1;
        switch_core_media_codec_control(session, SWITCH_MEDIA_TYPE_VIDEO, SWITCH_IO_READ, SCC_VIDEO_RESET, SCCT_INT, (void *)&type, SCCT_NONE, NULL, NULL, NULL);
        switch_core_session_request_video_refresh(session);

}

SWITCH_DECLARE(switch_status_t) switch_core_session_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags,
                                                                                                                                          int stream_id)
{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_time_t now = switch_micro_time_now();
        switch_codec_t *codec = switch_core_session_get_video_write_codec(session);
        switch_timer_t *timer;
        switch_media_handle_t *smh;
        switch_image_t *dup_img = NULL, *img = frame->img;
        switch_status_t encode_status;
        switch_frame_t write_frame = {0};
        switch_rtp_engine_t *v_engine = NULL;
        switch_bool_t need_free = SWITCH_FALSE;
        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_down(session->channel)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!codec) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING, "%s has no video codec\n", switch_core_session_get_name(session));
                return SWITCH_STATUS_FALSE;
        }


        if (switch_core_session_media_flow(session, SWITCH_MEDIA_TYPE_VIDEO) == SWITCH_MEDIA_FLOW_RECVONLY || switch_core_session_media_flow(session, SWITCH_MEDIA_TYPE_VIDEO) == SWITCH_MEDIA_FLOW_INACTIVE) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG3, "Writing video to RECVONLY/INACTIVE session\n");
                return SWITCH_STATUS_SUCCESS;
        }

        if (switch_channel_test_flag(session->channel, CF_VIDEO_PAUSE_WRITE)) {
                return SWITCH_STATUS_SUCCESS;
        }

        if (!(switch_channel_test_flag(session->channel, CF_VIDEO_READY) || (flags & SWITCH_IO_FLAG_FORCE))) {
                return SWITCH_STATUS_SUCCESS;
        }

        if (smh->write_mutex[SWITCH_MEDIA_TYPE_VIDEO] && switch_mutex_trylock(smh->write_mutex[SWITCH_MEDIA_TYPE_VIDEO]) != SWITCH_STATUS_SUCCESS) {
                /* return CNG, another thread is already writing  */
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "%s is already being written to for %s\n",
                                                  switch_channel_get_name(session->channel), type2str(SWITCH_MEDIA_TYPE_VIDEO));
                return SWITCH_STATUS_INUSE;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];
        if (v_engine->thread_write_lock && v_engine->thread_write_lock != switch_thread_self()) {
                switch_goto_status(SWITCH_STATUS_SUCCESS, done);
        }

        if (!smh->video_init && smh->mparams->video_key_first && (now - smh->video_last_key_time) > smh->mparams->video_key_first) {
                switch_core_media_gen_key_frame(session);

                if (smh->video_last_key_time) {
                        smh->video_init = 1;
                }

                smh->video_last_key_time = now;
        }

        if (smh->mparams->video_key_freq && (now - smh->video_last_key_time) > smh->mparams->video_key_freq) {
                switch_core_media_gen_key_frame(smh->session);
                smh->video_last_key_time = now;
        }

        if (!img) {
                switch_status_t vstatus;

                vstatus = switch_core_session_write_encoded_video_frame(session, frame, flags, stream_id);
                switch_goto_status(vstatus, done);
        }


    /* When desired, scale video to match the input signal (if output is bigger) */
        if (switch_channel_test_flag(session->channel, CF_VIDEO_READY) &&
                switch_channel_test_flag(session->channel, CF_VIDEO_MIRROR_INPUT)) {
                switch_vid_params_t vid_params = { 0 };

                switch_core_media_get_vid_params(session, &vid_params);

                if (vid_params.width && vid_params.height && ((vid_params.width != img->d_w) || (vid_params.height != img->d_h))) {
                        switch_img_letterbox(img, &dup_img, vid_params.width, vid_params.height, "#000000f");
                        if (!(img = dup_img)) {
                                switch_goto_status(SWITCH_STATUS_INUSE, done);
                        }
                }
        }

        if (!switch_channel_test_flag(session->channel, CF_VIDEO_WRITING)) {
                smh->vid_params.d_width = img->d_w;
                smh->vid_params.d_height = img->d_h;
        }

        if (session->bugs) {
                switch_media_bug_t *bp;
                int prune = 0;
                int patched = 0;

                switch_thread_rwlock_rdlock(session->bug_rwlock);
                for (bp = session->bugs; bp; bp = bp->next) {
                        switch_bool_t ok = SWITCH_TRUE;

                        if (switch_core_media_bug_test_flag(bp, SMBF_PAUSE) || (switch_channel_test_flag(session->channel, CF_PAUSE_BUGS) && !switch_core_media_bug_test_flag(bp, SMBF_NO_PAUSE))) {
                                continue;
                        }

                        if (!switch_channel_test_flag(session->channel, CF_ANSWERED) && switch_core_media_bug_test_flag(bp, SMBF_ANSWER_REQ)) {
                                continue;
                        }

                        if (switch_test_flag(bp, SMBF_PRUNE)) {
                                prune++;
                                continue;
                        }

                        if (bp->ready && switch_test_flag(bp, SMBF_WRITE_VIDEO_STREAM)) {
                                switch_image_t *dimg = NULL;

                                switch_img_copy(img, &dimg);
                                switch_queue_push(bp->write_video_queue, dimg);

                                if (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM_BLEG)) {
                                        switch_core_media_bug_patch_spy_frame(bp, img, SWITCH_RW_WRITE);
                                        patched = 1;
                                }

                        }

                        if (bp->ready && img &&
                                (switch_test_flag(bp, SMBF_WRITE_VIDEO_PING) || (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM) && !patched))) {
                                switch_frame_t bug_frame = { 0 };

                                bug_frame.img = img;

                                if (bp->callback && switch_test_flag(bp, SMBF_WRITE_VIDEO_PING)) {
                                        bp->video_ping_frame = &bug_frame;
                                        if (bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_WRITE_VIDEO_PING) == SWITCH_FALSE
                                                || (bp->stop_time && bp->stop_time <= switch_epoch_time_now(NULL))) {
                                                ok = SWITCH_FALSE;
                                        }
                                        bp->video_ping_frame = NULL;
                                }

                                if (bug_frame.img && bug_frame.img != img) {
                                        need_free = SWITCH_TRUE;
                                        img = bug_frame.img;
                                }

                                if (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM_BLEG) && !patched) {
                                        switch_core_media_bug_patch_spy_frame(bp, img, SWITCH_RW_WRITE);
                                }


                        }

                        if (ok == SWITCH_FALSE) {
                                switch_set_flag(bp, SMBF_PRUNE);
                                prune++;
                        }

                }

                switch_thread_rwlock_unlock(session->bug_rwlock);

                if (prune) {
                        switch_core_media_bug_prune(session);
                }

        }

        write_frame = *frame;
        frame = &write_frame;
        frame->img = img;

        if (!switch_test_flag(frame, SFF_USE_VIDEO_TIMESTAMP)) {

                if (!(timer = switch_core_media_get_timer(session, SWITCH_MEDIA_TYPE_VIDEO))) {

                        if (!smh->video_timer.timer_interface) {
                                switch_core_timer_init(&smh->video_timer, "soft", 1, 90, switch_core_session_get_pool(session));
                        }
                        switch_core_timer_sync(&smh->video_timer);
                        timer = &smh->video_timer;
                }

                frame->timestamp = timer->samplecount;
        }

        switch_clear_flag(frame, SFF_SAME_IMAGE);
        frame->m = 0;

        do {
                frame->datalen = SWITCH_DEFAULT_VIDEO_SIZE;
                encode_status = switch_core_codec_encode_video(codec, frame);

                if (encode_status == SWITCH_STATUS_SUCCESS || encode_status == SWITCH_STATUS_MORE_DATA) {

                        switch_assert((encode_status == SWITCH_STATUS_SUCCESS && frame->m) || !frame->m);

                        if (frame->flags & SFF_PICTURE_RESET) {
                                switch_core_session_video_reinit(session);
                                frame->flags &= ~SFF_PICTURE_RESET;
                        }

                        if (frame->datalen == 0) break;

                        switch_set_flag(frame, SFF_RAW_RTP_PARSE_FRAME);
                        status = switch_core_session_write_encoded_video_frame(session, frame, flags, stream_id);
                }

        } while(status == SWITCH_STATUS_SUCCESS && encode_status == SWITCH_STATUS_MORE_DATA);

 done:

        if (smh->write_mutex[SWITCH_MEDIA_TYPE_VIDEO]) {
                switch_mutex_unlock(smh->write_mutex[SWITCH_MEDIA_TYPE_VIDEO]);
        }

        switch_img_free(&dup_img);

        if (need_free) {
                switch_img_free(&frame->img);
        }

        return status;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_wait_for_video_input_params(switch_core_session_t *session, uint32_t timeout_ms)
{
        switch_media_handle_t *smh;
        switch_codec_implementation_t read_impl = { 0 };
        switch_rtp_engine_t *v_engine = NULL;

        switch_assert(session != NULL);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!switch_channel_test_flag(session->channel, CF_VIDEO_DECODED_READ)) {
                return SWITCH_STATUS_GENERR;
        }

        v_engine = &smh->engines[SWITCH_MEDIA_TYPE_VIDEO];

        if (v_engine->smode == SWITCH_MEDIA_FLOW_SENDONLY) {
                return SWITCH_STATUS_NOTIMPL;
        }

        switch_core_session_get_read_impl(session, &read_impl);

        while(switch_channel_ready(session->channel) && timeout_ms > 0) {
                switch_frame_t *read_frame;
                switch_status_t status;

                if (video_globals.synced &&
                        switch_channel_test_flag(session->channel, CF_VIDEO_READY) && smh->vid_params.width && smh->vid_params.height && smh->vid_params.fps) {
                        return SWITCH_STATUS_SUCCESS;
                }

                switch_core_session_request_video_refresh(session);
                status = switch_core_session_read_frame(session, &read_frame, SWITCH_IO_FLAG_NONE, 0);

                if (!SWITCH_READ_ACCEPTABLE(status)) {
                        return SWITCH_STATUS_FALSE;
                }

                timeout_ms -= (read_impl.microseconds_per_packet / 1000);
        }

        return SWITCH_STATUS_TIMEOUT;

}

SWITCH_DECLARE(switch_bool_t) switch_core_session_transcoding(switch_core_session_t *session_a, switch_core_session_t *session_b, switch_media_type_t type)
{
        switch_bool_t transcoding = SWITCH_FALSE;

        switch(type) {
        case SWITCH_MEDIA_TYPE_AUDIO:
                {
                        switch_codec_implementation_t read_impl_a = { 0 }, read_impl_b = { 0 };

                        switch_core_session_get_read_impl(session_a, &read_impl_a);
                        switch_core_session_get_read_impl(session_b, &read_impl_b);
                        
                        if (read_impl_a.impl_id && read_impl_b.impl_id) {
                                transcoding = (read_impl_a.impl_id != read_impl_b.impl_id || read_impl_a.decoded_bytes_per_packet != read_impl_b.decoded_bytes_per_packet);
                        }
                }
                break;
        case SWITCH_MEDIA_TYPE_VIDEO:
                transcoding = (switch_channel_test_flag(session_a->channel, CF_VIDEO_DECODED_READ) || 
                                           switch_channel_test_flag(session_b->channel, CF_VIDEO_DECODED_READ));
                break;
        default:
                break;
        }

        return transcoding;

}

SWITCH_DECLARE(void) switch_core_session_passthru(switch_core_session_t *session, switch_media_type_t type, switch_bool_t on)
{
        switch_rtp_engine_t *engine;

        if (!session->media_handle) return;

        engine = &session->media_handle->engines[type];


        if (switch_rtp_ready(engine->rtp_session)) {
                char var[50] = "";
                switch_snprintf(var, sizeof(var), "disable_%s_jb_during_passthru", type2str(type));

                if (switch_channel_var_true(session->channel, var)) {
                        if (on) {
                                switch_rtp_set_flag(engine->rtp_session, SWITCH_RTP_FLAG_PASSTHRU);
                        } else {
                                switch_rtp_clear_flag(engine->rtp_session, SWITCH_RTP_FLAG_PASSTHRU);
                        }
                }

                if (type == SWITCH_MEDIA_TYPE_VIDEO) {
                        switch_core_session_request_video_refresh(session);
                        if (!on) {
                                switch_core_media_gen_key_frame(session);
                        }
                }

        }

}

SWITCH_DECLARE(switch_status_t) switch_core_session_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags,
                                                                                                                                         int stream_id)
{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_io_event_hook_video_read_frame_t *ptr;
        switch_media_handle_t *smh;
        int is_keyframe = 0;

        switch_assert(session != NULL);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

 top:

        if (switch_channel_down_nosig(session->channel)) {
                return SWITCH_STATUS_FALSE;
        }

        if (session->endpoint_interface->io_routines->read_video_frame) {
                if ((status = session->endpoint_interface->io_routines->read_video_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
                        for (ptr = session->event_hooks.video_read_frame; ptr; ptr = ptr->next) {
                                if ((status = ptr->video_read_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }
                        }
                }
        }

        if (switch_channel_test_flag(session->channel, CF_VIDEO_PAUSE_READ)) {
                *frame = &runtime.dummy_cng_frame;
                switch_cond_next();
                return SWITCH_STATUS_SUCCESS;
        }

        if (status == SWITCH_STATUS_INUSE) {
                *frame = &runtime.dummy_cng_frame;
                switch_cond_next();
                return SWITCH_STATUS_SUCCESS;
        }

        if (status != SWITCH_STATUS_SUCCESS) {
                goto done;
        }

        if (!(*frame)) {
                goto done;
        }

        if (switch_channel_test_flag(session->channel, CF_VIDEO_DEBUG_READ)) {
                if (switch_test_flag((*frame), SFF_CNG)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "VIDEO: CNG\n");
                } else {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO,
                                                          "VIDEO: seq: %d ts: %u len: %4d %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x mark: %d\n",
                                                          (*frame)->seq, (*frame)->timestamp, (*frame)->datalen,
                                                          *((uint8_t *)(*frame)->data), *((uint8_t *)(*frame)->data + 1),
                                                          *((uint8_t *)(*frame)->data + 2), *((uint8_t *)(*frame)->data + 3),
                                                          *((uint8_t *)(*frame)->data + 4), *((uint8_t *)(*frame)->data + 5),
                                                          *((uint8_t *)(*frame)->data + 6), *((uint8_t *)(*frame)->data + 7),
                                                          *((uint8_t *)(*frame)->data + 8), *((uint8_t *)(*frame)->data + 9),
                                                          *((uint8_t *)(*frame)->data + 10), (*frame)->m);
                }
        }


        if (switch_test_flag(*frame, SFF_CNG)) {
                status = SWITCH_STATUS_SUCCESS;
                goto done;
        }

        if (switch_channel_test_flag(session->channel, CF_VIDEO_DECODED_READ) && (*frame)->img == NULL) {
                switch_status_t decode_status;

                (*frame)->img = NULL;

                decode_status = switch_core_codec_decode_video((*frame)->codec, *frame);
                if (switch_test_flag(*frame, SFF_IS_KEYFRAME)) {
                        is_keyframe++;
                }
                if ((*frame)->img && switch_channel_test_flag(session->channel, CF_VIDEO_DEBUG_READ)) {
                        switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "IMAGE %dx%d %dx%d\n",
                                                          (*frame)->img->w, (*frame)->img->h, (*frame)->img->d_w, (*frame)->img->d_h);
                }

                if ((*frame)->img && (*frame)->img->d_w && (*frame)->img->d_h) {
                        int new_w = 0, new_h = 0;
                        
                        if ((*frame)->img->d_w != smh->vid_params.width || (*frame)->img->d_h != smh->vid_params.height) {
                                new_w = (*frame)->img->d_w;
                                new_h = (*frame)->img->d_h;

                                if (new_w && new_h) {
                                        switch_mutex_lock(smh->control_mutex);
                                        smh->vid_params.width = new_w;
                                        smh->vid_params.height = new_h;
                                        switch_channel_set_variable_printf(session->channel, "video_width", "%d", new_w);
                                        switch_channel_set_variable_printf(session->channel, "video_height", "%d", new_h);
                                        switch_mutex_unlock(smh->control_mutex);
                                }
                        }
                }

                if (switch_test_flag((*frame), SFF_WAIT_KEY_FRAME)) {
                        switch_core_session_request_video_refresh(session);
                        switch_clear_flag((*frame), SFF_WAIT_KEY_FRAME);

                        if (!(*frame)->img) {
                                *frame = &runtime.dummy_cng_frame;
                                switch_cond_next();
                                return SWITCH_STATUS_SUCCESS;
                        }
                }

                if (decode_status == SWITCH_STATUS_MORE_DATA || !(*frame)->img) {
                        goto top;
                }
        }

        if (!switch_channel_test_flag(session->channel, CF_VIDEO_READY) && *frame) {
                if (switch_channel_test_flag(session->channel, CF_VIDEO_DECODED_READ)) {
                        if ((*frame)->img) {
                                switch_channel_set_flag(session->channel, CF_VIDEO_READY);
                        }
                } else if ((*frame)->m || ++smh->ready_loops > 5) {
                        switch_channel_set_flag(session->channel, CF_VIDEO_READY);
                }
        }

  done:

        if (*frame && is_keyframe) {
                switch_set_flag(*frame, SFF_IS_KEYFRAME);
        }

        if (session->bugs) {
                switch_media_bug_t *bp;
                int prune = 0;
                int patched = 0;

                switch_thread_rwlock_rdlock(session->bug_rwlock);
                for (bp = session->bugs; bp; bp = bp->next) {
                        switch_bool_t ok = SWITCH_TRUE;

                        if (switch_core_media_bug_test_flag(bp, SMBF_PAUSE) || (switch_channel_test_flag(session->channel, CF_PAUSE_BUGS) && !switch_core_media_bug_test_flag(bp, SMBF_NO_PAUSE))) {
                                continue;
                        }

                        if (!switch_channel_test_flag(session->channel, CF_ANSWERED) && switch_core_media_bug_test_flag(bp, SMBF_ANSWER_REQ)) {
                                continue;
                        }

                        if (switch_test_flag(bp, SMBF_PRUNE)) {
                                prune++;
                                continue;
                        }

                        if (bp->ready && switch_test_flag(bp, SMBF_READ_VIDEO_STREAM)) {
                                if ((*frame) && (*frame)->img) {
                                        switch_image_t *img = NULL;
                                        switch_img_copy((*frame)->img, &img);
                                        switch_queue_push(bp->read_video_queue, img);
                                        if (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM)) {
                                                switch_core_media_bug_patch_spy_frame(bp, (*frame)->img, SWITCH_RW_READ);
                                                patched = 1;
                                        }
                                }
                        }

                        if (bp->ready && (*frame) && (*frame)->img &&
                                (switch_test_flag(bp, SMBF_READ_VIDEO_PING) || (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM) && !patched))) {


                                if (bp->callback && switch_test_flag(bp, SMBF_READ_VIDEO_PING)) {
                                        bp->video_ping_frame = *frame;

                                        if (bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_READ_VIDEO_PING) == SWITCH_FALSE
                                                || (bp->stop_time && bp->stop_time <= switch_epoch_time_now(NULL))) {
                                                ok = SWITCH_FALSE;
                                        }
                                        bp->video_ping_frame = NULL;
                                }

                                if (switch_core_media_bug_test_flag(bp, SMBF_SPY_VIDEO_STREAM) && !patched) {
                                        switch_core_media_bug_patch_spy_frame(bp, (*frame)->img, SWITCH_RW_READ);
                                }
                        }

                        if (ok == SWITCH_FALSE) {
                                switch_set_flag(bp, SMBF_PRUNE);
                                prune++;
                        }
                }

                switch_thread_rwlock_unlock(session->bug_rwlock);

                if (prune) {
                        switch_core_media_bug_prune(session);
                }
        }

        if ((*frame) && (*frame)->codec) {
                (*frame)->pmap = NULL;
        }

        if (status == SWITCH_STATUS_SUCCESS) {
                switch_core_session_video_read_callback(session, *frame);
        }

        return status;
}


SWITCH_DECLARE(switch_status_t) switch_core_session_set_video_read_callback(switch_core_session_t *session,
                                                                                                                                                        switch_core_video_thread_callback_func_t func, void *user_data)
{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_media_handle_t *smh;

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        switch_mutex_lock(smh->control_mutex);
        if (!func) {
                session->video_read_callback = NULL;
                session->video_read_user_data = NULL;
        } else if (session->video_read_callback) {
                status = SWITCH_STATUS_FALSE;
        } else {
                session->video_read_callback = func;
                session->video_read_user_data = user_data;
        }

        switch_core_session_start_video_thread(session);
        switch_mutex_unlock(smh->control_mutex);

        return status;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_video_read_callback(switch_core_session_t *session, switch_frame_t *frame)
{
        switch_media_handle_t *smh;
        switch_status_t status = SWITCH_STATUS_CONTINUE;

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        switch_mutex_lock(smh->control_mutex);

        if (session->video_read_callback) {
                status = session->video_read_callback(session, frame, session->video_read_user_data);
        }

        switch_mutex_unlock(smh->control_mutex);

        return status;
}



SWITCH_DECLARE(switch_status_t) switch_core_session_set_text_read_callback(switch_core_session_t *session,
                                                                                                                                                        switch_core_text_thread_callback_func_t func, void *user_data)
{
        switch_status_t status = SWITCH_STATUS_SUCCESS;
        switch_media_handle_t *smh;

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        switch_mutex_lock(smh->control_mutex);
        if (!func) {
                session->text_read_callback = NULL;
                session->text_read_user_data = NULL;
        } else if (session->text_read_callback) {
                status = SWITCH_STATUS_FALSE;
        } else {
                session->text_read_callback = func;
                session->text_read_user_data = user_data;
        }

        switch_core_session_start_text_thread(session);
        switch_mutex_unlock(smh->control_mutex);

        return status;
}



SWITCH_DECLARE(switch_status_t) switch_core_session_text_read_callback(switch_core_session_t *session, switch_frame_t *frame)
{
        switch_media_handle_t *smh;
        switch_status_t status = SWITCH_STATUS_CONTINUE;

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        switch_mutex_lock(smh->control_mutex);

        if (session->text_read_callback) {
                status = session->text_read_callback(session, frame, session->text_read_user_data);
        }

        switch_mutex_unlock(smh->control_mutex);

        return status;
}



SWITCH_DECLARE(switch_status_t) switch_core_session_read_text_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags,
                                                                                                                                         int stream_id)
{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_io_event_hook_text_read_frame_t *ptr;
        switch_media_handle_t *smh;
        switch_io_read_text_frame_t read_text_frame = NULL;
        switch_time_t now;

        switch_assert(session != NULL);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_down_nosig(session->channel)) {
                return SWITCH_STATUS_FALSE;
        }

        if (!(read_text_frame = session->endpoint_interface->io_routines->read_text_frame)) {
                if (session->io_override) {
                        read_text_frame = session->io_override->read_text_frame;
                }
        }

        if (read_text_frame) {
                if ((status = read_text_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
                        for (ptr = session->event_hooks.text_read_frame; ptr; ptr = ptr->next) {
                                if ((status = ptr->text_read_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }
                        }
                }
        }

        if (status == SWITCH_STATUS_INUSE) {
                *frame = &runtime.dummy_cng_frame;
                switch_cond_next();
                return SWITCH_STATUS_SUCCESS;
        }

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

        if (!(*frame)) {
                goto done;
        }

        now = switch_micro_time_now();

        if (switch_test_flag((*frame), SFF_CNG)) {
                if (smh->last_text_frame && now - smh->last_text_frame > TEXT_PERIOD_TIMEOUT * 1000) {
                        switch_channel_set_flag(session->channel, CF_TEXT_IDLE);
                        switch_channel_clear_flag(session->channel, CF_TEXT_ACTIVE);
                        smh->last_text_frame = 0;
                }
        } else {
                unsigned char *p = (*frame)->data;

                smh->last_text_frame = now;
                switch_channel_set_flag(session->channel, CF_TEXT_ACTIVE);
                switch_channel_clear_flag(session->channel, CF_TEXT_IDLE);

                while(p && *p) {
                        if (*p == '\r' || *p == '\n') {
                                switch_set_flag((*frame), SFF_TEXT_LINE_BREAK);
                                break;
                        }

                        if (*p == 0xE2 && *(p+1) == 0x80 && *(p+2) == 0xA8) {
                                switch_set_flag((*frame), SFF_TEXT_LINE_BREAK);
                                break;
                        }

                        p++;
                }
        }

        if ((*frame)->data && (*frame)->datalen && !((*frame)->flags & SFF_CNG)) {
                if (!session->text_buffer) {
                        switch_mutex_init(&session->text_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
                        switch_buffer_create_dynamic(&session->text_buffer, 512, 1024, 0);
                }
                switch_buffer_write(session->text_buffer, (*frame)->data, (*frame)->datalen);
        }

        if (session->bugs) {
                switch_media_bug_t *bp;
                int prune = 0;

                switch_thread_rwlock_rdlock(session->bug_rwlock);
                for (bp = session->bugs; bp; bp = bp->next) {
                        switch_bool_t ok = SWITCH_TRUE;

                        if (switch_core_media_bug_test_flag(bp, SMBF_PAUSE) || (switch_channel_test_flag(session->channel, CF_PAUSE_BUGS) && !switch_core_media_bug_test_flag(bp, SMBF_NO_PAUSE))) {
                                continue;
                        }

                        if (!switch_channel_test_flag(session->channel, CF_ANSWERED) && switch_core_media_bug_test_flag(bp, SMBF_ANSWER_REQ)) {
                                continue;
                        }

                        if (switch_test_flag(bp, SMBF_PRUNE)) {
                                prune++;
                                continue;
                        }

                        if (bp->ready && switch_test_flag(bp, SMBF_READ_TEXT_STREAM)) {
                                int bytes = 0;

                                if ((*frame)) {
                                        switch_size_t inuse = 0;

                                        if ((*frame)->data && (*frame)->datalen && !((*frame)->flags & SFF_CNG)) {
                                                switch_mutex_lock(session->text_mutex);
                                                switch_buffer_write(bp->text_buffer, (char *)(*frame)->data, (*frame)->datalen);
                                                switch_mutex_unlock(session->text_mutex);
                                        }

                                        inuse = switch_buffer_inuse(bp->text_buffer);

                                        if (zstr(bp->text_framedata) && inuse &&
                                                (switch_channel_test_flag(session->channel, CF_TEXT_IDLE) || switch_test_flag((*frame), SFF_TEXT_LINE_BREAK))) {

                                                if (inuse + 1 > bp->text_framesize) {
                                                        void *tmp = malloc(inuse + 1024);
                                                        memcpy(tmp, bp->text_framedata, bp->text_framesize);

                                                        switch_assert(tmp);

                                                        bp->text_framesize = inuse + 1024;

                                                        free(bp->text_framedata);
                                                        bp->text_framedata = tmp;

                                                }


                                                bytes = switch_buffer_read(bp->text_buffer, bp->text_framedata, inuse);
                                                *(bp->text_framedata + bytes) = '\0';

                                                ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_READ_TEXT);
                                                bp->text_framedata[0] = '\0';
                                        } else ok = SWITCH_TRUE;
                                }
                        }

                        if (ok == SWITCH_FALSE) {
                                switch_set_flag(bp, SMBF_PRUNE);
                                prune++;
                        }
                }

                switch_thread_rwlock_unlock(session->bug_rwlock);

                if (prune) {
                        switch_core_media_bug_prune(session);
                }
        }

        if (status == SWITCH_STATUS_SUCCESS || status == SWITCH_STATUS_BREAK) {         
                if ((switch_channel_test_flag(session->channel, CF_QUEUE_TEXT_EVENTS) || switch_channel_test_flag(session->channel, CF_FIRE_TEXT_EVENTS)) && 
                        (*frame)->datalen && !switch_test_flag((*frame), SFF_CNG)) {
                        int ok = 1;
                        switch_event_t *event;
                        void *data = (*frame)->data;
                        char eof[1] = {'\0'};

                        //uint32_t datalen = (*frame)->datalen;

                        if (!switch_channel_test_flag(session->channel, CF_TEXT_LINE_BASED)) {
                                if (!session->text_line_buffer) {
                                        switch_buffer_create_dynamic(&session->text_line_buffer, 512, 1024, 0);
                                }
                                switch_buffer_write(session->text_line_buffer, (*frame)->data, (*frame)->datalen);


                                if (switch_channel_test_flag(session->channel, CF_TEXT_IDLE) || switch_test_flag((*frame), SFF_TEXT_LINE_BREAK)) {
                                        switch_buffer_write(session->text_line_buffer, eof, 1);
                                        data = switch_buffer_get_head_pointer(session->text_line_buffer);
                                        //datalen = strlen((char *)smh->line_text_frame.data);
                                } else {
                                        ok = 0;
                                }
                        }


                        if (ok) {
                                if (switch_event_create(&event, SWITCH_EVENT_TEXT) == SWITCH_STATUS_SUCCESS) {
                                        switch_channel_event_set_data(session->channel, event);

                                        switch_event_add_body(event, "%s", (char *)data);

                                        if (switch_channel_test_flag(session->channel, CF_QUEUE_TEXT_EVENTS)) {
                                                switch_event_t *q_event = NULL;

                                                if (switch_channel_test_flag(session->channel, CF_FIRE_TEXT_EVENTS)) {
                                                        switch_event_dup(&q_event, event);
                                                } else {
                                                        q_event = event;
                                                        event = NULL;
                                                }

                                                switch_core_session_queue_event(session, &q_event);
                                        }
                                        
                                        if (switch_channel_test_flag(session->channel, CF_FIRE_TEXT_EVENTS)) {
                                                switch_event_fire(&event);
                                        }
                                }
                                if (session->text_line_buffer) {
                                        switch_buffer_zero(session->text_line_buffer);
                                }
                        }
                }
                switch_core_session_text_read_callback(session, *frame);
        }

 done:

        return status;
}

static void build_red_packet(switch_rtp_engine_t *t_engine)
{
        int pos;
        switch_frame_t *frame = &t_engine->tf->text_write_frame;
        switch_byte_t *buf = (switch_byte_t *) frame->data;
        uint32_t plen = 0, loops = 0;
        uint16_t *u16;

        pos = t_engine->tf->red_pos + 1;

        if (pos == t_engine->tf->red_max) pos = 0;

        for (;;) {
                uint16_t ts = frame->timestamp - t_engine->tf->red_ts[pos];
                uint16_t len = t_engine->tf->red_buflen[pos];

                loops++;

                //1
                *buf = t_engine->t140_pt & 0x7f;

                if (pos != t_engine->tf->red_pos) {
                        *buf |= 0x80;

                        buf++; //2
                        u16 = (uint16_t *) buf;
                        *u16 = htons(ts << 2);
                        buf++;//3
                        *buf += (len & 0x300) >> 8;
                        buf++;//4
                        *buf = len & 0xff;
                }

                buf++;

                if (pos == t_engine->tf->red_pos) break;


                pos++;

                if (pos == t_engine->tf->red_max) pos = 0;
        }


        plen = ((loops - 1) * 4) + 1;
        pos = t_engine->tf->red_pos + 1;

        if (pos == t_engine->tf->red_max) pos = 0;

        for (;;) {
                if (t_engine->tf->red_buflen[pos]) {
                        memcpy(buf, t_engine->tf->red_buf[pos], t_engine->tf->red_buflen[pos]);
                        plen += t_engine->tf->red_buflen[pos];
                        buf += t_engine->tf->red_buflen[pos];
                }

                if (pos == t_engine->tf->red_pos) break;

                pos++;

                if (pos == t_engine->tf->red_max) pos = 0;
        }


        buf = frame->data;
        *(buf+plen) = '\0';

        frame->datalen = plen;
        frame->payload = t_engine->red_pt;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_write_text_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags,
                                                                                                                                          int stream_id)
{
        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_media_handle_t *smh;
        switch_io_event_hook_text_write_frame_t *ptr;
        switch_rtp_engine_t *t_engine;
        switch_io_write_text_frame_t write_text_frame = NULL;
        int is_msrp = switch_channel_test_flag(session->channel, CF_MSRP);

        switch_assert(session);

        if (!(smh = session->media_handle)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_down(session->channel)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_core_session_media_flow(session, SWITCH_MEDIA_TYPE_TEXT) == SWITCH_MEDIA_FLOW_RECVONLY || switch_core_session_media_flow(session, SWITCH_MEDIA_TYPE_TEXT) == SWITCH_MEDIA_FLOW_INACTIVE) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG3, "Writing text to RECVONLY/INACTIVE session\n");
                return SWITCH_STATUS_SUCCESS;
        }

        //if (switch_channel_test_flag(session->channel, CF_TEXT_PAUSE_WRITE)) {
        //      return SWITCH_STATUS_SUCCESS;
        //}

        if (smh->write_mutex[SWITCH_MEDIA_TYPE_TEXT] && switch_mutex_trylock(smh->write_mutex[SWITCH_MEDIA_TYPE_TEXT]) != SWITCH_STATUS_SUCCESS) {
                /* return CNG, another thread is already writing  */
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG1, "%s is already being written to for %s\n",
                                                  switch_channel_get_name(session->channel), type2str(SWITCH_MEDIA_TYPE_TEXT));
                goto done;
        }

        t_engine = &smh->engines[SWITCH_MEDIA_TYPE_TEXT];

        if (!is_msrp && switch_channel_test_cap(session->channel, CC_RTP_RTT)) {

                if (!t_engine || !t_engine->tf) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "text engine not available for processing\n");
                        switch_goto_status(SWITCH_STATUS_BREAK, done);
                }

                if (frame) {
                        char *str = (char *) frame->data;
                        switch_buffer_write(t_engine->tf->write_buffer, str, frame->datalen);
                }

                if (!switch_buffer_inuse(t_engine->tf->write_buffer)) {
                        t_engine->tf->write_empty++;
                        switch_goto_status(SWITCH_STATUS_BREAK, done);
                }

                frame = &t_engine->tf->text_write_frame;
                switch_core_timer_sync(&t_engine->tf->timer);
                frame->timestamp = t_engine->tf->timer.samplecount;

                if (t_engine->red_pt) {
                        t_engine->tf->red_ts[t_engine->tf->red_pos] = frame->timestamp;

                        if (t_engine->tf->write_empty > TEXT_PERIOD_TIMEOUT / TEXT_TIMER_MS) {
                                int pos;

                                for(pos = 0; pos < t_engine->tf->red_max; pos++) {
                                        t_engine->tf->red_ts[pos] = 0;
                                        t_engine->tf->red_buf[pos][0] = '\0';
                                        t_engine->tf->red_buflen[pos] = 0;
                                }

                                frame->m = 1;
                                t_engine->tf->write_empty = 0;

                        } else {
                                frame->m = 0;
                        }

                        t_engine->tf->red_buflen[t_engine->tf->red_pos] =
                                switch_buffer_read(t_engine->tf->write_buffer, t_engine->tf->red_buf[t_engine->tf->red_pos], RED_PACKET_SIZE);

                        *(t_engine->tf->red_buf[t_engine->tf->red_pos] + t_engine->tf->red_buflen[t_engine->tf->red_pos]) = '\0';

                        build_red_packet(t_engine);
                } else {
                        frame->datalen = switch_buffer_read(t_engine->tf->write_buffer, t_engine->tf->text_write_frame.data, RED_PACKET_SIZE);
                        frame->payload = t_engine->t140_pt;
                }
        }

        if (!(write_text_frame = session->endpoint_interface->io_routines->write_text_frame)) {
                if (session->io_override) {
                        write_text_frame = session->io_override->write_text_frame;
                }
        }

        if (write_text_frame) {
                if ((status = write_text_frame(session, frame, flags, stream_id)) == SWITCH_STATUS_SUCCESS) {
                        for (ptr = session->event_hooks.text_write_frame; ptr; ptr = ptr->next) {
                                if ((status = ptr->text_write_frame(session, frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }
                        }
                }
        }


        if (!is_msrp && switch_channel_test_cap(session->channel, CC_RTP_RTT)) {
                if (!t_engine || (t_engine->red_pt && !t_engine->tf)) {
                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "text engine not available for processing\n");
                        switch_goto_status(SWITCH_STATUS_BREAK, done);
                }

                if (t_engine->red_pt) {
                        t_engine->tf->red_pos++;
                        if (t_engine->tf->red_pos == t_engine->tf->red_max) {
                                t_engine->tf->red_pos = 0;
                        }
                }
        }

 done:

        if (smh->write_mutex[SWITCH_MEDIA_TYPE_TEXT]) {
                switch_mutex_unlock(smh->write_mutex[SWITCH_MEDIA_TYPE_TEXT]);
        }

        return status;
}

SWITCH_DECLARE(switch_status_t) switch_core_session_printf(switch_core_session_t *session, const char *fmt, ...)
{
        char *data = NULL;
        int ret = 0;
        va_list ap;
        switch_frame_t frame = { 0 };
        unsigned char CR[] = TEXT_UNICODE_LINEFEED;

        va_start(ap, fmt);
        ret = switch_vasprintf(&data, fmt, ap);
        va_end(ap);

        if (ret == -1) {
                abort();
        }

        frame.data = data;
        frame.datalen = strlen(data);

        switch_core_session_write_text_frame(session, &frame, 0, 0);

        frame.data = CR;
        frame.datalen = 3;

        switch_core_session_write_text_frame(session, &frame, 0, 0);

        switch_safe_free(data);

        return SWITCH_STATUS_SUCCESS;
}


SWITCH_DECLARE(switch_status_t) switch_core_session_print(switch_core_session_t *session, const char *data)
{
        switch_frame_t frame = { 0 };

        if (!switch_channel_test_flag(session->channel, CF_HAS_TEXT)) {
                return SWITCH_STATUS_NOTIMPL;
        }

        frame.data = (char *) data;
        frame.datalen = strlen(data);

        switch_core_session_write_text_frame(session, &frame, 0, 0);

        return SWITCH_STATUS_SUCCESS;
}

SWITCH_DECLARE(switch_msrp_session_t *) switch_core_media_get_msrp_session(switch_core_session_t *session)
{
        if (!session->media_handle) return NULL;

        return session->media_handle->msrp_session;
}


SWITCH_DECLARE(switch_status_t) switch_core_session_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags,
                                                                                                                                int stream_id)
{

        switch_status_t status = SWITCH_STATUS_FALSE;
        switch_frame_t *enc_frame = NULL, *write_frame = frame;
        unsigned int flag = 0, need_codec = 0, perfect = 0, do_bugs = 0, do_write = 0, do_resample = 0, ptime_mismatch = 0, pass_cng = 0, resample = 0;
        int did_write_resample = 0;

        switch_assert(session != NULL);
        switch_assert(frame != NULL);

        if (!switch_channel_up_nosig(session->channel)) {
                return SWITCH_STATUS_FALSE;
        }

        if (switch_mutex_trylock(session->codec_write_mutex) == SWITCH_STATUS_SUCCESS) {
                switch_mutex_unlock(session->codec_write_mutex);
        } else {
                return SWITCH_STATUS_SUCCESS;
        }

        if (switch_test_flag(frame, SFF_CNG)) {
                if (switch_channel_test_flag(session->channel, CF_ACCEPT_CNG)) {
                        pass_cng = 1;
                } else {
                        return SWITCH_STATUS_SUCCESS;
                }
        }

        if (switch_channel_test_flag(session->channel, CF_AUDIO_PAUSE_WRITE)) {
                return SWITCH_STATUS_SUCCESS;
        }

        if (!(session->write_codec && switch_core_codec_ready(session->write_codec)) && !pass_cng) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "%s has no write codec.\n", switch_channel_get_name(session->channel));
                switch_channel_hangup(session->channel, SWITCH_CAUSE_INCOMPATIBLE_DESTINATION);
                return SWITCH_STATUS_FALSE;
        }

        if (switch_channel_test_flag(session->channel, CF_HOLD)) {
                return SWITCH_STATUS_SUCCESS;
        }

        if (switch_test_flag(frame, SFF_PROXY_PACKET) || pass_cng) {
                /* Fast PASS! */
                switch_mutex_lock(session->codec_write_mutex);
                status = perform_write(session, frame, flag, stream_id);
                switch_mutex_unlock(session->codec_write_mutex);
                return status;
        }

        switch_mutex_lock(session->codec_write_mutex);

        if (!(frame->codec && frame->codec->implementation)) {
                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "%s has received a bad frame with no codec!\n",
                                                  switch_channel_get_name(session->channel));
                switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                switch_mutex_unlock(session->codec_write_mutex);
                return SWITCH_STATUS_FALSE;
        }

        switch_assert(frame->codec != NULL);
        switch_assert(frame->codec->implementation != NULL);

        if (!(switch_core_codec_ready(session->write_codec) && frame->codec) ||
                !switch_channel_ready(session->channel) || !switch_channel_media_ready(session->channel)) {
                switch_mutex_unlock(session->codec_write_mutex);
                return SWITCH_STATUS_FALSE;
        }

        switch_mutex_lock(session->write_codec->mutex);
        switch_mutex_lock(frame->codec->mutex);

        if (!(switch_core_codec_ready(session->write_codec) && switch_core_codec_ready(frame->codec))) goto error;

        if (frame->codec && session->write_codec->implementation != frame->codec->implementation) {
                if (session->write_impl.codec_id == frame->codec->implementation->codec_id ||
                        session->write_impl.microseconds_per_packet != frame->codec->implementation->microseconds_per_packet) {
                        ptime_mismatch = TRUE;

                        if ((switch_test_flag(frame->codec, SWITCH_CODEC_FLAG_PASSTHROUGH) || switch_test_flag(session->read_codec, SWITCH_CODEC_FLAG_PASSTHROUGH)) ||
                                switch_channel_test_flag(session->channel, CF_PASSTHRU_PTIME_MISMATCH)) {
                                status = perform_write(session, frame, flags, stream_id);
                                goto error;
                        }

                        if (session->write_impl.microseconds_per_packet < frame->codec->implementation->microseconds_per_packet) {
                                switch_core_session_start_audio_write_thread(session);
                        }
                }
                need_codec = TRUE;
        }

        if (session->write_codec && !frame->codec) {
                need_codec = TRUE;
        }

        if (session->bugs && !need_codec && !switch_test_flag(session, SSF_MEDIA_BUG_TAP_ONLY)) {
                do_bugs = TRUE;
                need_codec = TRUE;
        }

        if (frame->codec->implementation->actual_samples_per_second != session->write_impl.actual_samples_per_second) {
                need_codec = TRUE;
                do_resample = TRUE;
        }


        if ((frame->flags & SFF_NOT_AUDIO)) {
                do_resample = 0;
                do_bugs = 0;
                need_codec = 0;
        }

        if (switch_test_flag(session, SSF_WRITE_TRANSCODE) && !need_codec && switch_core_codec_ready(session->write_codec)) {
                switch_core_session_t *other_session;
                const char *uuid = switch_channel_get_partner_uuid(switch_core_session_get_channel(session));

                if (uuid && (other_session = switch_core_session_locate(uuid))) {
                        switch_set_flag(other_session, SSF_READ_CODEC_RESET);
                        switch_set_flag(other_session, SSF_READ_CODEC_RESET);
                        switch_set_flag(other_session, SSF_WRITE_CODEC_RESET);
                        switch_core_session_rwunlock(other_session);
                }

                switch_clear_flag(session, SSF_WRITE_TRANSCODE);
        }


        if (switch_test_flag(session, SSF_WRITE_CODEC_RESET)) {
                switch_core_codec_reset(session->write_codec);
                switch_clear_flag(session, SSF_WRITE_CODEC_RESET);
        }

        if (!need_codec) {
                do_write = TRUE;
                write_frame = frame;
                goto done;
        }

        if (!switch_test_flag(session, SSF_WARN_TRANSCODE)) {
                switch_core_session_message_t msg = { 0 };

                msg.message_id = SWITCH_MESSAGE_INDICATE_TRANSCODING_NECESSARY;
                switch_core_session_receive_message(session, &msg);
                switch_set_flag(session, SSF_WARN_TRANSCODE);
        }

        if (frame->codec) {
                session->raw_write_frame.datalen = session->raw_write_frame.buflen;
                frame->codec->cur_frame = frame;
                session->write_codec->cur_frame = frame;
                status = switch_core_codec_decode(frame->codec,
                                                                                  session->write_codec,
                                                                                  frame->data,
                                                                                  frame->datalen,
                                                                                  session->write_impl.actual_samples_per_second,
                                                                                  session->raw_write_frame.data, &session->raw_write_frame.datalen, &session->raw_write_frame.rate, &frame->flags);
                frame->codec->cur_frame = NULL;
                session->write_codec->cur_frame = NULL;
                if (do_resample && status == SWITCH_STATUS_SUCCESS) {
                        status = SWITCH_STATUS_RESAMPLE;
                }

                /* mux or demux to match */
                if (session->write_impl.number_of_channels != frame->codec->implementation->number_of_channels) {
                        uint32_t rlen = session->raw_write_frame.datalen / 2 / frame->codec->implementation->number_of_channels;
                        switch_mux_channels((int16_t *) session->raw_write_frame.data, rlen,
                                                                frame->codec->implementation->number_of_channels, session->write_impl.number_of_channels);
                        session->raw_write_frame.datalen = rlen * 2 * session->write_impl.number_of_channels;
                }

                switch (status) {
                case SWITCH_STATUS_RESAMPLE:
                        resample++;
                        write_frame = &session->raw_write_frame;
                        write_frame->rate = frame->codec->implementation->actual_samples_per_second;
                        if (!session->write_resampler) {
                                switch_mutex_lock(session->resample_mutex);
                                status = switch_resample_create(&session->write_resampler,
                                                                                                frame->codec->implementation->actual_samples_per_second,
                                                                                                session->write_impl.actual_samples_per_second,
                                                                                                session->write_impl.decoded_bytes_per_packet, SWITCH_RESAMPLE_QUALITY, session->write_impl.number_of_channels);


                                switch_mutex_unlock(session->resample_mutex);
                                if (status != SWITCH_STATUS_SUCCESS) {
                                        goto done;
                                } else {
                                        switch_core_session_message_t msg = { 0 };
                                        msg.numeric_arg = 1;
                                        msg.message_id = SWITCH_MESSAGE_RESAMPLE_EVENT;
                                        switch_core_session_receive_message(session, &msg);

                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Activating write resampler\n");
                                }
                        }
                        break;
                case SWITCH_STATUS_SUCCESS:
                        session->raw_write_frame.samples = session->raw_write_frame.datalen / sizeof(int16_t) / session->write_impl.number_of_channels;
                        session->raw_write_frame.channels = session->write_impl.number_of_channels;
                        session->raw_write_frame.timestamp = frame->timestamp;
                        session->raw_write_frame.rate = frame->rate;
                        session->raw_write_frame.m = frame->m;
                        session->raw_write_frame.ssrc = frame->ssrc;
                        session->raw_write_frame.seq = frame->seq;
                        session->raw_write_frame.payload = frame->payload;
                        session->raw_write_frame.flags = 0;
                        if (switch_test_flag(frame, SFF_PLC)) {
                                session->raw_write_frame.flags |= SFF_PLC;
                        }

                        write_frame = &session->raw_write_frame;
                        break;
                case SWITCH_STATUS_BREAK:
                        status = SWITCH_STATUS_SUCCESS;
                        goto error;
                case SWITCH_STATUS_NOOP:
                        if (session->write_resampler) {
                                switch_mutex_lock(session->resample_mutex);
                                switch_resample_destroy(&session->write_resampler);
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Deactivating write resampler\n");
                                switch_mutex_unlock(session->resample_mutex);

                                {
                                        switch_core_session_message_t msg = { 0 };
                                        msg.numeric_arg = 0;
                                        msg.message_id = SWITCH_MESSAGE_RESAMPLE_EVENT;
                                        switch_core_session_receive_message(session, &msg);
                                }

                        }
                        write_frame = frame;
                        status = SWITCH_STATUS_SUCCESS;
                        break;
                default:

                        if (status == SWITCH_STATUS_NOT_INITALIZED) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codec init error!\n");
                                goto error;
                        }
                        if (ptime_mismatch && status != SWITCH_STATUS_GENERR) {
                                perform_write(session, frame, flags, stream_id);
                                status = SWITCH_STATUS_SUCCESS;
                                goto error;
                        }

                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codec %s decoder error!\n",
                                                          frame->codec->codec_interface->interface_name);
                        goto error;
                }
        }



        if (session->write_resampler) {
                short *data = write_frame->data;

                switch_mutex_lock(session->resample_mutex);
                if (session->write_resampler) {

                        if (switch_resample_calc_buffer_size(session->write_resampler->to_rate, session->write_resampler->from_rate,
                                                                                                 write_frame->datalen / 2 / session->write_resampler->channels) > SWITCH_RECOMMENDED_BUFFER_SIZE) {

                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_CRIT, "%s not enough buffer space for required resample operation!\n",
                                                                  switch_channel_get_name(session->channel));
                                switch_channel_hangup(session->channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
                                switch_mutex_unlock(session->resample_mutex);
                                goto error;
                        }


                        switch_resample_process(session->write_resampler, data, write_frame->datalen / 2 / session->write_resampler->channels);

                        memcpy(data, session->write_resampler->to, session->write_resampler->to_len * 2 * session->write_resampler->channels);

                        write_frame->samples = session->write_resampler->to_len;
                        write_frame->channels = session->write_resampler->channels;
                        write_frame->datalen = write_frame->samples * 2 * session->write_resampler->channels;

                        write_frame->rate = session->write_resampler->to_rate;

                        did_write_resample = 1;
                }
                switch_mutex_unlock(session->resample_mutex);
        }



        if (session->bugs) {
                switch_media_bug_t *bp;
                int prune = 0;

                switch_thread_rwlock_rdlock(session->bug_rwlock);
                for (bp = session->bugs; bp; bp = bp->next) {
                        switch_bool_t ok = SWITCH_TRUE;

                        if (!bp->ready) {
                                continue;
                        }

                        if (switch_core_media_bug_test_flag(bp, SMBF_PAUSE) || (switch_channel_test_flag(session->channel, CF_PAUSE_BUGS) && !switch_core_media_bug_test_flag(bp, SMBF_NO_PAUSE))) {
                                continue;
                        }

                        if (!switch_channel_test_flag(session->channel, CF_ANSWERED) && switch_core_media_bug_test_flag(bp, SMBF_ANSWER_REQ)) {
                                continue;
                        }

                        if (switch_test_flag(bp, SMBF_PRUNE)) {
                                prune++;
                                continue;
                        }

                        if (switch_test_flag(bp, SMBF_WRITE_STREAM)) {
                                switch_mutex_lock(bp->write_mutex);
                                switch_buffer_write(bp->raw_write_buffer, write_frame->data, write_frame->datalen);
                                switch_mutex_unlock(bp->write_mutex);

                                if (bp->callback) {
                                        ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_WRITE);
                                }
                        }

                        if (switch_test_flag(bp, SMBF_WRITE_REPLACE)) {
                                do_bugs = 0;
                                if (bp->callback) {
                                        bp->write_replace_frame_in = write_frame;
                                        bp->write_replace_frame_out = write_frame;
                                        if ((ok = bp->callback(bp, bp->user_data, SWITCH_ABC_TYPE_WRITE_REPLACE)) == SWITCH_TRUE) {
                                                write_frame = bp->write_replace_frame_out;
                                        }
                                }
                        }

                        if (bp->stop_time && bp->stop_time <= switch_epoch_time_now(NULL)) {
                                ok = SWITCH_FALSE;
                        }


                        if (ok == SWITCH_FALSE) {
                                switch_set_flag(bp, SMBF_PRUNE);
                                prune++;
                        }
                }
                switch_thread_rwlock_unlock(session->bug_rwlock);
                if (prune) {
                        switch_core_media_bug_prune(session);
                }
        }

        if (do_bugs) {
                do_write = TRUE;
                write_frame = frame;
                goto done;
        }

        if (session->write_codec) {
                if (!ptime_mismatch && write_frame->codec && write_frame->codec->implementation &&
                        write_frame->codec->implementation->decoded_bytes_per_packet == session->write_impl.decoded_bytes_per_packet) {
                        perfect = TRUE;
                }



                if (perfect) {

                        if (write_frame->datalen < session->write_impl.decoded_bytes_per_packet) {
                                memset(write_frame->data, 255, session->write_impl.decoded_bytes_per_packet - write_frame->datalen);
                                write_frame->datalen = session->write_impl.decoded_bytes_per_packet;
                        }

                        enc_frame = write_frame;
                        session->enc_write_frame.datalen = session->enc_write_frame.buflen;
                        session->write_codec->cur_frame = frame;
                        frame->codec->cur_frame = frame;
                        switch_assert(enc_frame->datalen <= SWITCH_RECOMMENDED_BUFFER_SIZE);
                        switch_assert(session->enc_write_frame.datalen <= SWITCH_RECOMMENDED_BUFFER_SIZE);
                        status = switch_core_codec_encode(session->write_codec,
                                                                                          frame->codec,
                                                                                          enc_frame->data,
                                                                                          enc_frame->datalen,
                                                                                          session->write_impl.actual_samples_per_second,
                                                                                          session->enc_write_frame.data, &session->enc_write_frame.datalen, &session->enc_write_frame.rate, &flag);

                        switch_assert(session->enc_write_frame.datalen <= SWITCH_RECOMMENDED_BUFFER_SIZE);

                        session->write_codec->cur_frame = NULL;
                        frame->codec->cur_frame = NULL;
                        switch (status) {
                        case SWITCH_STATUS_RESAMPLE:
                                resample++;
                                /* switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Fixme 2\n"); */
                        case SWITCH_STATUS_SUCCESS:
                                session->enc_write_frame.codec = session->write_codec;
                                session->enc_write_frame.samples = enc_frame->datalen / sizeof(int16_t) / session->write_impl.number_of_channels;
                                session->enc_write_frame.channels = session->write_impl.number_of_channels;
                                if (frame->codec->implementation->samples_per_packet != session->write_impl.samples_per_packet) {
                                        session->enc_write_frame.timestamp = 0;
                                } else {
                                        session->enc_write_frame.timestamp = frame->timestamp;
                                }
                                session->enc_write_frame.payload = session->write_impl.ianacode;
                                session->enc_write_frame.m = frame->m;
                                session->enc_write_frame.ssrc = frame->ssrc;
                                session->enc_write_frame.seq = frame->seq;
                                session->enc_write_frame.flags = 0;
                                write_frame = &session->enc_write_frame;
                                break;
                        case SWITCH_STATUS_NOOP:
                                enc_frame->codec = session->write_codec;
                                enc_frame->samples = enc_frame->datalen / sizeof(int16_t) / session->write_impl.number_of_channels;
                                enc_frame->channels = session->write_impl.number_of_channels;
                                enc_frame->timestamp = frame->timestamp;
                                enc_frame->m = frame->m;
                                enc_frame->seq = frame->seq;
                                enc_frame->ssrc = frame->ssrc;
                                enc_frame->payload = enc_frame->codec->implementation->ianacode;
                                write_frame = enc_frame;
                                break;
                        case SWITCH_STATUS_NOT_INITALIZED:
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codec init error!\n");
                                write_frame = NULL;
                                goto error;
                        default:
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codec %s encoder error!\n",
                                                                  session->read_codec->codec_interface->interface_name);
                                write_frame = NULL;
                                goto error;
                        }
                        if (flag & SFF_CNG) {
                                switch_set_flag(write_frame, SFF_CNG);
                        }

                        status = perform_write(session, write_frame, flags, stream_id);
                        goto error;
                } else {
                        if (!session->raw_write_buffer) {
                                switch_size_t bytes_per_packet = session->write_impl.decoded_bytes_per_packet;
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
                                                                  "Engaging Write Buffer at %u bytes to accommodate %u->%u\n",
                                                                  (uint32_t) bytes_per_packet, write_frame->datalen, session->write_impl.decoded_bytes_per_packet);
                                if ((status = switch_buffer_create_dynamic(&session->raw_write_buffer,
                                                                                                                   bytes_per_packet * SWITCH_BUFFER_BLOCK_FRAMES,
                                                                                                                   bytes_per_packet * SWITCH_BUFFER_START_FRAMES, 0)) != SWITCH_STATUS_SUCCESS) {
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Write Buffer Failed!\n");
                                        goto error;
                                }

                                /* Need to retrain the recording data */
                                switch_core_media_bug_flush_all(session);
                        }

                        if (!(switch_buffer_write(session->raw_write_buffer, write_frame->data, write_frame->datalen))) {
                                switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Write Buffer %u bytes Failed!\n", write_frame->datalen);
                                status = SWITCH_STATUS_MEMERR;
                                goto error;
                        }

                        status = SWITCH_STATUS_SUCCESS;

                        while (switch_buffer_inuse(session->raw_write_buffer) >= session->write_impl.decoded_bytes_per_packet) {
                                int rate;

                                if (switch_channel_down(session->channel) || !session->raw_write_buffer) {
                                        goto error;
                                }
                                if ((session->raw_write_frame.datalen = (uint32_t)
                                         switch_buffer_read(session->raw_write_buffer, session->raw_write_frame.data, session->write_impl.decoded_bytes_per_packet)) == 0) {
                                        goto error;
                                }

                                enc_frame = &session->raw_write_frame;
                                session->raw_write_frame.rate = session->write_impl.actual_samples_per_second;
                                session->enc_write_frame.datalen = session->enc_write_frame.buflen;
                                session->enc_write_frame.timestamp = 0;


                                if (frame->codec && frame->codec->implementation && switch_core_codec_ready(frame->codec)) {
                                        rate = frame->codec->implementation->actual_samples_per_second;
                                } else {
                                        rate = session->write_impl.actual_samples_per_second;
                                }

                                session->write_codec->cur_frame = frame;
                                frame->codec->cur_frame = frame;
                                switch_assert(enc_frame->datalen <= SWITCH_RECOMMENDED_BUFFER_SIZE);
                                switch_assert(session->enc_write_frame.datalen <= SWITCH_RECOMMENDED_BUFFER_SIZE);
                                status = switch_core_codec_encode(session->write_codec,
                                                                                                  frame->codec,
                                                                                                  enc_frame->data,
                                                                                                  enc_frame->datalen,
                                                                                                  rate,
                                                                                                  session->enc_write_frame.data, &session->enc_write_frame.datalen, &session->enc_write_frame.rate, &flag);

                                switch_assert(session->enc_write_frame.datalen <= SWITCH_RECOMMENDED_BUFFER_SIZE);

                                session->write_codec->cur_frame = NULL;
                                frame->codec->cur_frame = NULL;
                                switch (status) {
                                case SWITCH_STATUS_RESAMPLE:
                                        resample++;
                                        session->enc_write_frame.codec = session->write_codec;
                                        session->enc_write_frame.samples = enc_frame->datalen / sizeof(int16_t) / session->write_impl.number_of_channels;
                                        session->enc_write_frame.channels = session->write_impl.number_of_channels;
                                        session->enc_write_frame.m = frame->m;
                                        session->enc_write_frame.ssrc = frame->ssrc;
                                        session->enc_write_frame.payload = session->write_impl.ianacode;
                                        write_frame = &session->enc_write_frame;
                                        if (!session->write_resampler) {
                                                switch_mutex_lock(session->resample_mutex);
                                                if (!session->write_resampler) {
                                                        status = switch_resample_create(&session->write_resampler,
                                                                                                                        frame->codec->implementation->actual_samples_per_second,
                                                                                                                        session->write_impl.actual_samples_per_second,
                                                                                                                        session->write_impl.decoded_bytes_per_packet, SWITCH_RESAMPLE_QUALITY,
                                                                                                                        session->write_impl.number_of_channels);
                                                }
                                                switch_mutex_unlock(session->resample_mutex);



                                                if (status != SWITCH_STATUS_SUCCESS) {
                                                        goto done;
                                                } else {
                                                        switch_core_session_message_t msg = { 0 };
                                                        msg.numeric_arg = 1;
                                                        msg.message_id = SWITCH_MESSAGE_RESAMPLE_EVENT;
                                                        switch_core_session_receive_message(session, &msg);


                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Activating write resampler\n");
                                                }
                                        }
                                        break;
                                case SWITCH_STATUS_SUCCESS:
                                        session->enc_write_frame.codec = session->write_codec;
                                        session->enc_write_frame.samples = enc_frame->datalen / sizeof(int16_t) / session->write_impl.number_of_channels;
                                        session->enc_write_frame.channels = session->write_impl.number_of_channels;
                                        session->enc_write_frame.m = frame->m;
                                        session->enc_write_frame.ssrc = frame->ssrc;
                                        session->enc_write_frame.payload = session->write_impl.ianacode;
                                        session->enc_write_frame.flags = 0;
                                        write_frame = &session->enc_write_frame;
                                        break;
                                case SWITCH_STATUS_NOOP:
                                        if (session->write_resampler) {
                                                switch_core_session_message_t msg = { 0 };
                                                int ok = 0;

                                                switch_mutex_lock(session->resample_mutex);
                                                if (session->write_resampler) {
                                                        switch_resample_destroy(&session->write_resampler);
                                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_NOTICE, "Deactivating write resampler\n");
                                                        ok = 1;
                                                }
                                                switch_mutex_unlock(session->resample_mutex);

                                                if (ok) {
                                                        msg.numeric_arg = 0;
                                                        msg.message_id = SWITCH_MESSAGE_RESAMPLE_EVENT;
                                                        switch_core_session_receive_message(session, &msg);
                                                }

                                        }
                                        enc_frame->codec = session->write_codec;
                                        enc_frame->samples = enc_frame->datalen / sizeof(int16_t) / session->read_impl.number_of_channels;
                                        enc_frame->channels = session->read_impl.number_of_channels;
                                        enc_frame->m = frame->m;
                                        enc_frame->ssrc = frame->ssrc;
                                        enc_frame->payload = enc_frame->codec->implementation->ianacode;
                                        write_frame = enc_frame;
                                        break;
                                case SWITCH_STATUS_NOT_INITALIZED:
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codec init error!\n");
                                        write_frame = NULL;
                                        goto error;
                                default:
                                        switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Codec %s encoder error %d!\n",
                                                                          session->read_codec->codec_interface->interface_name, status);
                                        write_frame = NULL;
                                        goto error;
                                }

                                if (!did_write_resample && session->read_resampler) {
                                        short *data = write_frame->data;
                                        switch_mutex_lock(session->resample_mutex);
                                        if (session->read_resampler) {
                                                switch_resample_process(session->read_resampler, data, write_frame->datalen / 2 / session->read_resampler->channels);
                                                memcpy(data, session->read_resampler->to, session->read_resampler->to_len * 2 * session->read_resampler->channels);
                                                write_frame->samples = session->read_resampler->to_len;
                                                write_frame->channels = session->read_resampler->channels;
                                                write_frame->datalen = session->read_resampler->to_len * 2 * session->read_resampler->channels;
                                                write_frame->rate = session->read_resampler->to_rate;
                                        }
                                        switch_mutex_unlock(session->resample_mutex);

                                }

                                if (flag & SFF_CNG) {
                                        switch_set_flag(write_frame, SFF_CNG);
                                }

                                if (ptime_mismatch || resample) {
                                        write_frame->timestamp = 0;
                                }

                                if ((status = perform_write(session, write_frame, flags, stream_id)) != SWITCH_STATUS_SUCCESS) {
                                        break;
                                }

                        }

                        goto error;
                }
        }





  done:

        if (ptime_mismatch || resample) {
                write_frame->timestamp = 0;
        }

        if (do_write) {
                status = perform_write(session, write_frame, flags, stream_id);
        }

  error:

        switch_mutex_unlock(session->write_codec->mutex);
        switch_mutex_unlock(frame->codec->mutex);
        switch_mutex_unlock(session->codec_write_mutex);

        return status;
}

SWITCH_DECLARE(switch_rtp_engine_t *) switch_core_media_get_engine(switch_core_session_t *session, int media_type)
{
    if (!session) return NULL;

    return &session->media_handle->engines[media_type];
}

SWITCH_DECLARE(switch_codec_t*) switch_core_media_get_codec(switch_core_session_t *session, switch_media_type_t type)
{
    switch_rtp_engine_t *engine = switch_core_media_get_engine(session, type);

    if (!engine) return NULL;

    return &engine->read_codec;
}

/* 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:
 */