switch_assert(tech_pvt != NULL);
- tech_pvt->read_frame.buflen = SWITCH_RTP_MAX_BUF_LEN;
+
switch_mutex_lock(tech_pvt->sofia_mutex);
- sofia_glue_check_dtmf_type(tech_pvt);
+ switch_core_media_check_dtmf_type(session);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s SOFIA INIT\n", switch_channel_get_name(channel));
if (switch_channel_test_flag(channel, CF_PROXY_MODE) || switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
- sofia_media_tech_absorb_sdp(tech_pvt);
+ switch_core_media_absorb_sdp(session);
}
if (switch_channel_test_flag(tech_pvt->channel, CF_RECOVERING) || switch_channel_test_flag(tech_pvt->channel, CF_RECOVERING_BRIDGE)) {
static stfu_instance_t *sofia_get_jb(switch_core_session_t *session, switch_media_type_t type)
{
private_object_t *tech_pvt = (private_object_t *) switch_core_session_get_private(session);
- switch_rtp_t *rtp;
-
- if (type == SWITCH_MEDIA_TYPE_AUDIO) {
- rtp = tech_pvt->rtp_session;
- } else {
- rtp = tech_pvt->video_rtp_session;
- }
- if (rtp && switch_rtp_ready(rtp)) {
- return switch_rtp_get_jitter_buffer(rtp);
- }
-
- return NULL;
+ return switch_core_media_get_jb(tech_pvt->session, type);
}
/* map QSIG cause codes to SIP from RFC4497 section 8.4.1 */
switch_mutex_unlock(tech_pvt->profile->flag_mutex);
}
- if (switch_core_codec_ready(&tech_pvt->read_codec)) {
- switch_core_codec_destroy(&tech_pvt->read_codec);
- }
-
- if (switch_core_codec_ready(&tech_pvt->write_codec)) {
- switch_core_codec_destroy(&tech_pvt->write_codec);
- }
-
- if (switch_core_codec_ready(&tech_pvt->video_read_codec)) {
- switch_core_codec_destroy(&tech_pvt->video_read_codec);
- }
-
- if (switch_core_codec_ready(&tech_pvt->video_write_codec)) {
- switch_core_codec_destroy(&tech_pvt->video_write_codec);
- }
-
- switch_core_session_unset_read_codec(session);
- switch_core_session_unset_write_codec(session);
switch_mutex_lock(tech_pvt->profile->flag_mutex);
tech_pvt->profile->inuse--;
switch_mutex_unlock(tech_pvt->profile->flag_mutex);
- sofia_glue_deactivate_rtp(tech_pvt);
+ switch_media_handle_destroy(session);
+
if (sofia_test_pflag(tech_pvt->profile, PFLAG_DESTROY) && !tech_pvt->profile->inuse) {
sofia_profile_destroy(tech_pvt->profile);
if (switch_channel_test_flag(channel, CF_CONFERENCE)) {
tech_pvt->reply_contact = switch_core_session_sprintf(session, "%s;isfocus", tech_pvt->reply_contact);
}
-
+ //switch_core_media_set_local_sdp
if(sofia_test_flag(tech_pvt, TFLAG_3PCC_INVITE)) {
// SNARK: complete hack to get final ack sent when a 3pcc invite has been passed from the other leg in bypass_media mode.
// This code handles the pass_indication sent after the 3pcc ack is received by the other leg in the is_3pcc && is_proxy case below.
// Is there a better place to hang this...?
b_sdp = switch_channel_get_variable(channel, SWITCH_B_SDP_VARIABLE);
- sofia_media_tech_set_local_sdp(tech_pvt, b_sdp, SWITCH_TRUE);
+ switch_core_media_set_local_sdp(session, b_sdp, SWITCH_TRUE);
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "3PCC-PROXY nomedia - sending ack\n");
nua_ack(tech_pvt->nh,
TAG_IF(!zstr(tech_pvt->user_via), SIPTAG_VIA_STR(tech_pvt->user_via)),
SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
- SOATAG_USER_SDP_STR(tech_pvt->local_sdp_str),
+ SOATAG_USER_SDP_STR(tech_pvt->mparams.local_sdp_str),
SOATAG_REUSE_REJECTED(1),
SOATAG_RTP_SELECT(1), SOATAG_ORDERED_USER(1), SOATAG_AUDIO_AUX("cn telephone-event"),
TAG_IF(sofia_test_pflag(tech_pvt->profile, PFLAG_DISABLE_100REL), NUTAG_INCLUDE_EXTRA_SDP(1)),
is_3pcc = (sofia_test_pflag(tech_pvt->profile, PFLAG_3PCC_PROXY) && sofia_test_flag(tech_pvt, TFLAG_3PCC));
if (b_sdp && is_proxy && !is_3pcc) {
- sofia_media_tech_set_local_sdp(tech_pvt, b_sdp, SWITCH_TRUE);
+ switch_core_media_set_local_sdp(session, b_sdp, SWITCH_TRUE);
if (switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
- sofia_media_tech_patch_sdp(tech_pvt);
+ switch_core_media_patch_sdp(tech_pvt->session);
if (sofia_media_activate_rtp(tech_pvt) != SWITCH_STATUS_SUCCESS) {
return SWITCH_STATUS_FALSE;
}
if (is_3pcc) {
if(!is_proxy) {
- tech_pvt->num_codecs = 0;
- sofia_media_tech_prepare_codecs(tech_pvt);
- tech_pvt->local_sdp_str = NULL;
- sofia_glue_tech_choose_port(tech_pvt, 0);
- sofia_media_set_local_sdp(tech_pvt, NULL, 0, NULL, 0);
+ switch_core_media_prepare_codecs(tech_pvt->session, SWITCH_TRUE);
+ tech_pvt->mparams.local_sdp_str = NULL;
+
+ switch_core_media_choose_port(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO, 0);
+ switch_core_media_gen_local_sdp(session, NULL, 0, NULL, 0);
} else {
- sofia_media_tech_set_local_sdp(tech_pvt, b_sdp, SWITCH_TRUE);
+ switch_core_media_set_local_sdp(session, b_sdp, SWITCH_TRUE);
if (switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
- sofia_media_tech_patch_sdp(tech_pvt);
+ switch_core_media_patch_sdp(tech_pvt->session);
if (sofia_media_activate_rtp(tech_pvt) != SWITCH_STATUS_SUCCESS) {
return SWITCH_STATUS_FALSE;
}
nua_respond(tech_pvt->nh, SIP_200_OK,
TAG_IF(is_proxy, NUTAG_AUTOANSWER(0)),
SIPTAG_CONTACT_STR(tech_pvt->profile->url),
- SOATAG_USER_SDP_STR(tech_pvt->local_sdp_str),
+ SOATAG_USER_SDP_STR(tech_pvt->mparams.local_sdp_str),
TAG_IF(call_info, SIPTAG_CALL_INFO_STR(call_info)),
SOATAG_REUSE_REJECTED(1), TAG_IF(is_proxy, SOATAG_RTP_SELECT(1)),
SOATAG_ORDERED_USER(1), SOATAG_AUDIO_AUX("cn telephone-event"), NUTAG_INCLUDE_EXTRA_SDP(1),
TAG_IF(!zstr(extra_headers), SIPTAG_HEADER_STR(extra_headers)),
TAG_IF(call_info, SIPTAG_CALL_INFO_STR(call_info)),
SIPTAG_CONTENT_TYPE_STR("application/sdp"),
- SIPTAG_PAYLOAD_STR(tech_pvt->local_sdp_str),
+ SIPTAG_PAYLOAD_STR(tech_pvt->mparams.local_sdp_str),
TAG_IF(switch_stristr("update_display", tech_pvt->x_freeswitch_support_remote),
SIPTAG_HEADER_STR("X-FS-Support: " FREESWITCH_SUPPORT)), TAG_END());
}
return SWITCH_STATUS_SUCCESS;
}
- if ((is_proxy && !b_sdp) || sofia_test_flag(tech_pvt, TFLAG_LATE_NEGOTIATION) || !tech_pvt->iananame) {
+ if ((is_proxy && !b_sdp) || sofia_test_flag(tech_pvt, TFLAG_LATE_NEGOTIATION) ||
+ switch_core_media_codec_chosen(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO) != SWITCH_STATUS_SUCCESS) {
sofia_clear_flag_locked(tech_pvt, TFLAG_LATE_NEGOTIATION);
if (is_proxy) {
if (switch_channel_direction(tech_pvt->channel) == SWITCH_CALL_DIRECTION_INBOUND) {
const char *r_sdp = switch_channel_get_variable(channel, SWITCH_R_SDP_VARIABLE);
- tech_pvt->num_codecs = 0;
- sofia_media_tech_prepare_codecs(tech_pvt);
+
+ switch_core_media_prepare_codecs(tech_pvt->session, SWITCH_TRUE);
if (sofia_media_tech_media(tech_pvt, r_sdp) != SWITCH_STATUS_SUCCESS) {
switch_channel_set_variable(channel, SWITCH_ENDPOINT_DISPOSITION_VARIABLE, "CODEC NEGOTIATION ERROR");
}
}
- if ((status = sofia_glue_tech_choose_port(tech_pvt, 0)) != SWITCH_STATUS_SUCCESS) {
+ if ((status = switch_core_media_choose_port(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO, 0)) != SWITCH_STATUS_SUCCESS) {
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return status;
}
- sofia_media_set_local_sdp(tech_pvt, NULL, 0, NULL, 0);
+ switch_core_media_gen_local_sdp(session, NULL, 0, NULL, 0);
if (sofia_media_activate_rtp(tech_pvt) != SWITCH_STATUS_SUCCESS) {
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
}
if (tech_pvt->nh) {
- if (tech_pvt->local_sdp_str) {
+ if (tech_pvt->mparams.local_sdp_str) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Local SDP %s:\n%s\n", switch_channel_get_name(channel),
- tech_pvt->local_sdp_str);
+ tech_pvt->mparams.local_sdp_str);
}
}
}
cid = generate_pai_str(tech_pvt);
- if (switch_channel_test_flag(tech_pvt->channel, CF_PROXY_MODE) && tech_pvt->early_sdp) {
+ if (switch_channel_test_flag(tech_pvt->channel, CF_PROXY_MODE) && tech_pvt->mparams.early_sdp) {
char *a, *b;
/* start at the s= line to avoid some devices who update the o= between messages */
- a = strstr(tech_pvt->early_sdp, "s=");
- b = strstr(tech_pvt->local_sdp_str, "s=");
+ a = strstr(tech_pvt->mparams.early_sdp, "s=");
+ b = strstr(tech_pvt->mparams.local_sdp_str, "s=");
if (!a || !b || strcmp(a, b)) {
NUTAG_SESSION_REFRESHER(tech_pvt->session_refresher),
SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
SIPTAG_CALL_INFO_STR(switch_channel_get_variable(tech_pvt->channel, SOFIA_SIP_HEADER_PREFIX "call_info")),
- SOATAG_USER_SDP_STR(tech_pvt->local_sdp_str),
+ SOATAG_USER_SDP_STR(tech_pvt->mparams.local_sdp_str),
SOATAG_REUSE_REJECTED(1), SOATAG_ORDERED_USER(1), SOATAG_AUDIO_AUX("cn telephone-event"),
TAG_IF(sofia_test_pflag(tech_pvt->profile, PFLAG_DISABLE_100REL), NUTAG_INCLUDE_EXTRA_SDP(1)),
TAG_IF(is_proxy, SOATAG_RTP_SELECT(1)),
SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
SIPTAG_CALL_INFO_STR(switch_channel_get_variable(tech_pvt->channel, SOFIA_SIP_HEADER_PREFIX "call_info")),
SIPTAG_CONTENT_TYPE_STR("application/sdp"),
- SIPTAG_PAYLOAD_STR(tech_pvt->local_sdp_str),
+ SIPTAG_PAYLOAD_STR(tech_pvt->mparams.local_sdp_str),
TAG_IF(!zstr(extra_headers), SIPTAG_HEADER_STR(extra_headers)),
TAG_IF(switch_stristr("update_display", tech_pvt->x_freeswitch_support_remote),
SIPTAG_HEADER_STR("X-FS-Support: " FREESWITCH_SUPPORT)), TAG_END());
return SWITCH_STATUS_FALSE;
}
#if 0
- while (!(tech_pvt->video_read_codec.implementation && switch_rtp_ready(tech_pvt->video_rtp_session) && !switch_channel_test_flag(channel, CF_REQ_MEDIA))) {
+ while (!(tech_pvt->video_read_codec.implementation && switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_VIDEO) && !switch_channel_test_flag(channel, CF_REQ_MEDIA))) {
switch_ivr_parse_all_messages(tech_pvt->session);
if (--sanity && switch_channel_ready(channel)) {
switch_assert(tech_pvt != NULL);
#if 0
- while (!(tech_pvt->video_read_codec.implementation && switch_rtp_ready(tech_pvt->video_rtp_session))) {
+ while (!(tech_pvt->video_read_codec.implementation && switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_VIDEO))) {
if (switch_channel_ready(channel)) {
switch_yield(10000);
} else {
return SWITCH_STATUS_SUCCESS;
}
- return switch_core_media_write_frame(session, frame, flags, stream_id, SWITCH_MEDIA_TYPE_VIDEO);
-
+ if (switch_core_media_write_frame(session, frame, flags, stream_id, SWITCH_MEDIA_TYPE_VIDEO)) {
+ return SWITCH_STATUS_SUCCESS;
+ }
+
+ return SWITCH_STATUS_FALSE;
}
static switch_status_t sofia_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id)
private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = switch_core_session_get_channel(session);
uint32_t sanity = 1000;
- switch_rtcp_frame_t rtcp_frame;
+ switch_status_t status = SWITCH_STATUS_FALSE;
switch_assert(tech_pvt != NULL);
return SWITCH_STATUS_FALSE;
}
- while (!(tech_pvt->read_codec.implementation && switch_rtp_ready(tech_pvt->rtp_session) && !switch_channel_test_flag(channel, CF_REQ_MEDIA))) {
+ while (!(switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO) && !switch_channel_test_flag(channel, CF_REQ_MEDIA))) {
switch_ivr_parse_all_messages(tech_pvt->session);
if (--sanity && switch_channel_up(channel)) {
switch_yield(10000);
}
}
- tech_pvt->read_frame.datalen = 0;
+
sofia_set_flag_locked(tech_pvt, TFLAG_READING);
- if (sofia_test_flag(tech_pvt, TFLAG_HUP) || sofia_test_flag(tech_pvt, TFLAG_BYE) || !tech_pvt->read_codec.implementation ||
- !switch_core_codec_ready(&tech_pvt->read_codec)) {
+ if (sofia_test_flag(tech_pvt, TFLAG_HUP) || sofia_test_flag(tech_pvt, TFLAG_BYE)) {
return SWITCH_STATUS_FALSE;
}
- if (sofia_test_flag(tech_pvt, TFLAG_IO)) {
- switch_status_t status;
-
- if (!sofia_test_flag(tech_pvt, TFLAG_RTP)) {
- return SWITCH_STATUS_GENERR;
- }
-
- switch_assert(tech_pvt->rtp_session != NULL);
- tech_pvt->read_frame.datalen = 0;
-
-
- if (sofia_test_flag(tech_pvt, TFLAG_SIMPLIFY) && sofia_test_flag(tech_pvt, TFLAG_GOT_ACK)) {
- if (sofia_glue_tech_simplify(tech_pvt)) {
- sofia_clear_flag(tech_pvt, TFLAG_SIMPLIFY);
- }
- }
-
- while (sofia_test_flag(tech_pvt, TFLAG_IO) && tech_pvt->read_frame.datalen == 0) {
- tech_pvt->read_frame.flags = SFF_NONE;
-
- status = switch_rtp_zerocopy_read_frame(tech_pvt->rtp_session, &tech_pvt->read_frame, flags);
-
- if (status != SWITCH_STATUS_SUCCESS && status != SWITCH_STATUS_BREAK) {
- if (status == SWITCH_STATUS_TIMEOUT) {
-
- if (sofia_test_flag(tech_pvt, TFLAG_SIP_HOLD)) {
- switch_core_media_toggle_hold(session, 0);
- sofia_clear_flag_locked(tech_pvt, TFLAG_SIP_HOLD);
- switch_channel_clear_flag(channel, CF_LEG_HOLDING);
- }
-
- if (switch_channel_get_variable(tech_pvt->channel, "execute_on_media_timeout")) {
- *frame = &tech_pvt->read_frame;
- switch_set_flag((*frame), SFF_CNG);
- (*frame)->datalen = tech_pvt->read_impl.encoded_bytes_per_packet;
- memset((*frame)->data, 0, (*frame)->datalen);
- switch_channel_execute_on(tech_pvt->channel, "execute_on_media_timeout");
- return SWITCH_STATUS_SUCCESS;
- }
-
-
- switch_channel_hangup(tech_pvt->channel, SWITCH_CAUSE_MEDIA_TIMEOUT);
- }
- return status;
- }
-
- /* Try to read an RTCP frame, if successful raise an event */
- if (switch_rtcp_zerocopy_read_frame(tech_pvt->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), "%" SWITCH_SIZE_T_FMT, tech_pvt->read_frame.timestamp);
- switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "Last-RTP-Timestamp", value);
-
- snprintf(value, sizeof(value), "%u", tech_pvt->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-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);
- }
-
- 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((&tech_pvt->read_frame), SFF_PROXY_PACKET)) {
- sofia_clear_flag_locked(tech_pvt, TFLAG_READING);
- *frame = &tech_pvt->read_frame;
- return SWITCH_STATUS_SUCCESS;
- }
-
- if (switch_rtp_has_dtmf(tech_pvt->rtp_session)) {
- switch_dtmf_t dtmf = { 0 };
- switch_rtp_dequeue_dtmf(tech_pvt->rtp_session, &dtmf);
- switch_channel_queue_dtmf(channel, &dtmf);
- }
-
- if (tech_pvt->read_frame.datalen > 0) {
- uint32_t bytes = 0;
- int frames = 1;
-
- if (!switch_test_flag((&tech_pvt->read_frame), SFF_CNG)) {
- if (!tech_pvt->read_codec.implementation || !switch_core_codec_ready(&tech_pvt->read_codec)) {
- *frame = NULL;
- return SWITCH_STATUS_GENERR;
- }
-
- if ((tech_pvt->read_frame.datalen % 10) == 0 &&
- sofia_test_media_flag(tech_pvt->profile, SCMF_AUTOFIX_TIMING) && tech_pvt->check_frames < MAX_CODEC_CHECK_FRAMES) {
- tech_pvt->check_frames++;
-
- if (!tech_pvt->read_impl.encoded_bytes_per_packet) {
- tech_pvt->check_frames = MAX_CODEC_CHECK_FRAMES;
- goto skip;
- }
-
- if (tech_pvt->last_ts && tech_pvt->read_frame.datalen != tech_pvt->read_impl.encoded_bytes_per_packet) {
- uint32_t codec_ms = (int) (tech_pvt->read_frame.timestamp -
- tech_pvt->last_ts) / (tech_pvt->read_impl.samples_per_second / 1000);
-
- if ((codec_ms % 10) != 0 || codec_ms > tech_pvt->read_impl.samples_per_packet * 10) {
- tech_pvt->last_ts = 0;
- goto skip;
- }
-
-
- if (tech_pvt->last_codec_ms && tech_pvt->last_codec_ms == codec_ms) {
- tech_pvt->mismatch_count++;
- }
-
- tech_pvt->last_codec_ms = codec_ms;
-
- if (tech_pvt->mismatch_count > MAX_MISMATCH_FRAMES) {
- if (switch_rtp_ready(tech_pvt->rtp_session) && codec_ms != tech_pvt->codec_ms) {
- const char *val;
- int rtp_timeout_sec = 0;
- int rtp_hold_timeout_sec = 0;
-
- if (codec_ms > 120) { /* yeah right */
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
- "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);
- tech_pvt->check_frames = MAX_CODEC_CHECK_FRAMES;
- goto skip;
- }
-
- tech_pvt->read_frame.datalen = 0;
-
- if (codec_ms != tech_pvt->codec_ms) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
- "Asynchronous PTIME not supported, changing our end from %d to %d\n",
- (int) tech_pvt->codec_ms,
- (int) codec_ms
- );
-
- switch_channel_set_variable_printf(channel, "sip_h_X-Broken-PTIME", "Adv=%d;Sent=%d",
- (int) tech_pvt->codec_ms, (int) codec_ms);
-
- tech_pvt->codec_ms = codec_ms;
- }
-
- if (switch_core_media_set_codec(tech_pvt->session, 2, tech_pvt->profile->codec_flags) != SWITCH_STATUS_SUCCESS) {
- *frame = NULL;
- return SWITCH_STATUS_GENERR;
- }
-
- if ((val = switch_channel_get_variable(tech_pvt->channel, "rtp_timeout_sec"))) {
- int v = atoi(val);
- if (v >= 0) {
- rtp_timeout_sec = v;
- }
- }
-
- if ((val = switch_channel_get_variable(tech_pvt->channel, "rtp_hold_timeout_sec"))) {
- int v = atoi(val);
- if (v >= 0) {
- rtp_hold_timeout_sec = v;
- }
- }
-
- if (rtp_timeout_sec) {
- tech_pvt->max_missed_packets = (tech_pvt->read_impl.samples_per_second * rtp_timeout_sec) /
- tech_pvt->read_impl.samples_per_packet;
-
- switch_rtp_set_max_missed_packets(tech_pvt->rtp_session, tech_pvt->max_missed_packets);
- if (!rtp_hold_timeout_sec) {
- rtp_hold_timeout_sec = rtp_timeout_sec * 10;
- }
- }
-
- if (rtp_hold_timeout_sec) {
- tech_pvt->max_missed_hold_packets = (tech_pvt->read_impl.samples_per_second * rtp_hold_timeout_sec) /
- tech_pvt->read_impl.samples_per_packet;
- }
-
-
- tech_pvt->check_frames = 0;
- tech_pvt->last_ts = 0;
-
- /* inform them of the codec they are actually sending */
-#if 0
- if (++tech_pvt->codec_reinvites > 2) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_WARNING,
- "Ok, some devices *cough* X-lite *cough*\n"
- "seem to continue to lie over and over again so I guess we'll\n"
- "leave well-enough alone and let them lie\n");
- } else {
- sofia_glue_do_invite(session);
- }
-#endif
- *frame = &tech_pvt->read_frame;
- switch_set_flag((*frame), SFF_CNG);
- (*frame)->datalen = tech_pvt->read_impl.encoded_bytes_per_packet;
- memset((*frame)->data, 0, (*frame)->datalen);
- return SWITCH_STATUS_SUCCESS;
- }
-
- }
-
- } else {
- tech_pvt->mismatch_count = 0;
- }
-
- tech_pvt->last_ts = tech_pvt->read_frame.timestamp;
-
-
- } else {
- tech_pvt->mismatch_count = 0;
- tech_pvt->last_ts = 0;
- }
- skip:
-
- if ((bytes = tech_pvt->read_impl.encoded_bytes_per_packet)) {
- frames = (tech_pvt->read_frame.datalen / bytes);
- }
- tech_pvt->read_frame.samples = (int) (frames * tech_pvt->read_impl.samples_per_packet);
-
- if (tech_pvt->read_frame.datalen == 0) {
- continue;
- }
- }
- break;
- }
- }
- }
+ status = switch_core_media_read_frame(session, frame, flags, stream_id, SWITCH_MEDIA_TYPE_AUDIO);
sofia_clear_flag_locked(tech_pvt, TFLAG_READING);
- if (tech_pvt->read_frame.datalen == 0) {
- *frame = NULL;
- return SWITCH_STATUS_GENERR;
- }
-
- *frame = &tech_pvt->read_frame;
-
- return SWITCH_STATUS_SUCCESS;
+ return status;
}
static switch_status_t sofia_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id)
private_object_t *tech_pvt = switch_core_session_get_private(session);
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_status_t status = SWITCH_STATUS_SUCCESS;
- int bytes = 0, samples = 0, frames = 0;
switch_assert(tech_pvt != NULL);
- while (!(tech_pvt->read_codec.implementation && switch_rtp_ready(tech_pvt->rtp_session) && !switch_channel_test_flag(channel, CF_REQ_MEDIA))) {
+ while (!(switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO) && !switch_channel_test_flag(channel, CF_REQ_MEDIA))) {
if (switch_channel_ready(channel)) {
switch_yield(10000);
} else {
}
}
- if (!tech_pvt->read_codec.implementation || !switch_core_codec_ready(&tech_pvt->read_codec)) {
- return SWITCH_STATUS_GENERR;
- }
if (sofia_test_flag(tech_pvt, TFLAG_HUP)) {
return SWITCH_STATUS_FALSE;
}
+#if 0
if (!sofia_test_flag(tech_pvt, TFLAG_RTP)) {
return SWITCH_STATUS_GENERR;
}
if (!sofia_test_flag(tech_pvt, TFLAG_IO)) {
return SWITCH_STATUS_SUCCESS;
}
+#endif
- if (sofia_test_flag(tech_pvt, TFLAG_BYE) || !tech_pvt->read_codec.implementation || !switch_core_codec_ready(&tech_pvt->read_codec)) {
+ if (sofia_test_flag(tech_pvt, TFLAG_BYE)) {
return SWITCH_STATUS_FALSE;
}
sofia_set_flag_locked(tech_pvt, TFLAG_WRITING);
- if (!switch_test_flag(frame, SFF_CNG) && !switch_test_flag(frame, SFF_PROXY_PACKET)) {
- if (tech_pvt->read_impl.encoded_bytes_per_packet) {
- bytes = tech_pvt->read_impl.encoded_bytes_per_packet;
- frames = ((int) frame->datalen / bytes);
- } else
- frames = 1;
-
- samples = frames * tech_pvt->read_impl.samples_per_packet;
+ if (switch_core_media_write_frame(session, frame, flags, stream_id, SWITCH_MEDIA_TYPE_AUDIO)) {
+ status = SWITCH_STATUS_SUCCESS;
}
- tech_pvt->timestamp_send += samples;
- switch_rtp_write_frame(tech_pvt->rtp_session, frame);
-
sofia_clear_flag_locked(tech_pvt, TFLAG_WRITING);
return status;
}
switch (sig) {
case SWITCH_SIG_BREAK:
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
- switch_rtp_break(tech_pvt->rtp_session);
+ if (switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO)) {
+ switch_core_media_break(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO);
}
- if (switch_rtp_ready(tech_pvt->video_rtp_session)) {
- switch_rtp_break(tech_pvt->video_rtp_session);
+ if (switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_VIDEO)) {
+ switch_core_media_break(tech_pvt->session, SWITCH_MEDIA_TYPE_VIDEO);
}
break;
case SWITCH_SIG_KILL:
sofia_clear_flag_locked(tech_pvt, TFLAG_IO);
sofia_set_flag_locked(tech_pvt, TFLAG_HUP);
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
- switch_rtp_kill_socket(tech_pvt->rtp_session);
+ if (switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO)) {
+ switch_core_media_kill_socket(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO);
}
- if (switch_rtp_ready(tech_pvt->video_rtp_session)) {
- switch_rtp_kill_socket(tech_pvt->video_rtp_session);
+ if (switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_VIDEO)) {
+ switch_core_media_kill_socket(tech_pvt->session, SWITCH_MEDIA_TYPE_VIDEO);
}
break;
}
}
-static void start_udptl(private_object_t *tech_pvt, switch_t38_options_t *t38_options)
-{
-
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
- char *remote_host = switch_rtp_get_remote_host(tech_pvt->rtp_session);
- switch_port_t remote_port = switch_rtp_get_remote_port(tech_pvt->rtp_session);
- const char *err, *val;
-
- sofia_clear_flag(tech_pvt, TFLAG_NOTIMER_DURING_BRIDGE);
- switch_rtp_udptl_mode(tech_pvt->rtp_session);
-
- if (!t38_options || !t38_options->remote_ip) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->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(tech_pvt->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(tech_pvt->rtp_session, t38_options->remote_ip,
- t38_options->remote_port, 0, SWITCH_TRUE, &err) != SWITCH_STATUS_SUCCESS) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_ERROR, "IMAGE UDPTL REPORTS ERROR: [%s]\n", err);
- } else {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session), SWITCH_LOG_DEBUG, "IMAGE UDPTL CHANGING DEST TO: [%s:%d]\n",
- t38_options->remote_ip, t38_options->remote_port);
- if (!sofia_test_pflag(tech_pvt->profile, PFLAG_DISABLE_RTP_AUTOADJ) &&
- !((val = switch_channel_get_variable(tech_pvt->channel, "disable_udptl_auto_adjust")) && switch_true(val))) {
- /* Reactivate the NAT buster flag. */
- switch_rtp_set_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_AUTOADJ);
- }
- }
- }
-}
-
-
static switch_status_t sofia_send_dtmf(switch_core_session_t *session, const switch_dtmf_t *dtmf)
{
private_object_t *tech_pvt;
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL);
- if (sofia_test_flag(tech_pvt, TFLAG_DROP_DTMF)) {
+ if (switch_channel_test_flag(tech_pvt->channel, CF_DROP_DTMF)) {
return SWITCH_STATUS_SUCCESS;
}
- dtmf_type = tech_pvt->dtmf_type;
+ dtmf_type = tech_pvt->mparams.dtmf_type;
/* We only can send INFO when we have no media */
- if (!tech_pvt->rtp_session || !switch_channel_media_ready(tech_pvt->channel) || switch_channel_test_flag(tech_pvt->channel, CF_PROXY_MODE)) {
+ if (!switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO) ||
+ !switch_channel_media_ready(tech_pvt->channel) || switch_channel_test_flag(tech_pvt->channel, CF_PROXY_MODE)) {
dtmf_type = DTMF_INFO;
}
switch (dtmf_type) {
case DTMF_2833:
{
- return switch_rtp_queue_rfc2833(tech_pvt->rtp_session, dtmf);
+ return switch_core_media_queue_rfc2833(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO, dtmf);
}
case DTMF_INFO:
{
case SWITCH_MESSAGE_INDICATE_RECOVERY_REFRESH:
case SWITCH_MESSAGE_INDICATE_APPLICATION_EXEC:
break;
-
- case SWITCH_MESSAGE_INDICATE_PROXY_MEDIA:
+ case SWITCH_MESSAGE_INDICATE_MEDIA_RENEG:
{
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
- if (msg->numeric_arg) {
- switch_rtp_set_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA);
- } else {
- switch_rtp_clear_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA);
- }
+ if (msg->string_arg) {
+ sofia_set_pflag(tech_pvt->profile, PFLAG_RENEG_ON_REINVITE);
+ sofia_clear_flag(tech_pvt, TFLAG_ENABLE_SOA);
}
- }
- break;
-
- case SWITCH_MESSAGE_INDICATE_JITTER_BUFFER:
- {
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
- int len = 0, maxlen = 0, qlen = 0, maxqlen = 50, max_drift = 0;
-
- if (msg->string_arg) {
- char *p, *q;
- const char *s;
-
- if (!strcasecmp(msg->string_arg, "pause")) {
- switch_rtp_pause_jitter_buffer(tech_pvt->rtp_session, SWITCH_TRUE);
- goto end;
- } else if (!strcasecmp(msg->string_arg, "resume")) {
- switch_rtp_pause_jitter_buffer(tech_pvt->rtp_session, SWITCH_FALSE);
- goto end;
- } else if (!strncasecmp(msg->string_arg, "debug:", 6)) {
- s = msg->string_arg + 6;
- if (s && !strcmp(s, "off")) {
- s = NULL;
- }
- status = switch_rtp_debug_jitter_buffer(tech_pvt->rtp_session, s);
- goto end;
- }
-
-
- if ((len = atoi(msg->string_arg))) {
- qlen = len / (tech_pvt->read_impl.microseconds_per_packet / 1000);
- if (qlen < 1) {
- qlen = 3;
- }
- }
-
- if (qlen) {
- if ((p = strchr(msg->string_arg, ':'))) {
- p++;
- maxlen = atol(p);
- if ((q = strchr(p, ':'))) {
- q++;
- max_drift = abs(atol(q));
- }
- }
- }
-
- if (maxlen) {
- maxqlen = maxlen / (tech_pvt->read_impl.microseconds_per_packet / 1000);
- }
- }
-
- if (qlen) {
- if (maxqlen < qlen) {
- maxqlen = qlen * 5;
- }
- if (switch_rtp_activate_jitter_buffer(tech_pvt->rtp_session, qlen, maxqlen,
- tech_pvt->read_impl.samples_per_packet,
- tech_pvt->read_impl.samples_per_second, max_drift) == SWITCH_STATUS_SUCCESS) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session),
- SWITCH_LOG_DEBUG, "Setting Jitterbuffer to %dms (%d frames) (%d max frames) (%d max drift)\n",
- len, qlen, maxqlen, max_drift);
- switch_channel_set_flag(tech_pvt->channel, CF_JITTERBUFFER);
- if (!switch_false(switch_channel_get_variable(tech_pvt->channel, "sip_jitter_buffer_plc"))) {
- switch_channel_set_flag(tech_pvt->channel, CF_JITTERBUFFER_PLC);
- }
- } else {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(tech_pvt->session),
- SWITCH_LOG_WARNING, "Error Setting Jitterbuffer to %dms (%d frames)\n", len, qlen);
- }
-
- } else {
- switch_rtp_deactivate_jitter_buffer(tech_pvt->rtp_session);
- }
- }
+ sofia_glue_do_invite(session);
}
break;
- case SWITCH_MESSAGE_INDICATE_DEBUG_AUDIO:
- {
- if (switch_rtp_ready(tech_pvt->rtp_session) && !zstr(msg->string_array_arg[0]) && !zstr(msg->string_array_arg[1])) {
- int32_t flags = 0;
- if (!strcasecmp(msg->string_array_arg[0], "read")) {
- flags |= SWITCH_RTP_FLAG_DEBUG_RTP_READ;
- } else if (!strcasecmp(msg->string_array_arg[0], "write")) {
- flags |= SWITCH_RTP_FLAG_DEBUG_RTP_WRITE;
- } else if (!strcasecmp(msg->string_array_arg[0], "both")) {
- flags |= SWITCH_RTP_FLAG_DEBUG_RTP_READ | SWITCH_RTP_FLAG_DEBUG_RTP_WRITE;
- }
-
- if (flags) {
- if (switch_true(msg->string_array_arg[1])) {
- switch_rtp_set_flag(tech_pvt->rtp_session, flags);
- } else {
- switch_rtp_clear_flag(tech_pvt->rtp_session, flags);
- }
- } else {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR, "Invalid Options\n");
- }
- }
- }
- status = SWITCH_STATUS_FALSE;
- goto end;
- case SWITCH_MESSAGE_INDICATE_TRANSCODING_NECESSARY:
- if (tech_pvt->rtp_session && switch_rtp_test_flag(tech_pvt->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:
- {
-
switch_channel_set_variable(channel, SOFIA_REPLACES_HEADER, NULL);
-
- if (switch_true(switch_channel_get_variable(tech_pvt->channel, "sip_auto_simplify"))) {
+
+ if (switch_true(switch_channel_get_variable(channel, "sip_auto_simplify"))) {
sofia_set_flag(tech_pvt, TFLAG_SIMPLIFY);
}
-
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
- const char *val;
- int ok = 0;
-
- if (!(val = switch_channel_get_variable(tech_pvt->channel, "sip_jitter_buffer_during_bridge")) || switch_false(val)) {
- if (switch_channel_test_flag(tech_pvt->channel, CF_JITTERBUFFER) && switch_channel_test_cap_partner(tech_pvt->channel, CC_FS_RTP)) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
- "%s PAUSE Jitterbuffer\n", switch_channel_get_name(channel));
- switch_rtp_pause_jitter_buffer(tech_pvt->rtp_session, SWITCH_TRUE);
- sofia_set_flag(tech_pvt, TFLAG_JB_PAUSED);
- }
- }
-
- if (sofia_test_flag(tech_pvt, TFLAG_PASS_RFC2833) && switch_channel_test_flag_partner(channel, CF_FS_RTP)) {
- switch_rtp_set_flag(tech_pvt->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(channel));
- }
-
-
- if ((val = switch_channel_get_variable(channel, "rtp_notimer_during_bridge"))) {
- ok = switch_true(val);
- } else {
- ok = sofia_test_pflag(tech_pvt->profile, PFLAG_RTP_NOTIMER_DURING_BRIDGE);
- }
-
- if (ok && !switch_rtp_test_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_USE_TIMER)) {
- ok = 0;
- }
-
- if (ok) {
- switch_rtp_clear_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
- switch_rtp_clear_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
- sofia_set_flag(tech_pvt, TFLAG_NOTIMER_DURING_BRIDGE);
- }
- if (ok && sofia_test_flag(tech_pvt, TFLAG_NOTIMER_DURING_BRIDGE)) {
- /* these are not compat */
- ok = 0;
- } else {
- if ((val = switch_channel_get_variable(channel, "rtp_autoflush_during_bridge"))) {
- ok = switch_true(val);
- } else {
- ok = sofia_test_pflag(tech_pvt->profile, PFLAG_RTP_AUTOFLUSH_DURING_BRIDGE);
- }
- }
-
- if (ok) {
- rtp_flush_read_buffer(tech_pvt->rtp_session, SWITCH_RTP_FLUSH_STICK);
- sofia_set_flag(tech_pvt, TFLAG_AUTOFLUSH_DURING_BRIDGE);
- } else {
- rtp_flush_read_buffer(tech_pvt->rtp_session, SWITCH_RTP_FLUSH_ONCE);
- }
-
- }
- }
- goto end;
+ break;
case SWITCH_MESSAGE_INDICATE_BLIND_TRANSFER_RESPONSE:
{
const char *event = switch_channel_get_variable(channel, "sip_blind_transfer_event");
}
goto end;
- case SWITCH_MESSAGE_INDICATE_UNBRIDGE:
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
-
- if (sofia_test_flag(tech_pvt, TFLAG_JB_PAUSED)) {
- sofia_clear_flag(tech_pvt, TFLAG_JB_PAUSED);
- if (switch_channel_test_flag(tech_pvt->channel, CF_JITTERBUFFER)) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG,
- "%s RESUME Jitterbuffer\n", switch_channel_get_name(channel));
- switch_rtp_pause_jitter_buffer(tech_pvt->rtp_session, SWITCH_FALSE);
- }
- }
-
-
- if (switch_rtp_test_flag(tech_pvt->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(channel));
- switch_rtp_clear_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_PASS_RFC2833);
- }
-
- if (sofia_test_flag(tech_pvt, TFLAG_NOTIMER_DURING_BRIDGE)) {
- if (!switch_rtp_test_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_UDPTL) &&
- !switch_rtp_test_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_PROXY_MEDIA)) {
- switch_rtp_set_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_USE_TIMER);
- switch_rtp_set_flag(tech_pvt->rtp_session, SWITCH_RTP_FLAG_NOBLOCK);
- }
- sofia_clear_flag(tech_pvt, TFLAG_NOTIMER_DURING_BRIDGE);
- }
-
- if (sofia_test_flag(tech_pvt, TFLAG_AUTOFLUSH_DURING_BRIDGE)) {
- rtp_flush_read_buffer(tech_pvt->rtp_session, SWITCH_RTP_FLUSH_UNSTICK);
- sofia_clear_flag(tech_pvt, TFLAG_AUTOFLUSH_DURING_BRIDGE);
- } else {
- rtp_flush_read_buffer(tech_pvt->rtp_session, SWITCH_RTP_FLUSH_ONCE);
- }
-
- }
- goto end;
- case SWITCH_MESSAGE_INDICATE_AUDIO_SYNC:
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
- rtp_flush_read_buffer(tech_pvt->rtp_session, SWITCH_RTP_FLUSH_ONCE);
- }
- goto end;
-
case SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS:
if (!switch_channel_test_flag(channel, CF_ANSWERED)) {
sofia_clear_flag(tech_pvt, TFLAG_EARLY_MEDIA);
}
if (sofia_test_media_flag(tech_pvt->profile, SCMF_AUTOFIX_TIMING)) {
- tech_pvt->check_frames = 0;
- tech_pvt->last_ts = 0;
+ switch_core_media_reset_autofix_timing(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO);
}
}
break;
switch (msg->message_id) {
- case SWITCH_MESSAGE_INDICATE_MEDIA_RENEG:
- {
- switch_core_session_t *nsession;
-
- if (msg->string_arg) {
- switch_channel_set_variable(channel, "absolute_codec_string", NULL);
- if (*msg->string_arg == '=') {
- switch_channel_set_variable(channel, "codec_string", msg->string_arg);
- } else {
- switch_channel_set_variable_printf(channel, "codec_string", "=%s%s%s,%s",
- tech_pvt->video_rm_encoding ? tech_pvt->video_rm_encoding : "",
- tech_pvt->video_rm_encoding ? "," : "",
- tech_pvt->rm_encoding, msg->string_arg);
- }
-
-
- tech_pvt->num_codecs = 0;
- tech_pvt->rm_encoding = NULL;
- tech_pvt->video_rm_encoding = NULL;
- switch_channel_clear_flag(tech_pvt->channel, CF_VIDEO_POSSIBLE);
- sofia_media_tech_prepare_codecs(tech_pvt);
- switch_core_media_check_video_codecs(tech_pvt->session);
- sofia_media_set_local_sdp(tech_pvt, NULL, 0, NULL, 1);
- sofia_set_pflag(tech_pvt->profile, PFLAG_RENEG_ON_REINVITE);
- sofia_clear_flag(tech_pvt, TFLAG_ENABLE_SOA);
- }
-
- sofia_glue_do_invite(session);
-
- 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_VIDEO_REFRESH_REQ:
{
const char *pl = "<media_control><vc_primitive><to_encoder><picture_fast_update/></to_encoder></vc_primitive></media_control>";
ip = switch_channel_get_variable(channel, SWITCH_REMOTE_MEDIA_IP_VARIABLE);
port = switch_channel_get_variable(channel, SWITCH_REMOTE_MEDIA_PORT_VARIABLE);
if (ip && port) {
- sofia_media_set_local_sdp(tech_pvt, ip, (switch_port_t)atoi(port), msg->string_arg, 1);
+ switch_core_media_gen_local_sdp(session, ip, (switch_port_t)atoi(port), msg->string_arg, 1);
}
if (!sofia_test_flag(tech_pvt, TFLAG_BYE)) {
if (sofia_use_soa(tech_pvt)) {
nua_respond(tech_pvt->nh, SIP_200_OK,
SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
- SOATAG_USER_SDP_STR(tech_pvt->local_sdp_str),
+ SOATAG_USER_SDP_STR(tech_pvt->mparams.local_sdp_str),
SOATAG_REUSE_REJECTED(1), SOATAG_ORDERED_USER(1), SOATAG_AUDIO_AUX("cn telephone-event"), NUTAG_INCLUDE_EXTRA_SDP(1),
TAG_END());
} else {
nua_respond(tech_pvt->nh, SIP_200_OK,
NUTAG_MEDIA_ENABLE(0),
SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
- SIPTAG_CONTENT_TYPE_STR("application/sdp"), SIPTAG_PAYLOAD_STR(tech_pvt->local_sdp_str), TAG_END());
+ SIPTAG_CONTENT_TYPE_STR("application/sdp"), SIPTAG_PAYLOAD_STR(tech_pvt->mparams.local_sdp_str), TAG_END());
}
switch_channel_mark_answered(channel);
}
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(channel, CF_PROXY_MODE);
- if (tech_pvt->rm_encoding) {
- tech_pvt->rm_encoding = NULL;
- }
- sofia_media_tech_set_local_sdp(tech_pvt, NULL, SWITCH_FALSE);
-
- if ((uuid = switch_channel_get_partner_uuid(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) {
- sofia_media_set_local_sdp(tech_pvt, ip, (switch_port_t)atoi(port), NULL, 1);
- }
- }
-
-
- if (!tech_pvt->local_sdp_str) {
- sofia_media_tech_absorb_sdp(tech_pvt);
- }
-
sofia_glue_do_invite(session);
}
break;
- case SWITCH_MESSAGE_INDICATE_AUDIO_DATA:
- {
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
- if (msg->numeric_arg) {
- if (switch_channel_test_flag(tech_pvt->channel, CF_JITTERBUFFER)) {
- switch_rtp_pause_jitter_buffer(tech_pvt->rtp_session, SWITCH_TRUE);
- sofia_set_flag(tech_pvt, TFLAG_JB_PAUSED);
- }
-
- rtp_flush_read_buffer(tech_pvt->rtp_session, SWITCH_RTP_FLUSH_UNSTICK);
-
- } else {
- if (sofia_test_flag(tech_pvt, TFLAG_JB_PAUSED)) {
- sofia_clear_flag(tech_pvt, TFLAG_JB_PAUSED);
- if (switch_channel_test_flag(tech_pvt->channel, CF_JITTERBUFFER)) {
- switch_rtp_pause_jitter_buffer(tech_pvt->rtp_session, SWITCH_FALSE);
- }
- }
- }
- }
- }
- break;
case SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT:
{
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "%s Sending media re-direct:\n%s\n",
switch_channel_get_name(channel), msg->string_arg);
- sofia_media_tech_set_local_sdp(tech_pvt, msg->string_arg, SWITCH_TRUE);
+ switch_core_media_set_local_sdp(session, msg->string_arg, SWITCH_TRUE);
- if(zstr(tech_pvt->local_sdp_str)) {
+ if(zstr(tech_pvt->mparams.local_sdp_str)) {
sofia_set_flag(tech_pvt, TFLAG_3PCC_INVITE);
}
-
+
sofia_set_flag_locked(tech_pvt, TFLAG_SENT_UPDATE);
-
+
if (!switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
switch_channel_set_flag(channel, CF_REQ_MEDIA);
}
sofia_glue_do_invite(session);
+
}
break;
- case SWITCH_MESSAGE_INDICATE_UDPTL_MODE:
- {
- switch_t38_options_t *t38_options = switch_channel_get_private(tech_pvt->channel, "t38_options");
-
- if (!t38_options) {
- nua_respond(tech_pvt->nh, SIP_488_NOT_ACCEPTABLE, TAG_END());
- goto end_lock;
- }
-
- start_udptl(tech_pvt, t38_options);
-
- }
case SWITCH_MESSAGE_INDICATE_T38_DESCRIPTION:
{
switch_t38_options_t *t38_options = switch_channel_get_private(tech_pvt->channel, "t38_options");
goto end_lock;
}
- start_udptl(tech_pvt, t38_options);
+ switch_core_media_start_udptl(tech_pvt->session, t38_options);
- sofia_glue_set_udptl_image_sdp(tech_pvt, t38_options, msg->numeric_arg);
+ switch_core_media_set_image_sdp(tech_pvt->session, t38_options, msg->numeric_arg);
if (!sofia_test_flag(tech_pvt, TFLAG_BYE)) {
char *extra_headers = sofia_glue_get_extra_headers(channel, SOFIA_SIP_RESPONSE_HEADER_PREFIX);
NUTAG_AUTOANSWER(0),
SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
SIPTAG_CALL_INFO_STR(switch_channel_get_variable(tech_pvt->channel, SOFIA_SIP_HEADER_PREFIX "call_info")),
- SOATAG_USER_SDP_STR(tech_pvt->local_sdp_str),
+ SOATAG_USER_SDP_STR(tech_pvt->mparams.local_sdp_str),
SOATAG_REUSE_REJECTED(1), SOATAG_ORDERED_USER(1), SOATAG_AUDIO_AUX("cn telephone-event"), NUTAG_INCLUDE_EXTRA_SDP(1),
TAG_IF(!zstr(extra_headers), SIPTAG_HEADER_STR(extra_headers)), TAG_END());
} else {
SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
SIPTAG_CALL_INFO_STR(switch_channel_get_variable(tech_pvt->channel, SOFIA_SIP_HEADER_PREFIX "call_info")),
SIPTAG_CONTENT_TYPE_STR("application/sdp"),
- SIPTAG_PAYLOAD_STR(tech_pvt->local_sdp_str), TAG_IF(!zstr(extra_headers), SIPTAG_HEADER_STR(extra_headers)), TAG_END());
+ SIPTAG_PAYLOAD_STR(tech_pvt->mparams.local_sdp_str), TAG_IF(!zstr(extra_headers), SIPTAG_HEADER_STR(extra_headers)), TAG_END());
}
switch_safe_free(extra_headers);
sofia_set_flag_locked(tech_pvt, TFLAG_ANS);
switch_t38_options_t *t38_options = switch_channel_get_private(tech_pvt->channel, "t38_options");
if (t38_options) {
- sofia_glue_set_udptl_image_sdp(tech_pvt, t38_options, msg->numeric_arg);
+ switch_core_media_set_image_sdp(tech_pvt->session, t38_options, msg->numeric_arg);
if (!switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
switch_channel_set_flag(channel, CF_REQ_MEDIA);
uint32_t send_invite = 1;
switch_channel_clear_flag(channel, CF_PROXY_MODE);
- sofia_media_tech_set_local_sdp(tech_pvt, NULL, SWITCH_FALSE);
+ switch_core_media_set_local_sdp(session, NULL, SWITCH_FALSE);
if (!(switch_channel_test_flag(channel, CF_ANSWERED) || switch_channel_test_flag(channel, CF_EARLY_MEDIA))) {
if (switch_channel_direction(tech_pvt->channel) == SWITCH_CALL_DIRECTION_INBOUND) {
const char *r_sdp = switch_channel_get_variable(channel, SWITCH_R_SDP_VARIABLE);
- tech_pvt->num_codecs = 0;
- sofia_media_tech_prepare_codecs(tech_pvt);
+
+ switch_core_media_prepare_codecs(tech_pvt->session, SWITCH_TRUE);
if (sofia_media_tech_media(tech_pvt, r_sdp) != SWITCH_STATUS_SUCCESS) {
switch_channel_set_variable(channel, SWITCH_ENDPOINT_DISPOSITION_VARIABLE, "CODEC NEGOTIATION ERROR");
status = SWITCH_STATUS_FALSE;
}
}
- if (!switch_rtp_ready(tech_pvt->rtp_session)) {
- sofia_media_tech_prepare_codecs(tech_pvt);
- if ((status = sofia_glue_tech_choose_port(tech_pvt, 0)) != SWITCH_STATUS_SUCCESS) {
+ if (!switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO)) {
+ switch_core_media_prepare_codecs(tech_pvt->session, SWITCH_FALSE);
+ if ((status = switch_core_media_choose_port(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO, 0)) != SWITCH_STATUS_SUCCESS) {
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
goto end_lock;
}
}
- sofia_media_set_local_sdp(tech_pvt, NULL, 0, NULL, 1);
+ switch_core_media_gen_local_sdp(session, NULL, 0, NULL, 1);
if (send_invite) {
if (!switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
if (!strcasecmp(sdp, "t38")) {
switch_t38_options_t *t38_options = switch_channel_get_private(tech_pvt->channel, "t38_options");
if (t38_options) {
- sofia_glue_set_udptl_image_sdp(tech_pvt, t38_options, 0);
- if (switch_rtp_ready(tech_pvt->rtp_session)) {
- sofia_clear_flag(tech_pvt, TFLAG_NOTIMER_DURING_BRIDGE);
- switch_rtp_udptl_mode(tech_pvt->rtp_session);
+ switch_core_media_set_image_sdp(tech_pvt->session, t38_options, 0);
+ if (switch_core_media_ready(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO)) {
+ switch_channel_clear_flag(tech_pvt->channel, CF_NOTIMER_DURING_BRIDGE);
+ switch_core_media_udptl_mode(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO);
}
}
} else {
- sofia_media_tech_set_local_sdp(tech_pvt, sdp, SWITCH_TRUE);
+ switch_core_media_set_local_sdp(session, sdp, SWITCH_TRUE);
}
if (switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
- sofia_media_tech_patch_sdp(tech_pvt);
- sofia_glue_tech_proxy_remote_addr(tech_pvt, NULL);
+ switch_core_media_patch_sdp(tech_pvt->session);
+ switch_core_media_proxy_remote_addr(session, NULL);
}
if (sofia_use_soa(tech_pvt)) {
nua_respond(tech_pvt->nh, code, su_strdup(nua_handle_home(tech_pvt->nh), reason), SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
- SOATAG_USER_SDP_STR(tech_pvt->local_sdp_str),
+ SOATAG_USER_SDP_STR(tech_pvt->mparams.local_sdp_str),
SOATAG_REUSE_REJECTED(1),
SOATAG_ORDERED_USER(1), SOATAG_AUDIO_AUX("cn telephone-event"), NUTAG_INCLUDE_EXTRA_SDP(1),
TAG_IF(!zstr(extra_headers), SIPTAG_HEADER_STR(extra_headers)), TAG_END());
nua_respond(tech_pvt->nh, code, su_strdup(nua_handle_home(tech_pvt->nh), reason), SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
NUTAG_MEDIA_ENABLE(0),
SIPTAG_CONTENT_TYPE_STR("application/sdp"),
- SIPTAG_PAYLOAD_STR(tech_pvt->local_sdp_str),
+ SIPTAG_PAYLOAD_STR(tech_pvt->mparams.local_sdp_str),
TAG_IF(!zstr(extra_headers), SIPTAG_HEADER_STR(extra_headers)), TAG_END());
}
if (sofia_test_pflag(tech_pvt->profile, PFLAG_3PCC_PROXY) && sofia_test_flag(tech_pvt, TFLAG_3PCC)) {
if (switch_channel_test_flag(channel, CF_PROXY_MODE) || switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
const char *sdp = NULL;
if ((sdp = switch_channel_get_variable(channel, SWITCH_B_SDP_VARIABLE))) {
- sofia_media_tech_set_local_sdp(tech_pvt, sdp, SWITCH_TRUE);
+ switch_core_media_set_local_sdp(session, sdp, SWITCH_TRUE);
}
if (switch_channel_test_flag(channel, CF_PROXY_MEDIA)) {
- sofia_media_tech_patch_sdp(tech_pvt);
+ switch_core_media_patch_sdp(tech_pvt->session);
if (sofia_media_activate_rtp(tech_pvt) != SWITCH_STATUS_SUCCESS) {
status = SWITCH_STATUS_FALSE;
}
}
} else {
- if (sofia_test_flag(tech_pvt, TFLAG_LATE_NEGOTIATION) || !tech_pvt->iananame) {
+ if (sofia_test_flag(tech_pvt, TFLAG_LATE_NEGOTIATION) ||
+ switch_core_media_codec_chosen(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO) != SWITCH_STATUS_SUCCESS) {
sofia_clear_flag_locked(tech_pvt, TFLAG_LATE_NEGOTIATION);
if (switch_channel_direction(tech_pvt->channel) == SWITCH_CALL_DIRECTION_INBOUND) {
const char *r_sdp = switch_channel_get_variable(channel, SWITCH_R_SDP_VARIABLE);
- tech_pvt->num_codecs = 0;
- sofia_media_tech_prepare_codecs(tech_pvt);
+
+ switch_core_media_prepare_codecs(tech_pvt->session, SWITCH_TRUE);
if (zstr(r_sdp) || sofia_media_tech_media(tech_pvt, r_sdp) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_ERROR,
"CODEC NEGOTIATION ERROR. SDP:\n%s\n", r_sdp ? r_sdp : "NO SDP!");
switch_channel_check_zrtp(tech_pvt->channel);
- if ((status = sofia_glue_tech_choose_port(tech_pvt, 0)) != SWITCH_STATUS_SUCCESS) {
+ if ((status = switch_core_media_choose_port(tech_pvt->session, SWITCH_MEDIA_TYPE_AUDIO, 0)) != SWITCH_STATUS_SUCCESS) {
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
goto end_lock;
}
- sofia_media_set_local_sdp(tech_pvt, NULL, 0, NULL, 0);
+ switch_core_media_gen_local_sdp(session, NULL, 0, NULL, 0);
if (sofia_media_activate_rtp(tech_pvt) != SWITCH_STATUS_SUCCESS) {
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
}
- if (tech_pvt->local_sdp_str) {
- switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Ring SDP:\n%s\n", tech_pvt->local_sdp_str);
+ if (tech_pvt->mparams.local_sdp_str) {
+ switch_log_printf(SWITCH_CHANNEL_SESSION_LOG(session), SWITCH_LOG_DEBUG, "Ring SDP:\n%s\n", tech_pvt->mparams.local_sdp_str);
}
}
switch_channel_mark_pre_answered(channel);
if (switch_channel_test_flag(tech_pvt->channel, CF_PROXY_MODE) &&
- tech_pvt->early_sdp && strcmp(tech_pvt->early_sdp, tech_pvt->local_sdp_str)) {
+ tech_pvt->mparams.early_sdp && strcmp(tech_pvt->mparams.early_sdp, tech_pvt->mparams.local_sdp_str)) {
/* The SIP RFC for SOA forbids sending a 183 with one sdp then a 200 with another but it won't do us much good unless
we do so in this case we will abandon the SOA rules and go rogue.
*/
sofia_clear_flag(tech_pvt, TFLAG_ENABLE_SOA);
}
- tech_pvt->early_sdp = switch_core_session_strdup(tech_pvt->session, tech_pvt->local_sdp_str);
+ tech_pvt->mparams.early_sdp = switch_core_session_strdup(tech_pvt->session, tech_pvt->mparams.local_sdp_str);
if (sofia_use_soa(tech_pvt)) {
nua_respond(tech_pvt->nh,
SOATAG_REUSE_REJECTED(1),
SOATAG_ORDERED_USER(1),
SOATAG_RTP_SELECT(1),
- SOATAG_ADDRESS(tech_pvt->adv_sdp_audio_ip),
- SOATAG_USER_SDP_STR(tech_pvt->local_sdp_str), SOATAG_AUDIO_AUX("cn telephone-event"),
+ SOATAG_ADDRESS(tech_pvt->mparams.adv_sdp_audio_ip),
+ SOATAG_USER_SDP_STR(tech_pvt->mparams.local_sdp_str), SOATAG_AUDIO_AUX("cn telephone-event"),
TAG_IF(call_info, SIPTAG_CALL_INFO_STR(call_info)),
TAG_IF(!zstr(extra_header), SIPTAG_HEADER_STR(extra_header)),
TAG_IF(switch_stristr("update_display", tech_pvt->x_freeswitch_support_remote),
TAG_IF(cid, SIPTAG_HEADER_STR(cid)),
SIPTAG_CONTACT_STR(tech_pvt->reply_contact),
SIPTAG_CONTENT_TYPE_STR("application/sdp"),
- SIPTAG_PAYLOAD_STR(tech_pvt->local_sdp_str),
+ SIPTAG_PAYLOAD_STR(tech_pvt->mparams.local_sdp_str),
TAG_IF(call_info, SIPTAG_CALL_INFO_STR(call_info)),
TAG_IF(!zstr(extra_header), SIPTAG_HEADER_STR(extra_header)),
TAG_IF(switch_stristr("update_display", tech_pvt->x_freeswitch_support_remote),
}
}
break;
+
+ case SWITCH_MESSAGE_INDICATE_UDPTL_MODE:
+ {
+ switch_t38_options_t *t38_options = switch_channel_get_private(channel, "t38_options");
+
+ if (!t38_options) {
+ nua_respond(tech_pvt->nh, SIP_488_NOT_ACCEPTABLE, TAG_END());
+ }
+ }
+ break;
+
default:
break;
}
stream->write_function(stream, "ZRTP-PASSTHRU \t%s\n", sofia_test_flag(profile, TFLAG_ZRTP_PASSTHRU) ? "true" : "false");
stream->write_function(stream, "AGGRESSIVENAT \t%s\n",
sofia_test_pflag(profile, PFLAG_AGGRESSIVE_NAT_DETECTION) ? "true" : "false");
- stream->write_function(stream, "STUN-ENABLED \t%s\n", sofia_test_pflag(profile, PFLAG_STUN_ENABLED) ? "true" : "false");
- stream->write_function(stream, "STUN-AUTO-DISABLE\t%s\n", sofia_test_pflag(profile, PFLAG_STUN_AUTO_DISABLE) ? "true" : "false");
if (profile->user_agent_filter) {
stream->write_function(stream, "USER-AGENT-FILTER\t%s\n", switch_str_nil(profile->user_agent_filter));
}
stream->write_function(stream, " <zrtp-passthru>%s</zrtp-passthru>\n", sofia_test_flag(profile, TFLAG_ZRTP_PASSTHRU) ? "true" : "false");
stream->write_function(stream, " <aggressive-nat>%s</aggressive-nat>\n",
sofia_test_pflag(profile, PFLAG_AGGRESSIVE_NAT_DETECTION) ? "true" : "false");
- stream->write_function(stream, " <stun-enabled>%s</stun-enabled>\n",
- sofia_test_pflag(profile, PFLAG_STUN_ENABLED) ? "true" : "false");
- stream->write_function(stream, " <stun-auto-disable>%s</stun-auto-disable>\n",
- sofia_test_pflag(profile, PFLAG_STUN_AUTO_DISABLE) ? "true" : "false");
stream->write_function(stream, " <user-agent-filter>%s</user-agent-filter>\n", switch_str_nil(profile->user_agent_filter));
stream->write_function(stream, " <max-registrations-per-extension>%d</max-registrations-per-extension>\n",
profile->max_registrations_perext);
goto done;
}
- if (!strcasecmp(argv[1], "stun-auto-disable")) {
- if (argv[2]) {
- int is_true = switch_true(argv[2]);
- if (is_true) {
- sofia_set_pflag(profile, PFLAG_STUN_AUTO_DISABLE);
- } else {
- sofia_clear_pflag(profile, PFLAG_STUN_AUTO_DISABLE);
- }
- }
-
- stream->write_function(stream, "+OK stun-auto-disable=%s", sofia_test_pflag(profile, PFLAG_STUN_AUTO_DISABLE) ? "true" : "false");
-
- goto done;
- }
-
- if (!strcasecmp(argv[1], "stun-enabled")) {
- if (argv[2]) {
- int is_true = switch_true(argv[2]);
- if (is_true) {
- sofia_set_pflag(profile, PFLAG_STUN_ENABLED);
- } else {
- sofia_clear_pflag(profile, PFLAG_STUN_ENABLED);
- }
- }
-
- stream->write_function(stream, "+OK stun-enabled=%s", sofia_test_pflag(profile, PFLAG_STUN_ENABLED) ? "true" : "false");
-
- goto done;
- }
-
-
if (!strcasecmp(argv[1], "rescan")) {
switch_xml_reload(&err);
switch_url_decode(remote_host);
}
if (!zstr(remote_host)) {
- switch_split_user_domain(remote_host, NULL, &tech_pvt->remote_ip);
+ switch_split_user_domain(remote_host, NULL, &tech_pvt->mparams.remote_ip);
}
}
- if (zstr(tech_pvt->remote_ip)) {
- switch_split_user_domain(switch_core_session_strdup(nsession, tech_pvt->dest), NULL, &tech_pvt->remote_ip);
+ if (zstr(tech_pvt->mparams.remote_ip)) {
+ switch_split_user_domain(switch_core_session_strdup(nsession, tech_pvt->dest), NULL, &tech_pvt->mparams.remote_ip);
}
if (dest_to) {
}
}
- if (switch_channel_test_flag(o_channel, CF_PROXY_MEDIA)) {
- const char *r_sdp = switch_channel_get_variable(o_channel, SWITCH_R_SDP_VARIABLE);
+ switch_core_media_check_outgoing_proxy(session);
- if (switch_stristr("m=video", r_sdp)) {
- sofia_glue_tech_choose_video_port(tech_pvt, 1);
- tech_pvt->video_rm_encoding = "PROXY-VID";
- tech_pvt->video_rm_rate = 90000;
- tech_pvt->video_codec_ms = 0;
- switch_channel_set_flag(tech_pvt->channel, CF_VIDEO);
- switch_channel_set_flag(tech_pvt->channel, CF_VIDEO_POSSIBLE);
- }
- }
}
goto done;
projects / thirdparty / freeswitch.git / commitdiff
